LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: marktmu
static void marktmu (global_State *g) {
  GCObject *u = g->tmudata;
  if (u) {
    do {
      u = u->gch.next;
      makewhite(g, u);  /* may be marked, if left from previous GC */
      reallymarkobject(g, u);
    } while (u != g->tmudata);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf19f
jmp 0xf151
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x9(%rax), %eax
andl $0xf8, %eax
movq -0x8(%rbp), %rcx
movzbl 0x20(%rcx), %ecx
andl $0x3, %ecx
movzbl %cl, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x9(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xdf00
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jne 0xf151
jmp 0xf19f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: cleartable
static void cleartable (GCObject *l) {
  while (l) {
    Table *h = gco2h(l);
    int i = h->sizearray;
    lua_assert(testbit(h->marked, VALUEWEAKBIT) ||
               testbit(h->marked, KEYWEAKBIT));
    if (testbit(h->marked, VALUEWEAKBIT)) {
      while (i--) {
        TValue *o = &h->array[i];
        if (iscleared(o, 0))  /* value was collected? */
          setnilvalue(o);  /* remove value */
      }
    }
    i = sizenode(h);
    while (i--) {
      Node *n = gnode(h, i);
      if (!ttisnil(gval(n)) &&  /* non-empty entry? */
          (iscleared(key2tval(n), 1) || iscleared(gval(n), 0))) {
        setnilvalue(gval(n));  /* remove value ... */
        removeentry(n);  /* remove entry from table */
      }
    }
    l = h->gclist;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf2c2
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x9(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xf231
jmp 0xf1eb
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0xf22f
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xf2d0
cmpl $0x0, %eax
je 0xf22d
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0xf1eb
jmp 0xf231
movq -0x10(%rbp), %rax
movzbl 0xb(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0xf2b1
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0xf2af
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movl $0x1, %esi
callq 0xf2d0
cmpl $0x0, %eax
jne 0xf29b
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0xf2d0
cmpl $0x0, %eax
je 0xf2af
movq -0x28(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x28(%rbp), %rdi
callq 0xeee0
jmp 0xf243
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xf1bc
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lgc.c
// Function: iscleared
static int iscleared (const TValue *o, int iskey) {
  if (!iscollectable(o)) return 0;
  if (ttisstring(o)) {
    stringmark(rawtsvalue(o));  /* strings are `values', so are never weak */
    return 0;
  }
  return iswhite(gcvalue(o)) ||
    (ttisuserdata(o) && (!iskey && isfinalized(uvalue(o))));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x4, 0x8(%rax)
jge 0xf2f1
movl $0x0, -0x4(%rbp)
jmp 0xf378
movq -0x10(%rbp), %rax
cmpl $0x4, 0x8(%rax)
jne 0xf318
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %ecx
andl $0xfc, %ecx
movb %cl, 0x9(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xf378
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %ecx
andl $0x3, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
jne 0xf36d
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x7, 0x8(%rcx)
movb %al, -0x16(%rbp)
jne 0xf367
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x17(%rbp)
jne 0xf361
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x17(%rbp)
movb -0x17(%rbp), %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lmem.c
// Function: luaM_growaux_
void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
                     int limit, const char *errormsg) {
  void *newblock;
  int newsize;
  if (*size >= limit/2) {  /* cannot double it? */
    if (*size >= limit)  /* cannot grow even a little? */
      luaG_runerror(L, errormsg);
    newsize = limit;  /* still have at least one free place */
  }
  else {
    newsize = (*size)*2;
    if (newsize < MINSIZEARRAY)
      newsize = MINSIZEARRAY;  /* minimum size */
  }
  newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
  *size = newsize;  /* update only when everything else is OK */
  return newblock;
}

// 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 %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x40(%rbp)
movl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x40(%rbp), %eax
cmpl %ecx, %eax
jl 0xf3df
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x24(%rbp), %eax
jl 0xf3d7
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movb $0x0, %al
callq 0xa410
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0xf3f9
movq -0x18(%rbp), %rax
movl (%rax), %eax
shll %eax
movl %eax, -0x3c(%rbp)
cmpl $0x4, -0x3c(%rbp)
jge 0xf3f7
movl $0x4, -0x3c(%rbp)
jmp 0xf3f9
movl -0x3c(%rbp), %eax
addl $0x1, %eax
cltq
movq %rax, -0x48(%rbp)
movq $-0x3, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x20(%rbp)
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
ja 0xf448
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movslq (%rax), %rdx
imulq -0x20(%rbp), %rdx
movslq -0x3c(%rbp), %rcx
imulq -0x20(%rbp), %rcx
callq 0xf470
movq %rax, -0x50(%rbp)
jmp 0xf455
movq -0x8(%rbp), %rdi
callq 0xf500
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lmem.c
// Function: luaM_realloc_
void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
  global_State *g = G(L);
  lua_assert((osize == 0) == (block == NULL));
  block = (*g->frealloc)(g->ud, block, osize, nsize);
  if (block == NULL && nsize > 0)
    luaD_throw(L, LUA_ERRMEM);
  lua_assert((nsize == 0) == (block == NULL));
  g->totalbytes = (g->totalbytes - osize) + nsize;
  return block;
}

// 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 -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq *%rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xf4d2
cmpq $0x0, -0x20(%rbp)
jbe 0xf4d2
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0xaec0
movq -0x28(%rbp), %rax
movq 0x78(%rax), %rcx
subq -0x18(%rbp), %rcx
addq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lobject.c
// Function: luaO_int2fb
int luaO_int2fb (unsigned int x) {
  int e = 0;  /* expoent */
  while (x >= 16) {
    x = (x+1) >> 1;
    e++;
  }
  if (x < 8) return x;
  else return ((e+1) << 3) | (cast_int(x) - 8);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0x8(%rbp)
jb 0xf55a
movl -0x8(%rbp), %eax
addl $0x1, %eax
shrl %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xf53e
cmpl $0x8, -0x8(%rbp)
jae 0xf568
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xf57c
movl -0xc(%rbp), %eax
addl $0x1, %eax
shll $0x3, %eax
movl -0x8(%rbp), %ecx
subl $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lobject.c
// Function: luaO_log2
int luaO_log2 (unsigned int x) {
  static const lu_byte log_2[256] = {
    0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
    6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
  };
  int l = -1;
  while (x >= 256) { l += 8; x >>= 8; }
  return l + log_2[x];

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jb 0xf5fb
movl -0x8(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x4(%rbp)
jmp 0xf5de
movl -0x8(%rbp), %eax
movl -0x4(%rbp), %ecx
movl %ecx, %edx
leaq 0x1c106(%rip), %rcx     # 0x2b710
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lobject.c
// Function: luaO_rawequalObj
int luaO_rawequalObj (const TValue *t1, const TValue *t2) {
  if (ttype(t1) != ttype(t2)) return 0;
  else switch (ttype(t1)) {
    case LUA_TNIL:
      return 1;
    case LUA_TNUMBER:
      return luai_numeq(nvalue(t1), nvalue(t2));
    case LUA_TBOOLEAN:
      return bvalue(t1) == bvalue(t2);  /* boolean true must be 1 !! */
    case LUA_TLIGHTUSERDATA:
      return pvalue(t1) == pvalue(t2);
    default:
      lua_assert(iscollectable(t1));
      return gcvalue(t1) == gcvalue(t2);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0xf648
movl $0x0, -0x4(%rbp)
jmp 0xf6e5
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x3, %rax
ja 0xf6cc
movq -0x20(%rbp), %rax
leaq 0x1c08c(%rip), %rcx     # 0x2b6f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0xf6e5
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd (%rax), %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xf6e5
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xf6e5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xf6e5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lobject.c
// Function: luaO_str2d
int luaO_str2d (const char *s, lua_Number *result) {
  char *endptr;
  *result = lua_str2number(s, &endptr);
  if (endptr == s) return 0;  /* conversion failed */
  if (*endptr == 'x' || *endptr == 'X')  /* maybe an hexadecimal constant? */
    *result = cast_num(strtoul(s, &endptr, 16));
  if (*endptr == '\0') return 1;  /* most common case */
  while (isspace(cast(unsigned char, *endptr))) endptr++;
  if (*endptr != '\0') return 0;  /* invalid trailing characters? */
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x50f0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xf72b
movl $0x0, -0x4(%rbp)
jmp 0xf7e5
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x78, %eax
je 0xf743
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x58, %eax
jne 0xf784
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x5470
movq %rax, %xmm0
movaps 0x1c0af(%rip), %xmm1    # 0x2b810
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x1c0b3(%rip), %xmm1    # 0x2b820
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xf799
movl $0x1, -0x4(%rbp)
jmp 0xf7e5
jmp 0xf79b
callq 0x5570
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0xf7c9
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xf79b
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xf7de
movl $0x0, -0x4(%rbp)
jmp 0xf7e5
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lobject.c
// Function: luaO_chunkid
void luaO_chunkid (char *out, const char *source, size_t bufflen) {
  if (*source == '=') {
    strncpy(out, source+1, bufflen);  /* remove first char */
    out[bufflen-1] = '\0';  /* ensures null termination */
  }
  else {  /* out = "source", or "...source" */
    if (*source == '@') {
      size_t l;
      source++;  /* skip the `@' */
      bufflen -= sizeof(" '...' ");
      l = strlen(source);
      strcpy(out, "");
      if (l > bufflen) {
        source += (l-bufflen);  /* get last part of file name */
        strcat(out, "...");
      }
      strcat(out, source);
    }
    else {  /* out = [string "string"] */
      size_t len = strcspn(source, "\n\r");  /* stop at first newline */
      bufflen -= sizeof(" [string \"...\"] ");
      if (len > bufflen) len = bufflen;
      strcpy(out, "[string \"");
      if (source[len] != '\0') {  /* must truncate? */
        strncat(out, source, len);
        strcat(out, "...");
      }
      else
        strcat(out, source);
      strcat(out, "\"]");
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0xfe9a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
movq -0x18(%rbp), %rdx
callq 0x5080
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
jmp 0xffac
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x40, %eax
jne 0xff17
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
subq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5150
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1d440(%rip), %rsi     # 0x2d316
callq 0x50a0
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0xff05
movq -0x20(%rbp), %rax
subq -0x18(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1c923(%rip), %rsi     # 0x2c823
callq 0x5490
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5490
jmp 0xffaa
movq -0x10(%rbp), %rdi
leaq 0x1b917(%rip), %rsi     # 0x2b839
callq 0x5210
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
subq $0x11, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0xff49
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1b8e8(%rip), %rsi     # 0x2b83c
callq 0x50a0
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xff8d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x51d0
movq -0x8(%rbp), %rdi
leaq 0x1c89d(%rip), %rsi     # 0x2c823
callq 0x5490
jmp 0xff9a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5490
movq -0x8(%rbp), %rdi
leaq 0x1b8a1(%rip), %rsi     # 0x2b846
callq 0x5490
jmp 0xffac
addq $0x30, %rsp
popq %rbp
retq
nop
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: luaY_parser
Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
  struct LexState lexstate;
  struct FuncState funcstate;
  lexstate.buff = buff;
  luaX_setinput(L, &lexstate, z, luaS_new(L, name));
  open_func(&lexstate, &funcstate);
  funcstate.f->is_vararg = VARARG_ISVARARG;  /* main func. is always vararg */
  luaX_next(&lexstate);  /* read first token */
  chunk(&lexstate);
  check(&lexstate, TK_EOS);
  close_func(&lexstate);
  lua_assert(funcstate.prev == NULL);
  lua_assert(funcstate.f->nups == 0);
  lua_assert(lexstate.fs == NULL);
  return funcstate.f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x300, %rsp            # imm = 0x300
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2e8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x2e0(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2f8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x2f0(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5150
movq -0x2f8(%rbp), %rdi
movq -0x2f0(%rbp), %rsi
movq %rax, %rdx
callq 0x140d0
movq -0x2e8(%rbp), %rdi
movq -0x2e0(%rbp), %rdx
movq %rax, %rcx
leaq -0x80(%rbp), %rsi
callq 0x1e700
leaq -0x80(%rbp), %rdi
leaq -0x2d8(%rbp), %rsi
callq 0x100a0
movq -0x2d8(%rbp), %rax
movb $0x2, 0x72(%rax)
leaq -0x80(%rbp), %rdi
callq 0x1e820
leaq -0x80(%rbp), %rdi
callq 0x10260
leaq -0x80(%rbp), %rdi
movl $0x11f, %esi            # imm = 0x11F
callq 0x10300
leaq -0x80(%rbp), %rdi
callq 0x10330
movq -0x2d8(%rbp), %rax
addq $0x300, %rsp            # imm = 0x300
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: open_func
static void open_func (LexState *ls, FuncState *fs) {
  lua_State *L = ls->L;
  Proto *f = luaF_newproto(L);
  fs->f = f;
  fs->prev = ls->fs;  /* linked list of funcstates */
  fs->ls = ls;
  fs->L = L;
  ls->fs = fs;
  fs->pc = 0;
  fs->lasttarget = -1;
  fs->jpc = NO_JUMP;
  fs->freereg = 0;
  fs->nk = 0;
  fs->np = 0;
  fs->nlocvars = 0;
  fs->nactvar = 0;
  fs->bl = NULL;
  f->source = ls->source;
  f->maxstacksize = 2;  /* registers 0/1 are always valid */
  fs->h = luaH_new(L, 0, 0);
  /* anchor table of constants and prototype (to avoid being collected) */
  sethvalue2s(L, L->top, fs->h);
  incr_top(L);
  setptvalue2s(L, L->top, f);
  incr_top(L);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd0e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x34(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x44(%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x48(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x4a(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rax
movb $0x2, 0x73(%rax)
movq -0x18(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x14960
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movl $0x5, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
cmpq $0x10, %rax
jg 0x101e7
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xb380
jmp 0x101e9
jmp 0x101e9
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movl $0x9, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
cmpq $0x10, %rax
jg 0x10244
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xb380
jmp 0x10246
jmp 0x10246
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: chunk
static void chunk (LexState *ls) {
  /* chunk -> { stat [`;'] } */
  int islast = 0;
  enterlevel(ls);
  while (!islast && !block_follow(ls->t.token)) {
    islast = statement(ls);
    testnext(ls, ';');
    lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg &&
               ls->fs->freereg >= ls->fs->nactvar);
    ls->fs->freereg = ls->fs->nactvar;  /* free registers */
  }
  leavelevel(ls);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10790
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0xd(%rbp)
jne 0x1029e
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x107e0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x102a7
jmp 0x102da
movq -0x8(%rbp), %rdi
callq 0x10830
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3b, %esi
callq 0x109a0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movzbl 0x4a(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl %ecx, 0x3c(%rax)
jmp 0x1027c
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movw 0x60(%rax), %cx
addw $-0x1, %cx
movw %cx, 0x60(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: block_follow
static int block_follow (int token) {
  switch (token) {
    case TK_ELSE: case TK_ELSEIF: case TK_END:
    case TK_UNTIL: case TK_EOS:
      return 1;
    default: return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
addl $0xfffffefc, %eax       # imm = 0xFFFFFEFC
subl $0x3, %eax
jb 0x10811
jmp 0x107f9
movl -0xc(%rbp), %eax
subl $0x114, %eax            # imm = 0x114
je 0x10811
jmp 0x10805
movl -0xc(%rbp), %eax
subl $0x11f, %eax            # imm = 0x11F
jne 0x1081a
jmp 0x10811
movl $0x1, -0x4(%rbp)
jmp 0x10821
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: statement
static int statement (LexState *ls) {
  int line = ls->linenumber;  /* may be needed for error messages */
  switch (ls->t.token) {
    case TK_IF: {  /* stat -> ifstat */
      ifstat(ls, line);
      return 0;
    }
    case TK_WHILE: {  /* stat -> whilestat */
      whilestat(ls, line);
      return 0;
    }
    case TK_DO: {  /* stat -> DO block END */
      luaX_next(ls);  /* skip DO */
      block(ls);
      check_match(ls, TK_END, TK_DO, line);
      return 0;
    }
    case TK_FOR: {  /* stat -> forstat */
      forstat(ls, line);
      return 0;
    }
    case TK_REPEAT: {  /* stat -> repeatstat */
      repeatstat(ls, line);
      return 0;
    }
    case TK_FUNCTION: {
      funcstat(ls, line);  /* stat -> funcstat */
      return 0;
    }
    case TK_LOCAL: {  /* stat -> localstat */
      luaX_next(ls);  /* skip LOCAL */
      if (testnext(ls, TK_FUNCTION))  /* local function? */
        localfunc(ls);
      else
        localstat(ls);
      return 0;
    }
    case TK_RETURN: {  /* stat -> retstat */
      retstat(ls);
      return 1;  /* must be last statement */
    }
    case TK_BREAK: {  /* stat -> breakstat */
      luaX_next(ls);  /* skip BREAK */
      breakstat(ls);
      return 1;  /* must be last statement */
    }
    default: {
      exprstat(ls);
      return 0;  /* to avoid warnings */
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
addl $0xfffffefe, %eax       # imm = 0xFFFFFEFE
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x13, %eax
ja 0x10984
movq -0x20(%rbp), %rax
leaq 0x1b0f4(%rip), %rcx     # 0x2b960
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x109e0
movl $0x0, -0x4(%rbp)
jmp 0x10994
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x10ae0
movl $0x0, -0x4(%rbp)
jmp 0x10994
movq -0x10(%rbp), %rdi
callq 0x1e820
movq -0x10(%rbp), %rdi
callq 0x10ba0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %ecx
movl $0x106, %esi            # imm = 0x106
movl $0x103, %edx            # imm = 0x103
callq 0x10be0
movl $0x0, -0x4(%rbp)
jmp 0x10994
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x10c90
movl $0x0, -0x4(%rbp)
jmp 0x10994
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x10d50
movl $0x0, -0x4(%rbp)
jmp 0x10994
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x10e50
movl $0x0, -0x4(%rbp)
jmp 0x10994
movq -0x10(%rbp), %rdi
callq 0x1e820
movq -0x10(%rbp), %rdi
movl $0x109, %esi            # imm = 0x109
callq 0x109a0
cmpl $0x0, %eax
je 0x10945
movq -0x10(%rbp), %rdi
callq 0x10ec0
jmp 0x1094e
movq -0x10(%rbp), %rdi
callq 0x10f90
movl $0x0, -0x4(%rbp)
jmp 0x10994
movq -0x10(%rbp), %rdi
callq 0x11040
movl $0x1, -0x4(%rbp)
jmp 0x10994
movq -0x10(%rbp), %rdi
callq 0x1e820
movq -0x10(%rbp), %rdi
callq 0x11150
movl $0x1, -0x4(%rbp)
jmp 0x10994
movq -0x10(%rbp), %rdi
callq 0x11230
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: ifstat
static void ifstat (LexState *ls, int line) {
  /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */
  FuncState *fs = ls->fs;
  int flist;
  int escapelist = NO_JUMP;
  flist = test_then_block(ls);  /* IF cond THEN block */
  while (ls->t.token == TK_ELSEIF) {
    luaK_concat(fs, &escapelist, luaK_jump(fs));
    luaK_patchtohere(fs, flist);
    flist = test_then_block(ls);  /* ELSEIF cond THEN block */
  }
  if (ls->t.token == TK_ELSE) {
    luaK_concat(fs, &escapelist, luaK_jump(fs));
    luaK_patchtohere(fs, flist);
    luaX_next(ls);  /* skip ELSE (after patch, for correct line info) */
    block(ls);  /* `else' part */
  }
  else
    luaK_concat(fs, &escapelist, flist);
  luaK_patchtohere(fs, escapelist);
  check_match(ls, TK_END, TK_IF, line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
callq 0x112c0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x105, 0x10(%rax)      # imm = 0x105
jne 0x10a55
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c200
movq -0x28(%rbp), %rdi
movl %eax, %edx
leaq -0x20(%rbp), %rsi
callq 0x1c2b0
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1c3d0
movq -0x8(%rbp), %rdi
callq 0x112c0
movl %eax, -0x1c(%rbp)
jmp 0x10a0e
movq -0x8(%rbp), %rax
cmpl $0x104, 0x10(%rax)      # imm = 0x104
jne 0x10aa2
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c200
movq -0x30(%rbp), %rdi
movl %eax, %edx
leaq -0x20(%rbp), %rsi
callq 0x1c2b0
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1c3d0
movq -0x8(%rbp), %rdi
callq 0x1e820
movq -0x8(%rbp), %rdi
callq 0x10ba0
jmp 0x10ab2
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq -0x20(%rbp), %rsi
callq 0x1c2b0
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x1c3d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x106, %esi            # imm = 0x106
movl $0x10a, %edx            # imm = 0x10A
callq 0x10be0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: block
static void block (LexState *ls) {
  /* block -> chunk */
  FuncState *fs = ls->fs;
  BlockCnt bl;
  enterblock(fs, &bl, 0);
  chunk(ls);
  lua_assert(bl.breaklist == NO_JUMP);
  leaveblock(fs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x12d80
movq -0x8(%rbp), %rdi
callq 0x10260
movq -0x10(%rbp), %rdi
callq 0x12de0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: check_match
static void check_match (LexState *ls, int what, int who, int where) {
  if (!testnext(ls, what)) {
    if (where == ls->linenumber)
      error_expected(ls, what);
    else {
      luaX_syntaxerror(ls, luaO_pushfstring(ls->L,
             LUA_QS " expected (to close " LUA_QS " at line %d)",
              luaX_token2str(ls, what), luaX_token2str(ls, who), where));
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x109a0
cmpl $0x0, %eax
jne 0x10c7b
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x10c20
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x10660
jmp 0x10c79
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1e460
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x1e460
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movl -0x14(%rbp), %r8d
leaq 0x1aee4(%rip), %rsi     # 0x2bb4a
movb $0x0, %al
callq 0xfdb0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x1e620
jmp 0x10c7b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: repeatstat
static void repeatstat (LexState *ls, int line) {
  /* repeatstat -> REPEAT block UNTIL cond */
  int condexit;
  FuncState *fs = ls->fs;
  int repeat_init = luaK_getlabel(fs);
  BlockCnt bl1, bl2;
  enterblock(fs, &bl1, 1);  /* loop block */
  enterblock(fs, &bl2, 0);  /* scope block */
  luaX_next(ls);  /* skip REPEAT */
  chunk(ls);
  check_match(ls, TK_UNTIL, TK_REPEAT, line);
  condexit = cond(ls);  /* read condition (inside scope block) */
  if (!bl2.upval) {  /* no upvalues? */
    leaveblock(fs);  /* finish scope */
    luaK_patchlist(ls->fs, condexit, repeat_init);  /* close the loop */
  }
  else {  /* complete semantics when there are upvalues */
    breakstat(ls);  /* if condition then break */
    luaK_patchtohere(ls->fs, condexit);  /* else... */
    leaveblock(fs);  /* finish scope... */
    luaK_patchlist(ls->fs, luaK_jump(fs), repeat_init);  /* and repeat */
  }
  leaveblock(fs);  /* finish loop */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c360
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x1, %edx
callq 0x12d80
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
xorl %edx, %edx
callq 0x12d80
movq -0x8(%rbp), %rdi
callq 0x1e820
movq -0x8(%rbp), %rdi
callq 0x10260
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x114, %esi            # imm = 0x114
movl $0x110, %edx            # imm = 0x110
callq 0x10be0
movq -0x8(%rbp), %rdi
callq 0x11310
movl %eax, -0x10(%rbp)
cmpb $0x0, -0x33(%rbp)
jne 0x10df0
movq -0x18(%rbp), %rdi
callq 0x12de0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x10(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x1c380
jmp 0x10e35
movq -0x8(%rbp), %rdi
callq 0x11150
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x10(%rbp), %esi
callq 0x1c3d0
movq -0x18(%rbp), %rdi
callq 0x12de0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c200
movq -0x48(%rbp), %rdi
movl %eax, %esi
movl -0x1c(%rbp), %edx
callq 0x1c380
movq -0x18(%rbp), %rdi
callq 0x12de0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: funcstat
static void funcstat (LexState *ls, int line) {
  /* funcstat -> FUNCTION funcname body */
  int needself;
  expdesc v, b;
  luaX_next(ls);  /* skip FUNCTION */
  needself = funcname(ls, &v);
  body(ls, &b, needself, line);
  luaK_storevar(ls->fs, &v, &b);
  luaK_fixline(ls->fs, line);  /* definition `happens' in the first line */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e820
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x133c0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
movl -0xc(%rbp), %ecx
leaq -0x40(%rbp), %rsi
callq 0x11b30
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x1cff0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x1dbb0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: localfunc
static void localfunc (LexState *ls) {
  expdesc v, b;
  FuncState *fs = ls->fs;
  new_localvar(ls, str_checkname(ls), 0);
  init_exp(&v, VLOCAL, fs->freereg);
  luaK_reserveregs(fs, 1);
  adjustlocalvars(ls, 1);
  body(ls, &b, 0, ls->linenumber);
  luaK_storevar(fs, &v, &b);
  /* debug information will only see the variable after this point! */
  getlocvar(fs, fs->nactvar - 1).startpc = fs->pc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12100
movq -0x48(%rbp), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x12140
movq -0x40(%rbp), %rax
movl 0x3c(%rax), %edx
leaq -0x20(%rbp), %rdi
movl $0x6, %esi
callq 0x11890
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x1c5c0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x121c0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
leaq -0x38(%rbp), %rsi
xorl %edx, %edx
callq 0x11b30
movq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x1cff0
movq -0x40(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq -0x40(%rbp), %rdx
movq -0x40(%rbp), %rsi
movzbl 0x4a(%rsi), %esi
subl $0x1, %esi
movslq %esi, %rsi
movzwl 0xc4(%rdx,%rsi,2), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: localstat
static void localstat (LexState *ls) {
  /* stat -> LOCAL NAME {`,' NAME} [`=' explist1] */
  int nvars = 0;
  int nexps;
  expdesc e;
  do {
    new_localvar(ls, str_checkname(ls), nvars++);
  } while (testnext(ls, ','));
  if (testnext(ls, '='))
    nexps = explist1(ls, &e);
  else {
    e.k = VVOID;
    nexps = 0;
  }
  adjust_assign(ls, nvars, nexps, &e);
  adjustlocalvars(ls, nvars);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12100
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movl -0xc(%rbp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
callq 0x12140
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x109a0
cmpl $0x0, %eax
jne 0x10fa3
movq -0x8(%rbp), %rdi
movl $0x3d, %esi
callq 0x109a0
cmpl $0x0, %eax
je 0x11003
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x12d10
movl %eax, -0x10(%rbp)
jmp 0x11011
movl $0x0, -0x28(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq -0x28(%rbp), %rcx
callq 0x132f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x121c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: retstat
static void retstat (LexState *ls) {
  /* stat -> RETURN explist */
  FuncState *fs = ls->fs;
  expdesc e;
  int first, nret;  /* registers with returned values */
  luaX_next(ls);  /* skip RETURN */
  if (block_follow(ls->t.token) || ls->t.token == ';')
    first = nret = 0;  /* return no values */
  else {
    nret = explist1(ls, &e);  /* optional return values */
    if (hasmultret(e.k)) {
      luaK_setmultret(fs, &e);
      if (e.k == VCALL && nret == 1) {  /* tail call? */
        SET_OPCODE(getcode(fs,&e), OP_TAILCALL);
        lua_assert(GETARG_A(getcode(fs,&e)) == fs->nactvar);
      }
      first = fs->nactvar;
      nret = LUA_MULTRET;  /* return all values */
    }
    else {
      if (nret == 1)  /* only one single value? */
        first = luaK_exp2anyreg(fs, &e);
      else {
        luaK_exp2nextreg(fs, &e);  /* values must go to the `stack' */
        first = fs->nactvar;  /* return all `active' values */
        lua_assert(nret == fs->freereg - first);
      }
    }
  }
  luaK_ret(fs, first, nret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e820
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x107e0
cmpl $0x0, %eax
jne 0x1107c
movq -0x8(%rbp), %rax
cmpl $0x3b, 0x10(%rax)
jne 0x1108f
movl $0x0, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
jmp 0x1113b
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x12d10
movl %eax, -0x30(%rbp)
cmpl $0xd, -0x28(%rbp)
je 0x110ab
cmpl $0xe, -0x28(%rbp)
jne 0x11107
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1c840
cmpl $0xd, -0x28(%rbp)
jne 0x110f3
cmpl $0x1, -0x30(%rbp)
jne 0x110f3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %edx
andl $-0x40, %edx
orl $0x1d, %edx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movzbl 0x4a(%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
jmp 0x11139
cmpl $0x1, -0x30(%rbp)
jne 0x1111f
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1cd40
movl %eax, -0x2c(%rbp)
jmp 0x11137
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1cb50
movq -0x10(%rbp), %rax
movzbl 0x4a(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x11139
jmp 0x1113b
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
callq 0x1c320
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: breakstat
static void breakstat (LexState *ls) {
  FuncState *fs = ls->fs;
  BlockCnt *bl = fs->bl;
  int upval = 0;
  while (bl && !bl->isbreakable) {
    upval |= bl->upval;
    bl = bl->previous;
  }
  if (!bl)
    luaX_syntaxerror(ls, "no loop to break");
  if (upval)
    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
  luaK_concat(fs, &bl->breaklist, luaK_jump(fs));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1d(%rbp)
je 0x11197
movq -0x18(%rbp), %rax
cmpb $0x0, 0xe(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x111a0
jmp 0x111bb
movq -0x18(%rbp), %rax
movzbl 0xd(%rax), %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1117b
cmpq $0x0, -0x18(%rbp)
jne 0x111d2
movq -0x8(%rbp), %rdi
leaq 0x1aa08(%rip), %rsi     # 0x2bbd5
callq 0x1e620
cmpl $0x0, -0x1c(%rbp)
je 0x111f4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movzbl 0xc(%rax), %edx
movl $0x23, %esi
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x1c1a0
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c200
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl %eax, %edx
callq 0x1c2b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: exprstat
static void exprstat (LexState *ls) {
  /* stat -> func | assignment */
  FuncState *fs = ls->fs;
  struct LHS_assign v;
  primaryexp(ls, &v.v);
  if (v.v.k == VCALL)  /* stat -> func */
    SETARG_C(getcode(fs, &v.v), 1);  /* call statement uses no results */
  else {  /* stat -> assignment */
    v.prev = NULL;
    assignment(ls, &v, 1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
addq $0x8, %rsi
callq 0x11c30
cmpl $0xd, -0x28(%rbp)
jne 0x11291
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %edx
andl $0xff803fff, %edx       # imm = 0xFF803FFF
orl $0x4000, %edx           # imm = 0x4000
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x112ab
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x1, %edx
callq 0x13430
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: test_then_block
static int test_then_block (LexState *ls) {
  /* test_then_block -> [IF | ELSEIF] cond THEN block */
  int condexit;
  luaX_next(ls);  /* skip IF or ELSEIF */
  condexit = cond(ls);
  checknext(ls, TK_THEN);
  block(ls);  /* `then' part */
  return condexit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e820
movq -0x8(%rbp), %rdi
callq 0x11310
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x112, %esi            # imm = 0x112
callq 0x11350
movq -0x8(%rbp), %rdi
callq 0x10ba0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: subexpr
static BinOpr subexpr (LexState *ls, expdesc *v, unsigned int limit) {
  BinOpr op;
  UnOpr uop;
  enterlevel(ls);
  uop = getunopr(ls->t.token);
  if (uop != OPR_NOUNOPR) {
    luaX_next(ls);
    subexpr(ls, v, UNARY_PRIORITY);
    luaK_prefix(ls->fs, uop, v);
  }
  else simpleexp(ls, v);
  /* expand while operators have priorities higher than `limit' */
  op = getbinopr(ls->t.token);
  while (op != OPR_NOBINOPR && priority[op].left > limit) {
    expdesc v2;
    BinOpr nextop;
    luaX_next(ls);
    luaK_infix(ls->fs, op, v);
    /* read sub-expression with higher priority */
    nextop = subexpr(ls, &v2, priority[op].right);
    luaK_posfix(ls->fs, op, v, &v2);
    op = nextop;
  }
  leavelevel(ls);
  return op;  /* return first untreated operator */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10790
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x114e0
movl %eax, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
je 0x11412
movq -0x8(%rbp), %rdi
callq 0x1e820
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x113b0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x1d3e0
jmp 0x1141f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11540
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x11710
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0xf, -0x18(%rbp)
movb %al, -0x3d(%rbp)
je 0x11452
movl -0x18(%rbp), %eax
movl %eax, %ecx
leaq 0x1a56b(%rip), %rax     # 0x2b9b0
movzbl (%rax,%rcx,2), %eax
cmpl -0x14(%rbp), %eax
seta %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x1145b
jmp 0x114bc
movq -0x8(%rbp), %rdi
callq 0x1e820
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x1d6d0
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %ecx
leaq 0x1a528(%rip), %rax     # 0x2b9b0
movzbl 0x1(%rax,%rcx,2), %edx
leaq -0x38(%rbp), %rsi
callq 0x113b0
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x1d810
movl -0x3c(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x1142e
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movw 0x60(%rax), %cx
addw $-0x1, %cx
movw %cx, 0x60(%rax)
movl -0x18(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lparser.c
// Function: body
static void body (LexState *ls, expdesc *e, int needself, int line) {
  /* body ->  `(' parlist `)' chunk END */
  FuncState new_fs;
  open_func(ls, &new_fs);
  new_fs.f->linedefined = line;
  checknext(ls, '(');
  if (needself) {
    new_localvarliteral(ls, "self", 0);
    adjustlocalvars(ls, 1);
  }
  parlist(ls);
  checknext(ls, ')');
  chunk(ls);
  new_fs.f->lastlinedefined = ls->linenumber;
  check_match(ls, TK_END, TK_FUNCTION, line);
  close_func(ls);
  pushclosure(ls, &new_fs, e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x270(%rbp), %rsi
callq 0x100a0
movl -0x18(%rbp), %ecx
movq -0x270(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x8(%rbp), %rdi
movl $0x28, %esi
callq 0x11350
cmpl $0x0, -0x14(%rbp)
je 0x11bb9
movq -0x8(%rbp), %rax
movq %rax, -0x278(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x19f03(%rip), %rsi     # 0x2ba93
movl $0x4, %edx
callq 0x1e650
movq -0x278(%rbp), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x12140
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x121c0
movq -0x8(%rbp), %rdi
callq 0x12240
movq -0x8(%rbp), %rdi
movl $0x29, %esi
callq 0x11350
movq -0x8(%rbp), %rdi
callq 0x10260
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x270(%rbp), %rax
movl %ecx, 0x64(%rax)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %ecx
movl $0x106, %esi            # imm = 0x106
movl $0x109, %edx            # imm = 0x109
callq 0x10be0
movq -0x8(%rbp), %rdi
callq 0x10330
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x270(%rbp), %rsi
callq 0x123b0
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
nopw %cs:(%rax,%rax)