LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/ltablib.c
// Function: tmove
static int tmove (lua_State *L) {
  lua_Integer f = luaL_checkinteger(L, 2);
  lua_Integer e = luaL_checkinteger(L, 3);
  lua_Integer t = luaL_checkinteger(L, 4);
  int tt = !lua_isnoneornil(L, 5) ? 5 : 1;  /* destination table */
  checktab(L, 1, TAB_R);
  checktab(L, tt, TAB_W);
  if (e >= f) {  /* otherwise, nothing to move */
    lua_Integer n, i;
    luaL_argcheck(L, f > 0 || e < LUA_MAXINTEGER + f, 3,
                  "too many elements to move");
    n = e - f + 1;  /* number of elements to move */
    luaL_argcheck(L, t <= LUA_MAXINTEGER - n + 1, 4,
                  "destination wrap around");
    if (t > e || t <= f || (tt != 1 && !lua_compare(L, 1, tt, LUA_OPEQ))) {
      for (i = 0; i < n; i++) {
        lua_geti(L, 1, f + i);
        lua_seti(L, tt, t + i);
      }
    }
    else {
      for (i = n - 1; i >= 0; i--) {
        lua_geti(L, 1, f + i);
        lua_seti(L, tt, t + i);
      }
    }
  }
  lua_pushvalue(L, tt);  /* return destination table */
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x2
popq %r13
movl %r13d, %esi
callq 0x13252
movq %rax, %r14
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13252
movq %rax, %r15
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13252
movq %rax, 0x8(%rsp)
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x5d12
movl %eax, %r12d
xorl %eax, %eax
testl %r12d, %r12d
setg %al
leal 0x1(,%rax,4), %ebp
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %edx, %esi
callq 0x1d229
movq %rbx, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x1d229
movq %r15, %r13
subq %r14, %r13
jge 0x1d0ba
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5cee
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r12d, 0x14(%rsp)
movabsq $0x7fffffffffffffff, %r12 # imm = 0x7FFFFFFFFFFFFFFF
testq %r14, %r14
setg %al
leaq (%r14,%r12), %rcx
cmpq %rcx, %r15
setl %cl
orb %al, %cl
jne 0x1d0ef
leaq 0x49a9(%rip), %rdx      # 0x21a8d
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x12af2
subq %r13, %r12
cmpq %r12, 0x8(%rsp)
jle 0x1d10b
leaq 0x49a7(%rip), %rdx      # 0x21aa7
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x12af2
movq 0x8(%rsp), %r12
cmpq %r15, %r12
setle %al
subq %r14, %r12
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1d172
cmpl $0x0, 0x14(%rsp)
jle 0x1d13e
pushq $0x1
popq %rsi
pushq $0x5
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x5e4d
testl %eax, %eax
je 0x1d172
negq %r14
pushq $0x1
popq %r13
movq %r14, %rax
addq %r15, %rax
js 0x1d09e
movq %rbx, %rdi
movl %r13d, %esi
movq %r15, %rdx
callq 0x6518
leaq (%r12,%r15), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x68dd
decq %r15
jmp 0x1d145
xorl %r12d, %r12d
pushq $0x1
popq %r15
cmpq %r13, %r12
jg 0x1d09e
leaq (%r14,%r12), %rdx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x6518
movq 0x8(%rsp), %rax
leaq (%rax,%r12), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x68dd
incq %r12
jmp 0x1d179
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/ltablib.c
// Function: sort
static int sort (lua_State *L) {
  lua_Integer n = aux_getn(L, 1, TAB_RW);
  if (n > 1) {  /* non-trivial interval? */
    luaL_argcheck(L, n < INT_MAX, 1, "array too big");
    if (!lua_isnoneornil(L, 2))  /* is there a 2nd argument? */
      luaL_checktype(L, 2, LUA_TFUNCTION);  /* must be a function */
    lua_settop(L, 2);  /* make sure there are two arguments */
    auxsort(L, 1, (IdxT)n, 0);
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
pushq $0x7
popq %rdx
movl %ebp, %esi
callq 0x1d229
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13ad1
cmpq $0x2, %rax
jl 0x1d222
movq %rax, %r14
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
jb 0x1d1ea
leaq 0x48e0(%rip), %rdx      # 0x21abf
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x12af2
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x5d12
testl %eax, %eax
jle 0x1d207
pushq $0x2
popq %rsi
pushq $0x6
popq %rdx
movq %rbx, %rdi
callq 0x1315e
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x5b31
pushq $0x1
popq %rsi
movq %rbx, %rdi
movl %r14d, %edx
xorl %ecx, %ecx
callq 0x1d377
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/ltablib.c
// Function: checktab
static void checktab (lua_State *L, int arg, int what) {
  if (lua_type(L, arg) != LUA_TTABLE) {  /* is it not a table? */
    int n = 1;  /* number of elements to pop */
    if (lua_getmetatable(L, arg) &&  /* must have metatable */
        (!(what & TAB_R) || checkfield(L, "__index", ++n)) &&
        (!(what & TAB_W) || checkfield(L, "__newindex", ++n)) &&
        (!(what & TAB_L) || checkfield(L, "__len", ++n))) {
      lua_pop(L, n);  /* pop metatable and tested metamethods */
    }
    else
      luaL_checktype(L, arg, LUA_TTABLE);  /* force an error */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
callq 0x5d12
cmpl $0x5, %eax
jne 0x1d24d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl %ebp, %esi
callq 0x66b9
testl %eax, %eax
je 0x1d2d7
testb $0x1, %r14b
jne 0x1d267
pushq $0x1
popq %r15
jmp 0x1d281
leaq 0x2afb(%rip), %rsi      # 0x1fd69
pushq $0x2
popq %r15
movq %rbx, %rdi
movl %r15d, %edx
callq 0x1d34c
testl %eax, %eax
je 0x1d2d7
testb $0x2, %r14b
je 0x1d2a0
incl %r15d
leaq 0x2ae0(%rip), %rsi      # 0x1fd71
movq %rbx, %rdi
movl %r15d, %edx
callq 0x1d34c
testl %eax, %eax
je 0x1d2d7
testb $0x4, %r14b
je 0x1d2bf
incl %r15d
leaq 0x2ad8(%rip), %rsi      # 0x1fd88
movq %rbx, %rdi
movl %r15d, %edx
callq 0x1d34c
testl %eax, %eax
je 0x1d2d7
notl %r15d
movq %rbx, %rdi
movl %r15d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5b31
pushq $0x5
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1315e
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/ltablib.c
// Function: addfield
static void addfield (lua_State *L, luaL_Buffer *b, lua_Integer i) {
  lua_geti(L, 1, i);
  if (!lua_isstring(L, -1))
    luaL_error(L, "invalid value (%s) at index %d in table for 'concat'",
                  luaL_typename(L, -1), i);
  luaL_addvalue(b);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x1
popq %rsi
callq 0x6518
pushq $-0x1
popq %rsi
movq %r15, %rdi
callq 0x5d8e
testl %eax, %eax
jne 0x1d33f
pushq $-0x1
popq %rsi
movq %r15, %rdi
callq 0x5d12
movq %r15, %rdi
movl %eax, %esi
callq 0x5d31
leaq 0x46d1(%rip), %rsi      # 0x21a00
movq %r15, %rdi
movq %rax, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x12bd6
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x13515
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/ltablib.c
// Function: sort_comp
static int sort_comp (lua_State *L, int a, int b) {
  if (lua_isnil(L, 2))  /* no function? */
    return lua_compare(L, a, b, LUA_OPLT);  /* a < b */
  else {  /* function */
    int res;
    lua_pushvalue(L, 2);    /* push function */
    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);      /* call function */
    res = lua_toboolean(L, -1);  /* get result */
    lua_pop(L, 1);          /* pop result */
    return res;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
pushq $0x2
popq %rsi
callq 0x5d12
testl %eax, %eax
je 0x1d748
pushq $0x2
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5cee
decl %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5cee
addl $-0x2, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5cee
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %r15d, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6bb0
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x5fa6
movl %eax, %ebp
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x5b31
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rcx
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5e4d
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lutf8lib.c
// Function: luaopen_utf8
LUAMOD_API int luaopen_utf8 (lua_State *L) {
  luaL_newlib(L, funcs);
  lua_pushlstring(L, UTF8PATT, sizeof(UTF8PATT)/sizeof(char) - 1);
  lua_setfield(L, -2, "charpattern");
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movsd 0x358c(%rip), %xmm0     # 0x20d20
movl $0x88, %esi
callq 0x13f6d
pushq $0x6
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x665a
leaq 0x114de(%rip), %rsi     # 0x2ec90
movq %rbx, %rdi
xorl %edx, %edx
callq 0x13c52
leaq 0x432d(%rip), %rsi      # 0x21af0
pushq $0xe
popq %rdx
movq %rbx, %rdi
callq 0x616f
leaq 0x432a(%rip), %rdx      # 0x21aff
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x68b9
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lutf8lib.c
// Function: byteoffset
static int byteoffset (lua_State *L) {
  size_t len;
  const char *s = luaL_checklstring(L, 1, &len);
  lua_Integer n  = luaL_checkinteger(L, 2);
  lua_Integer posi = (n >= 0) ? 1 : len + 1;
  posi = u_posrelat(luaL_optinteger(L, 3, posi), len);
  luaL_argcheck(L, 1 <= posi && --posi <= (lua_Integer)len, 3,
                   "position out of range");
  if (n == 0) {
    /* find beginning of current byte sequence */
    while (posi > 0 && iscont(s + posi)) posi--;
  }
  else {
    if (iscont(s + posi))
      luaL_error(L, "initial position is a continuation byte");
    if (n < 0) {
       while (n < 0 && posi > 0) {  /* move back */
         do {  /* find beginning of previous character */
           posi--;
         } while (posi > 0 && iscont(s + posi));
         n++;
       }
     }
     else {
       n--;  /* do not move for 1st character */
       while (n > 0 && posi < (lua_Integer)len) {
         do {  /* find beginning of next character */
           posi++;
         } while (iscont(s + posi));  /* (cannot pass final '\0') */
         n--;
       }
     }
  }
  if (n == 0)  /* did it find given character? */
    lua_pushinteger(L, posi + 1);
  else  /* no such character */
    lua_pushnil(L);
  return 1;  
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r13
movq %r13, %rdx
callq 0x13131
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x13252
movq %rax, %r12
movq (%r13), %rax
incq %rax
testq %r12, %r12
pushq $0x1
popq %rdx
cmovsq %rax, %rdx
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x132b0
movq %rax, %r15
movq (%r13), %rax
testq %r15, %r15
jns 0x1d854
movq %r15, %rcx
negq %rcx
cmpq %rcx, %rax
jae 0x1d84e
xorl %r15d, %r15d
jmp 0x1d861
addq %rax, %r15
incq %r15
testq %r15, %r15
jle 0x1d861
decq %r15
cmpq %rax, %r15
jle 0x1d873
leaq 0x42b4(%rip), %rdx      # 0x21b1c
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x12af2
testq %r12, %r12
je 0x1d8f7
movb (%r14,%r15), %al
andb $-0x40, %al
negb %al
jno 0x1d893
leaq 0x42a9(%rip), %rsi      # 0x21b32
movq %rbx, %rdi
xorl %eax, %eax
callq 0x12bd6
testq %r12, %r12
js 0x1d8e0
movq 0x8(%rsp), %rax
movq %r12, %rcx
decq %r12
cmpq $0x2, %rcx
jl 0x1d8e5
cmpq %rax, %r15
jge 0x1d8e5
movb 0x1(%r14,%r15), %cl
incq %r15
andb $-0x40, %cl
negb %cl
jo 0x1d8ae
jmp 0x1d89d
testq %r15, %r15
jle 0x1d8e5
cmpq $0x2, %r15
jb 0x1d8da
movb -0x1(%r14,%r15), %al
decq %r15
andb $-0x40, %al
negb %al
jo 0x1d8c4
jmp 0x1d8dd
xorl %r15d, %r15d
incq %r12
testq %r12, %r12
js 0x1d8bf
movq %r15, %rsi
testq %r12, %r12
je 0x1d918
movq %rbx, %rdi
callq 0x6135
jmp 0x1d923
movq %r15, %rsi
sarq $0x3f, %rsi
andq %r15, %rsi
testq %r15, %r15
jle 0x1d918
movb (%r14,%r15), %al
andb $-0x40, %al
negb %al
jno 0x1d915
decq %r15
jmp 0x1d901
movq %r15, %rsi
incq %rsi
movq %rbx, %rdi
callq 0x615b
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lutf8lib.c
// Function: codepoint
static int codepoint (lua_State *L) {
  size_t len;
  const char *s = luaL_checklstring(L, 1, &len);
  lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), len);
  lua_Integer pose = u_posrelat(luaL_optinteger(L, 3, posi), len);
  int n;
  const char *se;
  luaL_argcheck(L, posi >= 1, 2, "out of range");
  luaL_argcheck(L, pose <= (lua_Integer)len, 3, "out of range");
  if (posi > pose) return 0;  /* empty interval; return no values */
  if (pose - posi >= INT_MAX)  /* (lua_Integer -> int) overflow? */
    return luaL_error(L, "string slice too long");
  n = (int)(pose -  posi) + 1;
  luaL_checkstack(L, n, "string slice too long");
  n = 0;
  se = s + pose;
  for (s += posi - 1; s < se;) {
    int code;
    s = utf8_decode(s, &code);
    if (s == NULL)
      return luaL_error(L, "invalid UTF-8 code");
    lua_pushinteger(L, code);
    n++;
  }
  return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
movq %rsp, %rdx
callq 0x13131
movq %rax, %r14
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x132b0
movq %rax, %r12
testq %rax, %rax
jns 0x1d981
movq (%rsp), %rax
movq %r12, %rcx
negq %rcx
cmpq %rcx, %rax
jae 0x1d97b
xorl %r12d, %r12d
jmp 0x1d981
addq %rax, %r12
incq %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x132b0
movq %rax, %r15
movq (%rsp), %rax
testq %r15, %r15
jns 0x1d9b1
movq %r15, %rcx
negq %rcx
cmpq %rcx, %rax
jae 0x1d9ab
xorl %r15d, %r15d
jmp 0x1d9b1
addq %rax, %r15
incq %r15
testq %r12, %r12
jg 0x1d9cc
leaq 0x332f(%rip), %rdx      # 0x20cec
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x12af2
movq (%rsp), %rax
cmpq %rax, %r15
jle 0x1d9e3
leaq 0x3314(%rip), %rdx      # 0x20cec
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x12af2
xorl %ebp, %ebp
movq %r15, %rsi
subq %r12, %rsi
jl 0x1da5c
cmpq $0x7fffffff, %rsi       # imm = 0x7FFFFFFF
jl 0x1d9ff
leaq 0x3ba7(%rip), %rsi      # 0x215a4
jmp 0x1da50
incl %esi
leaq 0x3b9c(%rip), %rdx      # 0x215a4
movq %rbx, %rdi
callq 0x12a9f
addq %r14, %r15
addq %r14, %r12
decq %r12
xorl %ebp, %ebp
leaq 0xc(%rsp), %r14
cmpq %r15, %r12
jae 0x1da5c
movq %r12, %rdi
movq %r14, %rsi
callq 0x1dc3b
testq %rax, %rax
je 0x1da49
movq %rax, %r12
movslq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x615b
incl %ebp
jmp 0x1da20
leaq 0x410a(%rip), %rsi      # 0x21b5a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x12bd6
movl %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lutf8lib.c
// Function: utfchar
static int utfchar (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  if (n == 1)  /* optimize common case of single char */
    pushutfchar(L, 1);
  else {
    int i;
    luaL_Buffer b;
    luaL_buffinit(L, &b);
    for (i = 1; i <= n; i++) {
      pushutfchar(L, i);
      luaL_addvalue(&b);
    }
    luaL_pushresult(&b);
  }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, %rbx
callq 0x5b1d
cmpl $0x1, %eax
jne 0x1da94
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1dcbb
jmp 0x1dadd
movl %eax, %ebp
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13589
xorl %r12d, %r12d
testl %ebp, %ebp
cmovgl %ebp, %r12d
negl %r12d
pushq $0x1
popq %r15
leal (%r12,%r15), %eax
cmpl $0x1, %eax
je 0x1dad5
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1dcbb
movq %r14, %rdi
callq 0x13515
incl %r15d
jmp 0x1dab4
movq %rsp, %rdi
callq 0x134ba
pushq $0x1
popq %rax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lutf8lib.c
// Function: utflen
static int utflen (lua_State *L) {
  int n = 0;
  size_t len;
  const char *s = luaL_checklstring(L, 1, &len);
  lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), len);
  lua_Integer posj = u_posrelat(luaL_optinteger(L, 3, -1), len);
  luaL_argcheck(L, 1 <= posi && --posi <= (lua_Integer)len, 2,
                   "initial position out of string");
  luaL_argcheck(L, --posj < (lua_Integer)len, 3,
                   "final position out of string");
  while (posi <= posj) {
    const char *s1 = utf8_decode(s + posi, NULL);
    if (s1 == NULL) {  /* conversion error? */
      lua_pushnil(L);  /* return nil ... */
      lua_pushinteger(L, posi + 1);  /* ... and current position */
      return 2;
    }
    posi = s1 - s;
    n++;
  }
  lua_pushinteger(L, n);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
movq %rsp, %rdx
callq 0x13131
movq %rax, %r15
pushq $0x2
popq %rbp
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x132b0
movq %rax, %r14
testq %rax, %rax
jns 0x1db3e
movq (%rsp), %rax
movq %r14, %rcx
negq %rcx
cmpq %rcx, %rax
jae 0x1db38
xorl %r14d, %r14d
jmp 0x1db3e
addq %rax, %r14
incq %r14
pushq $0x3
popq %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x132b0
movq %rax, %r13
movq (%rsp), %rax
testq %r13, %r13
jns 0x1db6e
movq %r13, %rcx
negq %rcx
cmpq %rcx, %rax
jae 0x1db68
xorl %r13d, %r13d
jmp 0x1db6e
addq %rax, %r13
incq %r13
testq %r14, %r14
jle 0x1db7b
decq %r14
cmpq %rax, %r14
jle 0x1db91
leaq 0x3dfe(%rip), %rdx      # 0x21980
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x12af2
movq (%rsp), %rax
cmpq %rax, %r13
jle 0x1dba8
leaq 0x3fd3(%rip), %rdx      # 0x21b70
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x12af2
xorl %r12d, %r12d
cmpq %r13, %r14
jge 0x1dbcb
leaq (%r15,%r14), %rdi
xorl %esi, %esi
callq 0x1dc3b
testq %rax, %rax
je 0x1dbd0
subq %r15, %rax
incq %r12
movq %rax, %r14
jmp 0x1dbab
pushq $0x1
popq %rbp
jmp 0x1dbde
movq %rbx, %rdi
callq 0x6135
incq %r14
movq %r14, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x615b
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lutf8lib.c
// Function: iter_codes
static int iter_codes (lua_State *L) {
  luaL_checkstring(L, 1);
  lua_pushcfunction(L, iter_aux);
  lua_pushvalue(L, 1);
  lua_pushinteger(L, 0);
  return 3;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x13131
leaq 0xea(%rip), %rsi        # 0x1dcfd
movq %rbx, %rdi
xorl %edx, %edx
callq 0x630a
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5cee
movq %rbx, %rdi
xorl %esi, %esi
callq 0x615b
pushq $0x3
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lutf8lib.c
// Function: utf8_decode
static const char *utf8_decode (const char *o, int *val) {
  static const unsigned int limits[] = {0xFF, 0x7F, 0x7FF, 0xFFFF};
  const unsigned char *s = (const unsigned char *)o;
  unsigned int c = s[0];
  unsigned int res = 0;  /* final result */
  if (c < 0x80)  /* ascii? */
    res = c;
  else {
    int count = 0;  /* to count number of continuation bytes */
    while (c & 0x40) {  /* still have continuation bytes? */
      int cc = s[++count];  /* read next byte */
      if ((cc & 0xC0) != 0x80)  /* not a continuation byte? */
        return NULL;  /* invalid byte sequence */
      res = (res << 6) | (cc & 0x3F);  /* add lower 6 bits from cont. byte */
      c <<= 1;  /* to test next bit */
    }
    res |= ((c & 0x7F) << (count * 5));  /* add first byte */
    if (count > 3 || res > MAXUNICODE || res <= limits[count])
      return NULL;  /* invalid byte sequence */
    s += count;  /* skip continuation bytes read */
  }
  if (val) *val = res;
  return (const char *)s + 1;  /* +1 to include first byte */
}

// Assembly:
pushq %rbx
movzbl (%rdi), %edx
testb %dl, %dl
js 0x1dc52
testq %rsi, %rsi
je 0x1dc4a
movl %edx, (%rsi)
incq %rdi
movq %rdi, %rax
jmp 0x1dcb9
leaq 0x3f37(%rip), %r8       # 0x21b90
xorl %eax, %eax
xorl %ecx, %ecx
xorl %r9d, %r9d
xorl %r10d, %r10d
testb $0x40, %dl
je 0x1dc95
movzbl 0x1(%rdi,%r9), %r11d
incq %r9
movl %r11d, %ebx
andl $-0x40, %ebx
shll $0x6, %r10d
andl $0x3f, %r11d
orl %r11d, %r10d
addl %edx, %edx
addq $0x4, %r8
addl $0x5, %ecx
cmpl $0x80, %ebx
je 0x1dc63
jmp 0x1dcb9
andl $0x3f, %edx
shll %cl, %edx
xorl %eax, %eax
cmpq $0x3, %r9
ja 0x1dcb9
orl %r10d, %edx
cmpl $0x10ffff, %edx         # imm = 0x10FFFF
ja 0x1dcb9
cmpl (%r8), %edx
jbe 0x1dcb7
addq %r9, %rdi
jmp 0x1dc43
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lutf8lib.c
// Function: iter_aux
static int iter_aux (lua_State *L) {
  size_t len;
  const char *s = luaL_checklstring(L, 1, &len);
  lua_Integer n = lua_tointeger(L, 2) - 1;
  if (n < 0)  /* first iteration? */
    n = 0;  /* start from here */
  else if (n < (lua_Integer)len) {
    n++;  /* skip current byte */
    while (iscont(s + n)) n++;  /* and its continuations */
  }
  if (n >= (lua_Integer)len)
    return 0;  /* no more codepoints */
  else {
    int code;
    const char *next = utf8_decode(s + n, &code);
    if (next == NULL || iscont(next))
      return luaL_error(L, "invalid UTF-8 code");
    lua_pushinteger(L, n + 1);
    lua_pushinteger(L, code);
    return 2;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x13131
movq %rax, %r14
xorl %r12d, %r12d
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x5f59
movq (%r15), %rcx
movl $0x0, %r15d
testq %rax, %rax
jle 0x1dd60
cmpq %rcx, %rax
jle 0x1dd4c
decq %rax
movq %rax, %r15
jmp 0x1dd60
decq %rax
movq %rax, %r15
movb 0x1(%r14,%r15), %al
andb $-0x40, %al
incq %r15
negb %al
jo 0x1dd52
cmpq %rcx, %r15
jge 0x1ddb5
addq %r15, %r14
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x1dc3b
testq %rax, %rax
je 0x1dd82
movb (%rax), %al
andb $-0x40, %al
negb %al
jno 0x1dd97
leaq 0x3dd1(%rip), %rsi      # 0x21b5a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x12bd6
movl %eax, %ebp
jmp 0x1ddb2
incq %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x615b
movslq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x615b
movl %ebp, %r12d
movl %r12d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/loadlib.c
// Function: setpath
static void setpath (lua_State *L, const char *fieldname, const char *envname1,
                                   const char *envname2, const char *def) {
  const char *path = getenv(envname1);
  if (path == NULL)  /* no environment variable? */
    path = getenv(envname2);  /* try alternative name */
  if (path == NULL || noenv(L))  /* no environment variable? */
    lua_pushstring(L, def);  /* use default */
  else {
    /* replace ";;" by ";AUXMARK;" and then AUXMARK by default path */
    path = luaL_gsub(L, path, LUA_PATH_SEP LUA_PATH_SEP,
                              LUA_PATH_SEP AUXMARK LUA_PATH_SEP);
    luaL_gsub(L, path, AUXMARK, def);
    lua_remove(L, -2);
  }
  setprogdir(L);
  lua_setfield(L, -2, fieldname);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x5040
testq %rax, %rax
jne 0x1dfef
movq %r13, %rdi
callq 0x5040
testq %rax, %rax
je 0x1e022
movq %rax, %r12
leaq 0x3df0(%rip), %rdx      # 0x21de9
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x64f4
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x5fa6
movl %eax, %ebp
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x5b31
testl %ebp, %ebp
je 0x1e02f
movq %r14, %rdi
movq %r15, %rsi
callq 0x61d0
jmp 0x1e077
leaq 0x3daa(%rip), %rdx      # 0x21de0
leaq 0x3da6(%rip), %rcx      # 0x21de3
movq %r14, %rdi
movq %r12, %rsi
callq 0x13e30
leaq 0x3d98(%rip), %rdx      # 0x21de7
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rcx
callq 0x13e30
pushq $-0x2
popq %rbp
pushq $-0x1
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x5b7f
movq %r14, %rdi
movl %ebp, %esi
callq 0x5b31
pushq $-0x2
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x68b9
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/loadlib.c
// Function: gctm
static int gctm (lua_State *L) {
  lua_Integer n = luaL_len(L, 1);
  for (; n >= 1; n--) {  /* for each handle, in reverse order */
    lua_rawgeti(L, 1, n);  /* get handle CLIBS[n] */
    lsys_unloadlib(lua_touserdata(L, -1));
    lua_pop(L, 1);  /* pop handle */
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x13ad1
movq %rax, %r14
pushq $-0x1
popq %r15
pushq $-0x2
popq %r12
testq %r14, %r14
jle 0x1e0e0
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x65cf
movq %rbx, %rdi
movl %r15d, %esi
callq 0x60b5
movq %rbx, %rdi
movl %r12d, %esi
callq 0x5b31
decq %r14
jmp 0x1e0b3
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/loadlib.c
// Function: ll_loadlib
static int ll_loadlib (lua_State *L) {
  const char *path = luaL_checkstring(L, 1);
  const char *init = luaL_checkstring(L, 2);
  int stat = lookforfunc(L, path, init);
  if (stat == 0)  /* no errors? */
    return 1;  /* return the loaded function */
  else {  /* error; error message is on stack top */
    lua_pushnil(L);
    lua_insert(L, -2);
    lua_pushstring(L, (stat == ERRLIB) ?  LIB_FAIL : "init");
    return 3;  /* return nil, error message, and where */
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x13131
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x13131
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1e201
testl %eax, %eax
je 0x1e15a
movl %eax, %r14d
movq %rbx, %rdi
callq 0x6135
pushq $-0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x5b7f
cmpl $0x1, %r14d
leaq 0x3bb3(%rip), %rax      # 0x21cf7
leaq 0xf85(%rip), %rsi       # 0x1f0d0
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x61d0
pushq $0x3
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/loadlib.c
// Function: ll_searchpath
static int ll_searchpath (lua_State *L) {
  const char *f = searchpath(L, luaL_checkstring(L, 1),
                                luaL_checkstring(L, 2),
                                luaL_optstring(L, 3, "."),
                                luaL_optstring(L, 4, LUA_DIRSEP));
  if (f != NULL) return 1;
  else {  /* error message is on top of the stack */
    lua_pushnil(L);
    lua_insert(L, -2);
    return 2;  /* return nil + error message */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %r14
movl %r14d, %esi
xorl %edx, %edx
callq 0x13131
movq %rax, %r15
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x13131
movq %rax, %r12
leaq 0x2110(%rip), %rdx      # 0x202a9
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x130d8
movq %rax, %r13
leaq 0x27e0(%rip), %rdx      # 0x20990
pushq $0x4
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x130d8
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rax, %r8
callq 0x1e294
testq %rax, %rax
jne 0x1e1ef
movq %rbx, %rdi
callq 0x6135
pushq $-0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x5b7f
movl %ebp, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/loadlib.c
// Function: lookforfunc
static int lookforfunc (lua_State *L, const char *path, const char *sym) {
  void *reg = checkclib(L, path);  /* check loaded C libraries */
  if (reg == NULL) {  /* must load library? */
    reg = lsys_load(L, path, *sym == '*');  /* global symbols if 'sym'=='*' */
    if (reg == NULL) return ERRLIB;  /* unable to load library */
    addtoclib(L, path, reg);
  }
  if (*sym == '*') {  /* loading only library (no function)? */
    lua_pushboolean(L, 1);  /* return 'true' */
    return 0;  /* no errors */
  }
  else {
    lua_CFunction f = lsys_sym(L, reg, sym);
    if (f == NULL)
      return ERRFUNC;  /* unable to find function */
    lua_pushcfunction(L, f);  /* else create new function */
    return 0;  /* no errors */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x3c20(%rip), %rdx      # 0x21e38
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x660d
pushq $-0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x64f4
movq %rbx, %rdi
movl %ebp, %esi
callq 0x60b5
movq %rax, %r15
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x5b31
testq %r15, %r15
je 0x1e264
cmpb $0x2a, (%r14)
jne 0x1e277
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x6386
xorl %eax, %eax
jmp 0x1e289
leaq 0x3a93(%rip), %rsi      # 0x21cfe
movq %rbx, %rdi
callq 0x61d0
pushq $0x1
jmp 0x1e288
leaq 0x3a80(%rip), %rsi      # 0x21cfe
movq %rbx, %rdi
callq 0x61d0
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/loadlib.c
// Function: searchpath
static const char *searchpath (lua_State *L, const char *name,
                                             const char *path,
                                             const char *sep,
                                             const char *dirsep) {
  luaL_Buffer msg;  /* to build error message */
  luaL_buffinit(L, &msg);
  if (*sep != '\0')  /* non-empty separator? */
    name = luaL_gsub(L, name, sep, dirsep);  /* replace it by 'dirsep' */
  while ((path = pushnexttemplate(L, path)) != NULL) {
    const char *filename = luaL_gsub(L, lua_tostring(L, -1),
                                     LUA_PATH_MARK, name);
    lua_remove(L, -2);  /* remove path template */
    if (readable(filename))  /* does file exist and is readable? */
      return filename;  /* return that file name */
    lua_pushfstring(L, "\n\tno file '%s'", filename);
    lua_remove(L, -2);  /* remove file name */
    luaL_addvalue(&msg);  /* concatenate error msg. entry */
  }
  luaL_pushresult(&msg);  /* create error message */
  return NULL;  /* not found */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2028, %rsp           # imm = 0x2028
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
callq 0x13589
cmpb $0x0, (%r12)
je 0x1e2d9
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x13e30
movq %rax, %r14
pushq $-0x1
popq %r15
pushq $-0x2
popq %r13
movzbl (%rbp), %eax
cmpl $0x3b, %eax
je 0x1e3c2
testl %eax, %eax
je 0x1e3ca
movq %rbp, %rdi
pushq $0x3b
popq %rsi
callq 0x5160
movq %rax, %r12
testq %rax, %rax
jne 0x1e317
movq %rbp, %rdi
callq 0x5140
movq %rax, %r12
addq %rbp, %r12
movq %r12, %rdx
subq %rbp, %rdx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x616f
testq %r12, %r12
je 0x1e3ca
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x5fca
movq %rbx, %rdi
movq %rax, %rsi
leaq 0x102b(%rip), %rdx      # 0x1f376
movq %r14, %rcx
callq 0x13e30
movq %rax, %rbp
movq %rbx, %rdi
movl %r13d, %esi
movl %r15d, %edx
callq 0x5b7f
movq %rbx, %rdi
movl %r13d, %esi
callq 0x5b31
movq %rbp, %rdi
leaq 0xcbd(%rip), %rsi       # 0x1f036
callq 0x52d0
testq %rax, %rax
jne 0x1e3d8
movq %rbx, %rdi
leaq 0x39ac(%rip), %rsi      # 0x21d39
movq %rbp, %rdx
xorl %eax, %eax
callq 0x6261
movq %rbx, %rdi
movl %r13d, %esi
movl %r15d, %edx
callq 0x5b7f
movq %rbx, %rdi
movl %r13d, %esi
callq 0x5b31
leaq 0x8(%rsp), %rdi
callq 0x13515
movq %r12, %rbp
jmp 0x1e2e1
incq %rbp
jmp 0x1e2e1
leaq 0x8(%rsp), %rdi
callq 0x134ba
xorl %ebp, %ebp
jmp 0x1e3e0
movq %rax, %rdi
callq 0x5130
movq %rbp, %rax
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/loadlib.c
// Function: searcher_preload
static int searcher_preload (lua_State *L) {
  const char *name = luaL_checkstring(L, 1);
  lua_getfield(L, LUA_REGISTRYINDEX, "_PRELOAD");
  if (lua_getfield(L, -1, name) == LUA_TNIL)  /* not found? */
    lua_pushfstring(L, "\n\tno field package.preload['%s']", name);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x13131
movq %rax, %r14
leaq 0x38b9(%rip), %rdx      # 0x21cc9
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x64f4
pushq $-0x1
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x64f4
testl %eax, %eax
jne 0x1e443
leaq 0x3912(%rip), %rsi      # 0x21d48
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x6261
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/loadlib.c
// Function: searcher_Lua
static int searcher_Lua (lua_State *L) {
  const char *filename;
  const char *name = luaL_checkstring(L, 1);
  filename = findfile(L, name, "path", LUA_LSUBSEP);
  if (filename == NULL) return 1;  /* module not found in this path */
  return checkload(L, (luaL_loadfile(L, filename) == LUA_OK), filename);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x13131
leaq 0x37e8(%rip), %rdx      # 0x21c4e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1e5d4
testq %rax, %rax
je 0x1e4a0
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x136bb
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1e63f
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/loadlib.c
// Function: searcher_C
static int searcher_C (lua_State *L) {
  const char *name = luaL_checkstring(L, 1);
  const char *filename = findfile(L, name, "cpath", LUA_CSUBSEP);
  if (filename == NULL) return 1;  /* module not found in this path */
  return checkload(L, (loadfunc(L, filename, name) == 0), filename);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x13131
movq %rax, %r15
leaq 0x3786(%rip), %rdx      # 0x21c4d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1e5d4
testq %rax, %rax
je 0x1e500
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1e69e
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1e63f
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/loadlib.c
// Function: searcher_Croot
static int searcher_Croot (lua_State *L) {
  const char *filename;
  const char *name = luaL_checkstring(L, 1);
  const char *p = strchr(name, '.');
  int stat;
  if (p == NULL) return 0;  /* is root */
  lua_pushlstring(L, name, p - name);
  filename = findfile(L, lua_tostring(L, -1), "cpath", LUA_CSUBSEP);
  if (filename == NULL) return 1;  /* root not found */
  if ((stat = loadfunc(L, filename, name)) != 0) {
    if (stat != ERRFUNC)
      return checkload(L, 0, filename);  /* real error */
    else {  /* open function not found */
      lua_pushfstring(L, "\n\tno module '%s' in file '%s'", name, filename);
      return 1;
    }
  }
  lua_pushstring(L, filename);  /* will be 2nd argument to module */
  return 2;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %r12d, %r12d
pushq $0x1
popq %rbx
movl %ebx, %esi
xorl %edx, %edx
callq 0x13131
movq %rax, %r15
pushq $0x2e
popq %rsi
movq %rax, %rdi
callq 0x5160
testq %rax, %rax
je 0x1e5b0
subq %r15, %rax
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x616f
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x5fca
leaq 0x36f2(%rip), %rdx      # 0x21c4d
movq %r14, %rdi
movq %rax, %rsi
callq 0x1e5d4
testq %rax, %rax
je 0x1e59c
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1e69e
testl %eax, %eax
je 0x1e5a1
cmpl $0x2, %eax
jne 0x1e5bf
leaq 0x3836(%rip), %rsi      # 0x21dc2
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x6261
movl %ebx, %r12d
jmp 0x1e5b0
movq %r14, %rdi
movq %r12, %rsi
callq 0x61d0
pushq $0x2
popq %r12
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1e63f
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/loadlib.c
// Function: findfile
static const char *findfile (lua_State *L, const char *name,
                                           const char *pname,
                                           const char *dirsep) {
  const char *path;
  lua_getfield(L, lua_upvalueindex(1), pname);
  path = lua_tostring(L, -1);
  if (path == NULL)
    luaL_error(L, "'package.%s' must be a string", pname);
  return searchpath(L, name, path, ".", dirsep);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x64f4
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x5fca
movq %rax, %r12
testq %rax, %rax
jne 0x1e618
leaq 0x375e(%rip), %rsi      # 0x21d69
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x12bd6
leaq 0x1c8a(%rip), %rcx      # 0x202a9
leaq 0x236a(%rip), %r8       # 0x20990
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1e294
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/loadlib.c
// Function: checkload
static int checkload (lua_State *L, int stat, const char *filename) {
  if (stat) {  /* module loaded successfully? */
    lua_pushstring(L, filename);  /* will be 2nd argument to module */
    return 2;  /* return open function and file name */
  }
  else
    return luaL_error(L, "error loading module '%s' from file '%s':\n\t%s",
                          lua_tostring(L, 1), filename, lua_tostring(L, -1));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
testl %esi, %esi
je 0x1e662
movq %r14, %rdi
movq %rbx, %rsi
callq 0x61d0
pushq $0x2
popq %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x5fca
movq %rax, %r15
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x5fca
leaq 0x3701(%rip), %rsi      # 0x21d87
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x12bd6
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/loadlib.c
// Function: loadfunc
static int loadfunc (lua_State *L, const char *filename, const char *modname) {
  const char *openfunc;
  const char *mark;
  modname = luaL_gsub(L, modname, ".", LUA_OFSEP);
  mark = strchr(modname, *LUA_IGMARK);
  if (mark) {
    int stat;
    openfunc = lua_pushlstring(L, modname, mark - modname);
    openfunc = lua_pushfstring(L, LUA_POF"%s", openfunc);
    stat = lookforfunc(L, filename, openfunc);
    if (stat != ERRFUNC) return stat;
    modname = mark + 1;  /* else go ahead and try old-style name */
  }
  openfunc = lua_pushfstring(L, LUA_POF"%s", modname);
  return lookforfunc(L, filename, openfunc);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1bf6(%rip), %rax      # 0x202a9
leaq 0x36fb(%rip), %rcx      # 0x21db5
movq %rdx, %rsi
movq %rax, %rdx
callq 0x13e30
movq %rax, %r12
pushq $0x2d
popq %rsi
movq %rax, %rdi
callq 0x5160
testq %rax, %rax
je 0x1e719
movq %rax, %r15
movq %rax, %rdx
subq %r12, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x616f
leaq 0x36c4(%rip), %rsi      # 0x21db7
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x6261
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1e201
cmpl $0x2, %eax
jne 0x1e746
incq %r15
movq %r15, %r12
leaq 0x3697(%rip), %rsi      # 0x21db7
movq %r14, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x6261
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1e201
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch4/Pair.c
// Function: Pair_new
int Pair_new(lua_State *L) {

  // Extract the x, y data from the stack.
  luaL_checktype(L, 2, LUA_TTABLE);
      // stack = [self, p]
  lua_rawgeti(L, 2, 1);  // 2, 1 = idx in stack, idx in table
      // stack = [self, p, p[1]]
  lua_rawgeti(L, 2, 2);
      // stack = [self, p, p[1], p[2]]
  lua_Number x = lua_tonumber(L, -2);  // p[1]
  lua_Number y = lua_tonumber(L, -1);  // p[2]
  lua_settop(L, 0);
      // stack = []

  // Create a Pair instance and set its metatable.
  Pair *pair = (Pair *)lua_newuserdata(L, sizeof(Pair));
      // stack = [pair]
  luaL_getmetatable(L, Pair_metatable);
      // stack = [pair, mt]
  lua_setmetatable(L, 1);
      // stack = [pair]

  // Set up the C data.
  pair->x = x;
  pair->y = y;

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x2
popq %r14
pushq $0x5
popq %rdx
movl %r14d, %esi
callq 0x1315e
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x65cf
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x65cf
pushq $-0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5f0b
movsd %xmm0, -0x28(%rbp)
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5f0b
movsd %xmm0, -0x20(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5b31
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x6ffe
movq %rax, %r14
leaq 0x6cf(%rip), %rdx       # 0x1f095
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x64f4
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x6ad0
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%r14)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x8(%r14)
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch4/Pair.c
// Function: push_new_pair
void push_new_pair(lua_State *L, lua_Number x, lua_Number y) {

  // Clear the stack.
  lua_settop(L, 0);
    // stack = []

  // Set up the new resulting Pair instance.
  lua_newtable(L);
    // stack = [t (the new table)]
  lua_pushnumber(L, x);
    // stack = [t, x]
  lua_rawseti(L, -2, 1);  // t[1] = x
    // stack = [t]
  lua_pushnumber(L, y);
    // stack = [t, y]
  lua_rawseti(L, -2, 2);  // t[2] = y
    // stack = [t]
  lua_pushvalue(L, -1);
    // stack = [t, t]
  Pair_new(L);
    // stack = [new Pair from t]
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm1, -0x20(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdi, %rbx
xorl %esi, %esi
callq 0x5b31
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x665a
movq %rbx, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x6146
pushq $-0x2
popq %r14
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x69fb
movq %rbx, %rdi
movsd -0x20(%rbp), %xmm0
callq 0x6146
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x69fb
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x5cee
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1e948
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch4/Pair.c
// Function: Pair_mt_index
int Pair_mt_index(lua_State *L) {

  // Expected: stack = [self, key]
  Pair *pair = (Pair *)luaL_checkudata(L, 1, Pair_metatable);

  // Find the key value as either 1 (x) or 2 (y).
  int key = 0;
  int t = lua_type(L, 2);
  if (t == LUA_TNUMBER) {
    int ok;
    key = (int)lua_tointegerx(L, 2, &ok);
    if (!ok || (key != 1 && key != 2)) key = 0;
  } else if (t == LUA_TSTRING) {
    const char *str_key = lua_tostring(L, 2);
    if (strcmp(str_key, "x") == 0) key = 1;
    if (strcmp(str_key, "y") == 0) key = 2;
  }

  // Push the value.
  if (key) {
    lua_pushnumber(L, key == 1 ? pair->x : pair->y);
  } else {
    lua_pushnil(L);
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5fc(%rip), %rdx       # 0x1f095
pushq $0x1
popq %rsi
callq 0x12fa2
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x5d12
cmpl $0x4, %eax
je 0x1eae1
cmpl $0x3, %eax
jne 0x1eb18
pushq $0x2
popq %rsi
leaq -0x1c(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x5f59
cmpl $0x0, (%r15)
sete %cl
leal -0x3(%rax), %edx
cmpl $-0x2, %edx
setb %dl
orb %cl, %dl
je 0x1eb07
jmp 0x1eb18
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5fca
movq %rax, %rcx
movzbl (%rax), %eax
cmpl $0x79, %eax
je 0x1eb12
cmpl $0x78, %eax
jne 0x1eb18
xorl %eax, %eax
cmpb $0x0, 0x1(%rcx)
sete %al
testl %eax, %eax
je 0x1eb18
cmpl $0x1, %eax
je 0x1eb26
jmp 0x1eb22
cmpb $0x0, 0x1(%rcx)
je 0x1eb22
movq %rbx, %rdi
callq 0x6135
jmp 0x1eb33
addq $0x8, %r14
movsd (%r14), %xmm0
movq %rbx, %rdi
callq 0x6146
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch4/Pair.c
// Function: Pair_mt_add
int Pair_mt_add(lua_State *L) {

  // Expected: stack = [self, other]
  // other may be a Pair or a table of the form {x, y}.
  
  // Extract the pairs p, q from the stack.
  Pair *pair = (Pair *)luaL_checkudata(L, 1, Pair_metatable);
  lua_Number p[2] = {pair->x, pair->y};
  lua_Number q[2];
  for (int i = 0; i < 2; ++i) {
    lua_pushnumber(L, i + 1);
      // stack = [self, other, i + 1]
    lua_gettable(L, 2);
      // stack = [self, other, other[i + 1]]
    if (lua_type(L, -1) != LUA_TNUMBER) {
      return luaL_argerror(L, 2, "bad 2nd addend");
    }
    q[i] = lua_tonumber(L, -1);
    lua_pop(L, 1);
      // stack = [self, other]
  }
  lua_settop(L, 0);
    // stack = []

  // Set up a new table with the sum.
  push_new_pair(L, p[0] + q[0], p[1] + q[1]);

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x539(%rip), %rdx       # 0x1f095
pushq $0x1
popq %rsi
callq 0x12fa2
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
xorl %r13d, %r13d
pushq $0x2
popq %r14
pushq $-0x1
popq %r15
pushq $-0x2
popq %r12
cmpq $0x2, %r13
je 0x1ebdb
leal 0x1(%r13), %eax
cvtsi2sd %eax, %xmm0
movq %rbx, %rdi
callq 0x6146
movq %rbx, %rdi
movl %r14d, %esi
callq 0x648d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5d12
cmpl $0x3, %eax
jne 0x1ec13
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x5f0b
movsd %xmm0, -0x50(%rbp,%r13,8)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x5b31
incq %r13
jmp 0x1eb86
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5b31
movsd -0x38(%rbp), %xmm0
addsd -0x50(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
addsd -0x48(%rbp), %xmm1
movq %rbx, %rdi
callq 0x1ea05
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3222(%rip), %rdx      # 0x21e3c
pushq $0x2
popq %rsi
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12af2
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch4/Pair.c
// Function: Pair_mt_mul
int Pair_mt_mul(lua_State *L) {

  // Expected: stack = [self, scalar]

  // Extract the needed values.
  Pair *pair = (Pair *)luaL_checkudata(L, 1, Pair_metatable);
  lua_Number scalar = luaL_checknumber(L, 2);

  // Set up the new resulting Pair instance.
  push_new_pair(L, pair->x * scalar, pair->y * scalar);

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x44e(%rip), %rdx       # 0x1f095
pushq $0x1
popq %r14
movl %r14d, %esi
callq 0x12fa2
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x131db
movapd %xmm0, %xmm1
movsd (%r15), %xmm0
mulsd %xmm1, %xmm0
mulsd 0x8(%r15), %xmm1
movq %rbx, %rdi
callq 0x1ea05
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq