LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lua53.c
// Function: luaH_free
void luaH_free (lua_State *L, Table *t) {
  if (!isdummy(t))
    luaM_freearray(L, t->node, cast(size_t, sizenode(t)));
  luaM_freearray(L, t->array, t->sizearray);
  luaM_free(L, t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1ea86
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movzbl 0xb(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rdx
shlq $0x5, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x14540
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %edx
shlq $0x4, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x14540
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x38, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x14540
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lua53.c
// Function: pairsmeta
static int pairsmeta (lua_State *L, const char *method, int iszero,
                      lua_CFunction iter) {
  luaL_checkany(L, 1);
  if (luaL_getmetafield(L, 1, method) == LUA_TNIL) {  /* no metamethod? */
    lua_pushcfunction(L, iter);  /* will return generator, */
    lua_pushvalue(L, 1);  /* state, */
    if (iszero) lua_pushinteger(L, 0);  /* and initial value */
    else lua_pushnil(L);
  }
  else {
    lua_pushvalue(L, 1);  /* argument 'self' to metamethod */
    lua_call(L, 1, 3);  /* get 3 values from metamethod */
  }
  return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xf140
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x1, %esi
callq 0xfe60
cmpl $0x0, %eax
jne 0x21f99
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x9900
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x7340
cmpl $0x0, -0x14(%rbp)
je 0x21f8e
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8e00
jmp 0x21f97
movq -0x8(%rbp), %rdi
callq 0x8d80
jmp 0x21fc2
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x7340
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x3, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0xbfb0
movl $0x3, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lua53.c
// Function: getfuncname
static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
  if (ci == NULL)  /* no 'ci'? */
    return NULL;  /* no info */
  else if (ci->callstatus & CIST_FIN) {  /* is this a finalizer? */
    *name = "__gc";
    return "metamethod";  /* report it as such */
  }
  /* calling function is a known Lua function? */
  else if (!(ci->callstatus & CIST_TAIL) && isLua(ci->previous))
    return funcnamefromcode(L, ci->previous, name);
  else return NULL;  /* no way to find a name */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x241f5
movq $0x0, -0x8(%rbp)
jmp 0x24269
movq -0x18(%rbp), %rax
movzwl 0x42(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x24222
movq -0x20(%rbp), %rax
leaq 0x31c51(%rip), %rcx     # 0x55e63
movq %rcx, (%rax)
leaq 0x3236c(%rip), %rax     # 0x56588
movq %rax, -0x8(%rbp)
jmp 0x24269
movq -0x18(%rbp), %rax
movzwl 0x42(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
jne 0x24261
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movzwl 0x42(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x24261
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x24280
movq %rax, -0x8(%rbp)
jmp 0x24269
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lua53.c
// Function: g_write
static int g_write (lua_State *L, FILE *f, int arg) {
  int nargs = lua_gettop(L) - arg;
  int status = 1;
  for (; nargs--; arg++) {
    if (lua_type(L, arg) == LUA_TNUMBER) {
      /* optimization: could be done exactly as for strings */
      int len = lua_isinteger(L, arg)
                ? fprintf(f, LUA_INTEGER_FMT,
                             (LUAI_UACINT)lua_tointeger(L, arg))
                : fprintf(f, LUA_NUMBER_FMT,
                             (LUAI_UACNUMBER)lua_tonumber(L, arg));
      status = status && (len > 0);
    }
    else {
      size_t l;
      const char *s = luaL_checklstring(L, arg, &l);
      status = status && (fwrite(s, sizeof(char), l, f) == l);
    }
  }
  if (status) return 1;  /* file handle already on stack top */
  else return luaL_fileresult(L, status, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6d60
subl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x20(%rbp)
cmpl $0x0, %eax
je 0x28644
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x7400
cmpl $0x3, %eax
jne 0x285ea
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x74d0
cmpl $0x0, %eax
je 0x28595
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x8490
movq -0x48(%rbp), %rdi
movq %rax, %rdx
leaq 0x2d708(%rip), %rsi     # 0x55c91
movb $0x0, %al
callq 0x66a0
movl %eax, -0x3c(%rbp)
jmp 0x285c2
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x8400
movq -0x50(%rbp), %rdi
leaq 0x2d6de(%rip), %rsi     # 0x55c96
movb $0x1, %al
callq 0x66a0
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x28(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x24(%rbp)
movb %al, -0x51(%rbp)
je 0x285dd
cmpl $0x0, -0x28(%rbp)
setg %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
jmp 0x28634
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
leaq -0x30(%rbp), %rdx
callq 0xf060
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x24(%rbp)
movb %al, -0x52(%rbp)
je 0x28629
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x6890
cmpq -0x30(%rbp), %rax
sete %al
movb %al, -0x52(%rbp)
movb -0x52(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
jmp 0x28636
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x28529
cmpl $0x0, -0x24(%rbp)
je 0x28653
movl $0x1, -0x4(%rbp)
jmp 0x28666
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xeae0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lua53.c
// Function: math_log
static int math_log (lua_State *L) {
  lua_Number x = luaL_checknumber(L, 1);
  lua_Number res;
  if (lua_isnoneornil(L, 2))
    res = l_mathop(log)(x);
  else {
    lua_Number base = luaL_checknumber(L, 2);
#if !defined(LUA_USE_C89)
    if (base == l_mathop(2.0))
      res = l_mathop(log2)(x); else
#endif
    if (base == l_mathop(10.0))
      res = l_mathop(log10)(x);
    else
      res = l_mathop(log)(x)/l_mathop(log)(base);
  }
  lua_pushnumber(L, res);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xf180
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x7400
cmpl $0x0, %eax
jg 0x2a326
movsd -0x10(%rbp), %xmm0
callq 0x63f0
movsd %xmm0, -0x18(%rbp)
jmp 0x2a3b3
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0xf180
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x2b392(%rip), %xmm1    # 0x556d8
ucomisd %xmm1, %xmm0
jne 0x2a35f
jp 0x2a35f
movsd -0x10(%rbp), %xmm0
callq 0x67c0
movsd %xmm0, -0x18(%rbp)
jmp 0x2a3b1
movsd -0x20(%rbp), %xmm0
movsd 0x2b374(%rip), %xmm1    # 0x556e0
ucomisd %xmm1, %xmm0
jne 0x2a385
jp 0x2a385
movsd -0x10(%rbp), %xmm0
callq 0x62a0
movsd %xmm0, -0x18(%rbp)
jmp 0x2a3af
movsd -0x10(%rbp), %xmm0
callq 0x63f0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x63f0
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x2a3b1
jmp 0x2a3b3
movq -0x8(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x8db0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lua53.c
// Function: searcher_preload
static int searcher_preload (lua_State *L) {
  const char *name = luaL_checkstring(L, 1);
  lua_getfield(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
  if (lua_getfield(L, -1, name) == LUA_TNIL)  /* not found? */
    lua_pushfstring(L, "\n\tno field package.preload['%s']", name);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xf060
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0x2abce(%rip), %rdx     # 0x55c80
callq 0xa390
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xa390
cmpl $0x0, %eax
jne 0x2b0e4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x2b976(%rip), %rsi     # 0x56a53
movb $0x0, %al
callq 0x9840
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lua53.c
// Function: ll_require
static int ll_require (lua_State *L) {
  const char *name = luaL_checkstring(L, 1);
  lua_settop(L, 1);  /* LOADED table will be at index 2 */
  lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
  lua_getfield(L, 2, name);  /* LOADED[name] */
  if (lua_toboolean(L, -1))  /* is it there? */
    return 1;  /* package is already loaded */
  /* else must load package */
  lua_pop(L, 1);  /* remove 'getfield' result */
  findloader(L, name);
  lua_pushstring(L, name);  /* pass name as argument to module loader */
  lua_insert(L, -2);  /* name is 1st argument (before search data) */
  lua_call(L, 2, 1);  /* run loader to load module */
  if (!lua_isnil(L, -1))  /* non-nil return? */
    lua_setfield(L, 2, name);  /* LOADED[name] = returned value */
  if (lua_getfield(L, 2, name) == LUA_TNIL) {   /* module set no value? */
    lua_pushboolean(L, 1);  /* use true as result */
    lua_pushvalue(L, -1);  /* extra copy to be returned */
    lua_setfield(L, 2, name);  /* LOADED[name] = true */
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xf060
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6d90
movq -0x10(%rbp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0x2a2e6(%rip), %rdx     # 0x558a6
callq 0xa390
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x2, %esi
callq 0xa390
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x86a0
cmpl $0x0, %eax
je 0x2b5f6
movl $0x1, -0x4(%rbp)
jmp 0x2b6bd
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6d90
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2b6d0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9100
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x6e30
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0xbfb0
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7400
cmpl $0x0, %eax
je 0x2b671
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x2, %esi
callq 0xb510
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x2, %esi
callq 0xa390
cmpl $0x0, %eax
jne 0x2b6b6
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x9b40
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7340
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x2, %esi
callq 0xb510
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lua53.c
// Function: checkoption
static const char *checkoption (lua_State *L, const char *conv,
                                ptrdiff_t convlen, char *buff) {
  const char *option = LUA_STRFTIMEOPTIONS;
  int oplen = 1;  /* length of options being checked */
  for (; *option != '\0' && oplen <= convlen; option += oplen) {
    if (*option == '|')  /* next block? */
      oplen++;  /* will check options with next length (+1) */
    else if (memcmp(conv, option, oplen) == 0) {  /* match? */
      memcpy(buff, conv, oplen);  /* copy valid option to buffer */
      buff[oplen] = '\0';
      return conv + oplen;  /* return next item */
    }
  }
  luaL_argerror(L, 1,
    lua_pushfstring(L, "invalid conversion specifier '%%%s'", conv));
  return conv;  /* to avoid warnings */
}

// 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)
leaq 0x2a9b6(%rip), %rax     # 0x56c05
movq %rax, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x35(%rbp)
je 0x2c279
movslq -0x34(%rbp), %rax
cmpq -0x20(%rbp), %rax
setle %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x2c282
jmp 0x2c2f7
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7c, %eax
jne 0x2c299
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2c2df
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq -0x34(%rbp), %rdx
callq 0x6270
cmpl $0x0, %eax
jne 0x2c2dd
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x34(%rbp), %rdx
callq 0x6410
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x2c32e
jmp 0x2c2df
jmp 0x2c2e1
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x2c25a
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x2a945(%rip), %rsi     # 0x56c53
movb $0x0, %al
callq 0x9840
movq -0x40(%rbp), %rdi
movq %rax, %rdx
movl $0x1, %esi
callq 0xe740
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lz4.c
// Function: LZ4_compress_destSize_extState
static int LZ4_compress_destSize_extState (LZ4_stream_t* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize)
{
    LZ4_resetStream(state);

    if (targetDstSize >= LZ4_compressBound(*srcSizePtr)) {  /* compression success is guaranteed */
        return LZ4_compress_fast_extState(state, src, dst, *srcSizePtr, targetDstSize, 1);
    } else {
        if (*srcSizePtr < LZ4_64Klimit)
            return LZ4_compress_destSize_generic(&state->internal_donotuse, src, dst, srcSizePtr, targetDstSize, byU16);
        else
            return LZ4_compress_destSize_generic(&state->internal_donotuse, src, dst, srcSizePtr, targetDstSize, sizeof(void*)==8 ? byU32 : byPtr);
    }
}

// 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)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b060
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edi
callq 0x36ef0
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jl 0x3d235
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movl -0x2c(%rbp), %r8d
movl $0x1, %r9d
callq 0x36f40
movl %eax, -0x4(%rbp)
jmp 0x3d287
movq -0x28(%rbp), %rax
cmpl $0x1000b, (%rax)        # imm = 0x1000B
jge 0x3d265
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
movl $0x2, %r9d
callq 0x4f550
movl %eax, -0x4(%rbp)
jmp 0x3d287
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
movl $0x1, %r9d
callq 0x4f550
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lz4.c
// Function: LZ4_renormDictT
static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, const BYTE* src)
{
    if ((LZ4_dict->currentOffset > 0x80000000) ||
        ((uptrval)LZ4_dict->currentOffset > (uptrval)src)) {   /* address space overflow */
        /* rescale hash table */
        U32 const delta = LZ4_dict->currentOffset - 64 KB;
        const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize;
        int i;
        for (i=0; i<LZ4_HASH_SIZE_U32; i++) {
            if (LZ4_dict->hashTable[i] < delta) LZ4_dict->hashTable[i]=0;
            else LZ4_dict->hashTable[i] -= delta;
        }
        LZ4_dict->currentOffset = 64 KB;
        if (LZ4_dict->dictSize > 64 KB) LZ4_dict->dictSize = 64 KB;
        LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x80000000, 0x4000(%rax) # imm = 0x80000000
ja 0x41853
movq -0x8(%rbp), %rax
movl 0x4000(%rax), %eax
movq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x41921
movq -0x8(%rbp), %rax
movl 0x4000(%rax), %eax
subl $0x10000, %eax          # imm = 0x10000
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x4008(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x4018(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x1000, -0x24(%rbp)    # imm = 0x1000
jge 0x418d2
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jae 0x418b2
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x418c5
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %edx
subl %esi, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x418c7
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x41888
movq -0x8(%rbp), %rax
movl $0x10000, 0x4000(%rax)  # imm = 0x10000
movq -0x8(%rbp), %rax
cmpl $0x10000, 0x4018(%rax)  # imm = 0x10000
jbe 0x418fe
movq -0x8(%rbp), %rax
movl $0x10000, 0x4018(%rax)  # imm = 0x10000
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movl 0x4018(%rax), %eax
movl %eax, %edx
xorl %eax, %eax
subq %rdx, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x4008(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lz4.c
// Function: LZ4_count
static unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit)
{
    const BYTE* const pStart = pIn;

    while (likely(pIn<pInLimit-(STEPSIZE-1))) {
        reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
        if (!diff) { pIn+=STEPSIZE; pMatch+=STEPSIZE; continue; }
        pIn += LZ4_NbCommonBytes(diff);
        return (unsigned)(pIn - pStart);
    }

    if ((STEPSIZE==8) && (pIn<(pInLimit-3)) && (LZ4_read32(pMatch) == LZ4_read32(pIn))) { pIn+=4; pMatch+=4; }
    if ((pIn<(pInLimit-1)) && (LZ4_read16(pMatch) == LZ4_read16(pIn))) { pIn+=2; pMatch+=2; }
    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
    return (unsigned)(pIn - pStart);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $-0x7, %rcx
cmpq %rcx, %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4f296
movq -0x18(%rbp), %rdi
callq 0x4f420
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4f420
movq %rax, %rcx
movq -0x38(%rbp), %rax
xorq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x4f26b
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x4f1fc
movq -0x30(%rbp), %rdi
callq 0x4f4e0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0x4f361
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $-0x3, %rcx
cmpq %rcx, %rax
jae 0x4f2dd
movq -0x18(%rbp), %rdi
callq 0x4f100
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4f100
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jne 0x4f2dd
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
jae 0x4f32b
movq -0x18(%rbp), %rdi
callq 0x4f530
movzwl %ax, %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4f530
movw %ax, %cx
movl -0x40(%rbp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
jne 0x4f32b
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x4f353
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x4f353
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lz4.c
// Function: LZ4_hash5
static U32 LZ4_hash5(U64 sequence, tableType_t const tableType)
{
    static const U64 prime5bytes = 889523592379ULL;
    static const U64 prime8bytes = 11400714785074694791ULL;
    const U32 hashLog = (tableType == byU16) ? LZ4_HASHLOG+1 : LZ4_HASHLOG;
    if (LZ4_isLittleEndian())
        return (U32)(((sequence << 24) * prime5bytes) >> (64 - hashLog));
    else
        return (U32)(((sequence >> 24) * prime8bytes) >> (64 - hashLog));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %edx
movl $0xc, %eax
movl $0xd, %ecx
cmpl $0x2, %edx
cmovel %ecx, %eax
movl %eax, -0x18(%rbp)
callq 0x4f480
cmpl $0x0, %eax
je 0x4f3e7
movq -0x10(%rbp), %rax
shlq $0x18, %rax
movabsq $0xcf1bbcdcbb, %rcx     # imm = 0xCF1BBCDCBB
imulq %rcx, %rax
movl $0x40, %ecx
subl -0x18(%rbp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movl %eax, -0x4(%rbp)
jmp 0x4f40d
movq -0x10(%rbp), %rax
shrq $0x18, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movl $0x40, %ecx
subl -0x18(%rbp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
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/kieselsteini[P]PiXL-old/pixl.c
// Function: main
int main(int argc, char **argv) {
  lua_State *L = luaL_newstate();
  margc = argc; margv = argv;
  px_register_args(L, argc, argv);
  luaL_openlibs(L);
  luaL_requiref(L, "pixl", px_lua_open, 1);
  lua_getglobal(L, "debug"); lua_getfield(L, -1, "traceback"); lua_remove(L, -2);
  lua_pushcfunction(L, px_lua_init);
  if (lua_pcall(L, 0, 0, -2) != LUA_OK) {
    const char *message = luaL_gsub(L, lua_tostring(L, -1), "\t", "  ");
    if (audio_device) SDL_PauseAudioDevice(audio_device, SDL_TRUE);
    #ifndef _WIN32
    fprintf(stderr, "=[ PiXL Panic ]=\n%s\n", message);
    #endif // _WIN32
    SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "PiXL Panic", message, window);
  }
  lua_close(L);
  px_shutdown();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x10520
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl %eax, 0x14244(%rip)     # 0x644fc
movq -0x10(%rbp), %rax
movq %rax, 0x1423d(%rip)     # 0x64500
movq -0x18(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x50420
movq -0x18(%rbp), %rdi
callq 0x1b6d0
movq -0x18(%rbp), %rdi
leaq 0x7c29(%rip), %rsi      # 0x57f10
leaq 0x1b2(%rip), %rdx       # 0x504a0
movl $0x1, %ecx
callq 0x10360
movq -0x18(%rbp), %rdi
leaq 0x60d0(%rip), %rsi      # 0x563d3
callq 0x9c90
movq -0x18(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x613d(%rip), %rdx      # 0x56455
callq 0xa390
movq -0x18(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x6e30
movq -0x18(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6d90
movq -0x18(%rbp), %rdi
leaq 0x1f7(%rip), %rsi       # 0x50540
xorl %edx, %edx
callq 0x9900
movq -0x18(%rbp), %rdi
xorl %edx, %edx
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
xorl %eax, %eax
movl %eax, %r9d
movl %edx, %esi
movq %r9, %r8
callq 0xc160
cmpl $0x0, %eax
je 0x503fc
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x8700
movq -0x28(%rbp), %rdi
movq %rax, %rsi
leaq 0x5f07(%rip), %rdx      # 0x562a2
leaq 0x7b73(%rip), %rcx      # 0x57f15
callq 0x10460
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x14146(%rip)     # 0x644f8
je 0x503c4
movl 0x1413e(%rip), %edi     # 0x644f8
movl $0x1, %esi
callq 0x6610
movq 0x13c15(%rip), %rax     # 0x63fe0
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x7b3f(%rip), %rsi      # 0x57f18
movb $0x0, %al
callq 0x66a0
movq -0x20(%rbp), %rdx
movq 0x140f5(%rip), %rcx     # 0x644e0
movl $0x10, %edi
leaq 0x7b36(%rip), %rsi      # 0x57f2d
callq 0x63e0
movq -0x18(%rbp), %rdi
callq 0x1deb0
callq 0x53380
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: px_register_args
static void px_register_args(lua_State *L, int argc, char **argv) {
  int i;
  lua_newtable(L);
  for (i = 0; i < argc; ++i) {
    lua_pushstring(L, argv[i]);
    lua_rawseti(L, -2, i);
  }
  lua_setglobal(L, "arg");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xa7f0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x50481
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x9100
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xb8b0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x50447
movq -0x8(%rbp), %rdi
leaq 0x606e(%rip), %rsi      # 0x564fa
callq 0xad70
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: px_lua_open
static int px_lua_open(lua_State *L) {
  luaL_newlib(L, px_functions);
  lua_pushstring(L, PX_AUTHOR); lua_setfield(L, -2, "_author");
  lua_pushinteger(L, PX_VERSION); lua_setfield(L, -2, "_version");
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movsd 0x51f0(%rip), %xmm0     # 0x556a8
movl $0x88, %esi
callq 0x10890
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1d, %edx
callq 0xa7f0
movq -0x8(%rbp), %rdi
leaq 0x13703(%rip), %rsi     # 0x63be0
xorl %edx, %edx
callq 0x10220
movq -0x8(%rbp), %rdi
leaq 0x7a49(%rip), %rsi      # 0x57f38
callq 0x9100
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x7a61(%rip), %rdx      # 0x57f65
callq 0xb510
movq -0x8(%rbp), %rdi
movl $0x212, %esi            # imm = 0x212
callq 0x8e00
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x7a46(%rip), %rdx      # 0x57f6d
callq 0xb510
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_point
static int f_point(lua_State *L) {
  Uint8 color = (Uint8)luaL_checkinteger(L, 1);
  int x0 = (int)luaL_checknumber(L, 2);
  int y0 = (int)luaL_checknumber(L, 3);
  _pixel(color, x0, y0);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xf220
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
movb -0x9(%rbp), %al
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
movzbl %al, %edi
callq 0x51e70
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_fill
static int f_fill(lua_State *L) {
  Uint8 color = (Uint8)luaL_checkinteger(L, 1);
  int x0 = (int)luaL_checknumber(L, 2);
  int y0 = (int)luaL_checknumber(L, 3);
  int x1 = (int)luaL_checknumber(L, 4);
  int y1 = (int)luaL_checknumber(L, 5);
  int x, y;
  if (x0 > x1) swap(int, x0, x1);
  if (y0 > y1) swap(int, y0, y1);
  for (y = y0; y <= y1; ++y) {
    for (x = x0; x <= x1; ++x) {
      _pixel(color, x, y);
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xf220
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x50a0f
jmp 0x509fb
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x50a0f
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x50a2d
jmp 0x50a19
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x50a2d
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x50a72
movl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x50a65
movb -0x9(%rbp), %al
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
movzbl %al, %edi
callq 0x51e70
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x50a41
jmp 0x50a67
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x50a33
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_rect
static int f_rect(lua_State *L) {
  Uint8 color = (Uint8)luaL_checkinteger(L, 1);
  int x0 = (int)luaL_checknumber(L, 2);
  int y0 = (int)luaL_checknumber(L, 3);
  int x1 = (int)luaL_checknumber(L, 4);
  int y1 = (int)luaL_checknumber(L, 5);
  int x, y;
  if (x0 > x1) swap(int, x0, x1);
  if (y0 > y1) swap(int, y0, y1);
  for (x = x0; x <= x1; ++x) {
    _pixel(color, x, y0);
    _pixel(color, x, y1);
  }
  for (y = y0; y <= y1; ++y) {
    _pixel(color, x0, y);
    _pixel(color, x1, y);
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xf220
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x50b0f
jmp 0x50afb
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x50b0f
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x50b2d
jmp 0x50b19
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x50b2d
movl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x50b68
movb -0x9(%rbp), %al
movl -0x20(%rbp), %esi
movl -0x14(%rbp), %edx
movzbl %al, %edi
callq 0x51e70
movb -0x9(%rbp), %al
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
movzbl %al, %edi
callq 0x51e70
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x50b33
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x50ba3
movb -0x9(%rbp), %al
movl -0x10(%rbp), %esi
movl -0x24(%rbp), %edx
movzbl %al, %edi
callq 0x51e70
movb -0x9(%rbp), %al
movl -0x18(%rbp), %esi
movl -0x24(%rbp), %edx
movzbl %al, %edi
callq 0x51e70
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x50b6e
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_line
static int f_line(lua_State *L) {
  Uint8 color = (Uint8)luaL_checkinteger(L, 1);
  int x0 = (int)luaL_checknumber(L, 2);
  int y0 = (int)luaL_checknumber(L, 3);
  int x1 = (int)luaL_checknumber(L, 4);
  int y1 = (int)luaL_checknumber(L, 5);
  int dx = SDL_abs(x1 - x0), sx = x0 < x1 ? 1 : -1;
  int dy = SDL_abs(y1 - y0), sy = y0 < y1 ? 1 : -1;
  int err = (dx > dy ? dx : -dy) / 2, e2;
  for (;;) {
    _pixel(color, x0, y0);
    if (x0 == x1 && y0 == y1) break;
    e2 = err;
    if (e2 > -dx) { err -= dy; x0 += sx; }
    if (e2 < dy) { err += dx; y0 += sy; }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xf220
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %edi
subl -0x10(%rbp), %edi
callq 0x60b0
movl %eax, -0x20(%rbp)
movl -0x10(%rbp), %edx
movl -0x18(%rbp), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl %esi, %edx
cmovll %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %edi
subl -0x14(%rbp), %edi
callq 0x60b0
movl %eax, -0x28(%rbp)
movl -0x14(%rbp), %edx
movl -0x1c(%rbp), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl %esi, %edx
cmovll %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x28(%rbp), %eax
jle 0x50c7d
movl -0x20(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x50c85
xorl %eax, %eax
subl -0x28(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x30(%rbp)
movb -0x9(%rbp), %al
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
movzbl %al, %edi
callq 0x51e70
movl -0x10(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x50cb6
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x50cb6
jmp 0x50cf8
movl -0x30(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
xorl %ecx, %ecx
subl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jle 0x50cdc
movl -0x28(%rbp), %ecx
movl -0x30(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x50cf6
movl -0x20(%rbp), %eax
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x50c93
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_circle
static int f_circle(lua_State *L) {
  Uint8 color = (Uint8)luaL_checkinteger(L, 1);
  int x0 = (int)luaL_checknumber(L, 2);
  int y0 = (int)luaL_checknumber(L, 3);
  int radius = (int)luaL_checknumber(L, 4);
  int fill = lua_toboolean(L, 5);
  int r0sq = fill ? 0 : (radius - 1) * (radius - 1);
  int r1sq = radius * radius;
  int x, y, dx, dy, dist;
  for (y = y0 - radius; y <= y0 + radius; ++y) {
    dy = y0 - y; dy *= dy;
    for (x = x0 - radius; x <= x0 + radius; ++x) {
      dx = x0 - x; dx *= dx;
      dist = dx + dy;
      if ((dist >= r0sq) && (dist < r1sq)) _pixel(color, x, y);
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xf220
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x86a0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x50d7a
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x50d8c
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
imull %ecx, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
imull -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jg 0x50e39
movl -0x14(%rbp), %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
imull -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x10(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl -0x10(%rbp), %ecx
addl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jg 0x50e29
movl -0x10(%rbp), %eax
subl -0x28(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
imull -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0x50e1c
movl -0x38(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x50e1c
movb -0x9(%rbp), %al
movl -0x28(%rbp), %esi
movl -0x2c(%rbp), %edx
movzbl %al, %edi
callq 0x51e70
jmp 0x50e1e
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x50dd2
jmp 0x50e2b
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x50da5
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_translate
static int f_translate(lua_State *L) {
  if (lua_gettop(L) == 2) {
    int x = (int)luaL_checknumber(L, 1);
    int y = (int)luaL_checknumber(L, 2);
    translation.x = x;
    translation.y = y;
  }
  lua_pushinteger(L, translation.x);
  lua_pushinteger(L, translation.y);
  return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6d60
cmpl $0x2, %eax
jne 0x50ea6
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, 0x113673(%rip)    # 0x164510
movl -0x10(%rbp), %eax
movl %eax, 0x11366e(%rip)    # 0x164514
movq -0x8(%rbp), %rdi
movslq 0x11365f(%rip), %rsi    # 0x164510
callq 0x8e00
movq -0x8(%rbp), %rdi
movslq 0x113653(%rip), %rsi    # 0x164514
callq 0x8e00
movl $0x2, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_sprite
static int f_sprite(lua_State *L) {
  size_t length;
  Uint8 color;
  int x, y, w, h;
  int x0 = (int)luaL_checknumber(L, 1);
  int y0 = (int)luaL_checknumber(L, 2);
  const char *data = luaL_checklstring(L, 3, &length);
  int transparent = (int)luaL_optinteger(L, 4, -1);
  switch (length) {
  case 64: w = h = 8; break;
  case 256: w = h = 16; break;
  case 1024: w = h = 32; break;
  case 384: w = 16; h = 24; break;
  default: return luaL_argerror(L, 3, "invalid sprite data length");
  }
  for (y = y0; y < y0 + h; ++y) {
    for (x = x0; x < x0 + w; ++x) {
      color = sprite_color_map[(*data++) & 127];
      if (color != transparent) _pixel(color, x, y);
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
leaq -0x18(%rbp), %rdx
callq 0xf060
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
movq $-0x1, %rdx
callq 0xf2b0
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
subq $0x40, %rax
je 0x50f7e
jmp 0x50f54
movq -0x50(%rbp), %rax
subq $0x100, %rax            # imm = 0x100
je 0x50f8e
jmp 0x50f62
movq -0x50(%rbp), %rax
subq $0x180, %rax            # imm = 0x180
je 0x50fae
jmp 0x50f70
movq -0x50(%rbp), %rax
subq $0x400, %rax            # imm = 0x400
je 0x50f9e
jmp 0x50fbe
movl $0x8, -0x2c(%rbp)
movl $0x8, -0x28(%rbp)
jmp 0x50fdb
movl $0x10, -0x2c(%rbp)
movl $0x10, -0x28(%rbp)
jmp 0x50fdb
movl $0x20, -0x2c(%rbp)
movl $0x20, -0x28(%rbp)
jmp 0x50fdb
movl $0x10, -0x28(%rbp)
movl $0x18, -0x2c(%rbp)
jmp 0x50fdb
movq -0x10(%rbp), %rdi
movl $0x3, %esi
leaq 0x7028(%rip), %rdx      # 0x57ff6
callq 0xe740
movl %eax, -0x4(%rbp)
jmp 0x51061
movl -0x34(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x34(%rbp), %ecx
addl -0x2c(%rbp), %ecx
cmpl %ecx, %eax
jge 0x5105a
movl -0x30(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x30(%rbp), %ecx
addl -0x28(%rbp), %ecx
cmpl %ecx, %eax
jge 0x5104d
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movsbl (%rax), %eax
andl $0x7f, %eax
movslq %eax, %rcx
leaq 0x6a30(%rip), %rax      # 0x57a50
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl -0x44(%rbp), %eax
je 0x51040
movb -0x19(%rbp), %al
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
movzbl %al, %edi
callq 0x51e70
jmp 0x51042
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x50ff4
jmp 0x5104f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x50fe1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_print
static int f_print(lua_State *L) {
  int x, y;
  Uint8 glyph;
  Uint8 color = (Uint8)luaL_checkinteger(L, 1);
  int x0 = (int)luaL_checknumber(L, 2);
  int y0 = (int)luaL_checknumber(L, 3);
  const char *str = luaL_checkstring(L, 4);
  for (; *str; ++str, x0 += 8) {
    for (y = 0; y < 8; ++y) {
      glyph = font8x8[*str & 127][y];
      for (x = 0; x < 8; ++x) {
        if (glyph & (1 << x)) _pixel(color, x0 + x, y0 + y);
      }
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xf220
movb %al, -0x12(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0xf180
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xf060
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5117d
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0x51161
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
andl $0x7f, %eax
movslq %eax, %rcx
leaq 0x69d5(%rip), %rax      # 0x57ad0
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x51154
movzbl -0x11(%rbp), %eax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x51147
movb -0x12(%rbp), %al
movl -0x18(%rbp), %esi
addl -0xc(%rbp), %esi
movl -0x1c(%rbp), %edx
addl -0x10(%rbp), %edx
movzbl %al, %edi
callq 0x51e70
jmp 0x51149
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x51113
jmp 0x51156
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x510e1
jmp 0x51163
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x18(%rbp)
jmp 0x510cd
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_play
static int f_play(lua_State *L) {
  AudioChannel *channel;
  int i = (int)luaL_checkinteger(L, 1);
  const char *str = luaL_checkstring(L, 2);
  luaL_argcheck(L, i >= 0 && i < PX_AUDIO_CHANNELS, 1, "invalid channel");
  if (audio_device) {
    SDL_LockAudioDevice(audio_device);
    channel = &channels[i];
    mml_reset_channel(channel);
    channel->source = channel->in = SDL_strdup(str);
    channel->looping = lua_toboolean(L, 3);
    SDL_UnlockAudioDevice(audio_device);
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xf220
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xf060
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x511d4
movb $0x1, %al
cmpl $0x8, -0x14(%rbp)
movb %al, -0x21(%rbp)
jl 0x511f2
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x6e2d(%rip), %rdx      # 0x58011
callq 0xe740
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
cmpl $0x0, 0x132fc(%rip)     # 0x644f8
je 0x51265
movl 0x132f4(%rip), %edi     # 0x644f8
callq 0x64d0
movslq -0x14(%rbp), %rcx
leaq 0x11330c(%rip), %rax    # 0x164520
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x51ee0
movq -0x20(%rbp), %rdi
callq 0x61a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x86a0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movl 0x13298(%rip), %edi     # 0x644f8
callq 0x6770
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_stop
static int f_stop(lua_State *L) {
  int i = (int)luaL_checkinteger(L, 1);
  luaL_argcheck(L, i >= 0 && i < PX_AUDIO_CHANNELS, 1, "invalid channel");
  if (audio_device) {
    SDL_LockAudioDevice(audio_device);
    mml_reset_channel(&channels[i]);
    SDL_UnlockAudioDevice(audio_device);
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xf220
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x5129e
movb $0x1, %al
cmpl $0x8, -0xc(%rbp)
movb %al, -0xd(%rbp)
jl 0x512bc
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x6d63(%rip), %rdx      # 0x58011
callq 0xe740
cmpl $0x0, %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
cmpl $0x0, 0x13232(%rip)     # 0x644f8
je 0x512f5
movl 0x1322a(%rip), %edi     # 0x644f8
callq 0x64d0
movslq -0xc(%rbp), %rax
leaq 0x113242(%rip), %rdi    # 0x164520
imulq $0x38, %rax, %rax
addq %rax, %rdi
callq 0x51ee0
movl 0x13208(%rip), %edi     # 0x644f8
callq 0x6770
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_mouse
static int f_mouse(lua_State *L) {
  Input *input = &inputs[_check_controller(L)];
  lua_pushinteger(L, input->mouse.x + translation.x);
  lua_pushinteger(L, input->mouse.y + translation.y);
  return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x51f50
movslq %eax, %rcx
leaq 0x1136d1(%rip), %rax    # 0x164af0
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
addl 0x1130d5(%rip), %eax    # 0x164510
movslq %eax, %rsi
callq 0x8e00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
addl 0x1130c0(%rip), %eax    # 0x164514
movslq %eax, %rsi
callq 0x8e00
movl $0x2, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)