LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lobject.c
// Function: luaO_ceillog2
int luaO_ceillog2 (unsigned int x) {
  static const lu_byte log_2[256] = {
    0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
    6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
  };
  int l = 0;
  x--;
  while (x >= 256) { l += 8; x >>= 8; }
  return l + log_2[x];
}

// Assembly:
movl %edi, -0x4(%rsp)
movl $0x0, -0x8(%rsp)
movl -0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rsp)
cmpl $0x100, -0x4(%rsp)      # imm = 0x100
jb 0x196b9
movl -0x8(%rsp), %eax
addl $0x8, %eax
movl %eax, -0x8(%rsp)
movl -0x4(%rsp), %eax
shrl $0x8, %eax
movl %eax, -0x4(%rsp)
jmp 0x19697
movl -0x8(%rsp), %eax
movl -0x4(%rsp), %ecx
movl %ecx, %edx
leaq 0x1cbd6(%rip), %rcx     # 0x362a0
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lobject.c
// Function: luaO_arith
lua_Number luaO_arith (int op, lua_Number v1, lua_Number v2) {
  switch (op) {
    case LUA_OPADD: return luai_numadd(NULL, v1, v2);
    case LUA_OPSUB: return luai_numsub(NULL, v1, v2);
    case LUA_OPMUL: return luai_nummul(NULL, v1, v2);
    case LUA_OPDIV: return luai_numdiv(NULL, v1, v2);
    case LUA_OPMOD: return luai_nummod(NULL, v1, v2);
    case LUA_OPPOW: return luai_numpow(NULL, v1, v2);
    case LUA_OPUNM: return luai_numunm(NULL, v1);
    default: lua_assert(0); return 0;
  }
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x2c(%rsp)
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movl 0x2c(%rsp), %eax
movq %rax, 0x10(%rsp)
subq $0x6, %rax
ja 0x19806
movq 0x10(%rsp), %rax
leaq 0x1cb5d(%rip), %rcx     # 0x36270
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd 0x20(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x1980f
movsd 0x20(%rsp), %xmm0
subsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x1980f
movsd 0x20(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x1980f
movsd 0x20(%rsp), %xmm0
divsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x1980f
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x20(%rsp), %xmm0
divsd 0x18(%rsp), %xmm0
callq 0x74e0
movsd 0x8(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x1980f
movsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x7140
movsd %xmm0, 0x30(%rsp)
jmp 0x1980f
movsd 0x20(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x1980f
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lobject.c
// Function: luaO_str2d
int luaO_str2d (const char *s, size_t len, lua_Number *result) {
  char *endptr;
  if (strpbrk(s, "nN"))  /* reject 'inf' and 'nan' */
    return 0;
  else if (strpbrk(s, "xX"))  /* hexa? */
    *result = lua_strx2number(s, &endptr);
  else
    *result = lua_str2number(s, &endptr);
  if (endptr == s) return 0;  /* nothing recognized */
  while (lisspace(cast_uchar(*endptr))) endptr++;
  return (endptr == s + len);  /* OK if no trailing characters */
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x1cb19(%rip), %rsi     # 0x363a8
callq 0x7420
cmpq $0x0, %rax
je 0x198a7
movl $0x0, 0x24(%rsp)
jmp 0x19950
movq 0x18(%rsp), %rdi
leaq 0x1caf8(%rip), %rsi     # 0x363ab
callq 0x7420
cmpq $0x0, %rax
je 0x198d6
movq 0x18(%rsp), %rdi
movq %rsp, %rsi
callq 0x19960
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax)
jmp 0x198ec
movq 0x18(%rsp), %rdi
movq %rsp, %rsi
callq 0x7110
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax)
jmp 0x198ee
movq (%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x19903
movl $0x0, 0x24(%rsp)
jmp 0x19950
jmp 0x19905
movq (%rsp), %rax
movzbl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x1de07(%rip), %rax     # 0x37720
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x19933
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x19905
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
addq 0x10(%rsp), %rcx
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lobject.c
// Function: readhexa
static lua_Number readhexa (const char **s, lua_Number r, int *count) {
  for (; lisxdigit(cast_uchar(**s)); (*s)++) {  /* read integer part */
    r = (r * cast_num(16.0)) + cast_num(luaO_hexavalue(cast_uchar(**s)));
    (*count)++;
  }
  return r;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x1d1b4(%rip), %rax     # 0x37720
movzbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x1a5d1
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %edi
callq 0x19820
movsd 0x8(%rsp), %xmm0
cvtsi2sd %eax, %xmm1
movsd 0x1bdfa(%rip), %xmm2    # 0x363a0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x1a554
movsd 0x18(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loslib.c
// Function: os_exit
static int os_exit (lua_State *L) {
  int status;
  if (lua_isboolean(L, 1))
    status = (lua_toboolean(L, 1) ? EXIT_SUCCESS : EXIT_FAILURE);
  else
    status = luaL_optint(L, 1, EXIT_SUCCESS);
  if (lua_toboolean(L, 2))
    lua_close(L);
  if (L) exit(status);  /* 'if' to avoid warnings for unreachable 'return' */
  return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x9350
cmpl $0x1, %eax
jne 0x1ab01
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x9a10
movl %eax, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0xc(%rsp)
jmp 0x1ab18
movq 0x10(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xcfe0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x9a10
cmpl $0x0, %eax
je 0x1ab36
movq 0x10(%rsp), %rdi
callq 0x202c0
cmpq $0x0, 0x10(%rsp)
je 0x1ab47
movl 0xc(%rsp), %edi
callq 0x7520
xorl %eax, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loslib.c
// Function: os_time
static int os_time (lua_State *L) {
  time_t t;
  if (lua_isnoneornil(L, 1))  /* called without args? */
    t = time(NULL);  /* get current time */
  else {
    struct tm ts;
    luaL_checktype(L, 1, LUA_TTABLE);
    lua_settop(L, 1);  /* make sure table is at the top */
    ts.tm_sec = getfield(L, "sec", 0);
    ts.tm_min = getfield(L, "min", 0);
    ts.tm_hour = getfield(L, "hour", 12);
    ts.tm_mday = getfield(L, "day", -1);
    ts.tm_mon = getfield(L, "month", -1) - 1;
    ts.tm_year = getfield(L, "year", -1) - 1900;
    ts.tm_isdst = getboolfield(L, "isdst");
    t = mktime(&ts);
  }
  if (t == (time_t)(-1))
    lua_pushnil(L);
  else
    lua_pushnumber(L, (lua_Number)t);
  return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0x9350
cmpl $0x0, %eax
jg 0x1ad20
xorl %eax, %eax
movl %eax, %edi
callq 0x7380
movq %rax, 0x38(%rsp)
jmp 0x1ae02
movq 0x40(%rsp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0xcdc0
movq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0x8e50
movq 0x40(%rsp), %rdi
leaq 0x1b80a(%rip), %rsi     # 0x36559
xorl %edx, %edx
callq 0x1b0d0
movl %eax, (%rsp)
movq 0x40(%rsp), %rdi
leaq 0x1b229(%rip), %rsi     # 0x35f8e
xorl %edx, %edx
callq 0x1b0d0
movl %eax, 0x4(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x1b7e1(%rip), %rsi     # 0x3655d
movl $0xc, %edx
callq 0x1b0d0
movl %eax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x1b7d8(%rip), %rsi     # 0x3656e
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1b0d0
movl %eax, 0xc(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x1b7b2(%rip), %rsi     # 0x36562
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1b0d0
subl $0x1, %eax
movl %eax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x1b79b(%rip), %rsi     # 0x36568
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1b0d0
subl $0x76c, %eax            # imm = 0x76C
movl %eax, 0x14(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x1b78b(%rip), %rsi     # 0x36577
callq 0x1b170
movl %eax, 0x20(%rsp)
movq %rsp, %rdi
callq 0x73f0
movq %rax, 0x38(%rsp)
cmpq $-0x1, 0x38(%rsp)
jne 0x1ae16
movq 0x40(%rsp), %rdi
callq 0x9df0
jmp 0x1ae27
movq 0x40(%rsp), %rdi
cvtsi2sdq 0x38(%rsp), %xmm0
callq 0x9e20
movl $0x1, %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loslib.c
// Function: checkoption
static const char *checkoption (lua_State *L, const char *conv, char *buff) {
  static const char *const options[] = LUA_STRFTIMEOPTIONS;
  unsigned int i;
  for (i = 0; i < sizeof(options)/sizeof(options[0]); i += 2) {
    if (*conv != '\0' && strchr(options[i], *conv) != NULL) {
      buff[1] = *conv;
      if (*options[i + 1] == '\0') {  /* one-char conversion specifier? */
        buff[2] = '\0';  /* end buffer */
        return conv + 1;
      }
      else if (*(conv + 1) != '\0' &&
               strchr(options[i + 1], *(conv + 1)) != NULL) {
        buff[2] = *(conv + 1);  /* valid two-char conversion specifier */
        buff[3] = '\0';  /* end buffer */
        return conv + 2;
      }
    }
  }
  luaL_argerror(L, 1,
    lua_pushfstring(L, "invalid conversion specifier '%%%s'", conv));
  return conv;  /* to avoid warnings */
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpq $0x6, %rax
jae 0x1b082
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1b070
movl 0x14(%rsp), %eax
movl %eax, %ecx
leaq 0x25609(%rip), %rax     # 0x405b0
movq (%rax,%rcx,8), %rdi
movq 0x20(%rsp), %rax
movsbl (%rax), %esi
callq 0x7190
cmpq $0x0, %rax
je 0x1b070
movq 0x20(%rsp), %rax
movb (%rax), %cl
movq 0x18(%rsp), %rax
movb %cl, 0x1(%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x255cd(%rip), %rax     # 0x405b0
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1b00b
movq 0x18(%rsp), %rax
movb $0x0, 0x2(%rax)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x1b0c0
movq 0x20(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x1b06c
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x25585(%rip), %rax     # 0x405b0
movq (%rax,%rcx,8), %rdi
movq 0x20(%rsp), %rax
movsbl 0x1(%rax), %esi
callq 0x7190
cmpq $0x0, %rax
je 0x1b06c
movq 0x20(%rsp), %rax
movb 0x1(%rax), %cl
movq 0x18(%rsp), %rax
movb %cl, 0x2(%rax)
movq 0x18(%rsp), %rax
movb $0x0, 0x3(%rax)
movq 0x20(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x30(%rsp)
jmp 0x1b0c0
jmp 0x1b06e
jmp 0x1b070
jmp 0x1b072
movl 0x14(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x1af7b
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0x1b51d(%rip), %rsi     # 0x365ba
movb $0x0, %al
callq 0xa0f0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x1, %esi
callq 0xc3a0
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loslib.c
// Function: getfield
static int getfield (lua_State *L, const char *key, int d) {
  int res, isnum;
  lua_getfield(L, -1, key);
  res = (int)lua_tointegerx(L, -1, &isnum);
  if (!isnum) {
    if (d < 0)
      return luaL_error(L, "field " LUA_QS " missing in date table", key);
    res = d;
  }
  lua_pop(L, 1);
  return res;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xa530
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x4(%rsp), %rdx
callq 0x98a0
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x1b142
cmpl $0x0, 0xc(%rsp)
jge 0x1b13a
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x1b4d0(%rip), %rsi     # 0x365fd
movb $0x0, %al
callq 0xc520
movl %eax, 0x24(%rsp)
jmp 0x1b159
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8e50
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loslib.c
// Function: getboolfield
static int getboolfield (lua_State *L, const char *key) {
  int res;
  lua_getfield(L, -1, key);
  res = lua_isnil(L, -1) ? -1 : lua_toboolean(L, -1);
  lua_pop(L, 1);
  return res;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xa530
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9350
cmpl $0x0, %eax
jne 0x1b1b0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, (%rsp)
jmp 0x1b1c2
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9a10
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8e50
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: luaY_parser
Closure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
                      Dyndata *dyd, const char *name, int firstchar) {
  LexState lexstate;
  FuncState funcstate;
  Closure *cl = luaF_newLclosure(L, 1);  /* create main closure */
  /* anchor closure (to avoid being collected) */
  setclLvalue(L, L->top, cl);
  incr_top(L);
  funcstate.f = cl->l.p = luaF_newproto(L);
  funcstate.f->source = luaS_new(L, name);  /* create and anchor TString */
  lexstate.buff = buff;
  lexstate.dyd = dyd;
  dyd->actvar.n = dyd->gt.n = dyd->label.n = 0;
  luaX_setinput(L, &lexstate, z, funcstate.f->source, firstchar);
  mainfunc(&lexstate, &funcstate);
  lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs);
  /* all scopes should be correctly finished */
  lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0);
  return cl;  /* it's on the stack too */
}

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq %rcx, 0xd8(%rsp)
movq %r8, 0xd0(%rsp)
movl %r9d, 0xcc(%rsp)
movq 0xf0(%rsp), %rdi
movl $0x1, %esi
callq 0x12380
movq %rax, 0x8(%rsp)
movq 0xf0(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movl $0x46, 0x8(%rax)
movq 0xf0(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
movq 0xf0(%rsp), %rax
movq 0x30(%rax), %rax
movq 0xf0(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
sarq $0x4, %rax
cmpq $0x0, %rax
jg 0x1b2af
movq 0xf0(%rsp), %rdi
xorl %esi, %esi
callq 0x10250
jmp 0x1b2b1
jmp 0x1b2b1
movq 0xf0(%rsp), %rdi
callq 0x127a0
movq 0x8(%rsp), %rcx
movq %rax, 0x18(%rcx)
movq %rax, 0x10(%rsp)
movq 0xf0(%rsp), %rdi
movq 0xd0(%rsp), %rsi
callq 0x209f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0xe0(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xd8(%rsp), %rax
movl $0x0, 0x28(%rax)
movq 0xd8(%rsp), %rax
movl $0x0, 0x18(%rax)
movq 0xd8(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rcx
movl 0xcc(%rsp), %r8d
leaq 0x58(%rsp), %rsi
callq 0x32510
leaq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1b390
movq 0x8(%rsp), %rax
addq $0xf8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: open_func
static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) {
  lua_State *L = ls->L;
  Proto *f;
  fs->prev = ls->fs;  /* linked list of funcstates */
  fs->ls = ls;
  ls->fs = fs;
  fs->pc = 0;
  fs->lasttarget = 0;
  fs->jpc = NO_JUMP;
  fs->freereg = 0;
  fs->nk = 0;
  fs->np = 0;
  fs->nups = 0;
  fs->nlocvars = 0;
  fs->nactvar = 0;
  fs->firstlocal = ls->dyd->actvar.n;
  fs->bl = NULL;
  f = fs->f;
  f->source = ls->source;
  f->maxstacksize = 2;  /* registers 0/1 are always valid */
  fs->h = luaH_new(L);
  /* anchor table of constants (to avoid being collected) */
  sethvalue2s(L, L->top, fs->h);
  incr_top(L);
  enterblock(fs, bl, 0);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x28(%rsp), %rax
movl $0x0, 0x28(%rax)
movq 0x28(%rsp), %rax
movl $0x0, 0x2c(%rax)
movq 0x28(%rsp), %rax
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rax
movb $0x0, 0x44(%rax)
movq 0x28(%rsp), %rax
movl $0x0, 0x34(%rax)
movq 0x28(%rsp), %rax
movl $0x0, 0x38(%rax)
movq 0x28(%rsp), %rax
movb $0x0, 0x43(%rax)
movq 0x28(%rsp), %rax
movw $0x0, 0x40(%rax)
movq 0x28(%rsp), %rax
movb $0x0, 0x42(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x3c(%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x58(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x10(%rsp), %rax
movb $0x2, 0x7a(%rax)
movq 0x18(%rsp), %rdi
callq 0x24970
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl $0x45, 0x8(%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
sarq $0x4, %rax
cmpq $0x0, %rax
jg 0x1b599
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x10250
jmp 0x1b59b
jmp 0x1b59b
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
xorl %edx, %edx
callq 0x1bb80
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: getunopr
static UnOpr getunopr (int op) {
  switch (op) {
    case TK_NOT: return OPR_NOT;
    case '-': return OPR_MINUS;
    case '#': return OPR_LEN;
    default: return OPR_NOUNOPR;
  }
}

// Assembly:
movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
movl %eax, -0xc(%rsp)
subl $0x23, %eax
je 0x1cf0f
jmp 0x1cee3
movl -0xc(%rsp), %eax
subl $0x2d, %eax
je 0x1cf05
jmp 0x1ceee
movl -0xc(%rsp), %eax
subl $0x10f, %eax            # imm = 0x10F
jne 0x1cf19
jmp 0x1cefb
movl $0x1, -0x4(%rsp)
jmp 0x1cf21
movl $0x0, -0x4(%rsp)
jmp 0x1cf21
movl $0x2, -0x4(%rsp)
jmp 0x1cf21
movl $0x3, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: getbinopr
static BinOpr getbinopr (int op) {
  switch (op) {
    case '+': return OPR_ADD;
    case '-': return OPR_SUB;
    case '*': return OPR_MUL;
    case '/': return OPR_DIV;
    case '%': return OPR_MOD;
    case '^': return OPR_POW;
    case TK_CONCAT: return OPR_CONCAT;
    case TK_NE: return OPR_NE;
    case TK_EQ: return OPR_EQ;
    case '<': return OPR_LT;
    case TK_LE: return OPR_LE;
    case '>': return OPR_GT;
    case TK_GE: return OPR_GE;
    case TK_AND: return OPR_AND;
    case TK_OR: return OPR_OR;
    default: return OPR_NOBINOPR;
  }
}

// Assembly:
movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
movl %eax, -0xc(%rsp)
subl $0x25, %eax
je 0x1d233
jmp 0x1d127
movl -0xc(%rsp), %eax
subl $0x2a, %eax
je 0x1d21c
jmp 0x1d136
movl -0xc(%rsp), %eax
subl $0x2b, %eax
je 0x1d202
jmp 0x1d145
movl -0xc(%rsp), %eax
subl $0x2d, %eax
je 0x1d20f
jmp 0x1d154
movl -0xc(%rsp), %eax
subl $0x2f, %eax
je 0x1d229
jmp 0x1d163
movl -0xc(%rsp), %eax
subl $0x3c, %eax
je 0x1d265
jmp 0x1d172
movl -0xc(%rsp), %eax
subl $0x3e, %eax
je 0x1d279
jmp 0x1d181
movl -0xc(%rsp), %eax
subl $0x5e, %eax
je 0x1d23d
jmp 0x1d190
movl -0xc(%rsp), %eax
subl $0x101, %eax            # imm = 0x101
je 0x1d28d
jmp 0x1d1a1
movl -0xc(%rsp), %eax
subl $0x110, %eax            # imm = 0x110
je 0x1d297
jmp 0x1d1b2
movl -0xc(%rsp), %eax
subl $0x117, %eax            # imm = 0x117
je 0x1d247
jmp 0x1d1c3
movl -0xc(%rsp), %eax
subl $0x119, %eax            # imm = 0x119
je 0x1d25b
jmp 0x1d1d4
movl -0xc(%rsp), %eax
subl $0x11a, %eax            # imm = 0x11A
je 0x1d283
jmp 0x1d1e5
movl -0xc(%rsp), %eax
subl $0x11b, %eax            # imm = 0x11B
je 0x1d26f
jmp 0x1d1f2
movl -0xc(%rsp), %eax
subl $0x11c, %eax            # imm = 0x11C
je 0x1d251
jmp 0x1d2a1
movl $0x0, -0x4(%rsp)
jmp 0x1d2a9
movl $0x1, -0x4(%rsp)
jmp 0x1d2a9
movl $0x2, -0x4(%rsp)
jmp 0x1d2a9
movl $0x3, -0x4(%rsp)
jmp 0x1d2a9
movl $0x4, -0x4(%rsp)
jmp 0x1d2a9
movl $0x5, -0x4(%rsp)
jmp 0x1d2a9
movl $0x6, -0x4(%rsp)
jmp 0x1d2a9
movl $0xa, -0x4(%rsp)
jmp 0x1d2a9
movl $0x7, -0x4(%rsp)
jmp 0x1d2a9
movl $0x8, -0x4(%rsp)
jmp 0x1d2a9
movl $0x9, -0x4(%rsp)
jmp 0x1d2a9
movl $0xb, -0x4(%rsp)
jmp 0x1d2a9
movl $0xc, -0x4(%rsp)
jmp 0x1d2a9
movl $0xd, -0x4(%rsp)
jmp 0x1d2a9
movl $0xe, -0x4(%rsp)
jmp 0x1d2a9
movl $0xf, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: singlevar
static void singlevar (LexState *ls, expdesc *var) {
  TString *varname = str_checkname(ls);
  FuncState *fs = ls->fs;
  if (singlevaraux(fs, varname, var, 1) == VVOID) {  /* global name? */
    expdesc key;
    singlevaraux(fs, ls->envn, var, 1);  /* get environment variable */
    lua_assert(var->k == VLOCAL || var->k == VUPVAL);
    codestring(ls, &key, varname);  /* key is variable name */
    luaK_indexed(fs, var, &key);  /* env[varname] */
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1c730
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl $0x1, %ecx
callq 0x1e480
cmpl $0x0, %eax
jne 0x1e47a
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x60(%rax), %rsi
movq 0x28(%rsp), %rdx
movl $0x1, %ecx
callq 0x1e480
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rdx
movq %rsp, %rsi
callq 0x1d2b0
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rsp, %rdx
callq 0x2f9c0
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: searchvar
static int searchvar (FuncState *fs, TString *n) {
  int i;
  for (i = cast_int(fs->nactvar) - 1; i >= 0; i--) {
    if (luaS_eqstr(n, getlocvar(fs, i)->varname))
      return i;
  }
  return -1;  /* not found */
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movzbl 0x42(%rax), %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0x1e5e6
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x1e0f0
movq (%rsp), %rdi
movq (%rax), %rsi
callq 0x20450
cmpl $0x0, %eax
je 0x1e5d7
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x1e5ee
jmp 0x1e5d9
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1e59e
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: searchupvalue
static int searchupvalue (FuncState *fs, TString *name) {
  int i;
  Upvaldesc *up = fs->f->upvalues;
  for (i = 0; i < fs->nups; i++) {
    if (luaS_eqstr(up[i].name, name)) return i;
  }
  return -1;  /* not found */
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
movzbl 0x43(%rcx), %ecx
cmpl %ecx, %eax
jge 0x1e6b2
movq (%rsp), %rax
movslq 0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x20450
cmpl $0x0, %eax
je 0x1e6a3
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x1e6ba
jmp 0x1e6a5
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1e666
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: undefgoto
static l_noret undefgoto (LexState *ls, Labeldesc *gt) {
  const char *msg = isreserved(gt->name)
                    ? "<%s> at line %d not inside a loop"
                    : "no visible label " LUA_QS " for <goto> at line %d";
  msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line);
  semerror(ls, msg);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movzbl 0x8(%rax), %ecx
xorl %eax, %eax
cmpl $0x4, %ecx
movb %al, 0xf(%rsp)
jne 0x1e95b
movq 0x18(%rsp), %rax
movq (%rax), %rax
movzbl 0xa(%rax), %eax
cmpl $0x0, %eax
setg %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %dl
leaq 0x17e68(%rip), %rax     # 0x367ce
leaq 0x17e3f(%rip), %rcx     # 0x367ac
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
movq (%rax), %rdx
addq $0x18, %rdx
movq 0x18(%rsp), %rax
movl 0xc(%rax), %ecx
movb $0x0, %al
callq 0x1a1b0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1ecd0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: findgotos
static void findgotos (LexState *ls, Labeldesc *lb) {
  Labellist *gl = &ls->dyd->gt;
  int i = ls->fs->bl->firstgoto;
  while (i < gl->n) {
    if (luaS_eqstr(gl->arr[i].name, lb->name))
      closegoto(ls, i, lb);
    else
      i++;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x20(%rax), %rax
movswl 0xa(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x1eb5e
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
callq 0x20450
cmpl $0x0, %eax
je 0x1eb51
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0x1eb70
jmp 0x1eb5c
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1eb05
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: closegoto
static void closegoto (LexState *ls, int g, Labeldesc *label) {
  int i;
  FuncState *fs = ls->fs;
  Labellist *gl = &ls->dyd->gt;
  Labeldesc *gt = &gl->arr[g];
  lua_assert(luaS_eqstr(gt->name, label->name));
  if (gt->nactvar < label->nactvar) {
    TString *vname = getlocvar(fs, gt->nactvar)->varname;
    const char *msg = luaO_pushfstring(ls->L,
      "<goto %s> at line %d jumps into the scope of local " LUA_QS,
      getstr(gt->name), gt->line, getstr(vname));
    semerror(ls, msg);
  }
  luaK_patchlist(fs, gt->pc, label->pc);
  /* remove goto from pending list */
  for (i = g; i < gl->n - 1; i++)
    gl->arr[i] = gl->arr[i + 1];
  gl->n--;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movslq 0x3c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl 0x10(%rax), %eax
movq 0x30(%rsp), %rcx
movzbl 0x10(%rcx), %ecx
cmpl %ecx, %eax
jge 0x1ec32
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl 0x10(%rax), %esi
callq 0x1e0f0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
addq $0x18, %rdx
movq 0x10(%rsp), %rax
movl 0xc(%rax), %ecx
movq 0x8(%rsp), %r8
addq $0x18, %r8
leaq 0x17b5b(%rip), %rsi     # 0x36774
movb $0x0, %al
callq 0x1a1b0
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
movq (%rsp), %rsi
callq 0x1ecd0
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x30(%rsp), %rax
movl 0x8(%rax), %edx
callq 0x2e420
movl 0x3c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movq 0x18(%rsp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1ecb7
movq 0x18(%rsp), %rax
movq (%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movl 0x2c(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1ec54
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: fornum
static void fornum (LexState *ls, TString *varname, int line) {
  /* fornum -> NAME = exp1,exp1[,exp1] forbody */
  FuncState *fs = ls->fs;
  int base = fs->freereg;
  new_localvarliteral(ls, "(for index)");
  new_localvarliteral(ls, "(for limit)");
  new_localvarliteral(ls, "(for step)");
  new_localvar(ls, varname);
  checknext(ls, '=');
  exp1(ls);  /* initial value */
  checknext(ls, ',');
  exp1(ls);  /* limit */
  if (testnext(ls, ','))
    exp1(ls);  /* optional step */
  else {  /* default step = 1 */
    luaK_codek(fs, fs->freereg, luaK_numberK(fs, 1));
    luaK_reserveregs(fs, 1);
  }
  forbody(ls, base, line, 1, 1);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl 0x44(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x17927(%rip), %rsi     # 0x36840
movl $0xb, %edx
callq 0x1dc50
movq 0x30(%rsp), %rdi
leaq 0x1791d(%rip), %rsi     # 0x3684c
movl $0xb, %edx
callq 0x1dc50
movq 0x30(%rsp), %rdi
leaq 0x17913(%rip), %rsi     # 0x36858
movl $0xa, %edx
callq 0x1dc50
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1dec0
movq 0x30(%rsp), %rdi
movl $0x3d, %esi
callq 0x1cba0
movq 0x30(%rsp), %rdi
callq 0x1f160
movq 0x30(%rsp), %rdi
movl $0x2c, %esi
callq 0x1cba0
movq 0x30(%rsp), %rdi
callq 0x1f160
movq 0x30(%rsp), %rdi
movl $0x2c, %esi
callq 0x1c4c0
cmpl $0x0, %eax
je 0x1efb0
movq 0x30(%rsp), %rdi
callq 0x1f160
jmp 0x1eff8
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movzbl 0x44(%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movsd 0x16f54(%rip), %xmm0    # 0x35f28
callq 0x2ebd0
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movl %eax, %edx
callq 0x2e7d0
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x2e8e0
movq 0x30(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x24(%rsp), %edx
movl $0x1, %r8d
movl %r8d, %ecx
callq 0x1f1a0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: checkrepeated
static void checkrepeated (FuncState *fs, Labellist *ll, TString *label) {
  int i;
  for (i = fs->bl->firstlabel; i < ll->n; i++) {
    if (luaS_eqstr(label, ll->arr[i].name)) {
      const char *msg = luaO_pushfstring(fs->ls->L,
                          "label " LUA_QS " already defined on line %d",
                          getstr(label), ll->arr[i].line);
      semerror(fs->ls, msg);
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movswl 0x8(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x1f51f
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x20450
cmpl $0x0, %eax
je 0x1f50d
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x38(%rax), %rdi
movq 0x10(%rsp), %rdx
addq $0x18, %rdx
movq 0x18(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
leaq 0x1739d(%rip), %rsi     # 0x3688d
movb $0x0, %al
callq 0x1a1b0
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq (%rsp), %rsi
callq 0x1ecd0
jmp 0x1f50f
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1f484
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: anchor_token
static void anchor_token (LexState *ls) {
  /* last token from outer function must be EOS */
  lua_assert(ls->fs != NULL || ls->t.token == TK_EOS);
  if (ls->t.token == TK_NAME || ls->t.token == TK_STRING) {
    TString *ts = ls->t.seminfo.ts;
    luaX_newstring(ls, getstr(ts), ts->tsv.len);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x120, 0x10(%rax)      # imm = 0x120
je 0x1f845
movq 0x10(%rsp), %rax
cmpl $0x121, 0x10(%rax)      # imm = 0x121
jne 0x1f86f
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x323f0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstate.c
// Function: luaE_extendCI
CallInfo *luaE_extendCI (lua_State *L) {
  CallInfo *ci = luaM_new(L, CallInfo);
  lua_assert(L->ci->next == NULL);
  L->ci->next = ci;
  ci->previous = L->ci;
  ci->next = NULL;
  return ci;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x50, %ecx
movq %rdx, %rsi
callq 0x18170
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstate.c
// Function: lua_newthread
LUA_API lua_State *lua_newthread (lua_State *L) {
  lua_State *L1;
  lua_lock(L);
  luaC_checkGC(L);
  L1 = &luaC_newobj(L, LUA_TTHREAD, sizeof(LX), NULL, offsetof(LX, l))->th;
  setthvalue(L, L->top, L1);
  api_incr_top(L);
  preinit_state(L1, G(L));
  L1->hookmask = L->hookmask;
  L1->basehookcount = L->basehookcount;
  L1->hook = L->hook;
  resethookcount(L1);
  luai_userstatethread(L, L1);
  stack_init(L1, L);  /* init stack */
  lua_unlock(L);
  return L1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x18(%rax)
jle 0x1f9b3
movq 0x10(%rsp), %rdi
callq 0x13f90
movq 0x10(%rsp), %rdi
movl $0x8, %esi
movl $0xd0, %edx
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x12f60
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movl $0x48, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x1fa80
movq 0x10(%rsp), %rax
movb 0x48(%rax), %cl
movq 0x8(%rsp), %rax
movb %cl, 0x48(%rax)
movq 0x10(%rsp), %rax
movl 0x4c(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4c(%rax)
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x8(%rsp), %rax
movl 0x4c(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x50(%rax)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1fb40
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstate.c
// Function: preinit_state
static void preinit_state (lua_State *L, global_State *g) {
  G(L) = g;
  L->stack = NULL;
  L->ci = NULL;
  L->stacksize = 0;
  L->errorJmp = NULL;
  L->nCcalls = 0;
  L->hook = NULL;
  L->hookmask = 0;
  L->basehookcount = 0;
  L->allowhook = 1;
  resethookcount(L);
  L->openupval = NULL;
  L->nny = 1;
  L->status = LUA_OK;
  L->errfunc = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x40(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x70(%rax)
movq -0x8(%rsp), %rax
movw $0x0, 0x46(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x58(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x48(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x4c(%rax)
movq -0x8(%rsp), %rax
movb $0x1, 0x49(%rax)
movq -0x8(%rsp), %rax
movl 0x4c(%rax), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x50(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x60(%rax)
movq -0x8(%rsp), %rax
movw $0x1, 0x44(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0xa(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x78(%rax)
retq
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstate.c
// Function: freestack
static void freestack (lua_State *L) {
  if (L->stack == NULL)
    return;  /* stack not completely built yet */
  L->ci = &L->base_ci;  /* free the entire 'ci' list */
  luaE_freeCI(L);
  luaM_freearray(L, L->stack, L->stacksize);  /* free stack array */
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x1fce2
jmp 0x1fd1f
movq (%rsp), %rcx
addq $0x80, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rdi
callq 0x1f920
movq (%rsp), %rdi
movq (%rsp), %rax
movq 0x38(%rax), %rsi
movq (%rsp), %rax
movslq 0x40(%rax), %rdx
shlq $0x4, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x18170
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstate.c
// Function: f_luaopen
static void f_luaopen (lua_State *L, void *ud) {
  global_State *g = G(L);
  UNUSED(ud);
  stack_init(L, L);  /* init stack */
  init_registry(L, g);
  luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
  luaT_init(L);
  luaX_init(L);
  /* pre-create memory-error message */
  g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
  luaS_fix(g->memerrmsg);  /* it should never be collected */
  g->gcrunning = 1;  /* allow gc */
  g->version = lua_version(NULL);
  luai_userstateopen(L);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1fb40
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x202f0
movq 0x10(%rsp), %rdi
movl $0x20, %esi
callq 0x20560
movq 0x10(%rsp), %rdi
callq 0x26450
movq 0x10(%rsp), %rdi
callq 0x321b0
movq 0x10(%rsp), %rdi
leaq 0x14eae(%rip), %rsi     # 0x35025
movl $0x11, %edx
callq 0x20780
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x118(%rax)
movq (%rsp), %rax
movq 0x118(%rax), %rax
movzbl 0x9(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x9(%rax)
movq (%rsp), %rax
movb $0x1, 0x57(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x8d80
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x110(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstate.c
// Function: init_registry
static void init_registry (lua_State *L, global_State *g) {
  TValue mt;
  /* create registry */
  Table *registry = luaH_new(L);
  sethvalue(L, &g->l_registry, registry);
  luaH_resize(L, registry, LUA_RIDX_LAST, 0);
  /* registry[LUA_RIDX_MAINTHREAD] = L */
  setthvalue(L, &mt, L);
  luaH_setint(L, registry, LUA_RIDX_MAINTHREAD, &mt);
  /* registry[LUA_RIDX_GLOBALS] = table of globals */
  sethvalue(L, &mt, luaH_new(L));
  luaH_setint(L, registry, LUA_RIDX_GLOBALS, &mt);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x24970
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movl $0x45, 0x8(%rax)
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x243b0
leaq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl $0x48, 0x8(%rax)
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
leaq 0x28(%rsp), %rcx
callq 0x247d0
leaq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x24970
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl $0x45, 0x8(%rax)
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x2, %edx
leaq 0x28(%rsp), %rcx
callq 0x247d0
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstring.c
// Function: luaS_eqlngstr
int luaS_eqlngstr (TString *a, TString *b) {
  size_t len = a->tsv.len;
  lua_assert(a->tsv.tt == LUA_TLNGSTR && b->tsv.tt == LUA_TLNGSTR);
  return (a == b) ||  /* same instance or... */
    ((len == b->tsv.len) &&  /* equal length and ... */
     (memcmp(getstr(a), getstr(b), len) == 0));  /* equal contents */
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movb $0x1, %al
cmpq 0x18(%rsp), %rcx
movb %al, 0xf(%rsp)
je 0x20442
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, 0xe(%rsp)
jne 0x2043a
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movq 0x18(%rsp), %rsi
addq $0x18, %rsi
movq 0x10(%rsp), %rdx
callq 0x7290
cmpl $0x0, %eax
sete %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstring.c
// Function: luaS_hash
unsigned int luaS_hash (const char *str, size_t l, unsigned int seed) {
  unsigned int h = seed ^ cast(unsigned int, l);
  size_t l1;
  size_t step = (l >> LUAI_HASHLIMIT) + 1;
  for (l1 = l; l1 >= step; l1 -= step)
    h = h ^ ((h<<5) + (h>>2) + cast_byte(str[l1 - 1]));
  return h;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x10(%rsp), %rcx
xorl %ecx, %eax
movl %eax, -0x18(%rsp)
movq -0x10(%rsp), %rax
shrq $0x5, %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x28(%rsp), %rax
jb 0x20557
movl -0x18(%rsp), %eax
movl -0x18(%rsp), %ecx
shll $0x5, %ecx
movl -0x18(%rsp), %edx
shrl $0x2, %edx
addl %edx, %ecx
movq -0x8(%rsp), %rdx
movq -0x20(%rsp), %rsi
subq $0x1, %rsi
movzbl (%rdx,%rsi), %edx
addl %edx, %ecx
xorl %ecx, %eax
movl %eax, -0x18(%rsp)
movq -0x28(%rsp), %rcx
movq -0x20(%rsp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rsp)
jmp 0x20509
movl -0x18(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstring.c
// Function: luaS_newlstr
TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
  if (l <= LUAI_MAXSHORTLEN)  /* short string? */
    return internshrstr(L, str, l);
  else {
    if (l + 1 > (MAX_SIZET - sizeof(TString))/sizeof(char))
      luaM_toobig(L);
    return createstrobj(L, str, l, LUA_TLNGSTR, G(L)->seed, NULL);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x28, 0x8(%rsp)
ja 0x207b6
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x20810
movq %rax, 0x20(%rsp)
jmp 0x207ff
movq 0x8(%rsp), %rax
addq $0x1, %rax
cmpq $-0x1b, %rax
jbe 0x207cf
movq 0x18(%rsp), %rdi
callq 0x18150
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x50(%rax), %r8d
movl $0x14, %ecx
xorl %eax, %eax
movl %eax, %r9d
callq 0x20940
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstring.c
// Function: internshrstr
static TString *internshrstr (lua_State *L, const char *str, size_t l) {
  GCObject *o;
  global_State *g = G(L);
  unsigned int h = luaS_hash(str, l, g->seed);
  for (o = g->strt.hash[lmod(h, g->strt.size)];
       o != NULL;
       o = gch(o)->next) {
    TString *ts = rawgco2ts(o);
    if (h == ts->tsv.hash &&
        l == ts->tsv.len &&
        (memcmp(str, getstr(ts), l * sizeof(char)) == 0)) {
      if (isdead(G(L), o))  /* string is dead (but was not collected yet)? */
        changewhite(o);  /* resurrect it */
      return ts;
    }
  }
  return newshrstr(L, str, l, h);  /* not found; create a new string */
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rax
movl 0x50(%rax), %edx
callq 0x204d0
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rdx
movl 0x3c(%rdx), %edx
subl $0x1, %edx
andl %edx, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x20919
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x20905
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x20905
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
movq 0x28(%rsp), %rdx
shlq $0x0, %rdx
callq 0x7290
cmpl $0x0, %eax
jne 0x20905
movq 0x20(%rsp), %rax
movzbl 0x9(%rax), %eax
xorl $0x3, %eax
movq 0x38(%rsp), %rcx
movq 0x18(%rcx), %rcx
movzbl 0x54(%rcx), %ecx
xorl $0x3, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x208f9
movq 0x20(%rsp), %rax
movzbl 0x9(%rax), %ecx
xorl $0x3, %ecx
movb %cl, 0x9(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x20936
jmp 0x20907
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x20872
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl 0x14(%rsp), %ecx
callq 0x20ac0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq