LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstring.c
// Function: createstrobj
static TString *createstrobj (lua_State *L, const char *str, size_t l,
                              int tag, unsigned int h, GCObject **list) {
  TString *ts;
  size_t totalsize;  /* total size of TString object */
  totalsize = sizeof(TString) + ((l + 1) * sizeof(char));
  ts = &luaC_newobj(L, tag, totalsize, list, 0)->ts;
  ts->tsv.len = l;
  ts->tsv.hash = h;
  ts->tsv.extra = 0;
  memcpy(ts+1, str, l*sizeof(char));
  ((char *)(ts+1))[l] = '\0';  /* ending 0 */
  return ts;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
shlq $0x0, %rax
addq $0x18, %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq (%rsp), %rdx
movq 0x10(%rsp), %rcx
xorl %r8d, %r8d
callq 0x12f60
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x18(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0xa(%rax)
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
shlq $0x0, %rdx
callq 0x7350
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movb $0x0, 0x18(%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstring.c
// Function: luaS_newudata
Udata *luaS_newudata (lua_State *L, size_t s, Table *e) {
  Udata *u;
  if (s > MAX_SIZET - sizeof(Udata))
    luaM_toobig(L);
  u = &luaC_newobj(L, LUA_TUSERDATA, sizeof(Udata) + s, NULL, 0)->u;
  u->uv.len = s;
  u->uv.metatable = NULL;
  u->uv.env = e;
  return u;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $-0x2b, 0x18(%rsp)
jbe 0x20a65
movq 0x20(%rsp), %rdi
callq 0x18150
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
addq $0x28, %rdx
movl $0x7, %esi
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x12f60
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%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: newshrstr
static TString *newshrstr (lua_State *L, const char *str, size_t l,
                                       unsigned int h) {
  GCObject **list;  /* (pointer to) list where it will be inserted */
  stringtable *tb = &G(L)->strt;
  TString *s;
  if (tb->nuse >= cast(lu_int32, tb->size) && tb->size <= MAX_INT/2)
    luaS_resize(L, tb->size*2);  /* too crowded */
  list = &tb->hash[lmod(h, tb->size)];
  s = createstrobj(L, str, l, LUA_TSHRSTR, h, list);
  tb->nuse++;
  return s;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
addq $0x30, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x20b1d
movq 0x8(%rsp), %rax
cmpl $0x3ffffffe, 0xc(%rax)  # imm = 0x3FFFFFFE
jg 0x20b1d
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0xc(%rax), %esi
shll %esi
callq 0x20560
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rdx
movl 0xc(%rdx), %edx
subl $0x1, %edx
andl %edx, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %r8d
movq 0x10(%rsp), %r9
movl $0x4, %ecx
callq 0x20940
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq (%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstrlib.c
// Function: str_byte
static int str_byte (lua_State *L) {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  size_t posi = posrelat(luaL_optinteger(L, 2, 1), l);
  size_t pose = posrelat(luaL_optinteger(L, 3, posi), l);
  int n, i;
  if (posi < 1) posi = 1;
  if (pose > l) pose = l;
  if (posi > pose) return 0;  /* empty interval; return no values */
  n = (int)(pose -  posi + 1);
  if (posi + n <= pose)  /* (size_t -> int) overflow? */
    return 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x20(%rsp), %rdx
callq 0xcd00
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0xcfe0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x21f60
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl $0x3, %esi
callq 0xcfe0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x21f60
movq %rax, 0x8(%rsp)
cmpq $0x1, 0x10(%rsp)
jae 0x20cdf
movq $0x1, 0x10(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jbe 0x20cf5
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jbe 0x20d0e
movl $0x0, 0x34(%rsp)
jmp 0x20daa
movq 0x8(%rsp), %rax
subq 0x10(%rsp), %rax
addq $0x1, %rax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
addq %rcx, %rax
cmpq 0x8(%rsp), %rax
ja 0x20d4d
movq 0x28(%rsp), %rdi
leaq 0x15db0(%rip), %rsi     # 0x36af0
movb $0x0, %al
callq 0xc520
movl %eax, 0x34(%rsp)
jmp 0x20daa
movq 0x28(%rsp), %rdi
movl 0x4(%rsp), %esi
leaq 0x15d93(%rip), %rdx     # 0x36af0
callq 0xcd50
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0x20da2
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movslq (%rsp), %rdx
addq %rdx, %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %esi
callq 0x9e70
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x20d69
movl 0x4(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
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/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;
  char *p = luaL_buffinitsize(L, &b, n);
  for (i=1; i<=n; i++) {
    int c = luaL_checkint(L, i);
    luaL_argcheck(L, uchar(c) == c, i, "value out of range");
    p[i - 1] = uchar(c);
  }
  luaL_pushresultsize(&b, n);
  return 1;
}

// Assembly:
subq $0x2048, %rsp           # imm = 0x2048
movq %rdi, 0x2040(%rsp)
movq 0x2040(%rsp), %rdi
callq 0x8e20
movl %eax, 0x203c(%rsp)
movq 0x2040(%rsp), %rdi
movslq 0x203c(%rsp), %rdx
leaq 0x18(%rsp), %rsi
callq 0xd3e0
movq %rax, 0x10(%rsp)
movl $0x1, 0x2038(%rsp)
movl 0x2038(%rsp), %eax
cmpl 0x203c(%rsp), %eax
jg 0x20ea6
movq 0x2040(%rsp), %rdi
movl 0x2038(%rsp), %esi
callq 0xcf40
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movzbl %al, %ecx
movb $0x1, %al
cmpl 0xc(%rsp), %ecx
movb %al, 0xb(%rsp)
je 0x20e71
movq 0x2040(%rsp), %rdi
movl 0x2038(%rsp), %esi
leaq 0x15ca4(%rip), %rdx     # 0x36b06
callq 0xc3a0
cmpl $0x0, %eax
setne %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
movl 0xc(%rsp), %eax
movb %al, %dl
movq 0x10(%rsp), %rax
movl 0x2038(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl 0x2038(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2038(%rsp)
jmp 0x20e0d
movslq 0x203c(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0xd2c0
movl $0x1, %eax
addq $0x2048, %rsp           # imm = 0x2048
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/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)
    return luaL_error(L, "unable to dump given function");
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
subq $0x2038, %rsp           # imm = 0x2038
movq %rdi, 0x2028(%rsp)
movq 0x2028(%rsp), %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0xcdc0
movq 0x2028(%rsp), %rdi
movl $0x1, %esi
callq 0x8e50
movq 0x2028(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xd390
movq 0x2028(%rsp), %rdi
leaq 0x1097(%rip), %rsi      # 0x21fc0
leaq 0x8(%rsp), %rdx
callq 0xb560
cmpl $0x0, %eax
je 0x20f57
movq 0x2028(%rsp), %rdi
leaq 0x15bd2(%rip), %rsi     # 0x36b19
movb $0x0, %al
callq 0xc520
movl %eax, 0x2034(%rsp)
jmp 0x20f6c
leaq 0x8(%rsp), %rdi
callq 0xd260
movl $0x1, 0x2034(%rsp)
movl 0x2034(%rsp), %eax
addq $0x2038, %rsp           # imm = 0x2038
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstrlib.c
// Function: gmatch
static int gmatch (lua_State *L) {
  luaL_checkstring(L, 1);
  luaL_checkstring(L, 2);
  lua_settop(L, 2);
  lua_pushinteger(L, 0);
  lua_pushcclosure(L, gmatch_aux, 3);
  return 1;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xcd00
movq (%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xcd00
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x8e50
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9e70
movq (%rsp), %rdi
leaq 0x2531(%rip), %rsi      # 0x23b40
movl $0x3, %edx
callq 0xa1e0
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstrlib.c
// Function: str_rep
static int str_rep (lua_State *L) {
  size_t l, lsep;
  const char *s = luaL_checklstring(L, 1, &l);
  int n = luaL_checkint(L, 2);
  const char *sep = luaL_optlstring(L, 3, "", &lsep);
  if (n <= 0) lua_pushliteral(L, "");
  else if (l + lsep < l || l + lsep >= MAXSIZE / n)  /* may overflow? */
    return luaL_error(L, "resulting string too large");
  else {
    size_t totallen = n * l + (n - 1) * lsep;
    luaL_Buffer b;
    char *p = luaL_buffinitsize(L, &b, totallen);
    while (n-- > 1) {  /* first n-1 copies (followed by separator) */
      memcpy(p, s, l * sizeof(char)); p += l;
      if (lsep > 0) {  /* avoid empty 'memcpy' (may be expensive) */
        memcpy(p, sep, lsep * sizeof(char)); p += lsep;
      }
    }
    memcpy(p, s, l * sizeof(char));  /* last copy (not followed by separator) */
    luaL_pushresultsize(&b, totallen);
  }
  return 1;
}

// Assembly:
subq $0x2078, %rsp           # imm = 0x2078
movq %rdi, 0x2068(%rsp)
movq 0x2068(%rsp), %rdi
movl $0x1, %esi
leaq 0x2060(%rsp), %rdx
callq 0xcd00
movq %rax, 0x2050(%rsp)
movq 0x2068(%rsp), %rdi
movl $0x2, %esi
callq 0xcf40
movl %eax, 0x204c(%rsp)
movq 0x2068(%rsp), %rdi
movl $0x3, %esi
leaq 0x14729(%rip), %rdx     # 0x36227
leaq 0x2058(%rsp), %rcx
callq 0xcc70
movq %rax, 0x2040(%rsp)
cmpl $0x0, 0x204c(%rsp)
jg 0x21b3a
movq 0x2068(%rsp), %rdi
leaq 0x146fb(%rip), %rsi     # 0x36227
xorl %eax, %eax
movl %eax, %edx
callq 0x9f40
jmp 0x21cba
movq 0x2060(%rsp), %rax
addq 0x2058(%rsp), %rax
cmpq 0x2060(%rsp), %rax
jb 0x21b8d
movq 0x2060(%rsp), %rax
addq 0x2058(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq 0x204c(%rsp), %rcx
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x21baf
movq 0x2068(%rsp), %rdi
leaq 0x151f6(%rip), %rsi     # 0x36d92
movb $0x0, %al
callq 0xc520
movl %eax, 0x2074(%rsp)
jmp 0x21cc5
movslq 0x204c(%rsp), %rax
imulq 0x2060(%rsp), %rax
movl 0x204c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq 0x2058(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x2038(%rsp)
movq 0x2068(%rsp), %rdi
movq 0x2038(%rsp), %rdx
leaq 0x18(%rsp), %rsi
callq 0xd3e0
movq %rax, 0x10(%rsp)
movl 0x204c(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x204c(%rsp)
cmpl $0x1, %eax
jle 0x21c88
movq 0x10(%rsp), %rdi
movq 0x2050(%rsp), %rsi
movq 0x2060(%rsp), %rdx
shlq $0x0, %rdx
callq 0x7350
movq 0x2060(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x2058(%rsp)
jbe 0x21c83
movq 0x10(%rsp), %rdi
movq 0x2040(%rsp), %rsi
movq 0x2058(%rsp), %rdx
shlq $0x0, %rdx
callq 0x7350
movq 0x2058(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x21c00
movq 0x10(%rsp), %rdi
movq 0x2050(%rsp), %rsi
movq 0x2060(%rsp), %rdx
shlq $0x0, %rdx
callq 0x7350
movq 0x2038(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0xd2c0
jmp 0x21cba
movl $0x1, 0x2074(%rsp)
movl 0x2074(%rsp), %eax
addq $0x2078, %rsp           # imm = 0x2078
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstrlib.c
// Function: str_sub
static int str_sub (lua_State *L) {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  size_t start = posrelat(luaL_checkinteger(L, 2), l);
  size_t end = posrelat(luaL_optinteger(L, 3, -1), l);
  if (start < 1) start = 1;
  if (end > l) end = l;
  if (start <= end)
    lua_pushlstring(L, s + start - 1, end - start + 1);
  else lua_pushliteral(L, "");
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
callq 0xcd00
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0xcf40
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x21f60
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
movq $-0x1, %rdx
callq 0xcfe0
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x21f60
movq %rax, (%rsp)
cmpq $0x1, 0x8(%rsp)
jae 0x21e2b
movq $0x1, 0x8(%rsp)
movq (%rsp), %rax
cmpq 0x18(%rsp), %rax
jbe 0x21e3f
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
ja 0x21e71
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq 0x8(%rsp), %rsi
addq $-0x1, %rsi
movq (%rsp), %rdx
subq 0x8(%rsp), %rdx
addq $0x1, %rdx
callq 0x9f40
jmp 0x21e86
movq 0x20(%rsp), %rdi
leaq 0x143aa(%rip), %rsi     # 0x36227
xorl %eax, %eax
movl %eax, %edx
callq 0x9f40
movl $0x1, %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstrlib.c
// Function: matchbalance
static const char *matchbalance (MatchState *ms, const char *s,
                                   const char *p) {
  if (p >= ms->p_end - 1)
    luaL_error(ms->L, "malformed pattern "
                      "(missing arguments to " LUA_QL("%%b") ")");
  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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x18(%rcx), %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
jb 0x22bc1
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x13fe9(%rip), %rsi     # 0x36ba3
movb $0x0, %al
callq 0xc520
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
movq 0x18(%rsp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x22be3
movq $0x0, 0x30(%rsp)
jmp 0x22c75
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movsbl 0x1(%rax), %eax
movl %eax, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x22c6a
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl 0x10(%rsp), %eax
jne 0x22c4d
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
jne 0x22c4b
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x22c75
jmp 0x22c68
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl 0x14(%rsp), %eax
jne 0x22c66
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x22c68
jmp 0x22c04
jmp 0x22c6c
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstrlib.c
// Function: push_onecapture
static void push_onecapture (MatchState *ms, int i, const char *s,
                                                    const char *e) {
  if (i >= ms->level) {
    if (i == 0)  /* ms->level == 0, too */
      lua_pushlstring(ms->L, s, e - s);  /* add whole match */
    else
      luaL_error(ms->L, "invalid capture index");
  }
  else {
    ptrdiff_t l = ms->capture[i].len;
    if (l == CAP_UNFINISHED) luaL_error(ms->L, "unfinished capture");
    if (l == CAP_POSITION)
      lua_pushinteger(ms->L, ms->capture[i].init - ms->src_init + 1);
    else
      lua_pushlstring(ms->L, ms->capture[i].init, l);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jl 0x234fa
cmpl $0x0, 0x1c(%rsp)
jne 0x234de
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
subq %rax, %rdx
callq 0x9f40
jmp 0x234f5
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x13742(%rip), %rsi     # 0x36c30
movb $0x0, %al
callq 0xc520
jmp 0x235a0
movq 0x20(%rsp), %rax
addq $0x30, %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $-0x1, (%rsp)
jne 0x23535
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x13718(%rip), %rsi     # 0x36c46
movb $0x0, %al
callq 0xc520
cmpq $-0x2, (%rsp)
jne 0x23574
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x20(%rsp), %rax
addq $0x30, %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
subq %rax, %rsi
addq $0x1, %rsi
callq 0x9e70
jmp 0x2359e
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x20(%rsp), %rax
addq $0x30, %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq (%rsp), %rdx
callq 0x9f40
jmp 0x235a0
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/lstrlib.c
// Function: gmatch_aux
static int gmatch_aux (lua_State *L) {
  MatchState ms;
  size_t ls, lp;
  const char *s = lua_tolstring(L, lua_upvalueindex(1), &ls);
  const char *p = lua_tolstring(L, lua_upvalueindex(2), &lp);
  const char *src;
  ms.L = L;
  ms.matchdepth = MAXCCALLS;
  ms.src_init = s;
  ms.src_end = s+ls;
  ms.p_end = p + lp;
  for (src = s + (size_t)lua_tointeger(L, lua_upvalueindex(3));
       src <= ms.src_end;
       src++) {
    const char *e;
    ms.level = 0;
    lua_assert(ms.matchdepth == MAXCCALLS);
    if ((e = match(&ms, src, p)) != NULL) {
      lua_Integer newstart = e-s;
      if (e == src) newstart++;  /* empty match? go at least one position */
      lua_pushinteger(L, newstart);
      lua_replace(L, lua_upvalueindex(3));
      return push_captures(&ms, src, e);
    }
  }
  return 0;  /* not found */
}

// Assembly:
subq $0x288, %rsp            # imm = 0x288
movq %rdi, 0x278(%rsp)
movq 0x278(%rsp), %rdi
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
leaq 0x40(%rsp), %rdx
callq 0x9a80
movq %rax, 0x30(%rsp)
movq 0x278(%rsp), %rdi
movl $0xfff0b9d6, %esi       # imm = 0xFFF0B9D6
leaq 0x38(%rsp), %rdx
callq 0x9a80
movq %rax, 0x28(%rsp)
movq 0x278(%rsp), %rax
movq %rax, 0x68(%rsp)
movl $0xc8, 0x48(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x30(%rsp), %rax
addq 0x40(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x28(%rsp), %rax
addq 0x38(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x278(%rsp), %rdi
movl $0xfff0b9d5, %esi       # imm = 0xFFF0B9D5
xorl %eax, %eax
movl %eax, %edx
callq 0x98a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x58(%rsp), %rax
ja 0x23cad
movl $0x0, 0x70(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x48(%rsp), %rdi
callq 0x22530
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x23c98
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jne 0x23c57
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x278(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x9e70
movq 0x278(%rsp), %rdi
movl $0xfff0b9d5, %esi       # imm = 0xFFF0B9D5
callq 0x9190
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x48(%rsp), %rdi
callq 0x22970
movl %eax, 0x284(%rsp)
jmp 0x23cb8
jmp 0x23c9a
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x23bf4
movl $0x0, 0x284(%rsp)
movl 0x284(%rsp), %eax
addq $0x288, %rsp            # imm = 0x288
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ltable.c
// Function: luaH_next
int luaH_next (lua_State *L, Table *t, StkId key) {
  int i = findindex(L, t, key);  /* find original element */
  for (i++; i < t->sizearray; i++) {  /* try first array part */
    if (!ttisnil(&t->array[i])) {  /* a non-nil value? */
      setnvalue(key, cast_num(i+1));
      setobj2s(L, key+1, &t->array[i]);
      return 1;
    }
  }
  for (i -= t->sizearray; i < sizenode(t); i++) {  /* then hash part */
    if (!ttisnil(gval(gnode(t, i)))) {  /* a non-nil value? */
      setobj2s(L, key, gkey(gnode(t, i)));
      setobj2s(L, key+1, gval(gnode(t, i)));
      return 1;
    }
  }
  return 0;  /* no more elements */
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x24270
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
movq 0x50(%rsp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x24164
movq 0x50(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x44(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0x24152
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
movq 0x38(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x38(%rsp), %rax
movl $0x3, 0x8(%rax)
movq 0x50(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x44(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x8(%rax)
movl $0x1, 0x64(%rsp)
jmp 0x24267
jmp 0x24154
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x240a6
movq 0x50(%rsp), %rax
movl 0x38(%rax), %ecx
movl 0x44(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
movq 0x50(%rsp), %rcx
movzbl 0xb(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
jge 0x2425f
movq 0x50(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x44(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0x2424d
movq 0x50(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x44(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
addq $0x10, %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x50(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x44(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movl $0x1, 0x64(%rsp)
jmp 0x24267
jmp 0x2424f
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x24176
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ltable.c
// Function: findindex
static int findindex (lua_State *L, Table *t, StkId key) {
  int i;
  if (ttisnil(key)) return -1;  /* first iteration */
  i = arrayindex(key);
  if (0 < i && i <= t->sizearray)  /* is `key' inside array part? */
    return i-1;  /* yes; that's the index (corrected to C) */
  else {
    Node *n = mainposition(t, key);
    for (;;) {  /* check whether `key' is somewhere in the chain */
      /* key may be dead already, but it is ok to use it in `next' */
      if (luaV_rawequalobj(gkey(n), key) ||
            (ttisdeadkey(gkey(n)) && iscollectable(key) &&
             deadvalue(gkey(n)) == gcvalue(key))) {
        i = cast_int(n - gnode(t, 0));  /* key index in hash table */
        /* hash elements are numbered after array ones */
        return i + t->sizearray;
      }
      else n = gnext(n);
      if (n == NULL)
        luaG_runerror(L, "invalid key to " LUA_QL("next"));  /* key not found */
    }
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x2429b
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x2439e
movq 0x18(%rsp), %rdi
callq 0x25580
movl %eax, 0x14(%rsp)
xorl %eax, %eax
cmpl 0x14(%rsp), %eax
jge 0x242cf
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x38(%rcx), %eax
jg 0x242cf
movl 0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x2439e
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x24ca0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x24311
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
movq 0x18(%rsp), %rdx
xorl %eax, %eax
movl %eax, %edi
callq 0x27e50
cmpl $0x0, %eax
jne 0x2433f
movq 0x8(%rsp), %rax
cmpl $0xb, 0x18(%rax)
jne 0x24370
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x24370
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
jne 0x24370
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movl $0x28, %ecx
cqto
idivq %rcx
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
addl 0x38(%rcx), %eax
movl %eax, 0x34(%rsp)
jmp 0x2439e
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x24399
movq 0x28(%rsp), %rdi
leaq 0x12ac4(%rip), %rsi     # 0x36e56
movb $0x0, %al
callq 0xf360
jmp 0x242e3
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ltable.c
// Function: setarrayvector
static void setarrayvector (lua_State *L, Table *t, int size) {
  int i;
  luaM_reallocvector(L, t->array, t->sizearray, size, TValue);
  for (i=t->sizearray; i<size; i++)
     setnilvalue(&t->array[i]);
  t->sizearray = size;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
cltq
movabsq $0xfffffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFFFF
cmpq %rcx, %rax
jbe 0x245f4
movq 0x10(%rsp), %rdi
callq 0x18150
jmp 0x245f6
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x8(%rsp), %rax
movslq 0x38(%rax), %rdx
shlq $0x4, %rdx
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
callq 0x18170
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0x24665
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movslq (%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x24636
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x38(%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/ltable.c
// Function: setnodevector
static void setnodevector (lua_State *L, Table *t, int size) {
  int lsize;
  if (size == 0) {  /* no elements to hash part? */
    t->node = cast(Node *, dummynode);  /* use common `dummynode' */
    lsize = 0;
  }
  else {
    int i;
    lsize = luaO_ceillog2(size);
    if (lsize > MAXBITS)
      luaG_runerror(L, "table overflow");
    size = twoto(lsize);
    t->node = luaM_newvector(L, size, Node);
    for (i=0; i<size; i++) {
      Node *n = gnode(t, i);
      gnext(n) = NULL;
      setnilvalue(gkey(n));
      setnilvalue(gval(n));
    }
  }
  t->lsizenode = cast_byte(lsize);
  t->lastfree = gnode(t, size);  /* all positions are free */
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x246b6
movq 0x18(%rsp), %rax
leaq 0x12763(%rip), %rcx     # 0x36e08
movq %rcx, 0x20(%rax)
movl $0x0, 0x10(%rsp)
jmp 0x24792
movl 0x14(%rsp), %edi
callq 0x19680
movl %eax, 0x10(%rsp)
cmpl $0x1e, 0x10(%rsp)
jle 0x246dd
movq 0x20(%rsp), %rdi
leaq 0x12796(%rip), %rsi     # 0x36e6c
movb $0x0, %al
callq 0xf360
movl 0x10(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
cltq
movabsq $0x666666666666666, %rcx # imm = 0x666666666666666
cmpq %rcx, %rax
jbe 0x2470e
movq 0x20(%rsp), %rdi
callq 0x18150
jmp 0x24710
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rax
imulq $0x28, %rax, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x18170
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x24790
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0xc(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movq (%rsp), %rax
movl $0x0, 0x18(%rax)
movq (%rsp), %rax
movl $0x0, 0x8(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2473e
jmp 0x24792
movl 0x10(%rsp), %eax
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, 0xb(%rax)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rcx
movslq 0x14(%rsp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rax)
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/ltable.c
// Function: luaH_setint
void luaH_setint (lua_State *L, Table *t, int key, TValue *value) {
  const TValue *p = luaH_getint(t, key);
  TValue *cell;
  if (p != luaO_nilobject)
    cell = cast(TValue *, p);
  else {
    TValue k;
    setnvalue(&k, cast_num(key));
    cell = luaH_newkey(L, t, &k);
  }
  setobj2t(L, cell, value);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0x25070
movq %rax, 0x30(%rsp)
leaq 0x11a8f(%rip), %rax     # 0x36290
cmpq %rax, 0x30(%rsp)
je 0x24814
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x24852
leaq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cvtsi2sdl 0x44(%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x10(%rsp), %rax
movl $0x3, 0x8(%rax)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x24a80
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ltable.c
// Function: luaH_new
Table *luaH_new (lua_State *L) {
  Table *t = &luaC_newobj(L, LUA_TTABLE, sizeof(Table), NULL, 0)->h;
  t->metatable = NULL;
  t->flags = cast_byte(~0);
  t->array = NULL;
  t->sizearray = 0;
  setnodevector(L, t, 0);
  return t;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x5, %esi
movl $0x40, %edx
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x12f60
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movb $-0x1, 0xa(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x38(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x24680
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/ltable.c
// Function: rehash
static void rehash (lua_State *L, Table *t, const TValue *ek) {
  int nasize, na;
  int nums[MAXBITS+1];  /* nums[i] = number of keys with 2^(i-1) < k <= 2^i */
  int i;
  int totaluse;
  for (i=0; i<=MAXBITS; i++) nums[i] = 0;  /* reset counts */
  nasize = numusearray(t, nums);  /* count keys in array part */
  totaluse = nasize;  /* all those keys are integer keys */
  totaluse += numusehash(t, nums, &nasize);  /* count keys in hash part */
  /* count extra key */
  nasize += countint(ek, nums);
  totaluse++;
  /* compute new size for array part */
  na = computesizes(nums, &nasize);
  /* resize the table to new computed sizes */
  luaH_resize(L, t, nasize, totaluse - na);
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x1e, 0xc(%rsp)
jg 0x24fa8
movslq 0xc(%rsp), %rax
movl $0x0, 0x10(%rsp,%rax,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x24f87
movq 0xa8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x255f0
movl %eax, 0x9c(%rsp)
movl 0x9c(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0xa8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x9c(%rsp), %rdx
callq 0x256f0
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0xa0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x257a0
addl 0x9c(%rsp), %eax
movl %eax, 0x9c(%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x9c(%rsp), %rsi
callq 0x25810
movl %eax, 0x98(%rsp)
movq 0xb0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
movl 0x9c(%rsp), %edx
movl 0x8(%rsp), %ecx
subl 0x98(%rsp), %ecx
callq 0x243b0
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ltable.c
// Function: luaH_getint
const TValue *luaH_getint (Table *t, int key) {
  /* (1 <= key && key <= t->sizearray) */
  if (cast(unsigned int, key-1) < cast(unsigned int, t->sizearray))
    return &t->array[key-1];
  else {
    lua_Number nk = cast_num(key);
    Node *n = hashnum(t, nk);
    do {  /* check whether `key' is somewhere in the chain */
      if (ttisnumber(gkey(n)) && luai_numeq(nvalue(gkey(n)), nk))
        return gval(n);  /* that's it */
      else n = gnext(n);
    } while (n);
    return luaO_nilobject;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl 0x14(%rsp), %eax
subl $0x1, %eax
movq 0x18(%rsp), %rcx
cmpl 0x38(%rcx), %eax
jae 0x250af
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x25118
cvtsi2sdl 0x14(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x25130
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x3, 0x18(%rax)
jne 0x250f7
movq (%rsp), %rax
movsd 0x10(%rax), %xmm0
ucomisd 0x8(%rsp), %xmm0
jne 0x250f7
jp 0x250f7
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x25118
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, (%rsp)
jmp 0x25105
cmpq $0x0, (%rsp)
jne 0x250cf
leaq 0x1117d(%rip), %rax     # 0x36290
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
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/ltable.c
// Function: hashnum
static Node *hashnum (const Table *t, lua_Number n) {
  int i;
  luai_hashnum(i, n);
  if (i < 0) {
    if (cast(unsigned int, i) == 0u - i)  /* use unsigned to avoid overflows */
      i = 0;  /* handle INT_MIN */
    i = -i;  /* must be a positive value */
  }
  return hashmod(t, i);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movsd 0x10de5(%rip), %xmm0    # 0x35f28
addsd -0x10(%rsp), %xmm0
movsd %xmm0, -0x20(%rsp)
movl -0x20(%rsp), %eax
movl %eax, -0x14(%rsp)
movl -0x1c(%rsp), %eax
addl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
cmpl $0x0, -0x14(%rsp)
jge 0x2518a
movl -0x14(%rsp), %eax
xorl %ecx, %ecx
subl -0x14(%rsp), %ecx
cmpl %ecx, %eax
jne 0x25180
movl $0x0, -0x14(%rsp)
xorl %eax, %eax
subl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rsp)
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
movzbl 0xb(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
orl $0x1, %ecx
cltd
idivl %ecx
movq -0x28(%rsp), %rax
movslq %edx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ltable.c
// Function: luaH_getstr
const TValue *luaH_getstr (Table *t, TString *key) {
  Node *n = hashstr(t, key);
  lua_assert(key->tsv.tt == LUA_TSHRSTR);
  do {  /* check whether `key' is somewhere in the chain */
    if (ttisshrstring(gkey(n)) && eqshrstr(rawtsvalue(gkey(n)), key))
      return gval(n);  /* that's it */
    else n = gnext(n);
  } while (n);
  return luaO_nilobject;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, -0x24(%rsp)
movq -0x10(%rsp), %rcx
movzbl 0xb(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl -0x24(%rsp), %ecx
subl $0x1, %edx
andl %edx, %ecx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpl $0x44, 0x18(%rax)
jne 0x2523e
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rsp), %rax
jne 0x2523e
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x25262
movq -0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x2524e
cmpq $0x0, -0x20(%rsp)
jne 0x25217
leaq 0x11033(%rip), %rax     # 0x36290
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ltable.c
// Function: luaH_get
const TValue *luaH_get (Table *t, const TValue *key) {
  switch (ttype(key)) {
    case LUA_TSHRSTR: return luaH_getstr(t, rawtsvalue(key));
    case LUA_TNIL: return luaO_nilobject;
    case LUA_TNUMBER: {
      int k;
      lua_Number n = nvalue(key);
      lua_number2int(k, n);
      if (luai_numeq(cast_num(k), n)) /* index is int? */
        return luaH_getint(t, k);  /* use specialized version */
      /* else go through */
    }
    default: {
      Node *n = mainposition(t, key);
      do {  /* check whether `key' is somewhere in the chain */
        if (luaV_rawequalobj(gkey(n), key))
          return gval(n);  /* that's it */
        else n = gnext(n);
      } while (n);
      return luaO_nilobject;
    }
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x3f, %eax
movl %eax, 0xc(%rsp)
je 0x252c7
jmp 0x25291
movl 0xc(%rsp), %eax
subl $0x3, %eax
je 0x252d8
jmp 0x2529c
movl 0xc(%rsp), %eax
subl $0x4, %eax
jne 0x2532a
jmp 0x252ab
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movq (%rax), %rsi
callq 0x251d0
movq %rax, 0x40(%rsp)
jmp 0x2539c
leaq 0x10fc2(%rip), %rax     # 0x36290
movq %rax, 0x40(%rsp)
jmp 0x2539c
movq 0x30(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x10019(%rip), %xmm0    # 0x35308
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x2c(%rsp)
cvtsi2sdl 0x2c(%rsp), %xmm0
ucomisd 0x20(%rsp), %xmm0
jne 0x25328
jp 0x25328
movq 0x38(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x25070
movq %rax, 0x40(%rsp)
jmp 0x2539c
jmp 0x2532a
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x24ca0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x30(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x25378
movq 0x10(%rsp), %rsi
addq $0x10, %rsi
movq 0x30(%rsp), %rdx
xorl %eax, %eax
movl %eax, %edi
callq 0x27e50
cmpl $0x0, %eax
je 0x25378
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x2539c
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x25388
cmpq $0x0, 0x10(%rsp)
jne 0x2533e
leaq 0x10ef9(%rip), %rax     # 0x36290
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
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/ltable.c
// Function: arrayindex
static int arrayindex (const TValue *key) {
  if (ttisnumber(key)) {
    lua_Number n = nvalue(key);
    int k;
    lua_number2int(k, n);
    if (luai_numeq(cast_num(k), n))
      return k;
  }
  return -1;  /* `key' did not match some condition */
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x255d7
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rsp)
movsd 0xfd61(%rip), %xmm0     # 0x35308
addsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x28(%rsp)
movl -0x28(%rsp), %eax
movl %eax, -0x1c(%rsp)
cvtsi2sdl -0x1c(%rsp), %xmm0
ucomisd -0x18(%rsp), %xmm0
jne 0x255d5
jp 0x255d5
movl -0x1c(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x255df
jmp 0x255d7
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
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/ltable.c
// Function: numusearray
static int numusearray (const Table *t, int *nums) {
  int lg;
  int ttlg;  /* 2^lg */
  int ause = 0;  /* summation of `nums' */
  int i = 1;  /* count to traverse all array keys */
  for (lg=0, ttlg=1; lg<=MAXBITS; lg++, ttlg*=2) {  /* for each slice */
    int lc = 0;  /* counter */
    int lim = ttlg;
    if (lim > t->sizearray) {
      lim = t->sizearray;  /* adjust upper limit */
      if (i > lim)
        break;  /* no more elements to count */
    }
    /* count elements in range (2^(lg-1), 2^lg] */
    for (; i <= lim; i++) {
      if (!ttisnil(&t->array[i-1]))
        lc++;
    }
    nums[lg] += lc;
    ause += lc;
  }
  return ause;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x1, -0x20(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x1, -0x18(%rsp)
cmpl $0x1e, -0x14(%rsp)
jg 0x256e0
movl $0x0, -0x24(%rsp)
movl -0x18(%rsp), %eax
movl %eax, -0x28(%rsp)
movl -0x28(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x38(%rcx), %eax
jle 0x25660
movq -0x8(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x28(%rsp)
movl -0x20(%rsp), %eax
cmpl -0x28(%rsp), %eax
jle 0x2565e
jmp 0x256e0
jmp 0x25660
jmp 0x25662
movl -0x20(%rsp), %eax
cmpl -0x28(%rsp), %eax
jg 0x256a6
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl -0x20(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0x25697
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x25699
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x25662
movl -0x24(%rsp), %edx
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rsp), %eax
addl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
movl -0x18(%rsp), %eax
shll %eax
movl %eax, -0x18(%rsp)
jmp 0x2561a
movl -0x1c(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ltable.c
// Function: numusehash
static int numusehash (const Table *t, int *nums, int *pnasize) {
  int totaluse = 0;  /* total number of elements */
  int ause = 0;  /* summation of `nums' */
  int i = sizenode(t);
  while (i--) {
    Node *n = &t->node[i];
    if (!ttisnil(gval(n))) {
      ause += countint(gkey(n), nums);
      totaluse++;
    }
  }
  *pnasize += ause;
  return totaluse;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rax
movzbl 0xb(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rsp)
cmpl $0x0, %eax
je 0x25786
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x14(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0x25784
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x28(%rsp), %rsi
callq 0x257a0
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x25727
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl 0x1c(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ltable.c
// Function: countint
static int countint (const TValue *key, int *nums) {
  int k = arrayindex(key);
  if (0 < k && k <= MAXASIZE) {  /* is `key' an appropriate array index? */
    nums[luaO_ceillog2(k)]++;  /* count as such */
    return 1;
  }
  else
    return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x25580
movl %eax, 0xc(%rsp)
xorl %eax, %eax
cmpl 0xc(%rsp), %eax
jge 0x257fc
cmpl $0x40000000, 0xc(%rsp)  # imm = 0x40000000
jg 0x257fc
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl 0xc(%rsp), %edi
callq 0x19680
movl %eax, %ecx
movq (%rsp), %rax
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl $0x1, 0x24(%rsp)
jmp 0x25804
movl $0x0, 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/ltable.c
// Function: computesizes
static int computesizes (int nums[], int *narray) {
  int i;
  int twotoi;  /* 2^i */
  int a = 0;  /* number of elements smaller than 2^i */
  int na = 0;  /* number of elements to go to array part */
  int n = 0;  /* optimal size for array part */
  for (i = 0, twotoi = 1; twotoi/2 < *narray; i++, twotoi *= 2) {
    if (nums[i] > 0) {
      a += nums[i];
      if (a > twotoi/2) {  /* more than half elements present? */
        n = twotoi;  /* optimal size (till now) */
        na = a;  /* all elements smaller than n will go to array part */
      }
    }
    if (a == *narray) break;  /* all elements already counted */
  }
  *narray = n;
  lua_assert(*narray/2 <= na && na <= *narray);
  return na;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x1, -0x18(%rsp)
movl -0x18(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movq -0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x258db
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x258b0
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movl %eax, -0x28(%rsp)
movl -0x18(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x28(%rsp), %eax
cmpl %ecx, %eax
jle 0x258ae
movl -0x18(%rsp), %eax
movl %eax, -0x24(%rsp)
movl -0x1c(%rsp), %eax
movl %eax, -0x20(%rsp)
jmp 0x258b0
movl -0x1c(%rsp), %eax
movq -0x10(%rsp), %rcx
cmpl (%rcx), %eax
jne 0x258bf
jmp 0x258db
jmp 0x258c1
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
movl -0x18(%rsp), %eax
shll %eax
movl %eax, -0x18(%rsp)
jmp 0x25842
movl -0x24(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
movl -0x20(%rsp), %eax
retq
nopl (%rax,%rax)