LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ltablib.c
// Function: tconcat
static int tconcat (lua_State *L) {
  luaL_Buffer b;
  size_t lsep;
  int i, last;
  const char *sep = luaL_optlstring(L, 2, "", &lsep);
  luaL_checktype(L, 1, LUA_TTABLE);
  i = luaL_optint(L, 3, 1);
  last = luaL_opt(L, luaL_checkint, 4, luaL_len(L, 1));
  luaL_buffinit(L, &b);
  for (; i < last; i++) {
    addfield(L, &b, i);
    luaL_addlstring(&b, sep, lsep);
  }
  if (i == last)  /* add last value (if interval was not empty) */
    addfield(L, &b, i);
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
subq $0x2048, %rsp           # imm = 0x2048
movq %rdi, 0x2040(%rsp)
movq 0x2040(%rsp), %rdi
movl $0x2, %esi
leaq 0x108e4(%rip), %rdx     # 0x36227
leaq 0x18(%rsp), %rcx
callq 0xcc70
movq %rax, 0x8(%rsp)
movq 0x2040(%rsp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0xcdc0
movq 0x2040(%rsp), %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0xcfe0
movl %eax, 0x14(%rsp)
movq 0x2040(%rsp), %rdi
movl $0x4, %esi
callq 0x9350
cmpl $0x0, %eax
jg 0x259b3
movq 0x2040(%rsp), %rdi
movl $0x1, %esi
callq 0xdbe0
movl %eax, 0x4(%rsp)
jmp 0x259c9
movq 0x2040(%rsp), %rdi
movl $0x4, %esi
callq 0xcf40
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x2040(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xd390
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x25a24
movq 0x2040(%rsp), %rdi
movl 0x14(%rsp), %edx
leaq 0x20(%rsp), %rsi
callq 0x25f40
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0xd1b0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x259e3
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jne 0x25a44
movq 0x2040(%rsp), %rdi
movl 0x14(%rsp), %edx
leaq 0x20(%rsp), %rsi
callq 0x25f40
leaq 0x20(%rsp), %rdi
callq 0xd260
movl $0x1, %eax
addq $0x2048, %rsp           # imm = 0x2048
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ltablib.c
// Function: tinsert
static int tinsert (lua_State *L) {
  int e = aux_getn(L, 1) + 1;  /* first empty element */
  int pos;  /* where to insert new element */
  switch (lua_gettop(L)) {
    case 2: {  /* called with only 2 arguments */
      pos = e;  /* insert new element at the end */
      break;
    }
    case 3: {
      int i;
      pos = luaL_checkint(L, 2);  /* 2nd argument is the position */
      luaL_argcheck(L, 1 <= pos && pos <= e, 2, "position out of bounds");
      for (i = e; i > pos; i--) {  /* move up elements */
        lua_rawgeti(L, 1, i-1);
        lua_rawseti(L, 1, i);  /* t[i] = t[i-1] */
      }
      break;
    }
    default: {
      return luaL_error(L, "wrong number of arguments to " LUA_QL("insert"));
    }
  }
  lua_rawseti(L, 1, pos);  /* t[pos] = v */
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
movl %esi, 0x4(%rsp)
movl $0x5, %edx
callq 0xcdc0
movl 0x4(%rsp), %esi
movq 0x18(%rsp), %rdi
callq 0xdbe0
incl %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0x8e20
movl %eax, %ecx
movl %ecx, 0x8(%rsp)
subl $0x2, %eax
je 0x25aba
jmp 0x25aac
movl 0x8(%rsp), %eax
subl $0x3, %eax
je 0x25ac7
jmp 0x25b63
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x25b7c
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0xcf40
movl %eax, 0x10(%rsp)
movl $0x1, %eax
cmpl 0x10(%rsp), %eax
jg 0x25af5
movl 0x10(%rsp), %ecx
movb $0x1, %al
cmpl 0x14(%rsp), %ecx
movb %al, 0x3(%rsp)
jle 0x25b15
movq 0x18(%rsp), %rdi
movl $0x2, %esi
leaq 0x113b6(%rip), %rdx     # 0x36ebc
callq 0xc3a0
cmpl $0x0, %eax
setne %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
jle 0x25b61
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %edx
subl $0x1, %edx
movl $0x1, %esi
callq 0xa660
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %edx
movl $0x1, %esi
callq 0xac80
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x25b21
jmp 0x25b7c
movq 0x18(%rsp), %rdi
leaq 0x11364(%rip), %rsi     # 0x36ed3
movb $0x0, %al
callq 0xc520
movl %eax, 0x24(%rsp)
jmp 0x25b97
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %edx
movl $0x1, %esi
callq 0xac80
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ltablib.c
// Function: pack
static int pack (lua_State *L) {
  int n = lua_gettop(L);  /* number of elements to pack */
  lua_createtable(L, n, 1);  /* create result table */
  lua_pushinteger(L, n);
  lua_setfield(L, -2, "n");  /* t.n = number of elements */
  if (n > 0) {  /* at least one element? */
    int i;
    lua_pushvalue(L, 1);
    lua_rawseti(L, -2, 1);  /* insert first element */
    lua_replace(L, 1);  /* move table into index 1 */
    for (i = n; i >= 2; i--)  /* assign other elements */
      lua_rawseti(L, 1, i);
  }
  return 1;  /* return table */
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x8e20
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x1, %edx
callq 0xa780
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x9e70
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x11353(%rip), %rdx     # 0x36f3d
callq 0xaad0
cmpl $0x0, 0xc(%rsp)
jle 0x25c59
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x92e0
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0xac80
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x9190
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
cmpl $0x2, 0x8(%rsp)
jl 0x25c57
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %edx
movl $0x1, %esi
callq 0xac80
movl 0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x25c30
jmp 0x25c59
movl $0x1, %eax
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/ltablib.c
// Function: unpack
static int unpack (lua_State *L) {
  int i, e, n;
  luaL_checktype(L, 1, LUA_TTABLE);
  i = luaL_optint(L, 2, 1);
  e = luaL_opt(L, luaL_checkint, 3, luaL_len(L, 1));
  if (i > e) return 0;  /* empty range */
  n = e - i + 1;  /* number of elements */
  if (n <= 0 || !lua_checkstack(L, n))  /* n <= 0 means arith. overflow */
    return luaL_error(L, "too many results to unpack");
  lua_rawgeti(L, 1, i);  /* push arg[i] (avoiding overflow problems) */
  while (i++ < e)  /* push arg[i + 1...e] */
    lua_rawgeti(L, 1, i);
  return n;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0xcdc0
movq 0x18(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0xcfe0
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0x3, %esi
callq 0x9350
cmpl $0x0, %eax
jg 0x25cce
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0xdbe0
movl %eax, 0x8(%rsp)
jmp 0x25ce1
movq 0x18(%rsp), %rdi
movl $0x3, %esi
callq 0xcf40
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jle 0x25d00
movl $0x0, 0x24(%rsp)
jmp 0x25d85
movl 0x10(%rsp), %eax
subl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jle 0x25d29
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x8b50
cmpl $0x0, %eax
jne 0x25d42
movq 0x18(%rsp), %rdi
leaq 0x111c4(%rip), %rsi     # 0x36ef9
movb $0x0, %al
callq 0xc520
movl %eax, 0x24(%rsp)
jmp 0x25d85
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %edx
movl $0x1, %esi
callq 0xa660
movl 0x14(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rsp)
cmpl 0x10(%rsp), %eax
jge 0x25d7d
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %edx
movl $0x1, %esi
callq 0xa660
jmp 0x25d55
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ltablib.c
// Function: tremove
static int tremove (lua_State *L) {
  int size = aux_getn(L, 1);
  int pos = luaL_optint(L, 2, size);
  if (pos != size)  /* validate 'pos' if given */
    luaL_argcheck(L, 1 <= pos && pos <= size + 1, 1, "position out of bounds");
  lua_rawgeti(L, 1, pos);  /* result = t[pos] */
  for ( ; pos < size; pos++) {
    lua_rawgeti(L, 1, pos+1);
    lua_rawseti(L, 1, pos);  /* t[pos] = t[pos+1] */
  }
  lua_pushnil(L);
  lua_rawseti(L, 1, pos);  /* t[pos] = nil */
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0xcdc0
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xdbe0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rdx
movl $0x2, %esi
callq 0xcfe0
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
je 0x25e26
movl $0x1, %eax
cmpl 0x8(%rsp), %eax
jg 0x25e02
movl 0x8(%rsp), %ecx
movl 0xc(%rsp), %edx
addl $0x1, %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, 0x7(%rsp)
jle 0x25e22
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x110a9(%rip), %rdx     # 0x36ebc
callq 0xc3a0
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %edx
movl $0x1, %esi
callq 0xa660
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x25e79
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %edx
addl $0x1, %edx
movl $0x1, %esi
callq 0xa660
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %edx
movl $0x1, %esi
callq 0xac80
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x25e39
movq 0x10(%rsp), %rdi
callq 0x9df0
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %edx
movl $0x1, %esi
callq 0xac80
movl $0x1, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ltablib.c
// Function: sort
static int sort (lua_State *L) {
  int n = aux_getn(L, 1);
  luaL_checkstack(L, 40, "");  /* assume array is smaller than 2^40 */
  if (!lua_isnoneornil(L, 2))  /* is there a 2nd argument? */
    luaL_checktype(L, 2, LUA_TFUNCTION);
  lua_settop(L, 2);  /* make sure there is two arguments */
  auxsort(L, 1, n);
  return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0xcdc0
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xdbe0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x28, %esi
leaq 0x10346(%rip), %rdx     # 0x36227
callq 0xcd50
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x9350
cmpl $0x0, %eax
jle 0x25f0e
movq 0x10(%rsp), %rdi
movl $0x2, %esi
movl $0x6, %edx
callq 0xcdc0
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x8e50
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
movl $0x1, %esi
callq 0x25fd0
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ltablib.c
// Function: addfield
static void addfield (lua_State *L, luaL_Buffer *b, int i) {
  lua_rawgeti(L, 1, i);
  if (!lua_isstring(L, -1))
    luaL_error(L, "invalid value (%s) at index %d in table for "
                  LUA_QL("concat"), luaL_typename(L, -1), i);
  luaL_addvalue(b);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %edx
movl $0x1, %esi
callq 0xa660
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9480
cmpl $0x0, %eax
jne 0x25fc0
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9350
movq (%rsp), %rdi
movl %eax, %esi
callq 0x93b0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl 0x14(%rsp), %ecx
leaq 0x10ece(%rip), %rsi     # 0x36e87
movb $0x0, %al
callq 0xc520
movq 0x18(%rsp), %rdi
callq 0xd2f0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ltablib.c
// Function: sort_comp
static int sort_comp (lua_State *L, int a, int b) {
  if (!lua_isnil(L, 2)) {  /* function? */
    int res;
    lua_pushvalue(L, 2);
    lua_pushvalue(L, a-1);  /* -1 to compensate function */
    lua_pushvalue(L, b-2);  /* -2 to compensate function and `a' */
    lua_call(L, 2, 1);
    res = lua_toboolean(L, -1);
    lua_pop(L, 1);
    return res;
  }
  else  /* a < b? */
    return lua_compare(L, a, b, LUA_OPLT);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x9350
cmpl $0x0, %eax
je 0x263dd
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x92e0
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
subl $0x1, %esi
callq 0x92e0
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
subl $0x2, %esi
callq 0x92e0
movq 0x18(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0xb0e0
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9a10
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8e50
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x263f8
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl $0x1, %ecx
callq 0x96f0
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/ltm.c
// Function: luaT_init
void luaT_init (lua_State *L) {
  static const char *const luaT_eventname[] = {  /* ORDER TM */
    "__index", "__newindex",
    "__gc", "__mode", "__len", "__eq",
    "__add", "__sub", "__mul", "__div", "__mod",
    "__pow", "__unm", "__lt", "__le",
    "__concat", "__call"
  };
  int i;
  for (i=0; i<TM_N; i++) {
    G(L)->tmname[i] = luaS_new(L, luaT_eventname[i]);
    luaS_fix(G(L)->tmname[i]);  /* never collect these names */
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x11, 0xc(%rsp)
jge 0x264c8
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rcx
leaq 0x1a367(%rip), %rax     # 0x407e0
movq (%rax,%rcx,8), %rsi
callq 0x209f0
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, 0x120(%rax,%rcx,8)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
movq 0x120(%rax,%rcx,8), %rax
movzbl 0x9(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x9(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x26461
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ltm.c
// Function: luaT_gettm
const TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
  const TValue *tm = luaH_getstr(events, ename);
  lua_assert(event <= TM_EQ);
  if (ttisnil(tm)) {  /* no tag method? */
    events->flags |= cast_byte(1u<<event);  /* cache this fact */
    return NULL;
  }
  else return tm;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x251d0
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x26526
movl 0x14(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movzbl %al, %edx
movq 0x18(%rsp), %rax
movzbl 0xa(%rax), %ecx
orl %edx, %ecx
movb %cl, 0xa(%rax)
movq $0x0, 0x20(%rsp)
jmp 0x2652f
movq (%rsp), %rax
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/ltm.c
// Function: luaT_gettmbyobj
const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
  Table *mt;
  switch (ttypenv(o)) {
    case LUA_TTABLE:
      mt = hvalue(o)->metatable;
      break;
    case LUA_TUSERDATA:
      mt = uvalue(o)->metatable;
      break;
    default:
      mt = G(L)->mt[ttypenv(o)];
  }
  return (mt ? luaH_getstr(mt, G(L)->tmname[event]) : luaO_nilobject);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
movl %eax, 0x14(%rsp)
subl $0x5, %eax
je 0x26573
jmp 0x26568
movl 0x14(%rsp), %eax
subl $0x7, %eax
je 0x26586
jmp 0x26599
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x265bd
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x265bd
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rsp), %rcx
movl 0x8(%rcx), %ecx
andl $0xf, %ecx
movslq %ecx, %rcx
movq 0x1a8(%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x265eb
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x24(%rsp), %ecx
movq 0x120(%rax,%rcx,8), %rsi
callq 0x251d0
movq %rax, 0x8(%rsp)
jmp 0x265f9
leaq 0xfc9e(%rip), %rax      # 0x36290
movq %rax, 0x8(%rsp)
jmp 0x265f9
movq 0x8(%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/lundump.c
// Function: luaU_undump
Closure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name)
{
 LoadState S;
 Closure* cl;
 if (*name=='@' || *name=='=')
  S.name=name+1;
 else if (*name==LUA_SIGNATURE[0])
  S.name="binary string";
 else
  S.name=name;
 S.L=L;
 S.Z=Z;
 S.b=buff;
 LoadHeader(&S);
 cl=luaF_newLclosure(L,1);
 setclLvalue(L,L->top,cl); incr_top(L);
 cl->l.p=luaF_newproto(L);
 LoadFunction(&S,cl->l.p);
 if (cl->l.p->sizeupvalues != 1)
 {
  Proto* p=cl->l.p;
  cl=luaF_newLclosure(L,cl->l.p->sizeupvalues);
  cl->l.p=p;
  setclLvalue(L,L->top-1,cl);
 }
 luai_verifycode(L,buff,cl->l.p);
 return cl;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x48(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x40, %eax
je 0x26642
movq 0x48(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x26652
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x2667f
movq 0x48(%rsp), %rax
movsbl (%rax), %eax
movsbl 0xef0c(%rip), %ecx      # 0x3556d
cmpl %ecx, %eax
jne 0x26673
leaq 0x10964(%rip), %rax     # 0x36fd0
movq %rax, 0x40(%rsp)
jmp 0x2667d
movq 0x48(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x2667f
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x267d0
movq 0x60(%rsp), %rdi
movl $0x1, %esi
callq 0x12380
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movl $0x46, 0x8(%rax)
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
movq 0x60(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x60(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
sarq $0x4, %rax
cmpq $0x0, %rax
jg 0x26720
movq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0x10250
jmp 0x26722
jmp 0x26722
movq 0x60(%rsp), %rdi
callq 0x127a0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rsi
leaq 0x28(%rsp), %rdi
callq 0x268b0
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
cmpl $0x1, 0x50(%rax)
je 0x267bc
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x50(%rax), %esi
callq 0x12380
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
addq $-0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl $0x46, 0x8(%rax)
movq 0x20(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lundump.c
// Function: LoadHeader
static void LoadHeader(LoadState* S)
{
 lu_byte h[LUAC_HEADERSIZE];
 lu_byte s[LUAC_HEADERSIZE];
 luaU_header(h);
 memcpy(s,h,sizeof(char));			/* first char already read */
 LoadBlock(S,s+sizeof(char),LUAC_HEADERSIZE-sizeof(char));
 if (memcmp(h,s,N0)==0) return;
 if (memcmp(h,s,N1)!=0) error(S,"not a");
 if (memcmp(h,s,N2)!=0) error(S,"version mismatch in");
 if (memcmp(h,s,N3)!=0) error(S,"incompatible"); else error(S,"corrupted");
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x26970
movb 0x20(%rsp), %al
movb %al, (%rsp)
movq 0x40(%rsp), %rdi
movq %rsp, %rsi
addq $0x1, %rsi
movl $0x11, %edx
callq 0x26a70
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movl $0x12, %edx
callq 0x7290
cmpl $0x0, %eax
jne 0x2681c
addq $0x48, %rsp
retq
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movl (%rcx), %ecx
movl (%rax), %eax
subl %ecx, %eax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x26846
movq 0x40(%rsp), %rdi
leaq 0x107a6(%rip), %rsi     # 0x36fe7
callq 0x26ac0
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movl $0x6, %edx
callq 0x7290
cmpl $0x0, %eax
je 0x2686e
movq 0x40(%rsp), %rdi
leaq 0x10784(%rip), %rsi     # 0x36fed
callq 0x26ac0
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movl $0xc, %edx
callq 0x7290
cmpl $0x0, %eax
je 0x26896
movq 0x40(%rsp), %rdi
leaq 0x10770(%rip), %rsi     # 0x37001
callq 0x26ac0
movq 0x40(%rsp), %rdi
leaq 0x1076c(%rip), %rsi     # 0x3700e
callq 0x26ac0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lundump.c
// Function: LoadFunction
static void LoadFunction(LoadState* S, Proto* f)
{
 f->linedefined=LoadInt(S);
 f->lastlinedefined=LoadInt(S);
 f->numparams=LoadByte(S);
 f->is_vararg=LoadByte(S);
 f->maxstacksize=LoadByte(S);
 LoadCode(S,f);
 LoadConstants(S,f);
 LoadUpvalues(S,f);
 LoadDebug(S,f);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x26b10
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x68(%rax)
movq 0x10(%rsp), %rdi
callq 0x26b10
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x6c(%rax)
movq 0x10(%rsp), %rdi
callq 0x26b50
movb %al, %cl
movq 0x8(%rsp), %rax
movb %cl, 0x78(%rax)
movq 0x10(%rsp), %rdi
callq 0x26b50
movb %al, %cl
movq 0x8(%rsp), %rax
movb %cl, 0x79(%rax)
movq 0x10(%rsp), %rdi
callq 0x26b50
movb %al, %cl
movq 0x8(%rsp), %rax
movb %cl, 0x7a(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x26b80
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x26c20
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x26f00
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x27020
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/lundump.c
// Function: luaU_header
void luaU_header (lu_byte* h)
{
 int x=1;
 memcpy(h,LUA_SIGNATURE,sizeof(LUA_SIGNATURE)-sizeof(char));
 h+=sizeof(LUA_SIGNATURE)-sizeof(char);
 *h++=cast_byte(VERSION);
 *h++=cast_byte(FORMAT);
 *h++=cast_byte(*(char*)&x);			/* endianness */
 *h++=cast_byte(sizeof(int));
 *h++=cast_byte(sizeof(size_t));
 *h++=cast_byte(sizeof(Instruction));
 *h++=cast_byte(sizeof(lua_Number));
 *h++=cast_byte(((lua_Number)0.5)==0);		/* is lua_Number integral? */
 memcpy(h,LUAC_TAIL,sizeof(LUAC_TAIL)-sizeof(char));
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x1, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl 0xebe5(%rip), %ecx      # 0x3556d
movl %ecx, (%rax)
movq -0x8(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rsp)
movsbl 0x1063f(%rip), %eax     # 0x36fde
subl $0x30, %eax
shll $0x4, %eax
movsbl 0x108ba(%rip), %ecx     # 0x37266
subl $0x30, %ecx
addl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rsp)
movb %cl, (%rax)
movq -0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rsp)
movb $0x0, (%rax)
movb -0xc(%rsp), %cl
movq -0x8(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rsp)
movb %cl, (%rax)
movq -0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rsp)
movb $0x4, (%rax)
movq -0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rsp)
movb $0x8, (%rax)
movq -0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rsp)
movb $0x4, (%rax)
movq -0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rsp)
movb $0x8, (%rax)
movq -0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rsp)
movb $0x0, (%rax)
movq -0x8(%rsp), %rax
movl 0x10580(%rip), %ecx     # 0x36fe0
movl %ecx, (%rax)
movw 0x1057b(%rip), %cx      # 0x36fe4
movw %cx, 0x4(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lundump.c
// Function: LoadCode
static void LoadCode(LoadState* S, Proto* f)
{
 int n=LoadInt(S);
 f->code=luaM_newvector(S->L,n,Instruction);
 f->sizecode=n;
 LoadVector(S,f->code,n,sizeof(Instruction));
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x26b10
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
cltq
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rcx, %rax
jbe 0x26bc1
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x18150
jmp 0x26bc3
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movslq 0x4(%rsp), %rcx
shlq $0x2, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x18170
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x58(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
movslq 0x4(%rsp), %rdx
shlq $0x2, %rdx
callq 0x26a70
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lundump.c
// Function: LoadUpvalues
static void LoadUpvalues(LoadState* S, Proto* f)
{
 int i,n;
 n=LoadInt(S);
 f->upvalues=luaM_newvector(S->L,n,Upvaldesc);
 f->sizeupvalues=n;
 for (i=0; i<n; i++) f->upvalues[i].name=NULL;
 for (i=0; i<n; i++)
 {
  f->upvalues[i].instack=LoadByte(S);
  f->upvalues[i].idx=LoadByte(S);
 }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x26b10
movl %eax, (%rsp)
movl (%rsp), %eax
addl $0x1, %eax
cltq
movabsq $0xfffffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFFFF
cmpq %rcx, %rax
jbe 0x26f3f
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x18150
jmp 0x26f41
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movslq (%rsp), %rcx
shlq $0x4, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x18170
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movl (%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x50(%rax)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
jge 0x26fae
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x26f7c
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
jge 0x27014
movq 0x10(%rsp), %rdi
callq 0x26b50
movb %al, %cl
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movslq 0x4(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movb %cl, 0x8(%rax)
movq 0x10(%rsp), %rdi
callq 0x26b50
movb %al, %cl
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movslq 0x4(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movb %cl, 0x9(%rax)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x26fb6
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lundump.c
// Function: LoadString
static TString* LoadString(LoadState* S)
{
 size_t size;
 LoadVar(S,size);
 if (size==0)
  return NULL;
 else
 {
  char* s=luaZ_openspace(S->L,S->b,size);
  LoadBlock(S,s,size*sizeof(char));
  return luaS_newlstr(S->L,s,size-1);		/* remove trailing '\0' */
 }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x8, %edx
callq 0x26a70
cmpq $0x0, 0x10(%rsp)
jne 0x272b0
movq $0x0, 0x20(%rsp)
jmp 0x27308
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x10(%rsp), %rdx
callq 0x2c5c0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
shlq $0x0, %rdx
callq 0x26a70
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
subq $0x1, %rdx
callq 0x20780
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %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/lvm.c
// Function: luaV_tonumber
const TValue *luaV_tonumber (const TValue *obj, TValue *n) {
  lua_Number num;
  if (ttisnumber(obj)) return obj;
  if (ttisstring(obj) && luaO_str2d(svalue(obj), tsvalue(obj)->len, &num)) {
    setnvalue(n, num);
    return n;
  }
  else
    return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x27345
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x273b3
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x273aa
movq 0x18(%rsp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rsi
leaq 0x8(%rsp), %rdx
callq 0x19870
cmpl $0x0, %eax
je 0x273aa
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movsd 0x8(%rsp), %xmm0
movq (%rsp), %rax
movsd %xmm0, (%rax)
movq (%rsp), %rax
movl $0x3, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x273b3
movq $0x0, 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/lvm.c
// Function: luaV_tostring
int luaV_tostring (lua_State *L, StkId obj) {
  if (!ttisnumber(obj))
    return 0;
  else {
    char s[LUAI_MAXNUMBER2STR];
    lua_Number n = nvalue(obj);
    int l = lua_number2str(s, n);
    setsvalue2s(L, obj, luaS_newlstr(L, s, l));
    return 1;
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpl $0x3, 0x8(%rax)
je 0x273e3
movl $0x0, 0x54(%rsp)
jmp 0x27458
movq 0x40(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
leaq 0xea7a(%rip), %rsi      # 0x35e7e
movb $0x1, %al
callq 0x7510
movl %eax, 0x14(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movslq 0x14(%rsp), %rdx
callq 0x20780
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movzbl 0x8(%rax), %ecx
orl $0x40, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movl $0x1, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lvm.c
// Function: luaV_gettable
void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) {
  int loop;
  for (loop = 0; loop < MAXTAGLOOP; loop++) {
    const TValue *tm;
    if (ttistable(t)) {  /* `t' is a table? */
      Table *h = hvalue(t);
      const TValue *res = luaH_get(h, key); /* do a primitive get */
      if (!ttisnil(res) ||  /* result is not nil? */
          (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */
        setobj2s(L, val, res);
        return;
      }
      /* else will try the tag method */
    }
    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX)))
      luaG_typeerror(L, t, "index");
    if (ttisfunction(tm)) {
      callTM(L, tm, t, key, val, 1);
      return;
    }
    t = tm;  /* else repeat with 'tm' */
  }
  luaG_runerror(L, "loop in gettable");
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
cmpl $0x64, 0x44(%rsp)
jge 0x27607
movq 0x58(%rsp), %rax
cmpl $0x45, 0x8(%rax)
jne 0x27583
movq 0x58(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x25270
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x27548
movq 0x30(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x274eb
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x27538
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movzbl 0xa(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x27509
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x2752e
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x120(%rax), %rdx
xorl %esi, %esi
callq 0x264d0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, %rax
jne 0x27581
movq 0x28(%rsp), %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)
jmp 0x2761a
jmp 0x275b7
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
xorl %edx, %edx
callq 0x26540
movq %rax, 0x38(%rsp)
cmpl $0x0, 0x8(%rax)
jne 0x275b5
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
leaq 0xf690(%rip), %rdx      # 0x36c40
callq 0xee00
jmp 0x275b7
movq 0x38(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x6, %eax
jne 0x275ed
movq 0x60(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rcx
movq 0x48(%rsp), %r8
movl $0x1, %r9d
callq 0x27620
jmp 0x2761a
movq 0x38(%rsp), %rax
movq %rax, 0x58(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x27490
movq 0x60(%rsp), %rdi
leaq 0xfb99(%rip), %rsi      # 0x371ac
movb $0x0, %al
callq 0xf360
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lvm.c
// Function: callTM
static void callTM (lua_State *L, const TValue *f, const TValue *p1,
                    const TValue *p2, TValue *p3, int hasres) {
  ptrdiff_t result = savestack(L, p3);
  setobj2s(L, L->top++, f);  /* push function */
  setobj2s(L, L->top++, p1);  /* 1st argument */
  setobj2s(L, L->top++, p2);  /* 2nd argument */
  if (!hasres)  /* no result? 'p3' is third argument */
    setobj2s(L, L->top++, p3);  /* 3rd argument */
  /* metamethod may yield only when called from Lua code */
  luaD_call(L, L->top - (4 - hasres), hasres, isLua(L->ci));
  if (hasres) {  /* if has result, move it to its place */
    p3 = restorestack(L, result);
    setobjs2s(L, p3, --L->top);
  }
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movl %r9d, 0x5c(%rsp)
movq 0x60(%rsp), %rax
movq 0x80(%rsp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
movq %rax, 0x50(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x80(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, 0x10(%rcx)
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x48(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x40(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x70(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x80(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, 0x10(%rcx)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x38(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x80(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, 0x10(%rcx)
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
cmpl $0x0, 0x5c(%rsp)
jne 0x27780
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x80(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, 0x10(%rcx)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x80(%rsp), %rdi
movq 0x80(%rsp), %rax
movq 0x10(%rax), %rsi
movl $0x4, %eax
subl 0x5c(%rsp), %eax
movslq %eax, %rcx
xorl %eax, %eax
subq %rcx, %rax
shlq $0x4, %rax
addq %rax, %rsi
movl 0x5c(%rsp), %edx
movq 0x80(%rsp), %rax
movq 0x20(%rax), %rax
movzbl 0x22(%rax), %ecx
andl $0x1, %ecx
callq 0x10e90
cmpl $0x0, 0x5c(%rsp)
je 0x27825
movq 0x80(%rsp), %rax
movq 0x38(%rax), %rax
addq 0x50(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x80(%rsp), %rcx
movq 0x10(%rcx), %rax
addq $-0x10, %rax
movq %rax, 0x10(%rcx)
movq %rax, 0x8(%rsp)
movq 0x60(%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 $0x88, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lvm.c
// Function: luaV_lessthan
int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) {
  int res;
  if (ttisnumber(l) && ttisnumber(r))
    return luai_numlt(L, nvalue(l), nvalue(r));
  else if (ttisstring(l) && ttisstring(r))
    return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0;
  else if ((res = call_orderTM(L, l, r, TM_LT)) < 0)
    luaG_ordererror(L, l, r);
  return res;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x27ac0
movq 0x8(%rsp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x27ac0
movq 0x10(%rsp), %rax
movsd (%rax), %xmm1
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x27b48
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x27b06
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x27b06
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x27b60
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x27b48
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl $0xd, %ecx
callq 0x27c80
movl %eax, 0x4(%rsp)
cmpl $0x0, %eax
jge 0x27b3c
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xf4e0
jmp 0x27b3e
jmp 0x27b40
movl 0x4(%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/lvm.c
// Function: l_strcmp
static int l_strcmp (const TString *ls, const TString *rs) {
  const char *l = getstr(ls);
  size_t ll = ls->tsv.len;
  const char *r = getstr(rs);
  size_t lr = rs->tsv.len;
  for (;;) {
    int temp = strcoll(l, r);
    if (temp != 0) return temp;
    else {  /* strings are equal up to a `\0' */
      size_t len = strlen(l);  /* index of first `\0' in both strings */
      if (len == lr)  /* r is finished? */
        return (len == ll) ? 0 : 1;
      else if (len == ll)  /* l is finished? */
        return -1;  /* l is smaller than r (because r is not finished) */
      /* both strings longer than `len'; go on comparing (after the `\0') */
      len++;
      l += len; ll -= len; r += len; lr -= len;
    }
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x73e0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x27bcd
movl 0xc(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x27c68
movq 0x28(%rsp), %rdi
callq 0x7170
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x27c02
movq (%rsp), %rdx
movq 0x20(%rsp), %rsi
movl $0x1, %eax
xorl %ecx, %ecx
cmpq %rsi, %rdx
cmovel %ecx, %eax
movl %eax, 0x44(%rsp)
jmp 0x27c68
movq (%rsp), %rax
cmpq 0x20(%rsp), %rax
jne 0x27c17
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x27c68
jmp 0x27c19
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movq (%rsp), %rcx
movq 0x20(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0x27ba6
movl 0x44(%rsp), %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/lvm.c
// Function: call_orderTM
static int call_orderTM (lua_State *L, const TValue *p1, const TValue *p2,
                         TMS event) {
  if (!call_binTM(L, p1, p2, L->top, event))
    return -1;  /* no metamethod */
  else
    return !l_isfalse(L->top);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
movl 0x4(%rsp), %r8d
callq 0x28630
cmpl $0x0, %eax
jne 0x27cc8
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x27d1c
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
movb $0x1, %al
cmpl $0x0, 0x8(%rcx)
movb %al, 0x3(%rsp)
je 0x27d0d
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
xorl %eax, %eax
cmpl $0x1, 0x8(%rcx)
movb %al, 0x2(%rsp)
jne 0x27d05
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, (%rax)
sete %al
movb %al, 0x2(%rsp)
movb 0x2(%rsp), %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %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/lvm.c
// Function: luaV_lessequal
int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r) {
  int res;
  if (ttisnumber(l) && ttisnumber(r))
    return luai_numle(L, nvalue(l), nvalue(r));
  else if (ttisstring(l) && ttisstring(r))
    return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0;
  else if ((res = call_orderTM(L, l, r, TM_LE)) >= 0)  /* first try `le' */
    return res;
  else if ((res = call_orderTM(L, r, l, TM_LT)) < 0)  /* else try `lt' */
    luaG_ordererror(L, l, r);
  return !res;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x27d80
movq 0x8(%rsp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x27d80
movq 0x10(%rsp), %rax
movsd (%rax), %xmm1
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
setae %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x27e41
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x27dc6
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x27dc6
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x27b60
cmpl $0x0, %eax
setle %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x27e41
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl $0xe, %ecx
callq 0x27c80
movl %eax, 0x4(%rsp)
cmpl $0x0, %eax
jl 0x27df2
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x27e41
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl $0xd, %ecx
callq 0x27c80
movl %eax, 0x4(%rsp)
cmpl $0x0, %eax
jge 0x27e28
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xf4e0
jmp 0x27e2a
jmp 0x27e2c
jmp 0x27e2e
cmpl $0x0, 0x4(%rsp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
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/lvm.c
// Function: get_equalTM
static const TValue *get_equalTM (lua_State *L, Table *mt1, Table *mt2,
                                  TMS event) {
  const TValue *tm1 = fasttm(L, mt1, event);
  const TValue *tm2;
  if (tm1 == NULL) return NULL;  /* no metamethod */
  if (mt1 == mt2) return tm1;  /* same metatables => same metamethods */
  tm2 = fasttm(L, mt2, event);
  if (tm2 == NULL) return NULL;  /* no metamethod */
  if (luaV_rawequalobj(tm1, tm2))  /* same metamethods? */
    return tm1;
  return NULL;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movl %ecx, 0x34(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x28118
xorl %eax, %eax
movq %rax, 0x18(%rsp)
jmp 0x28170
movq 0x40(%rsp), %rax
movzbl 0xa(%rax), %eax
movl 0x34(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x2813e
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x28166
movq 0x40(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x48(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x34(%rsp), %ecx
movq 0x120(%rax,%rcx,8), %rdx
callq 0x264d0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x28190
movq $0x0, 0x50(%rsp)
jmp 0x2826d
movq 0x40(%rsp), %rax
cmpq 0x38(%rsp), %rax
jne 0x281ab
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x2826d
cmpq $0x0, 0x38(%rsp)
jne 0x281bc
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x28211
movq 0x38(%rsp), %rax
movzbl 0xa(%rax), %eax
movl 0x34(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x281e1
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x28208
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x48(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x34(%rsp), %ecx
movq 0x120(%rax,%rcx,8), %rdx
callq 0x264d0
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x2822e
movq $0x0, 0x50(%rsp)
jmp 0x2826d
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x28264
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
xorl %eax, %eax
movl %eax, %edi
callq 0x27e50
cmpl $0x0, %eax
je 0x28264
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x2826d
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lvm.c
// Function: call_binTM
static int call_binTM (lua_State *L, const TValue *p1, const TValue *p2,
                       StkId res, TMS event) {
  const TValue *tm = luaT_gettmbyobj(L, p1, event);  /* try first operand */
  if (ttisnil(tm))
    tm = luaT_gettmbyobj(L, p2, event);  /* try second operand */
  if (ttisnil(tm)) return 0;
  callTM(L, tm, p1, p2, res, 1);
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x26540
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x28685
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x26540
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x28699
movl $0x0, 0x34(%rsp)
jmp 0x286c4
movq 0x28(%rsp), %rdi
movq (%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movl $0x1, %r9d
callq 0x27620
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)