LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: unpackint
static lua_Integer unpackint (lua_State *L, const char *str,
                              int islittle, int size, int issigned) {
  lua_Unsigned res = 0;
  int i;
  int limit = (size  <= SZINT) ? size : SZINT;
  for (i = limit - 1; i >= 0; i--) {
    res <<= NB;
    res |= (lua_Unsigned)(unsigned char)str[islittle ? i : size - 1 - i];
  }
  if (size < SZINT) {  /* real size smaller than lua_Integer? */
    if (issigned) {  /* needs sign extension? */
      lua_Unsigned mask = (lua_Unsigned)1 << (size*NB - 1);
      res = ((res ^ mask) - mask);  /* do sign extension */
    }
  }
  else if (size > SZINT) {  /* must check unread bytes */
    int mask = (!issigned || (lua_Integer)res >= 0) ? 0 : MC;
    for (i = limit; i < size; i++) {
      if ((unsigned char)str[islittle ? i : size - 1 - i] != mask)
        luaL_error(L, "%d-byte integer does not fit into Lua Integer", size);
    }
  }
  return (lua_Integer)res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movq %rdi, 0x10(%rsp)
cmpl $0x8, %ecx
movl $0x8, %r13d
cmovll %ecx, %r13d
testl %ecx, %ecx
jle 0x1f80f
movl %edx, %ebp
movq %rsi, %r15
leal 0x1(%r13), %eax
movl %ebx, %ecx
subl %r13d, %ecx
xorl %r14d, %r14d
leal -0x2(%rax), %esi
movq %r14, %rdx
shlq $0x8, %rdx
testl %ebp, %ebp
cmovel %ecx, %esi
movslq %esi, %rsi
movzbl (%r15,%rsi), %r14d
orq %rdx, %r14
decl %eax
incl %ecx
cmpl $0x1, %eax
jg 0x1f787
cmpl $0x7, %ebx
jle 0x1f812
cmpl $0x8, %ebx
je 0x1f82d
xorl %eax, %eax
testq %rdx, %rdx
movl $0xff, %ecx
cmovnsl %eax, %ecx
testl %r8d, %r8d
cmovel %r8d, %ecx
movl %r13d, %r12d
notl %r12d
addl %ebx, %r12d
movl %ecx, 0xc(%rsp)
testl %ebp, %ebp
movl %r13d, %eax
cmovel %r12d, %eax
cltq
movzbl (%r15,%rax), %eax
cmpl %eax, %ecx
je 0x1f802
movq 0x10(%rsp), %rdi
leaq 0x5169(%rip), %rsi      # 0x2495e
movl %ebx, %edx
xorl %eax, %eax
callq 0x14a62
movl 0xc(%rsp), %ecx
incl %r13d
decl %r12d
cmpl %ebx, %r13d
jl 0x1f7d5
jmp 0x1f82d
xorl %r14d, %r14d
testl %r8d, %r8d
je 0x1f82d
shll $0x3, %ebx
decb %bl
movl $0x1, %eax
movl %ebx, %ecx
shlq %cl, %rax
btcq %rbx, %r14
subq %rax, %r14
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltablib.c
// Function: tconcat
static int tconcat (lua_State *L) {
  luaL_Buffer b;
  lua_Integer last = aux_getn(L, 1, TAB_R);
  size_t lsep;
  const char *sep = luaL_optlstring(L, 2, "", &lsep);
  lua_Integer i = luaL_optinteger(L, 3, 1);
  last = luaL_optinteger(L, 4, last);
  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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2030, %rsp           # imm = 0x2030
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x1fea4
movq %rbx, %rdi
movl $0x1, %esi
callq 0x15a57
movq %rax, %r15
leaq 0x54d2(%rip), %rdx      # 0x24d88
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x14fa6
movq %rax, %r14
movl $0x1, %edx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1518f
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
movq %r15, %rdx
callq 0x1518f
movq %rax, %r15
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x154c8
cmpq %r15, %r12
jge 0x1f932
leaq 0x10(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1ff8f
movq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0x1534f
incq %r12
cmpq %r12, %r15
jne 0x1f90a
jmp 0x1f934
jne 0x1f944
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1ff8f
leaq 0x10(%rsp), %rdi
callq 0x153c0
movl $0x1, %eax
addq $0x2030, %rsp           # imm = 0x2030
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltablib.c
// Function: tinsert
static int tinsert (lua_State *L) {
  lua_Integer e = aux_getn(L, 1, TAB_RW) + 1;  /* first empty element */
  lua_Integer 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: {
      lua_Integer i;
      pos = luaL_checkinteger(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_geti(L, 1, i - 1);
        lua_seti(L, 1, i);  /* t[i] = t[i - 1] */
      }
      break;
    }
    default: {
      return luaL_error(L, "wrong number of arguments to 'insert'");
    }
  }
  lua_seti(L, 1, pos);  /* t[pos] = v */
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
movl $0x7, %edx
callq 0x1fea4
movq %rbx, %rdi
movl $0x1, %esi
callq 0x15a57
movq %rax, %r14
leaq 0x1(%rax), %r12
movq %rbx, %rdi
callq 0x5d39
cmpl $0x2, %eax
je 0x1fa17
cmpl $0x3, %eax
jne 0x1fa35
movq %rbx, %rdi
movl $0x2, %esi
callq 0x15124
movq %rax, %r15
testq %rax, %rax
setle %al
cmpq %r12, %r15
setg %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1f9df
leaq 0x4ffb(%rip), %rdx      # 0x249cd
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1497c
cmpq %r15, %r14
jl 0x1fa14
leaq 0x1(%r14), %r12
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x68b9
movq %rbx, %rdi
movl $0x1, %esi
movq %r12, %rdx
callq 0x6c8a
leaq -0x1(%r14), %rax
cmpq %r15, %r14
movq %rax, %r14
jg 0x1f9e4
movq %r15, %r12
movq %rbx, %rdi
movl $0x1, %esi
movq %r12, %rdx
callq 0x6c8a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4fa8(%rip), %rsi      # 0x249e4
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x14a62
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltablib.c
// Function: pack
static int pack (lua_State *L) {
  int i;
  int n = lua_gettop(L);  /* number of elements to pack */
  lua_createtable(L, n, 1);  /* create result table */
  lua_insert(L, 1);  /* put it at index 1 */
  for (i = n; i >= 1; i--)  /* assign elements */
    lua_seti(L, 1, i);
  lua_pushinteger(L, n);
  lua_setfield(L, 1, "n");  /* t.n = number of elements */
  return 1;  /* return table */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x5d39
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
movl $0x1, %edx
callq 0x69fb
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x5eb2
testl %ebp, %ebp
jle 0x1faa4
movl %ebp, %r14d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x6c8a
leaq -0x1(%r14), %rax
cmpq $0x1, %r14
movq %rax, %r14
ja 0x1fa87
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0x64f6
leaq 0x327c(%rip), %rdx      # 0x22d32
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6c66
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltablib.c
// Function: unpack
static int unpack (lua_State *L) {
  lua_Unsigned n;
  lua_Integer i = luaL_optinteger(L, 2, 1);
  lua_Integer e = luaL_opt(L, luaL_checkinteger, 3, luaL_len(L, 1));
  if (i > e) return 0;  /* empty range */
  n = (lua_Unsigned)e - i;  /* number of elements minus 1 (avoid overflows) */
  if (n >= (unsigned int)INT_MAX  || !lua_checkstack(L, (int)(++n)))
    return luaL_error(L, "too many results to unpack");
  for (; i < e; i++) {  /* push arg[i..e - 1] (to avoid overflows) */
    lua_geti(L, 1, i);
  }
  lua_geti(L, 1, e);  /* push last element */
  return (int)n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edx
movl $0x2, %esi
callq 0x1518f
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x608f
movq %rbx, %rdi
testl %eax, %eax
jle 0x1fb09
movl $0x3, %esi
callq 0x15124
jmp 0x1fb13
movl $0x1, %esi
callq 0x15a57
movq %rax, %r15
xorl %ebp, %ebp
subq %r14, %rax
jl 0x1fb64
cmpq $0x7ffffffe, %rax       # imm = 0x7FFFFFFE
ja 0x1fb71
movl %eax, %ebp
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5c18
testl %eax, %eax
je 0x1fb71
cmpq %r14, %r15
jle 0x1fb54
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x68b9
incq %r14
cmpq %r14, %r15
jne 0x1fb3c
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x68b9
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4e92(%rip), %rsi      # 0x24a0a
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x14a62
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ltablib.c
// Function: tremove
static int tremove (lua_State *L) {
  lua_Integer size = aux_getn(L, 1, TAB_RW);
  lua_Integer pos = luaL_optinteger(L, 2, size);
  if (pos != size)  /* validate 'pos' if given */
    luaL_argcheck(L, 1 <= pos && pos <= size + 1, 1, "position out of bounds");
  lua_geti(L, 1, pos);  /* result = t[pos] */
  for ( ; pos < size; pos++) {
    lua_geti(L, 1, pos + 1);
    lua_seti(L, 1, pos);  /* t[pos] = t[pos + 1] */
  }
  lua_pushnil(L);
  lua_seti(L, 1, pos);  /* t[pos] = nil */
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
movl $0x7, %edx
callq 0x1fea4
movq %rbx, %rdi
movl $0x1, %esi
callq 0x15a57
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x1518f
movq %rax, %r14
cmpq %r15, %rax
je 0x1fbf9
testq %r14, %r14
setle %al
leaq 0x1(%r15), %rcx
cmpq %rcx, %r14
setg %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1fbf9
leaq 0x4de1(%rip), %rdx      # 0x249cd
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1497c
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x68b9
cmpq %r15, %r14
jge 0x1fc3d
leaq 0x1(%r14), %r12
movq %rbx, %rdi
movl $0x1, %esi
movq %r12, %rdx
callq 0x68b9
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x6c8a
movq %r12, %r14
cmpq %r12, %r15
jne 0x1fc0e
movq %r15, %r14
movq %rbx, %rdi
callq 0x64cd
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x6c8a
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x2, %esi
callq 0x15124
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x15124
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x15124
movq %rax, %r12
movq %rbx, %rdi
movl $0x5, %esi
callq 0x608f
movl %eax, %r13d
xorl %eax, %eax
testl %r13d, %r13d
setg %al
leal 0x1(,%rax,4), %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x1fea4
movq %rbx, %rdi
movl %ebp, %esi
movl $0x2, %edx
callq 0x1fea4
movq %r15, %rdx
subq %r14, %rdx
jl 0x1fdf2
movl %r13d, 0x14(%rsp)
movabsq $0x7fffffffffffffff, %r13 # imm = 0x7FFFFFFFFFFFFFFF
testq %r14, %r14
setg %al
leaq (%r14,%r13), %rcx
cmpq %rcx, %r15
setl %cl
orb %al, %cl
jne 0x1fd31
movq %rdx, 0x8(%rsp)
leaq 0x4d06(%rip), %rdx      # 0x24a25
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1497c
movq 0x8(%rsp), %rdx
subq %rdx, %r13
cmpq %r13, %r12
jle 0x1fd53
movq %rdx, %r13
leaq 0x4cfc(%rip), %rdx      # 0x24a3f
movq %rbx, %rdi
movl $0x4, %esi
callq 0x1497c
movq %r13, %rdx
cmpq %r15, %r12
setle %al
movq %r12, %r13
subq %r14, %r13
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1fdc2
cmpl $0x0, 0x14(%rsp)
jle 0x1fd92
movq %rbx, %rdi
movl $0x1, %esi
movq %rdx, 0x8(%rsp)
movl $0x5, %edx
xorl %ecx, %ecx
callq 0x61d0
movq 0x8(%rsp), %rdx
testl %eax, %eax
je 0x1fdc2
testq %rdx, %rdx
js 0x1fdf2
decq %r14
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x68b9
leaq (%r15,%r13), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6c8a
decq %r15
cmpq %r15, %r14
jne 0x1fd9a
jmp 0x1fdf2
testq %rdx, %rdx
js 0x1fdf2
incq %r15
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x68b9
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x6c8a
incq %r14
incq %r12
cmpq %r14, %r15
jne 0x1fdca
movq %rbx, %rdi
movl %ebp, %esi
callq 0x606b
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
movl $0x7, %edx
callq 0x1fea4
movq %rbx, %rdi
movl $0x1, %esi
callq 0x15a57
cmpq $0x2, %rax
jl 0x1fe9a
movq %rax, %r14
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
jb 0x1fe58
leaq 0x4c0c(%rip), %rdx      # 0x24a57
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1497c
movq %rbx, %rdi
movl $0x2, %esi
callq 0x608f
testl %eax, %eax
jle 0x1fe7b
movq %rbx, %rdi
movl $0x2, %esi
movl $0x6, %edx
callq 0x15039
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5d4d
movq %rbx, %rdi
movl $0x1, %esi
movl %r14d, %edx
xorl %ecx, %ecx
callq 0x1fff3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x608f
cmpl $0x5, %eax
jne 0x1fec8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6a5a
testl %eax, %eax
je 0x1ff76
movl $0x1, %r15d
testb $0x1, %r14b
je 0x1ff0c
leaq 0x2e54(%rip), %rsi      # 0x22d41
movq %rbx, %rdi
callq 0x656b
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x693a
movl $0x2, %r15d
testl %eax, %eax
je 0x1ff76
testb $0x2, %r14b
je 0x1ff35
leaq 0x2e30(%rip), %rsi      # 0x22d49
movq %rbx, %rdi
callq 0x656b
movl %r15d, %esi
notl %esi
movq %rbx, %rdi
callq 0x693a
testl %eax, %eax
je 0x1ff76
incl %r15d
testb $0x4, %r14b
je 0x1ff5e
leaq 0x2e1e(%rip), %rsi      # 0x22d60
movq %rbx, %rdi
callq 0x656b
movl %r15d, %esi
notl %esi
movq %rbx, %rdi
callq 0x693a
testl %eax, %eax
je 0x1ff76
incl %r15d
notl %r15d
movq %rbx, %rdi
movl %r15d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5d4d
movq %rbx, %rdi
movl %ebp, %esi
movl $0x5, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x15039
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x68b9
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6111
testl %eax, %eax
jne 0x1ffe6
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x608f
movq %r15, %rdi
movl %eax, %esi
callq 0x60b0
leaq 0x49c2(%rip), %rsi      # 0x24998
movq %r15, %rdi
movq %rax, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x14a62
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x15429
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl $0x2, %esi
callq 0x608f
testl %eax, %eax
je 0x20430
movq %rbx, %rdi
movl $0x2, %esi
callq 0x606b
decl %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x606b
addl $-0x2, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x606b
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6f67
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6333
movl %eax, %ebp
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
movl $0x1, %ecx
popq %rbx
popq %r14
popq %rbp
jmp 0x61d0
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x383c(%rip), %xmm0     # 0x23c90
movl $0x88, %esi
callq 0x15ef6
movq %rbx, %rdi
xorl %esi, %esi
movl $0x6, %edx
callq 0x69fb
leaq 0xf81c(%rip), %rsi      # 0x2fc90
movq %rbx, %rdi
xorl %edx, %edx
callq 0x15bde
leaq 0x4603(%rip), %rsi      # 0x24a88
movl $0xe, %edx
movq %rbx, %rdi
callq 0x650a
leaq 0x45fe(%rip), %rdx      # 0x24a97
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6c66
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq %rsp, %rdx
movl $0x1, %esi
callq 0x14fff
movq %rax, %r14
movl $0x1, %edx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1518f
movq %rax, %r12
testq %rax, %rax
jns 0x2068a
movq (%rsp), %rax
movq %r12, %rcx
negq %rcx
cmpq %rcx, %rax
jae 0x20684
xorl %r12d, %r12d
jmp 0x2068a
addq %rax, %r12
incq %r12
movq %rbx, %rdi
movl $0x3, %esi
movq %r12, %rdx
callq 0x1518f
movq %rax, %r15
movq (%rsp), %rax
testq %r15, %r15
jns 0x206bc
movq %r15, %rcx
negq %rcx
cmpq %rcx, %rax
jae 0x206b6
xorl %r15d, %r15d
jmp 0x206bc
addq %rax, %r15
incq %r15
testq %r12, %r12
jg 0x206d9
leaq 0x3594(%rip), %rdx      # 0x23c5c
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1497c
movq (%rsp), %rax
cmpq %rax, %r15
jle 0x206f2
leaq 0x3577(%rip), %rdx      # 0x23c5c
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1497c
xorl %ebp, %ebp
movq %r15, %rsi
subq %r12, %rsi
jl 0x20770
cmpq $0x7fffffff, %rsi       # imm = 0x7FFFFFFF
jl 0x2070e
leaq 0x3e30(%rip), %rsi      # 0x2453c
jmp 0x20764
incl %esi
leaq 0x3e25(%rip), %rdx      # 0x2453c
movq %rbx, %rdi
callq 0x14929
addq %r14, %r15
addq %r12, %r14
decq %r14
cmpq %r15, %r14
jae 0x20770
xorl %ebp, %ebp
leaq 0xc(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x20971
testq %rax, %rax
je 0x2075d
movq %rax, %r14
movslq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f6
incl %ebp
cmpq %r15, %r14
jb 0x20734
jmp 0x20770
leaq 0x438e(%rip), %rsi      # 0x24af2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x14a62
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_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2028, %rsp           # imm = 0x2028
movq %rdi, %rbx
callq 0x5d39
cmpl $0x1, %eax
jne 0x207a9
movq %rbx, %rdi
movl $0x1, %esi
callq 0x209f1
jmp 0x207fc
movl %eax, %r14d
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x154c8
testl %r14d, %r14d
jle 0x207f2
negl %r14d
movl $0x1, %r12d
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movl %r12d, %esi
callq 0x209f1
movq %r15, %rdi
callq 0x15429
leal (%r14,%r12), %eax
incl %eax
movl %r12d, %ecx
incl %ecx
movl %ecx, %r12d
cmpl $0x1, %eax
jne 0x207cc
leaq 0x8(%rsp), %rdi
callq 0x153c0
movl $0x1, %eax
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq %rsp, %rdx
movl $0x1, %esi
callq 0x14fff
movq %rax, %r14
movl $0x1, %edx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1518f
movq %rax, %r15
testq %rax, %rax
jns 0x20862
movq (%rsp), %rax
movq %r15, %rcx
negq %rcx
cmpq %rcx, %rax
jae 0x2085c
xorl %r15d, %r15d
jmp 0x20862
addq %rax, %r15
incq %r15
movq %rbx, %rdi
movl $0x3, %esi
movq $-0x1, %rdx
callq 0x1518f
movq %rax, %r12
movq (%rsp), %rax
testq %r12, %r12
jns 0x20898
movq %r12, %rcx
negq %rcx
cmpq %rcx, %rax
jae 0x20892
xorl %r12d, %r12d
jmp 0x20898
addq %rax, %r12
incq %r12
testq %r15, %r15
jle 0x208a5
decq %r15
cmpq %rax, %r15
jle 0x208bd
leaq 0x406c(%rip), %rdx      # 0x24918
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1497c
movq (%rsp), %rax
cmpq %rax, %r12
jle 0x208d6
leaq 0x423f(%rip), %rdx      # 0x24b08
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1497c
movl $0x1, %ebp
xorl %r13d, %r13d
cmpq %r12, %r15
jge 0x20916
leaq (%r14,%r15), %rdi
xorl %esi, %esi
callq 0x20971
testq %rax, %rax
je 0x20903
subq %r14, %rax
incq %r13
movq %rax, %r15
cmpq %r12, %rax
jl 0x208e3
jmp 0x20916
movq %rbx, %rdi
callq 0x64cd
incq %r15
movl $0x2, %ebp
movq %r15, %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x64f6
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_O3/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 %rbx
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x14fff
leaq 0xea(%rip), %rsi        # 0x20a33
movq %rbx, %rdi
xorl %edx, %edx
callq 0x66a8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x606b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x64f6
movl $0x3, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x20988
testq %rsi, %rsi
je 0x20980
movl %edx, (%rsi)
incq %rdi
movq %rdi, %rax
jmp 0x209ef
leaq 0x41a1(%rip), %r8       # 0x24b30
xorl %eax, %eax
xorl %ecx, %ecx
xorl %r9d, %r9d
xorl %r10d, %r10d
testb $0x40, %dl
je 0x209cb
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 0x20999
jmp 0x209ef
andl $0x3f, %edx
shll %cl, %edx
xorl %eax, %eax
cmpq $0x3, %r9
ja 0x209ef
orl %r10d, %edx
cmpl $0x10ffff, %edx         # imm = 0x10FFFF
ja 0x209ef
cmpl (%r8), %edx
jbe 0x209ed
addq %r9, %rdi
jmp 0x20979
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movl $0x1, %esi
movq %r12, %rdx
callq 0x14fff
movq %rax, %r15
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x62e1
movq (%r12), %rcx
movl $0x0, %r12d
testq %rax, %rax
jle 0x20a98
cmpq %rcx, %rax
jle 0x20a84
decq %rax
movq %rax, %r12
jmp 0x20a98
decq %rax
movq %rax, %r12
movb 0x1(%r15,%r12), %al
andb $-0x40, %al
incq %r12
negb %al
jo 0x20a8a
cmpq %rcx, %r12
jge 0x20af1
addq %r12, %r15
leaq 0xc(%rsp), %rsi
movq %r15, %rdi
callq 0x20971
testq %rax, %rax
je 0x20aba
movb (%rax), %al
andb $-0x40, %al
negb %al
jno 0x20ad0
leaq 0x4031(%rip), %rsi      # 0x24af2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x14a62
movl %eax, %r14d
jmp 0x20af1
incq %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x64f6
movslq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x64f6
movl $0x2, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x20d3c
movq %r13, %rdi
callq 0x5040
testq %rax, %rax
je 0x20d73
movq %rax, %r12
leaq 0x4043(%rip), %rdx      # 0x24d89
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6895
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6333
movl %eax, %ebp
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
testl %ebp, %ebp
je 0x20d80
movq %r14, %rdi
movq %r15, %rsi
callq 0x656b
jmp 0x20dcd
leaq 0x3ff9(%rip), %rdx      # 0x24d80
leaq 0x3ff5(%rip), %rcx      # 0x24d83
movq %r14, %rdi
movq %r12, %rsi
callq 0x15dc6
leaq 0x3fe7(%rip), %rdx      # 0x24d87
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rcx
callq 0x15dc6
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5eb2
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6c66
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x15a57
testq %rax, %rax
jle 0x20e3b
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x6970
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x644d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
leaq -0x1(%r14), %rax
cmpq $0x1, %r14
movq %rax, %r14
ja 0x20e04
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %ebp
movl $0x1, %esi
xorl %edx, %edx
callq 0x14fff
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x14fff
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x20f6b
testl %eax, %eax
je 0x20ec1
movl %eax, %r14d
movq %rbx, %rdi
callq 0x64cd
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x5eb2
cmpl $0x1, %r14d
leaq 0x3dee(%rip), %rax      # 0x24c97
leaq 0x1218(%rip), %rsi      # 0x220c8
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x656b
movl $0x3, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1, %ebp
movl $0x1, %esi
xorl %edx, %edx
callq 0x14fff
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x14fff
movq %rax, %r15
leaq 0x236d(%rip), %rdx      # 0x2326d
movq %rbx, %rdi
movl $0x3, %esi
xorl %ecx, %ecx
callq 0x14fa6
movq %rax, %r12
leaq 0x29e7(%rip), %rdx      # 0x23900
movq %rbx, %rdi
movl $0x4, %esi
xorl %ecx, %ecx
callq 0x14fa6
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x21003
testq %rax, %rax
jne 0x20f60
movq %rbx, %rdi
callq 0x64cd
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x5eb2
movl $0x2, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x3e58(%rip), %rdx      # 0x24dd8
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x69ae
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x6895
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x644d
movq %rax, %r15
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x5d4d
testq %r15, %r15
je 0x20fd3
cmpb $0x2a, (%r14)
jne 0x20fe9
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6725
xorl %eax, %eax
jmp 0x20ffd
leaq 0x3cc4(%rip), %rsi      # 0x24c9e
movq %rbx, %rdi
callq 0x656b
movl $0x1, %eax
jmp 0x20ffd
leaq 0x3cae(%rip), %rsi      # 0x24c9e
movq %rbx, %rdi
callq 0x656b
movl $0x2, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r13
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
callq 0x154c8
cmpb $0x0, (%r12)
je 0x21048
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x15dc6
movq %rax, %r14
leaq 0x1343(%rip), %r15      # 0x22392
leaq 0xfd8(%rip), %r12       # 0x2202e
movzbl (%r13), %eax
cmpl $0x3b, %eax
je 0x21085
testl %eax, %eax
je 0x2113d
movq %r13, %rdi
movl $0x3b, %esi
callq 0x5160
testq %rax, %rax
je 0x2108a
movq %rax, %rbp
movq %rax, %rdx
subq %r13, %rdx
jmp 0x2109b
incq %r13
jmp 0x21056
movq %r13, %rdi
callq 0x5140
movq %rax, %rdx
movq %rax, %rbp
addq %r13, %rbp
movq %rbx, %rdi
movq %r13, %rsi
callq 0x650a
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x6359
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x15dc6
movq %rax, %r13
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5eb2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
movq %r13, %rdi
movq %r12, %rsi
callq 0x52e0
testq %rax, %rax
jne 0x2114c
movq %rbx, %rdi
leaq 0x3bd7(%rip), %rsi      # 0x24cd9
movq %r13, %rdx
xorl %eax, %eax
callq 0x65ff
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5eb2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
leaq 0x8(%rsp), %rdi
callq 0x15429
movq %rbp, %r13
jmp 0x21056
leaq 0x8(%rsp), %rdi
callq 0x153c0
xorl %r13d, %r13d
jmp 0x21154
movq %rax, %rdi
callq 0x5130
movq %r13, %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_O3/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
movl $0x1, %esi
xorl %edx, %edx
callq 0x14fff
movq %rax, %r14
leaq 0x3ae3(%rip), %rdx      # 0x24c69
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6895
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdx
callq 0x6895
testl %eax, %eax
jne 0x211bb
leaq 0x3b3a(%rip), %rsi      # 0x24ce8
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x65ff
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
xorl %edx, %edx
callq 0x14fff
leaq 0x3a0c(%rip), %rdx      # 0x24bee
movq %rbx, %rdi
movq %rax, %rsi
callq 0x21354
testq %rax, %rax
je 0x2121c
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x1560a
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x213cd
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
xorl %edx, %edx
callq 0x14fff
movq %rax, %r15
leaq 0x39a6(%rip), %rdx      # 0x24bed
movq %rbx, %rdi
movq %rax, %rsi
callq 0x21354
testq %rax, %rax
je 0x21280
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x21432
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x213cd
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movl $0x1, %esi
xorl %edx, %edx
callq 0x14fff
movq %rax, %r14
movq %rax, %rdi
movl $0x2e, %esi
callq 0x5160
testq %rax, %rax
je 0x2133c
subq %r14, %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x650a
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x6359
leaq 0x390b(%rip), %rdx      # 0x24bed
movq %rbx, %rdi
movq %rax, %rsi
callq 0x21354
testq %rax, %rax
je 0x21323
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x21432
testl %eax, %eax
je 0x2132b
cmpl $0x2, %eax
jne 0x21345
leaq 0x3a4f(%rip), %rsi      # 0x24d62
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x65ff
movl $0x1, %r15d
jmp 0x2133c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x656b
movl $0x2, %r15d
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x213cd
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x6895
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x6359
testq %rax, %rax
je 0x21399
leaq 0x1ee6(%rip), %rcx      # 0x2326d
leaq 0x2572(%rip), %r8       # 0x23900
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
jmp 0x213c3
leaq 0x3969(%rip), %rsi      # 0x24d09
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x14a62
leaq 0x1eb9(%rip), %rcx      # 0x2326d
leaq 0x2545(%rip), %r8       # 0x23900
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x21003
// File: /workspace/github_c_makefile_star2_O3/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 0x213f2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x656b
movl $0x2, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x6359
movq %rax, %r15
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x6359
leaq 0x390d(%rip), %rsi      # 0x24d27
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x14a62
// File: /workspace/github_c_makefile_star2_O3/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 0x1e26(%rip), %rax      # 0x2326d
leaq 0x3907(%rip), %rcx      # 0x24d55
movq %rdx, %rsi
movq %rax, %rdx
callq 0x15dc6
movq %rax, %r12
movq %rax, %rdi
movl $0x2d, %esi
callq 0x5160
testq %rax, %rax
je 0x214af
movq %rax, %r15
movq %rax, %rdx
subq %r12, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x650a
leaq 0x38ce(%rip), %rsi      # 0x24d57
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x65ff
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x20f6b
cmpl $0x2, %eax
jne 0x214dc
incq %r15
movq %r15, %r12
leaq 0x38a1(%rip), %rsi      # 0x24d57
movq %r14, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x65ff
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20f6b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq