LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: read_chars
static int read_chars (lua_State *L, FILE *f, size_t n) {
  size_t rlen;  /* how much to read */
  size_t nr;  /* number of chars actually read */
  luaL_Buffer b;
  luaL_buffinit(L, &b);
  rlen = LUAL_BUFFERSIZE;  /* try to read that much each time */
  do {
    char *p = luaL_prepbuffer(&b);
    if (rlen > n) rlen = n;  /* cannot read more than asked */
    nr = fread(p, sizeof(char), rlen, f);
    luaL_addsize(&b, nr);
    n -= nr;  /* still have to read `n' chars */
  } while (n > 0 && nr == rlen);  /* until end of count or eof */
  luaL_pushresult(&b);  /* close buffer */
  return (n == 0 || lua_objlen(L, -1) > 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2050, %rsp           # imm = 0x2050
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2040(%rbp), %rsi
callq 0x1b530
movq $0x2000, -0x20(%rbp)    # imm = 0x2000
leaq -0x2040(%rbp), %rdi
callq 0x1b680
movq %rax, -0x2048(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x23af4
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x2048(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x50e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq -0x2040(%rbp), %rax
movq %rax, -0x2040(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x2049(%rbp)
jbe 0x23b52
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
sete %al
movb %al, -0x2049(%rbp)
movb -0x2049(%rbp), %al
testb $0x1, %al
jne 0x23acf
leaq -0x2040(%rbp), %rdi
callq 0x1b640
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x204a(%rbp)
je 0x23b96
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7560
cmpq $0x0, %rax
seta %al
movb %al, -0x204a(%rbp)
movb -0x204a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x2050, %rsp           # imm = 0x2050
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: g_write
static int g_write (lua_State *L, FILE *f, int arg) {
  int nargs = lua_gettop(L) - 1;
  int status = 1;
  for (; nargs--; arg++) {
    if (lua_type(L, arg) == LUA_TNUMBER) {
      /* optimization: could be done exactly as for strings */
      status = status &&
          fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 0;
    }
    else {
      size_t l;
      const char *s = luaL_checklstring(L, arg, &l);
      status = status && (fwrite(s, sizeof(char), l, f) == l);
    }
  }
  return pushresult(L, status, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6a80
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x18(%rbp)
cmpl $0x0, %eax
je 0x23cff
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6fe0
cmpl $0x3, %eax
jne 0x23ca5
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x31(%rbp)
je 0x23c98
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x7350
movq -0x40(%rbp), %rdi
leaq 0x81f4(%rip), %rsi      # 0x2be7c
movb $0x1, %al
callq 0x52d0
cmpl $0x0, %eax
setg %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
jmp 0x23cef
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x28(%rbp), %rdx
callq 0x1abe0
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x41(%rbp)
je 0x23ce4
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x54e0
cmpq -0x28(%rbp), %rax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
jmp 0x23cf1
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x23c39
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x23520
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: io_lines
static int io_lines (lua_State *L) {
  if (lua_isnoneornil(L, 1)) {  /* no arguments? */
    /* will iterate over default input */
    lua_rawgeti(L, LUA_ENVIRONINDEX, IO_INPUT);
    return f_lines(L);
  }
  else {
    const char *filename = luaL_checkstring(L, 1);
    FILE **pf = newfile(L);
    *pf = fopen(filename, "r");
    if (*pf == NULL)
      fileerror(L, 1, filename);
    aux_lines(L, lua_gettop(L), 1);
    return 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6fe0
cmpl $0x0, %eax
jg 0x23de3
movq -0x10(%rbp), %rdi
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
movl $0x1, %edx
callq 0x7ea0
movq -0x10(%rbp), %rdi
callq 0x231d0
movl %eax, -0x4(%rbp)
jmp 0x23e64
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1abe0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x242d0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x923f(%rip), %rsi      # 0x2d050
callq 0x5430
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x23e3c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x1, %esi
callq 0x24330
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a80
movq -0x28(%rbp), %rdi
movl %eax, %esi
movl $0x1, %edx
callq 0x235e0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: io_open
static int io_open (lua_State *L) {
  const char *filename = luaL_checkstring(L, 1);
  const char *mode = luaL_optstring(L, 2, "r");
  FILE **pf = newfile(L);
  *pf = fopen(filename, mode);
  return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1abe0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x91ae(%rip), %rdx      # 0x2d050
xorl %eax, %eax
movl %eax, %ecx
callq 0x1ab60
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x242d0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5430
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x23ef1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x23520
movl %eax, -0x24(%rbp)
jmp 0x23efb
movl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x23efb
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: io_popen
static int io_popen (lua_State *L) {
  const char *filename = luaL_checkstring(L, 1);
  const char *mode = luaL_optstring(L, 2, "r");
  FILE **pf = newfile(L);
  *pf = lua_popen(L, filename, mode);
  return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1abe0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x90de(%rip), %rdx      # 0x2d050
xorl %eax, %eax
movl %eax, %ecx
callq 0x1ab60
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x242d0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x89c2(%rip), %rsi      # 0x2c959
movb $0x0, %al
callq 0x1a8b0
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x23fc7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x23520
movl %eax, -0x24(%rbp)
jmp 0x23fd1
movl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x23fd1
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: io_type
static int io_type (lua_State *L) {
  void *ud;
  luaL_checkany(L, 1);
  ud = lua_touserdata(L, 1);
  lua_getfield(L, LUA_REGISTRYINDEX, LUA_FILEHANDLE);
  if (ud == NULL || !lua_getmetatable(L, 1) || !lua_rawequal(L, -2, -1))
    lua_pushnil(L);  /* not a file */
  else if (*((FILE **)ud) == NULL)
    lua_pushliteral(L, "closed file");
  else
    lua_pushliteral(L, "file");
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x1ae40
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x76a0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
leaq 0x87c8(%rip), %rdx      # 0x2c884
callq 0x7d90
cmpq $0x0, -0x10(%rbp)
je 0x240f3
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x7fa0
cmpl $0x0, %eax
je 0x240f3
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x71c0
cmpl $0x0, %eax
jne 0x240fe
movq -0x8(%rbp), %rdi
callq 0x7800
jmp 0x24136
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2411f
movq -0x8(%rbp), %rdi
leaq 0x87a1(%rip), %rsi      # 0x2c8b4
movl $0xb, %edx
callq 0x78d0
jmp 0x24134
movq -0x8(%rbp), %rdi
leaq 0x8791(%rip), %rsi      # 0x2c8bb
movl $0x4, %edx
callq 0x78d0
jmp 0x24136
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: getiofile
static FILE *getiofile (lua_State *L, int findex) {
  FILE *f;
  lua_rawgeti(L, LUA_ENVIRONINDEX, findex);
  f = *(FILE **)lua_touserdata(L, -1);
  if (f == NULL)
    luaL_error(L, "standard %s file is closed", fnames[findex - 1]);
  return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x7ea0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x76a0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x241f2
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x126e0(%rip), %rax     # 0x368c0
movq (%rax,%rcx,8), %rdx
leaq 0x8753(%rip), %rsi      # 0x2c93e
movb $0x0, %al
callq 0x1a8b0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: g_iofile
static int g_iofile (lua_State *L, int f, const char *mode) {
  if (!lua_isnoneornil(L, 1)) {
    const char *filename = lua_tostring(L, 1);
    if (filename) {
      FILE **pf = newfile(L);
      *pf = fopen(filename, mode);
      if (*pf == NULL)
        fileerror(L, 1, filename);
    }
    else {
      tofile(L);  /* check that it's a valid file handle */
      lua_pushvalue(L, 1);
    }
    lua_rawseti(L, LUA_ENVIRONINDEX, f);
  }
  /* return current value */
  lua_rawgeti(L, LUA_ENVIRONINDEX, f);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6fe0
cmpl $0x0, %eax
jle 0x242b1
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x74a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x24289
movq -0x8(%rbp), %rdi
callq 0x242d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5430
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x24287
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x1, %esi
callq 0x24330
jmp 0x242a0
movq -0x8(%rbp), %rdi
callq 0x23480
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6f80
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x8350
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
callq 0x7ea0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/liolib.c
// Function: newfile
static FILE **newfile (lua_State *L) {
  FILE **pf = (FILE **)lua_newuserdata(L, sizeof(FILE *));
  *pf = NULL;  /* file handle is currently `closed' */
  luaL_getmetatable(L, LUA_FILEHANDLE);
  lua_setmetatable(L, -2);
  return pf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x8da0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
leaq 0x857b(%rip), %rdx      # 0x2c884
callq 0x7d90
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8420
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lmathlib.c
// Function: luaopen_math
LUALIB_API int luaopen_math (lua_State *L) {
  luaL_register(L, LUA_MATHLIBNAME, mathlib);
  lua_pushnumber(L, PI);
  lua_setfield(L, -2, "pi");
  lua_pushnumber(L, HUGE_VAL);
  lua_setfield(L, -2, "huge");
#if defined(LUA_COMPAT_MOD)
  lua_getfield(L, -1, "fmod");
  lua_setfield(L, -2, "mod");
#endif
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x7c87(%rip), %rsi      # 0x2c04e
leaq 0x12502(%rip), %rdx     # 0x368d0
callq 0x1b100
movq -0x8(%rbp), %rdi
movsd 0x85d1(%rip), %xmm0     # 0x2c9b0
callq 0x7830
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x85ec(%rip), %rdx      # 0x2c9e0
callq 0x81e0
movq -0x8(%rbp), %rdi
movsd 0x85a3(%rip), %xmm0     # 0x2c9a8
callq 0x7830
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x85c9(%rip), %rdx      # 0x2c9e3
callq 0x81e0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x85b9(%rip), %rdx      # 0x2c9e8
callq 0x7d90
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x78a2(%rip), %rdx      # 0x2bce6
callq 0x81e0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lmathlib.c
// Function: math_frexp
static int math_frexp (lua_State *L) {
  int e;
  lua_pushnumber(L, frexp(luaL_checknumber(L, 1), &e));
  lua_pushinteger(L, e);
  return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x1ae80
leaq -0xc(%rbp), %rdi
callq 0x5270
movq -0x18(%rbp), %rdi
callq 0x7830
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x7880
movl $0x2, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lmathlib.c
// Function: math_modf
static int math_modf (lua_State *L) {
  double ip;
  double fp = modf(luaL_checknumber(L, 1), &ip);
  lua_pushnumber(L, ip);
  lua_pushnumber(L, fp);
  return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x1ae80
leaq -0x10(%rbp), %rdi
callq 0x5190
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x7830
movq -0x8(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x7830
movl $0x2, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/loslib.c
// Function: getfield
static int getfield (lua_State *L, const char *key, int d) {
  int res;
  lua_getfield(L, -1, key);
  if (lua_isnumber(L, -1))
    res = (int)lua_tointeger(L, -1);
  else {
    if (d < 0)
      return luaL_error(L, "field " LUA_QS " missing in date table", key);
    res = d;
  }
  lua_pop(L, 1);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7d90
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x70c0
cmpl $0x0, %eax
je 0x2570b
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x73c0
movl %eax, -0x20(%rbp)
jmp 0x25732
cmpl $0x0, -0x1c(%rbp)
jge 0x2572c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x7406(%rip), %rsi      # 0x2cb26
movb $0x0, %al
callq 0x1a8b0
movl %eax, -0x4(%rbp)
jmp 0x25746
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6ab0
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltablib.c
// Function: foreach
static int foreach (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  luaL_checktype(L, 2, LUA_TFUNCTION);
  lua_pushnil(L);  /* first key */
  while (lua_next(L, 1)) {
    lua_pushvalue(L, 2);  /* function */
    lua_pushvalue(L, -3);  /* key */
    lua_pushvalue(L, -3);  /* value */
    lua_call(L, 2, 1);
    if (!lua_isnil(L, -1))
      return 1;
    lua_pop(L, 2);  /* remove value and result */
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1adb0
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x6, %edx
callq 0x1adb0
movq -0x10(%rbp), %rdi
callq 0x7800
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x8bd0
cmpl $0x0, %eax
je 0x259f7
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x6f80
movq -0x10(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x6f80
movq -0x10(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x6f80
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x8680
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6fe0
cmpl $0x0, %eax
je 0x259e7
movl $0x1, -0x4(%rbp)
jmp 0x259fe
movq -0x10(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x6ab0
jmp 0x2597b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltablib.c
// Function: foreachi
static int foreachi (lua_State *L) {
  int i;
  int n = aux_getn(L, 1);
  luaL_checktype(L, 2, LUA_TFUNCTION);
  for (i=1; i <= n; i++) {
    lua_pushvalue(L, 2);  /* function */
    lua_pushinteger(L, i);  /* 1st argument */
    lua_rawgeti(L, 1, i);  /* 2nd argument */
    lua_call(L, 2, 1);
    if (!lua_isnil(L, -1))
      return 1;
    lua_pop(L, 1);  /* remove nil result */
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1adb0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x7560
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x6, %edx
callq 0x1adb0
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x25ad6
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x6f80
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x7880
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movl $0x1, %esi
callq 0x7ea0
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x8680
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6fe0
cmpl $0x0, %eax
je 0x25abd
movl $0x1, -0x4(%rbp)
jmp 0x25add
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6ab0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x25a5a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltablib.c
// Function: maxn
static int maxn (lua_State *L) {
  lua_Number max = 0;
  luaL_checktype(L, 1, LUA_TTABLE);
  lua_pushnil(L);  /* first key */
  while (lua_next(L, 1)) {
    lua_pop(L, 1);  /* remove value */
    if (lua_type(L, -1) == LUA_TNUMBER) {
      lua_Number v = lua_tonumber(L, -1);
      if (v > max) max = v;
    }
  }
  lua_pushnumber(L, max);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1adb0
movq -0x8(%rbp), %rdi
callq 0x7800
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x8bd0
cmpl $0x0, %eax
je 0x25bd1
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6ab0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6fe0
cmpl $0x3, %eax
jne 0x25bcf
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7350
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x25bcd
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x25bcf
jmp 0x25b70
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x7830
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltablib.c
// Function: tinsert
static int tinsert (lua_State *L) {
  int e = aux_getn(L, 1) + 1;  /* first empty element */
  int pos;  /* where to insert new element */
  switch (lua_gettop(L)) {
    case 2: {  /* called with only 2 arguments */
      pos = e;  /* insert new element at the end */
      break;
    }
    case 3: {
      int i;
      pos = luaL_checkint(L, 2);  /* 2nd argument is the position */
      if (pos > e) e = pos;  /* `grow' array if necessary */
      for (i = e; i > pos; i--) {  /* move up elements */
        lua_rawgeti(L, 1, i-1);
        lua_rawseti(L, 1, i);  /* t[i] = t[i-1] */
      }
      break;
    }
    default: {
      return luaL_error(L, "wrong number of arguments to " LUA_QL("insert"));
    }
  }
  luaL_setn(L, 1, e);  /* new size */
  lua_rawseti(L, 1, pos);  /* t[pos] = v */
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl %esi, -0x24(%rbp)
movl $0x5, %edx
callq 0x1adb0
movl -0x24(%rbp), %esi
movq -0x10(%rbp), %rdi
callq 0x7560
incl %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a80
movl %eax, %ecx
movl %ecx, -0x20(%rbp)
subl $0x2, %eax
je 0x25c42
jmp 0x25c38
movl -0x20(%rbp), %eax
subl $0x3, %eax
je 0x25c4a
jmp 0x25ca9
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x25cc0
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x1af30
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x25c69
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x25ca7
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %edx
subl $0x1, %edx
movl $0x1, %esi
callq 0x7ea0
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %edx
movl $0x1, %esi
callq 0x8350
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x25c6f
jmp 0x25cc0
movq -0x10(%rbp), %rdi
leaq 0x6f35(%rip), %rsi      # 0x2cbe9
movb $0x0, %al
callq 0x1a8b0
movl %eax, -0x4(%rbp)
jmp 0x25cd8
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %edx
movl $0x1, %esi
callq 0x8350
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltablib.c
// Function: tremove
static int tremove (lua_State *L) {
  int e = aux_getn(L, 1);
  int pos = luaL_optint(L, 2, e);
  if (!(1 <= pos && pos <= e))  /* position is outside bounds? */
   return 0;  /* nothing to remove */
  luaL_setn(L, 1, e - 1);  /* t.n = n-1 */
  lua_rawgeti(L, 1, pos);  /* result = t[pos] */
  for ( ;pos<e; pos++) {
    lua_rawgeti(L, 1, pos+1);
    lua_rawseti(L, 1, pos);  /* t[pos] = t[pos+1] */
  }
  lua_pushnil(L);
  lua_rawseti(L, 1, e);  /* t[e] = nil */
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1adb0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x7560
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rdx
movl $0x2, %esi
callq 0x1af90
movl %eax, -0x18(%rbp)
movl $0x1, %eax
cmpl -0x18(%rbp), %eax
jg 0x25d47
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x25d50
movl $0x0, -0x4(%rbp)
jmp 0x25dba
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %edx
movl $0x1, %esi
callq 0x7ea0
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x25d99
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %edx
addl $0x1, %edx
movl $0x1, %esi
callq 0x7ea0
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %edx
movl $0x1, %esi
callq 0x8350
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x25d61
movq -0x10(%rbp), %rdi
callq 0x7800
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movl $0x1, %esi
callq 0x8350
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltablib.c
// Function: setn
static int setn (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
#ifndef luaL_setn
  luaL_setn(L, 1, luaL_checkint(L, 2));
#else
  luaL_error(L, LUA_QL("setn") " is obsolete");
#endif
  lua_pushvalue(L, 1);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1adb0
movq -0x8(%rbp), %rdi
leaq 0x6e15(%rip), %rsi      # 0x2cc0f
movb $0x0, %al
callq 0x1a8b0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6f80
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/ltablib.c
// Function: sort_comp
static int sort_comp (lua_State *L, int a, int b) {
  if (!lua_isnil(L, 2)) {  /* function? */
    int res;
    lua_pushvalue(L, 2);
    lua_pushvalue(L, a-1);  /* -1 to compensate function */
    lua_pushvalue(L, b-2);  /* -2 to compensate function and `a' */
    lua_call(L, 2, 1);
    res = lua_toboolean(L, -1);
    lua_pop(L, 1);
    return res;
  }
  else  /* a < b? */
    return lua_lessthan(L, a, b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x6fe0
cmpl $0x0, %eax
je 0x262fb
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x6f80
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x6f80
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
subl $0x2, %esi
callq 0x6f80
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x8680
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7440
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6ab0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2630d
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x72d0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: luaopen_string
LUALIB_API int luaopen_string (lua_State *L) {
  luaL_register(L, LUA_STRLIBNAME, strlib);
#if defined(LUA_COMPAT_GFIND)
  lua_getfield(L, -1, "gmatch");
  lua_setfield(L, -2, "gfind");
#endif
  createmetatable(L);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x6f28(%rip), %rsi      # 0x2d29f
leaq 0x108c2(%rip), %rdx     # 0x36c40
callq 0x1b100
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x6af5(%rip), %rdx      # 0x2ce88
callq 0x7d90
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x6ae7(%rip), %rdx      # 0x2ce8f
callq 0x81e0
movq -0x8(%rbp), %rdi
callq 0x263d0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: createmetatable
static void createmetatable (lua_State *L) {
  lua_createtable(L, 0, 1);  /* create metatable for strings */
  lua_pushliteral(L, "");  /* dummy string */
  lua_pushvalue(L, -2);
  lua_setmetatable(L, -2);  /* set string metatable */
  lua_pop(L, 1);  /* pop dummy string */
  lua_pushvalue(L, -2);  /* string library... */
  lua_setfield(L, -2, "__index");  /* ...is the __index metamethod */
  lua_pop(L, 1);  /* pop metatable */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x7f20
movq -0x8(%rbp), %rdi
leaq 0x6f1f(%rip), %rsi      # 0x2d316
xorl %eax, %eax
movl %eax, %edx
callq 0x78d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6f80
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8420
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6ab0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6f80
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x5860(%rip), %rdx      # 0x2bca8
callq 0x81e0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6ab0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: str_byte
static int str_byte (lua_State *L) {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  ptrdiff_t posi = posrelat(luaL_optinteger(L, 2, 1), l);
  ptrdiff_t pose = posrelat(luaL_optinteger(L, 3, posi), l);
  int n, i;
  if (posi <= 0) posi = 1;
  if ((size_t)pose > l) pose = l;
  if (posi > pose) return 0;  /* empty interval; return no values */
  n = (int)(pose -  posi + 1);
  if (posi + n <= pose)  /* overflow? */
    luaL_error(L, "string slice too long");
  luaL_checkstack(L, n, "string slice too long");
  for (i=0; i<n; i++)
    lua_pushinteger(L, uchar(s[posi+i-1]));
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq -0x18(%rbp), %rdx
callq 0x1abe0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x1af90
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x27380
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x3, %esi
callq 0x1af90
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x27380
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
jg 0x264e6
movq $0x1, -0x28(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x264f8
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x2650e
movl $0x0, -0x4(%rbp)
jmp 0x26595
movq -0x30(%rbp), %rax
subq -0x28(%rbp), %rax
addq $0x1, %rax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
addq %rcx, %rax
cmpq -0x30(%rbp), %rax
jg 0x26540
movq -0x10(%rbp), %rdi
leaq 0x6988(%rip), %rsi      # 0x2cec1
movb $0x0, %al
callq 0x1a8b0
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
leaq 0x6973(%rip), %rdx      # 0x2cec1
callq 0x1ad70
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x2658f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq -0x38(%rbp), %rdx
addq %rdx, %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %esi
callq 0x7880
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2655a
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: str_char
static int str_char (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int i;
  luaL_Buffer b;
  luaL_buffinit(L, &b);
  for (i=1; i<=n; i++) {
    int c = luaL_checkint(L, i);
    luaL_argcheck(L, uchar(c) == c, i, "invalid value");
    luaL_addchar(&b, uchar(c));
  }
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2030, %rsp           # imm = 0x2030
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6a80
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2028(%rbp), %rsi
callq 0x1b530
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x266a0
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x1af30
movl %eax, -0x202c(%rbp)
movl -0x202c(%rbp), %eax
movzbl %al, %ecx
movb $0x1, %al
cmpl -0x202c(%rbp), %ecx
movb %al, -0x202d(%rbp)
je 0x26628
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
leaq 0x68c0(%rip), %rdx      # 0x2ced7
callq 0x1a7b0
cmpl $0x0, %eax
setne %al
movb %al, -0x202d(%rbp)
movb -0x202d(%rbp), %al
movq -0x2028(%rbp), %rcx
leaq -0x2028(%rbp), %rdx
addq $0x18, %rdx
addq $0x2000, %rdx           # imm = 0x2000
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x202e(%rbp)
jb 0x2666d
leaq -0x2028(%rbp), %rdi
callq 0x1b680
cmpq $0x0, %rax
setne %al
movb %al, -0x202e(%rbp)
movb -0x202e(%rbp), %al
movl -0x202c(%rbp), %eax
movb %al, %cl
movq -0x2028(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x2028(%rbp)
movb %cl, (%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x265d2
leaq -0x2028(%rbp), %rdi
callq 0x1b640
movl $0x1, %eax
addq $0x2030, %rsp           # imm = 0x2030
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: str_dump
static int str_dump (lua_State *L) {
  luaL_Buffer b;
  luaL_checktype(L, 1, LUA_TFUNCTION);
  lua_settop(L, 1);
  luaL_buffinit(L,&b);
  if (lua_dump(L, writer, &b) != 0)
    luaL_error(L, "unable to dump given function");
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x1adb0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6ab0
movq -0x8(%rbp), %rdi
leaq -0x2020(%rbp), %rsi
callq 0x1b530
movq -0x8(%rbp), %rdi
leaq 0xcc5(%rip), %rsi       # 0x273d0
leaq -0x2020(%rbp), %rdx
callq 0x89b0
cmpl $0x0, %eax
je 0x2672e
movq -0x8(%rbp), %rdi
leaq 0x67be(%rip), %rsi      # 0x2cee5
movb $0x0, %al
callq 0x1a8b0
leaq -0x2020(%rbp), %rdi
callq 0x1b640
movl $0x1, %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: str_len
static int str_len (lua_State *L) {
  size_t l;
  luaL_checklstring(L, 1, &l);
  lua_pushinteger(L, l);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0x1abe0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7880
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: str_lower
static int str_lower (lua_State *L) {
  size_t l;
  size_t i;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  luaL_buffinit(L, &b);
  for (i=0; i<l; i++)
    luaL_addchar(&b, tolower(uchar(s[i])));
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2040, %rsp           # imm = 0x2040
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0x1abe0
movq %rax, -0x2038(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2030(%rbp), %rsi
callq 0x1b530
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x26ff1
movq -0x2030(%rbp), %rcx
leaq -0x2030(%rbp), %rdx
addq $0x18, %rdx
addq $0x2000, %rdx           # imm = 0x2000
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x2039(%rbp)
jb 0x26fad
leaq -0x2030(%rbp), %rdi
callq 0x1b680
cmpq $0x0, %rax
setne %al
movb %al, -0x2039(%rbp)
movb -0x2039(%rbp), %al
movq -0x2038(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x5350
movb %al, %cl
movq -0x2030(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x2030(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x26f60
leaq -0x2030(%rbp), %rdi
callq 0x1b640
movl $0x1, %eax
addq $0x2040, %rsp           # imm = 0x2040
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: str_rep
static int str_rep (lua_State *L) {
  size_t l;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  int n = luaL_checkint(L, 2);
  luaL_buffinit(L, &b);
  while (n-- > 0)
    luaL_addlstring(&b, s, l);
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2040, %rsp           # imm = 0x2040
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0x1abe0
movq %rax, -0x2030(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x1af30
movl %eax, -0x2034(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2028(%rbp), %rsi
callq 0x1b530
movl -0x2034(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x2034(%rbp)
cmpl $0x0, %eax
jle 0x270ab
movq -0x2030(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x2028(%rbp), %rdi
callq 0x1b570
jmp 0x2707c
leaq -0x2028(%rbp), %rdi
callq 0x1b640
movl $0x1, %eax
addq $0x2040, %rsp           # imm = 0x2040
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: str_reverse
static int str_reverse (lua_State *L) {
  size_t l;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  luaL_buffinit(L, &b);
  while (l--) luaL_addchar(&b, s[l]);
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2040, %rsp           # imm = 0x2040
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0x1abe0
movq %rax, -0x2030(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2028(%rbp), %rsi
callq 0x1b530
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
je 0x2718c
movq -0x2028(%rbp), %rcx
leaq -0x2028(%rbp), %rdx
addq $0x18, %rdx
addq $0x2000, %rdx           # imm = 0x2000
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x2031(%rbp)
jb 0x2715c
leaq -0x2028(%rbp), %rdi
callq 0x1b680
cmpq $0x0, %rax
setne %al
movb %al, -0x2031(%rbp)
movb -0x2031(%rbp), %al
movq -0x2030(%rbp), %rax
movq -0x10(%rbp), %rcx
movb (%rax,%rcx), %cl
movq -0x2028(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x2028(%rbp)
movb %cl, (%rax)
jmp 0x27108
leaq -0x2028(%rbp), %rdi
callq 0x1b640
movl $0x1, %eax
addq $0x2040, %rsp           # imm = 0x2040
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: str_sub
static int str_sub (lua_State *L) {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  ptrdiff_t start = posrelat(luaL_checkinteger(L, 2), l);
  ptrdiff_t end = posrelat(luaL_optinteger(L, 3, -1), l);
  if (start < 1) start = 1;
  if (end > (ptrdiff_t)l) end = (ptrdiff_t)l;
  if (start <= end)
    lua_pushlstring(L, s+start-1, end-start+1);
  else lua_pushliteral(L, "");
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0x1abe0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x1af30
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x27380
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
movq $-0x1, %rdx
callq 0x1af90
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x27380
movq %rax, -0x28(%rbp)
cmpq $0x1, -0x20(%rbp)
jge 0x27224
movq $0x1, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jle 0x27236
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jg 0x27263
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq -0x20(%rbp), %rsi
addq $-0x1, %rsi
movq -0x28(%rbp), %rdx
subq -0x20(%rbp), %rdx
addq $0x1, %rdx
callq 0x78d0
jmp 0x27277
movq -0x8(%rbp), %rdi
leaq 0x60a8(%rip), %rsi      # 0x2d316
xorl %eax, %eax
movl %eax, %edx
callq 0x78d0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: str_upper
static int str_upper (lua_State *L) {
  size_t l;
  size_t i;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  luaL_buffinit(L, &b);
  for (i=0; i<l; i++)
    luaL_addchar(&b, toupper(uchar(s[i])));
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2040, %rsp           # imm = 0x2040
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0x1abe0
movq %rax, -0x2038(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2030(%rbp), %rsi
callq 0x1b530
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x27361
movq -0x2030(%rbp), %rcx
leaq -0x2030(%rbp), %rdx
addq $0x18, %rdx
addq $0x2000, %rdx           # imm = 0x2000
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x2039(%rbp)
jb 0x2731d
leaq -0x2030(%rbp), %rdi
callq 0x1b680
cmpq $0x0, %rax
setne %al
movb %al, -0x2039(%rbp)
movb -0x2039(%rbp), %al
movq -0x2038(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x50c0
movb %al, %cl
movq -0x2030(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x2030(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x272d0
leaq -0x2030(%rbp), %rdi
callq 0x1b640
movl $0x1, %eax
addq $0x2040, %rsp           # imm = 0x2040
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: matchbalance
static const char *matchbalance (MatchState *ms, const char *s,
                                   const char *p) {
  if (*p == 0 || *(p+1) == 0)
    luaL_error(ms->L, "unbalanced pattern");
  if (*s != *p) return NULL;
  else {
    int b = *p;
    int e = *(p+1);
    int cont = 1;
    while (++s < ms->src_end) {
      if (*s == e) {
        if (--cont == 0) return s+1;
      }
      else if (*s == b) cont++;
    }
  }
  return NULL;  /* string ends out of balance */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x27dad
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x27dc3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x519f(%rip), %rsi      # 0x2cf5b
movb $0x0, %al
callq 0x1a8b0
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x27ddf
movq $0x0, -0x8(%rbp)
jmp 0x27e5e
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
movl %eax, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x27e54
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl -0x28(%rbp), %eax
jne 0x27e3b
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x27e39
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x27e5e
jmp 0x27e52
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0x27e50
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x27e52
jmp 0x27dfb
jmp 0x27e56
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: classend
static const char *classend (MatchState *ms, const char *p) {
  switch (*p++) {
    case L_ESC: {
      if (*p == '\0')
        luaL_error(ms->L, "malformed pattern (ends with " LUA_QL("%%") ")");
      return p+1;
    }
    case '[': {
      if (*p == '^') p++;
      do {  /* look for a `]' */
        if (*p == '\0')
          luaL_error(ms->L, "malformed pattern (missing " LUA_QL("]") ")");
        if (*(p++) == L_ESC && *p != '\0')
          p++;  /* skip escapes (e.g. `%]') */
      } while (*p != ']');
      return p+1;
    }
    default: {
      return p;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x25, %eax
je 0x27ea8
jmp 0x27e9b
movl -0x1c(%rbp), %eax
subl $0x5b, %eax
je 0x27edb
jmp 0x27f62
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x27eca
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x50ab(%rip), %rsi      # 0x2cf6e
movb $0x0, %al
callq 0x1a8b0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x27f6a
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5e, %eax
jne 0x27ef3
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x27ef5
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x27f17
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x5081(%rip), %rsi      # 0x2cf91
movb $0x0, %al
callq 0x1a8b0
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x27f46
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x27f46
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x27f48
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x27ef5
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x27f6a
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: singlematch
static int singlematch (int c, const char *p, const char *ep) {
  switch (*p) {
    case '.': return 1;  /* matches any char */
    case L_ESC: return match_class(c, uchar(*(p+1)));
    case '[': return matchbracketclass(c, p, ep-1);
    default:  return (uchar(*p) == c);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x25, %eax
je 0x28171
jmp 0x28154
movl -0x1c(%rbp), %eax
subl $0x2e, %eax
je 0x28168
jmp 0x2815e
movl -0x1c(%rbp), %eax
subl $0x5b, %eax
je 0x28186
jmp 0x2819f
movl $0x1, -0x4(%rbp)
jmp 0x281b4
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %esi
callq 0x283a0
movl %eax, -0x4(%rbp)
jmp 0x281b4
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $-0x1, %rdx
callq 0x27f80
movl %eax, -0x4(%rbp)
jmp 0x281b4
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl -0x8(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lstrlib.c
// Function: max_expand
static const char *max_expand (MatchState *ms, const char *s,
                                 const char *p, const char *ep) {
  ptrdiff_t i = 0;  /* counts maximum expand for item */
  while ((s+i)<ms->src_end && singlematch(uchar(*(s+i)), p, ep))
    i++;
  /* keeps trying to match with the maximum repetitions */
  while (i>=0) {
    const char *res = match(ms, (s+i), ep+1);
    if (res) return res;
    i--;  /* else didn't match; reduce 1 repetition to try again */
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rcx
addq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x39(%rbp)
jae 0x28219
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x28130
cmpl $0x0, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x28222
jmp 0x28230
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x281e0
jmp 0x28232
cmpq $0x0, -0x30(%rbp)
jl 0x28275
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
addq $0x1, %rdx
callq 0x277b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x28267
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2827d
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x28232
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)