LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: singlematch
static int singlematch (MatchState *ms, const char *s, const char *p,
                        const char *ep) {
  if (s >= ms->src_end)
    return 0;
  else {
    int c = uchar(*s);
    switch (*p) {
      case '.': return 1;  /* matches any char */
      case L_ESC: return match_class(c, uchar(*(p+1)));
      case '[': return matchbracketclass(c, p, ep-1);
      default:  return (uchar(*p) == c);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x2ed0f
movl $0x0, -0x4(%rbp)
jmp 0x2ed8a
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x30(%rbp)
subl $0x25, %eax
je 0x2ed47
jmp 0x2ed2a
movl -0x30(%rbp), %eax
subl $0x2e, %eax
je 0x2ed3e
jmp 0x2ed34
movl -0x30(%rbp), %eax
subl $0x5b, %eax
je 0x2ed5c
jmp 0x2ed75
movl $0x1, -0x4(%rbp)
jmp 0x2ed8a
movl -0x2c(%rbp), %edi
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %esi
callq 0x2ef60
movl %eax, -0x4(%rbp)
jmp 0x2ed8a
movl -0x2c(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
addq $-0x1, %rdx
callq 0x2eb30
movl %eax, -0x4(%rbp)
jmp 0x2ed8a
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl -0x2c(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: max_expand
static const char *max_expand (MatchState *ms, const char *s,
                                 const char *p, const char *ep) {
  ptrdiff_t i = 0;  /* counts maximum expand for item */
  while (singlematch(ms, s + i, p, ep))
    i++;
  /* keeps trying to match with the maximum repetitions */
  while (i>=0) {
    const char *res = match(ms, (s+i), ep+1);
    if (res) return res;
    i--;  /* else didn't match; reduce 1 repetition to try again */
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x2ece0
cmpl $0x0, %eax
je 0x2edec
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2edc0
jmp 0x2edee
cmpq $0x0, -0x30(%rbp)
jl 0x2ee31
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
addq $0x1, %rdx
callq 0x2e350
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x2ee23
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2ee39
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2edee
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: min_expand
static const char *min_expand (MatchState *ms, const char *s,
                                 const char *p, const char *ep) {
  for (;;) {
    const char *res = match(ms, s, ep+1);
    if (res != NULL)
      return res;
    else if (singlematch(ms, s, p, ep))
      s++;  /* try with one more repetition */
    else return NULL;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
addq $0x1, %rdx
callq 0x2e350
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x2ee92
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2eec8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x2ece0
cmpl $0x0, %eax
je 0x2eeba
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2eec4
movq $0x0, -0x8(%rbp)
jmp 0x2eec8
jmp 0x2eec6
jmp 0x2ee68
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: capture_to_close
static int capture_to_close (MatchState *ms) {
  int level = ms->level;
  for (level--; level>=0; level--)
    if (ms->capture[level].len == CAP_UNFINISHED) return level;
  return luaL_error(ms->L, "invalid pattern capture");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x24(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x2ef35
movq -0x10(%rbp), %rax
addq $0x28, %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $-0x1, 0x8(%rax)
jne 0x2ef28
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2ef4e
jmp 0x2ef2a
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2ef00
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x7f9b(%rip), %rsi      # 0x36edf
movb $0x0, %al
callq 0x1fbf0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: check_capture
static int check_capture (MatchState *ms, int l) {
  l -= '1';
  if (l < 0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED)
    return luaL_error(ms->L, "invalid capture index %%%d", l + 1);
  return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl $0x31, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x2f167
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl 0x24(%rcx), %ecx
cmpl %ecx, %eax
jge 0x2f167
movq -0x10(%rbp), %rax
addq $0x28, %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $-0x1, 0x8(%rax)
jne 0x2f188
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x14(%rbp), %edx
addl $0x1, %edx
leaq 0x7ded(%rip), %rsi      # 0x36f69
movb $0x0, %al
callq 0x1fbf0
movl %eax, -0x4(%rbp)
jmp 0x2f18e
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: push_onecapture
static void push_onecapture (MatchState *ms, int i, const char *s,
                                                    const char *e) {
  if (i >= ms->level) {
    if (i == 0)  /* ms->level == 0, too */
      lua_pushlstring(ms->L, s, e - s);  /* add whole match */
    else
      luaL_error(ms->L, "invalid capture index %%%d", i + 1);
  }
  else {
    ptrdiff_t l = ms->capture[i].len;
    if (l == CAP_UNFINISHED) luaL_error(ms->L, "unfinished capture");
    if (l == CAP_POSITION)
      lua_pushinteger(ms->L, (ms->capture[i].init - ms->src_init) + 1);
    else
      lua_pushlstring(ms->L, ms->capture[i].init, l);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movzbl 0x24(%rcx), %ecx
cmpl %ecx, %eax
jl 0x2f20b
cmpl $0x0, -0xc(%rbp)
jne 0x2f1ea
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
callq 0x6c20
jmp 0x2f206
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %edx
addl $0x1, %edx
leaq 0x7d6a(%rip), %rsi      # 0x36f69
movb $0x0, %al
callq 0x1fbf0
jmp 0x2f2a6
movq -0x8(%rbp), %rax
addq $0x28, %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x2f243
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x7d48(%rip), %rsi      # 0x36f84
movb $0x0, %al
callq 0x1fbf0
cmpq $-0x2, -0x28(%rbp)
jne 0x2f27d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
addq $0x28, %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rax
subq %rax, %rsi
addq $0x1, %rsi
callq 0x6be0
jmp 0x2f2a4
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
addq $0x28, %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x6c20
jmp 0x2f2a6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: addlenmod
static void addlenmod (char *form, const char *lenmod) {
  size_t l = strlen(form);
  size_t lm = strlen(lenmod);
  char spec = form[l - 1];
  strcpy(form + l - 1, lenmod);
  form[l + lm - 1] = spec;
  form[l + lm] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5150
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5150
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rdi
addq -0x18(%rbp), %rdi
addq $-0x1, %rdi
movq -0x10(%rbp), %rsi
callq 0x50b0
movb -0x21(%rbp), %dl
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
addq -0x20(%rbp), %rcx
subq $0x1, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
addq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: checkdp
static void checkdp (char *buff, int nb) {
  if (memchr(buff, '.', nb) == NULL) {  /* no dot? */
    char point = lua_getlocaledecpoint();  /* try locale point */
    char *ppoint = memchr(buff, point, nb);
    if (ppoint) *ppoint = '.';  /* change it to a dot */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
movl $0x2e, %esi
callq 0x5200
cmpq $0x0, %rax
jne 0x2f989
callq 0x5100
movq (%rax), %rax
movb (%rax), %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rdi
movsbl -0xd(%rbp), %esi
movslq -0xc(%rbp), %rdx
callq 0x5200
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2f987
movq -0x18(%rbp), %rax
movb $0x2e, (%rax)
jmp 0x2f989
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: gmatch_aux
static int gmatch_aux (lua_State *L) {
  GMatchState *gm = (GMatchState *)lua_touserdata(L, lua_upvalueindex(3));
  const char *src;
  gm->ms.L = L;
  for (src = gm->src; src <= gm->ms.src_end; src++) {
    const char *e;
    reprepstate(&gm->ms);
    if ((e = match(&gm->ms, src, gm->p)) != NULL && e != gm->lastmatch) {
      gm->src = gm->lastmatch = e;
      return push_captures(&gm->ms, src, e);
    }
  }
  return 0;  /* not found */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfff0b9d5, %esi       # imm = 0xFFF0B9D5
callq 0x69e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x20(%rcx), %rax
ja 0x2fa51
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x2e330
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x2e350
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2fa3e
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x2fa3e
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2e730
movl %eax, -0x4(%rbp)
jmp 0x2fa58
jmp 0x2fa40
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2f9c5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: add_value
static void add_value (MatchState *ms, luaL_Buffer *b, const char *s,
                                       const char *e, int tr) {
  lua_State *L = ms->L;
  switch (tr) {
    case LUA_TFUNCTION: {
      int n;
      lua_pushvalue(L, 3);
      n = push_captures(ms, s, e);
      lua_call(L, n, 1);
      break;
    }
    case LUA_TTABLE: {
      push_onecapture(ms, 0, s, e);
      lua_gettable(L, 3);
      break;
    }
    default: {  /* LUA_TNUMBER or LUA_TSTRING */
      add_s(ms, b, s, e);
      return;
    }
  }
  if (!lua_toboolean(L, -1)) {  /* nil or false? */
    lua_pop(L, 1);
    lua_pushlstring(L, s, e - s);  /* keep original text */
  }
  else if (!lua_isstring(L, -1))
    luaL_error(L, "invalid replacement value (a %s)", luaL_typename(L, -1));
  luaL_addvalue(b);  /* add result to accumulator */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x38(%rbp)
subl $0x5, %eax
je 0x2faec
jmp 0x2faa5
movl -0x38(%rbp), %eax
subl $0x6, %eax
jne 0x2fb0f
jmp 0x2faaf
movq -0x30(%rbp), %rdi
movl $0x3, %esi
callq 0x6190
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2e730
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x8140
jmp 0x2fb29
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
xorl %esi, %esi
callq 0x2f1a0
movq -0x30(%rbp), %rdi
movl $0x3, %esi
callq 0x7220
jmp 0x2fb29
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2fbd0
jmp 0x2fbc0
movq -0x30(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6770
cmpl $0x0, %eax
jne 0x2fb64
movq -0x30(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
callq 0x6c20
jmp 0x2fbb7
movq -0x30(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6360
cmpl $0x0, %eax
jne 0x2fbb5
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x61f0
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0x6240
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x74c1(%rip), %rsi      # 0x3706f
movb $0x0, %al
callq 0x1fbf0
jmp 0x2fbb7
movq -0x10(%rbp), %rdi
callq 0x209f0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: getdetails
static KOption getdetails (Header *h, size_t totalsize,
                           const char **fmt, int *psize, int *ntoalign) {
  KOption opt = getoption(h, fmt, psize);
  int align = *psize;  /* usually, alignment follows size */
  if (opt == Kpaddalign) {  /* 'X' gets alignment from following option */
    if (**fmt == '\0' || getoption(h, fmt, &align) == Kchar || align == 0)
      luaL_argerror(h->L, 1, "invalid next option for option 'X'");
  }
  if (align <= 1 || opt == Kchar)  /* need no alignment? */
    *ntoalign = 0;
  else {
    if (align > h->maxalign)  /* enforce maximum alignment */
      align = h->maxalign;
    if ((align & (align - 1)) != 0)  /* is 'align' not a power of 2? */
      luaL_argerror(h->L, 1, "format asks for alignment not power of 2");
    *ntoalign = (align - (int)(totalsize & (align - 1))) & (align - 1);
  }
  return opt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x30130
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
cmpl $0x7, -0x2c(%rbp)
jne 0x2feb4
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2fe9a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x30130
cmpl $0x3, %eax
je 0x2fe9a
cmpl $0x0, -0x30(%rbp)
jne 0x2feb2
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
leaq 0x7292(%rip), %rdx      # 0x3713f
callq 0x1fab0
jmp 0x2feb4
cmpl $0x1, -0x30(%rbp)
jle 0x2fec0
cmpl $0x3, -0x2c(%rbp)
jne 0x2fecc
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
jmp 0x2ff2d
movl -0x30(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jle 0x2fee2
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl -0x30(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x2ff0a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
leaq 0x725d(%rip), %rdx      # 0x37162
callq 0x1fab0
movl -0x30(%rbp), %ecx
movq -0x10(%rbp), %rax
movl -0x30(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
andq %rdx, %rax
subl %eax, %ecx
movl -0x30(%rbp), %eax
subl $0x1, %eax
andl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: packint
static void packint (luaL_Buffer *b, lua_Unsigned n,
                     int islittle, int size, int neg) {
  char *buff = luaL_prepbuffsize(b, size);
  int i;
  buff[islittle ? 0 : size - 1] = (char)(n & MC);  /* first byte */
  for (i = 1; i < size; i++) {
    n >>= NB;
    buff[islittle ? i : size - 1 - i] = (char)(n & MC);
  }
  if (neg && size > SZINT) {  /* negative number need sign extension? */
    for (i = SZINT; i < size; i++)  /* correct extra bytes */
      buff[islittle ? i : size - 1 - i] = (char)MC;
  }
  luaL_addsize(b, size);  /* add result to buffer */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x20630
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
andq $0xff, %rax
movb %al, -0x39(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2ff8d
xorl %eax, %eax
movl %eax, -0x40(%rbp)
jmp 0x2ff96
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movb -0x39(%rbp), %dl
movl -0x40(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x3000b
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0xff, %rax
movb %al, -0x49(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2ffe4
movl -0x2c(%rbp), %eax
movl %eax, -0x50(%rbp)
jmp 0x2fff0
movl -0x18(%rbp), %eax
subl $0x1, %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movb -0x49(%rbp), %dl
movl -0x50(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2ffad
cmpl $0x0, -0x1c(%rbp)
je 0x30063
cmpl $0x8, -0x18(%rbp)
jle 0x30063
movl $0x8, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x30061
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x3003c
movl -0x2c(%rbp), %eax
movl %eax, -0x5c(%rbp)
jmp 0x30048
movl -0x18(%rbp), %eax
subl $0x1, %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rax
movl -0x5c(%rbp), %ecx
movslq %ecx, %rcx
movb $-0x1, (%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3001e
jmp 0x30063
movslq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: copywithendian
static void copywithendian (volatile char *dest, volatile const char *src,
                            int size, int islittle) {
  if (islittle == nativeendian.little) {
    while (size-- != 0)
      *(dest++) = *(src++);
  }
  else {
    dest += size - 1;
    while (size-- != 0)
      *(dest--) = *(src++);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x18(%rbp), %eax
movsbl 0x6d68(%rip), %ecx      # 0x36e04
cmpl %ecx, %eax
jne 0x300d8
jmp 0x300a2
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0x300d6
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x300a2
jmp 0x30122
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0x30120
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x300ec
jmp 0x30122
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: getnumlimit
static int getnumlimit (Header *h, const char **fmt, int df) {
  int sz = getnum(fmt, df);
  if (sz > MAXINTSIZE || sz <= 0)
    luaL_error(h->L, "integral size (%d) out of limits [1,%d]",
                     sz, MAXINTSIZE);
  return sz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x30440
movl %eax, -0x18(%rbp)
cmpl $0x10, -0x18(%rbp)
jg 0x3040e
cmpl $0x0, -0x18(%rbp)
jg 0x3042b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %edx
leaq 0x6daa(%rip), %rsi      # 0x371c9
movl $0x10, %ecx
movb $0x0, %al
callq 0x1fbf0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: getnum
static int getnum (const char **fmt, int df) {
  if (!digit(**fmt))  /* no number? */
    return df;  /* return default value */
  else {
    int a = 0;
    do {
      a = a*10 + (*((*fmt)++) - '0');
    } while (digit(**fmt) && a <= ((int)MAXSIZE - 9)/10);
    return a;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x304d0
cmpl $0x0, %eax
jne 0x3046b
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x304c7
movl $0x0, -0x18(%rbp)
imull $0xa, -0x18(%rbp), %eax
movq -0x10(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movsbl (%rcx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x304d0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x304ba
cmpl $0xccccccb, -0x18(%rbp) # imm = 0xCCCCCCB
setle %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x30472
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x2050, %rsp           # imm = 0x2050
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x30ef0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x212b0
movq %rax, -0x2030(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x6f6f(%rip), %rdx      # 0x37686
leaq -0x2038(%rbp), %rcx
callq 0x20310
movq %rax, -0x2040(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0x205e0
movq %rax, -0x2048(%rbp)
movq -0x8(%rbp), %rdi
movq -0x2030(%rbp), %rdx
movl $0x4, %esi
callq 0x205e0
movq %rax, -0x2030(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2028(%rbp), %rsi
callq 0x20aa0
movq -0x2048(%rbp), %rax
cmpq -0x2030(%rbp), %rax
jge 0x307c5
movq -0x8(%rbp), %rdi
movq -0x2048(%rbp), %rdx
leaq -0x2028(%rbp), %rsi
callq 0x30fe0
movq -0x2040(%rbp), %rsi
movq -0x2038(%rbp), %rdx
leaq -0x2028(%rbp), %rdi
callq 0x208a0
movq -0x2048(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x2048(%rbp)
jmp 0x30770
movq -0x2048(%rbp), %rax
cmpq -0x2030(%rbp), %rax
jne 0x307ec
movq -0x8(%rbp), %rdi
movq -0x2048(%rbp), %rdx
leaq -0x2028(%rbp), %rsi
callq 0x30fe0
leaq -0x2028(%rbp), %rdi
callq 0x20940
movl $0x1, %eax
addq $0x2050, %rsp           # imm = 0x2050
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl %esi, -0x30(%rbp)
movl $0x7, %edx
callq 0x30ef0
movl -0x30(%rbp), %esi
movq -0x10(%rbp), %rdi
callq 0x212b0
incq %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5d90
movl %eax, %ecx
movl %ecx, -0x2c(%rbp)
subl $0x2, %eax
je 0x30867
jmp 0x3085a
movl -0x2c(%rbp), %eax
subl $0x3, %eax
je 0x30874
jmp 0x3090b
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x30922
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x20550
movq %rax, -0x20(%rbp)
movl $0x1, %eax
cmpq -0x20(%rbp), %rax
jg 0x308a0
movq -0x20(%rbp), %rcx
movb $0x1, %al
cmpq -0x18(%rbp), %rcx
movb %al, -0x31(%rbp)
jle 0x308be
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x6a25(%rip), %rdx      # 0x372d5
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jle 0x30909
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
subq $0x1, %rdx
movl $0x1, %esi
callq 0x7330
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x1, %esi
callq 0x7b20
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x308c9
jmp 0x30922
movq -0x10(%rbp), %rdi
leaq 0x69d6(%rip), %rsi      # 0x372ec
movb $0x0, %al
callq 0x1fbf0
movl %eax, -0x4(%rbp)
jmp 0x3093b
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x1, %esi
callq 0x7b20
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d90
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl $0x1, %edx
callq 0x75e0
movq -0x8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x5e60
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jl 0x309b2
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
movl $0x1, %esi
callq 0x7b20
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3098f
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x6be0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x476b(%rip), %rdx      # 0x3513a
callq 0x7ae0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x205e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x61f0
cmpl $0x0, %eax
jg 0x30a2a
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x212b0
movq %rax, -0x30(%rbp)
jmp 0x30a3c
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x20550
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jle 0x30a5a
movl $0x0, -0x4(%rbp)
jmp 0x30ae8
movq -0x28(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x7fffffff, -0x18(%rbp) # imm = 0x7FFFFFFF
jae 0x30a8c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movl %eax, %esi
callq 0x5b00
cmpl $0x0, %eax
jne 0x30aa3
movq -0x10(%rbp), %rdi
leaq 0x687b(%rip), %rsi      # 0x37312
movb $0x0, %al
callq 0x1fbf0
movl %eax, -0x4(%rbp)
jmp 0x30ae8
jmp 0x30aa5
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x30acf
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x1, %esi
callq 0x7330
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x30aa5
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x1, %esi
callq 0x7330
movq -0x18(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x7, %edx
callq 0x30ef0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x212b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x2, %esi
callq 0x205e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x30b93
movl $0x1, %eax
cmpq -0x18(%rbp), %rax
jg 0x30b72
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdx
addq $0x1, %rdx
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x19(%rbp)
jle 0x30b90
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x6753(%rip), %rdx      # 0x372d5
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x1, %esi
callq 0x7330
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x30be5
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x1, %rdx
movl $0x1, %esi
callq 0x7330
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x1, %esi
callq 0x7b20
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x30ba5
movq -0x8(%rbp), %rdi
callq 0x6b60
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x1, %esi
callq 0x7b20
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x7, %edx
callq 0x30ef0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x212b0
movq %rax, -0x10(%rbp)
cmpq $0x1, -0x10(%rbp)
jle 0x30ee2
movb $0x1, %al
cmpq $0x7fffffff, -0x10(%rbp) # imm = 0x7FFFFFFF
movb %al, -0x11(%rbp)
jl 0x30e95
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x64d8(%rip), %rdx      # 0x3735f
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x61f0
cmpl $0x0, %eax
jle 0x30ebe
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0x6, %edx
callq 0x203e0
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x5dc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %edx
movl $0x1, %esi
xorl %ecx, %ecx
callq 0x310b0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x61f0
cmpl $0x5, %eax
je 0x30fd4
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x7680
cmpl $0x0, %eax
je 0x30fc1
movl -0x10(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x30f5c
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
leaq 0x41f7(%rip), %rsi      # 0x35149
callq 0x31070
cmpl $0x0, %eax
je 0x30fc1
movl -0x10(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x30f85
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
leaq 0x41d6(%rip), %rsi      # 0x35151
callq 0x31070
cmpl $0x0, %eax
je 0x30fc1
movl -0x10(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x30fae
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
leaq 0x41c4(%rip), %rsi      # 0x35168
callq 0x31070
cmpl $0x0, %eax
je 0x30fc1
movq -0x8(%rbp), %rdi
xorl %esi, %esi
subl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x5dc0
jmp 0x30fd2
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x5, %edx
callq 0x203e0
jmp 0x30fd4
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x1, %esi
callq 0x7330
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6360
cmpl $0x0, %eax
jne 0x3105b
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x61f0
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x6240
movq -0x20(%rbp), %rdi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
leaq 0x624c(%rip), %rsi      # 0x372a0
movb $0x0, %al
callq 0x1fbf0
movq -0x10(%rbp), %rdi
callq 0x209f0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x61f0
cmpl $0x0, %eax
jne 0x3134e
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl $0x1, %ecx
callq 0x6530
movl %eax, -0x4(%rbp)
jmp 0x313ba
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x6190
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x6190
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
subl $0x2, %esi
callq 0x6190
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x8140
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6770
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ltablib.c
// Function: choosePivot
static IdxT choosePivot (IdxT lo, IdxT up, unsigned int rnd) {
  IdxT r4 = (up - lo) / 4;  /* range/4 */
  IdxT p = rnd % (r4 * 2) + (lo + r4);
  lua_assert(lo + r4 <= p && p <= up - r4);
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x8(%rbp), %eax
subl -0x4(%rbp), %eax
shrl $0x2, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
shll %ecx
xorl %edx, %edx
divl %ecx
movl -0x4(%rbp), %eax
addl -0x10(%rbp), %eax
addl %eax, %edx
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ltablib.c
// Function: partition
static IdxT partition (lua_State *L, IdxT lo, IdxT up) {
  IdxT i = lo;  /* will be incremented before first use */
  IdxT j = up - 1;  /* will be decremented before first use */
  /* loop invariant: a[lo .. i] <= P <= a[j .. up] */
  for (;;) {
    /* next loop: repeat ++i while a[i] < P */
    while (lua_geti(L, 1, ++i), sort_comp(L, -1, -2)) {
      if (i == up - 1)  /* a[i] < P  but a[up - 1] == P  ?? */
        luaL_error(L, "invalid order function for sorting");
      lua_pop(L, 1);  /* remove a[i] */
    }
    /* after the loop, a[i] >= P and a[lo .. i - 1] < P */
    /* next loop: repeat --j while P < a[j] */
    while (lua_geti(L, 1, --j), sort_comp(L, -3, -1)) {
      if (j < i)  /* j < i  but  a[j] > P ?? */
        luaL_error(L, "invalid order function for sorting");
      lua_pop(L, 1);  /* remove a[j] */
    }
    /* after the loop, a[j] <= P and a[j + 1 .. up] >= P */
    if (j < i) {  /* no elements out of place? */
      /* a[lo .. i - 1] <= P <= a[j + 1 .. i .. up] */
      lua_pop(L, 1);  /* pop a[j] */
      /* swap pivot (a[up - 1]) with a[i] to satisfy pos-condition */
      set2(L, up - 1, i);
      return i;
    }
    /* otherwise, swap a[i] - a[j] to restore invariant and repeat */
    set2(L, i, j);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x31473
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl %eax, %eax
movl %eax, %edx
movl $0x1, %esi
callq 0x7330
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
callq 0x31310
cmpl $0x0, %eax
je 0x314d5
movl -0x14(%rbp), %eax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x314c5
movq -0x8(%rbp), %rdi
leaq 0x5eaf(%rip), %rsi      # 0x3736d
movb $0x0, %al
callq 0x1fbf0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
jmp 0x31473
jmp 0x314d7
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
movl %eax, %eax
movl %eax, %edx
movl $0x1, %esi
callq 0x7330
movq -0x8(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x31310
cmpl $0x0, %eax
je 0x31534
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x31524
movq -0x8(%rbp), %rdi
leaq 0x5e50(%rip), %rsi      # 0x3736d
movb $0x0, %al
callq 0x1fbf0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
jmp 0x314d7
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x31565
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
subl $0x1, %esi
movl -0x14(%rbp), %edx
callq 0x313d0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x313d0
jmp 0x31471
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ltablib.c
// Function: l_randomizePivot
static unsigned int l_randomizePivot (void) {
  clock_t c = clock();
  time_t t = time(NULL);
  unsigned int buff[sof(c) + sof(t)];
  unsigned int i, rnd = 0;
  memcpy(buff, &c, sof(c) * sizeof(unsigned int));
  memcpy(buff + sof(c), &t, sof(t) * sizeof(unsigned int));
  for (i = 0; i < sof(buff); i++)
    rnd += buff[i];
  return rnd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x5130
movq %rax, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x5320
movq %rax, -0x10(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpq $0x4, %rax
jae 0x315dd
movl -0x24(%rbp), %eax
movl -0x20(%rbp,%rax,4), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x315bc
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movsd 0x4d78(%rip), %xmm0     # 0x36380
movl $0x88, %esi
callq 0x218a0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x6, %edx
callq 0x75e0
movq -0x8(%rbp), %rdi
leaq 0x11663(%rip), %rsi     # 0x42c90
xorl %edx, %edx
callq 0x214b0
movq -0x8(%rbp), %rdi
leaq 0x5d51(%rip), %rsi      # 0x37390
movl $0xe, %edx
callq 0x6c20
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x5d57(%rip), %rdx      # 0x373b0
callq 0x7ae0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq -0x18(%rbp), %rdx
callq 0x20390
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x205e0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x31cd0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x3, %esi
callq 0x205e0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x31cd0
movq %rax, -0x30(%rbp)
movb $0x1, %al
cmpq $0x1, -0x28(%rbp)
movb %al, -0x45(%rbp)
jge 0x31951
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x49fb(%rip), %rdx      # 0x3633e
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
movq -0x30(%rbp), %rcx
movb $0x1, %al
cmpq -0x18(%rbp), %rcx
movb %al, -0x46(%rbp)
jle 0x31981
movq -0x10(%rbp), %rdi
movl $0x3, %esi
leaq 0x49cb(%rip), %rdx      # 0x3633e
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x46(%rbp)
movb -0x46(%rbp), %al
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x3199a
movl $0x0, -0x4(%rbp)
jmp 0x31a5f
movq -0x30(%rbp), %rax
subq -0x28(%rbp), %rax
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
jl 0x319c4
movq -0x10(%rbp), %rdi
leaq 0x548f(%rip), %rsi      # 0x36e44
movb $0x0, %al
callq 0x1fbf0
movl %eax, -0x4(%rbp)
jmp 0x31a5f
movq -0x30(%rbp), %rax
subq -0x28(%rbp), %rax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
leaq 0x5464(%rip), %rdx      # 0x36e44
callq 0x1f930
movl $0x0, -0x34(%rbp)
movq -0x20(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
subq $0x1, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x31a59
movq -0x20(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x31d20
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x31a41
movq -0x10(%rbp), %rdi
leaq 0x59d6(%rip), %rsi      # 0x3740b
movb $0x0, %al
callq 0x1fbf0
movl %eax, -0x4(%rbp)
jmp 0x31a5f
movq -0x10(%rbp), %rdi
movslq -0x44(%rbp), %rsi
callq 0x6be0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x31a08
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)