LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/lua53.c
// Function: internshrstr
static TString *internshrstr (lua_State *L, const char *str, size_t l) {
  TString *ts;
  global_State *g = G(L);
  unsigned int h = luaS_hash(str, l, g->seed);
  TString **list = &g->strt.hash[lmod(h, g->strt.size)];
  lua_assert(str != NULL);  /* otherwise 'memcmp'/'memcpy' are undefined */
  for (ts = *list; ts != NULL; ts = ts->u.hnext) {
    if (l == ts->shrlen &&
        (memcmp(str, getstr(ts), l * sizeof(char)) == 0)) {
      /* found! */
      if (isdead(g, ts))  /* dead (but not collected yet)? */
        changewhite(ts);  /* resurrect it */
      return ts;
    }
  }
  if (g->strt.nuse >= g->strt.size && g->strt.size <= MAX_INT/2) {
    luaS_resize(L, g->strt.size * 2);
    list = &g->strt.hash[lmod(h, g->strt.size)];  /* recompute with new size */
  }
  ts = createstrobj(L, l, LUA_TSHRSTR, h);
  memcpy(getstr(ts), str, l * sizeof(char));
  ts->shrlen = cast_byte(l);
  ts->u.hnext = *list;
  *list = ts;
  g->strt.nuse++;
  return ts;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movq 0x18(%rdi), %r15
movl 0x50(%r15), %edx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x129a2
movl 0x3c(%r15), %r13d
leal -0x1(%r13), %ecx
movl %eax, 0xc(%rsp)
andl %eax, %ecx
movslq %ecx, %rbp
shlq $0x3, %rbp
addq 0x30(%r15), %rbp
movq %rbp, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x12c77
movzbl 0xb(%r12), %eax
cmpq %rbx, %rax
jne 0x12c71
leaq 0x18(%r12), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x64d0
testl %eax, %eax
je 0x12cb2
addq $0x10, %r12
jmp 0x12c49
cmpl $0x3fffffff, %r13d      # imm = 0x3FFFFFFF
jg 0x12ccb
cmpl %r13d, 0x38(%r15)
movq 0x10(%rsp), %r12
jl 0x12cd0
addl %r13d, %r13d
movq %r12, %rdi
movl %r13d, %esi
callq 0x12a03
movslq 0x3c(%r15), %rax
decq %rax
movslq 0xc(%rsp), %rbp
andq %rax, %rbp
shlq $0x3, %rbp
addq 0x30(%r15), %rbp
jmp 0x12cd0
movb 0x9(%r12), %al
xorb $0x3, %al
movb 0x54(%r15), %cl
xorb $0x3, %cl
testb %al, %cl
jne 0x12d0a
movb %al, 0x9(%r12)
jmp 0x12d0a
movq 0x10(%rsp), %r12
pushq $0x4
popq %rdx
movq %r12, %rdi
movq %rbx, %rsi
movl 0xc(%rsp), %ecx
callq 0x12ba2
movq %rax, %r12
leaq 0x18(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x63f0
movb %bl, 0xb(%r12)
movq (%rbp), %rax
movq %rax, 0x10(%r12)
movq %r12, (%rbp)
incl 0x38(%r15)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x20(%rsi)
je 0x12e01
movb 0xb(%rbx), %cl
pushq $0x1
popq %rax
shll %cl, %eax
movq 0x18(%rbx), %rsi
movslq %eax, %rdx
shlq $0x5, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xde9a
movq 0x10(%rbx), %rsi
movl 0xc(%rbx), %edx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xde9a
pushq $0x38
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xde9a
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movq 0x10(%rdi), %r12
movq 0x20(%rdi), %rax
subq (%rax), %r12
movq %rsi, %r14
addq $-0x10, %r12
shrq $0x4, %r12
pushq $0x1
popq %r15
movq %rsp, %r13
cmpl %ebp, %r12d
je 0x17bbb
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6d43
movq %rbx, %rdi
movl %ebp, %esi
cmpl $0x3, %eax
jne 0x17b5c
callq 0x6d8e
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
testl %eax, %eax
je 0x17b88
callq 0x779c
movq %r14, %rdi
leaq 0x1287c(%rip), %rsi     # 0x2a3cc
movq %rax, %rdx
xorl %eax, %eax
callq 0x66a0
jmp 0x17b9e
movq %r13, %rdx
callq 0xafc5
testl %r15d, %r15d
je 0x17bb1
movq (%rsp), %rdx
movq %rax, %rdi
pushq $0x1
popq %rsi
movq %r14, %rcx
callq 0x6870
xorl %r15d, %r15d
cmpq (%rsp), %rax
sete %r15b
jmp 0x17bb4
callq 0x774c
movq %r14, %rdi
leaq 0x1283a(%rip), %rsi     # 0x2a3d1
movb $0x1, %al
callq 0x66a0
testl %r15d, %r15d
setne %cl
testl %eax, %eax
setg %al
andb %cl, %al
movzbl %al, %r15d
jmp 0x17bb4
xorl %r15d, %r15d
incl %ebp
jmp 0x17b14
testl %r15d, %r15d
je 0x17bc5
pushq $0x1
popq %rax
jmp 0x17bd1
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xac2f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xb053
movsd %xmm0, (%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6d43
testl %eax, %eax
jle 0x18703
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xb053
ucomisd 0x116dd(%rip), %xmm0    # 0x29dd0
jne 0x1870f
jp 0x1870f
movsd (%rsp), %xmm0
callq 0x67c0
jmp 0x18753
movsd (%rsp), %xmm0
callq 0x63d0
jmp 0x18753
movapd %xmm0, %xmm1
ucomisd 0x116bd(%rip), %xmm0    # 0x29dd8
movsd (%rsp), %xmm0
jne 0x1872b
jp 0x1872b
callq 0x6290
jmp 0x18753
movsd %xmm1, 0x8(%rsp)
callq 0x63d0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x63d0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax)
movl $0x3, 0x8(%rax)
addq $0x10, 0x10(%rbx)
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/lua53.c
// Function: pushnumint
static void pushnumint (lua_State *L, lua_Number d) {
  lua_Integer n;
  if (lua_numbertointeger(d, &n))  /* does 'd' fit in an integer? */
    lua_pushinteger(L, n);  /* result is integer */
  else
    lua_pushnumber(L, d);  /* result is float */
}

// Assembly:
ucomisd 0x1124e(%rip), %xmm0    # 0x29da0
jb 0x18b76
movsd 0x1123c(%rip), %xmm1    # 0x29d98
ucomisd %xmm0, %xmm1
jbe 0x18b76
cvttsd2si %xmm0, %rcx
movq 0x10(%rdi), %rax
addq $0x10, %rdi
movq %rcx, (%rax)
pushq $0x13
jmp 0x18b84
movq 0x10(%rdi), %rax
addq $0x10, %rdi
movsd %xmm0, (%rax)
pushq $0x3
popq %rcx
movl %ecx, 0x8(%rax)
addq $0x10, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0xafc5
movq %rax, %r14
leaq 0x114c3(%rip), %rdx     # 0x2a3bb
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x86b4
pushq $-0x1
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x86b4
testl %eax, %eax
jne 0x18f2b
leaq 0x12249(%rip), %rsi     # 0x2b167
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x822d
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/lz4.c
// Function: LZ4_compress_destSize
int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targetDstSize)
{
#if (LZ4_HEAPMODE)
    LZ4_stream_t* ctx = (LZ4_stream_t*)ALLOCATOR(1, sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
#else
    LZ4_stream_t ctxBody;
    LZ4_stream_t* ctx = &ctxBody;
#endif

    int result = LZ4_compress_destSize_extState(ctx, src, dst, srcSizePtr, targetDstSize);

#if (LZ4_HEAPMODE)
    FREEMEM(ctx);
#endif
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x4020, %rsp           # imm = 0x4020
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq %rsp, %rdi
xorl %ebp, %ebp
movl $0x4020, %edx           # imm = 0x4020
xorl %esi, %esi
callq 0x62d0
movl (%r15), %ecx
cmpl $0x7e000000, %ecx       # imm = 0x7E000000
ja 0x21174
movl $0xff, %esi
movl %ecx, %eax
xorl %edx, %edx
divl %esi
leal (%rcx,%rax), %ebp
addl $0x10, %ebp
movq %rsp, %rdi
cmpl %ebx, %ebp
jle 0x21187
cmpl $0x1000a, %ecx          # imm = 0x1000A
jg 0x2119b
pushq $0x2
jmp 0x2119d
pushq $0x1
popq %r9
movq %r12, %rsi
movq %r14, %rdx
movl %ebx, %r8d
callq 0x1fdc3
jmp 0x211b0
pushq $0x1
popq %r9
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
movl %ebx, %r8d
callq 0x259f9
addq $0x4020, %rsp           # imm = 0x4020
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0x4000(%rdi), %ecx
movl $0x80000001, %eax       # imm = 0x80000001
cmpq %rax, %rcx
setb %al
cmpq %rsi, %rcx
setbe %dl
testb %dl, %al
jne 0x22478
addl $0xffff0000, %ecx       # imm = 0xFFFF0000
movq 0x4008(%rdi), %rax
movl 0x4018(%rdi), %edx
xorl %esi, %esi
xorl %r8d, %r8d
cmpq $0x1000, %r8            # imm = 0x1000
je 0x22442
movl (%rdi,%r8,4), %r9d
subl %ecx, %r9d
cmovbl %esi, %r9d
movl %r9d, (%rdi,%r8,4)
incq %r8
jmp 0x22425
addq %rdx, %rax
movl $0x10000, 0x4000(%rdi)  # imm = 0x10000
movl 0x4018(%rdi), %ecx
cmpl $0x10001, %ecx          # imm = 0x10001
jb 0x2246c
movl $0x10000, 0x4018(%rdi)  # imm = 0x10000
movl $0x10000, %ecx          # imm = 0x10000
movl %ecx, %ecx
subq %rcx, %rax
movq %rax, 0x4008(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leaq -0x7(%rdx), %rcx
movq %rdi, %rax
cmpq %rcx, %rax
jae 0x259b6
movq (%rsi), %r8
movq (%rax), %r9
cmpq %r9, %r8
jne 0x259a6
addq $0x8, %rax
addq $0x8, %rsi
jmp 0x2598c
xorq %r8, %r9
bsfq %r9, %rcx
shrl $0x3, %ecx
addq %rcx, %rax
subl %edi, %eax
retq
leaq -0x3(%rdx), %rcx
cmpq %rcx, %rax
jae 0x259cd
movl (%rsi), %ecx
cmpl (%rax), %ecx
jne 0x259cd
addq $0x4, %rax
addq $0x4, %rsi
leaq -0x1(%rdx), %rcx
cmpq %rcx, %rax
jae 0x259e6
movzwl (%rsi), %ecx
cmpw (%rax), %cx
jne 0x259e6
addq $0x2, %rax
addq $0x2, %rsi
cmpq %rdx, %rax
jae 0x259b3
movb (%rsi), %cl
xorl %edx, %edx
cmpb (%rax), %cl
sete %dl
addq %rdx, %rax
jmp 0x259b3
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movl %edi, %r15d
callq 0xbd65
movq %rax, %rbx
movl %r15d, 0x155e7(%rip)    # 0x3b4ec
movq %r14, 0x155e4(%rip)     # 0x3b4f0
xorl %r12d, %r12d
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x881a
testl %r15d, %r15d
cmovlel %r12d, %r15d
pushq $-0x2
popq %rbp
cmpq %r12, %r15
je 0x25f48
movq (%r14,%r12,8), %rsi
movq %rbx, %rdi
callq 0x7e73
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x9031
incq %r12
jmp 0x25f25
leaq 0x4ce0(%rip), %rsi      # 0x2ac2f
movq %rbx, %rdi
callq 0x8b3e
movq %rbx, %rdi
callq 0x110e2
leaq 0x64e2(%rip), %rsi      # 0x2c448
leaq 0x152(%rip), %rdx       # 0x260bf
pushq $0x1
popq %rcx
movq %rbx, %rdi
callq 0xbbdf
leaq 0x4b89(%rip), %rsi      # 0x2ab08
movq %rbx, %rdi
callq 0x83bf
leaq 0x4bfc(%rip), %rdx      # 0x2ab8a
pushq $-0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x86b4
pushq $-0x2
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x6b97
movq %rbx, %rdi
movl %r14d, %esi
callq 0x6b49
leaq 0x182(%rip), %rsi       # 0x26140
movq %rbx, %rdi
xorl %edx, %edx
callq 0x82d6
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %r14d, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x93f3
testl %eax, %eax
jne 0x2604b
movq %rbx, %rdi
callq 0x12964
movl 0x154f9(%rip), %edi     # 0x3b4e8
testl %edi, %edi
je 0x25ff8
callq 0x6240
movq 0x154e1(%rip), %rdi     # 0x3b4e0
testq %rdi, %rdi
je 0x26009
callq 0x6370
movq 0x154c8(%rip), %rdi     # 0x3b4d8
testq %rdi, %rdi
je 0x2601a
callq 0x6230
movq 0x154af(%rip), %rdi     # 0x3b4d0
testq %rdi, %rdi
je 0x2602b
callq 0x6030
callq 0x60b0
movl 0x115b16(%rip), %edi    # 0x13bb4c
cmpl $-0x1, %edi
je 0x26040
callq 0x6880
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7901
leaq 0x63ee(%rip), %rdx      # 0x2c44d
leaq 0x63e9(%rip), %rcx      # 0x2c44f
movq %rbx, %rdi
movq %rax, %rsi
callq 0xbcab
movq %rax, %r14
movl 0x1546e(%rip), %edi     # 0x3b4e8
testl %edi, %edi
je 0x26086
pushq $0x1
popq %rsi
callq 0x6610
movq 0x14f53(%rip), %rax     # 0x3afe0
movq (%rax), %rdi
leaq 0x63bb(%rip), %rsi      # 0x2c452
movq %r14, %rdx
xorl %eax, %eax
callq 0x66a0
movq 0x15428(%rip), %rcx     # 0x3b4d0
leaq 0x63b8(%rip), %rsi      # 0x2c467
pushq $0x10
popq %rdi
movq %r14, %rdx
callq 0x63c0
jmp 0x25fe1
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x3ce3(%rip), %xmm0     # 0x29db0
movl $0x88, %esi
callq 0xbf71
pushq $0x1d
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x881a
leaq 0x14af5(%rip), %rsi     # 0x3abe0
movq %rbx, %rdi
xorl %edx, %edx
callq 0xbae2
leaq 0x6376(%rip), %rsi      # 0x2c472
movq %rbx, %rdi
callq 0x7e73
leaq 0x6394(%rip), %rdx      # 0x2c49f
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8e94
movl $0x212, %esi            # imm = 0x212
movq %rbx, %rdi
callq 0x7d27
leaq 0x637b(%rip), %rdx      # 0x2c4a7
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8e94
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xb0c0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xb053
cvttsd2si %xmm0, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xb053
cvttsd2si %xmm0, %edx
movzbl %r14b, %edi
movl %ebp, %esi
callq 0x277fe
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rsi
callq 0xb0c0
movq %rax, (%rsp)
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0xb053
cvttsd2si %xmm0, %r13d
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0xb053
cvttsd2si %xmm0, %ebx
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0xb053
cvttsd2si %xmm0, %r15d
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0xb053
cvttsd2si %xmm0, %ebp
cmpl %r15d, %r13d
movl %r15d, %r12d
cmovgl %r13d, %r12d
cmovll %r13d, %r15d
cmpl %ebp, %ebx
movl %ebp, %r13d
cmovgl %ebx, %r13d
cmovll %ebx, %ebp
movzbl (%rsp), %ebx
cmpl %r13d, %ebp
jg 0x269e6
movl %r15d, %r14d
cmpl %r12d, %r14d
jg 0x269e2
movl %ebx, %edi
movl %r14d, %esi
movl %ebp, %edx
callq 0x277fe
incl %r14d
jmp 0x269cc
incl %ebp
jmp 0x269c4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rsi
callq 0xb0c0
movq %rax, %r12
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0xb053
cvttsd2si %xmm0, %r15d
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0xb053
cvttsd2si %xmm0, %r13d
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0xb053
cvttsd2si %xmm0, %ebx
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0xb053
cvttsd2si %xmm0, %ebp
cmpl %ebx, %r15d
movl %ebx, %r14d
cmovgl %r15d, %r14d
cmovll %r15d, %ebx
cmpl %ebp, %r13d
movl %ebp, %r15d
cmovgl %r13d, %r15d
cmovll %r13d, %ebp
movzbl %r12b, %r12d
movl %ebx, %r13d
cmpl %r14d, %r13d
jg 0x26ab1
movl %r12d, %edi
movl %r13d, %esi
movl %ebp, %edx
callq 0x277fe
movl %r12d, %edi
movl %r13d, %esi
movl %r15d, %edx
callq 0x277fe
incl %r13d
jmp 0x26a71
movl %r12d, %edi
movl %ebx, %esi
movl %ebp, %edx
callq 0x277fe
movl %r12d, %edi
movl %r14d, %esi
movl %ebp, %edx
callq 0x277fe
incl %ebp
cmpl %r15d, %ebp
jle 0x26a96
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
pushq $0x1
popq %rsi
callq 0xb0c0
movq %rax, 0x20(%rsp)
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0xb053
cvttsd2si %xmm0, %ebx
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0xb053
cvttsd2si %xmm0, %ebp
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0xb053
cvttsd2si %xmm0, %r13d
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0xb053
cvttsd2si %xmm0, %r12d
xorl %r14d, %r14d
movl %r13d, 0x1c(%rsp)
movl %r13d, %edi
subl %ebx, %edi
setg %r14b
callq 0x60a0
movl %eax, %r15d
leal -0x1(,%r14,2), %eax
movl %eax, 0x14(%rsp)
xorl %r14d, %r14d
movl %r12d, 0xc(%rsp)
subl %ebp, %r12d
setg %r14b
movl %r12d, %edi
callq 0x60a0
movl %eax, %r13d
negl %eax
cmpl %r13d, %r15d
cmovgl %r15d, %eax
leal -0x1(,%r14,2), %ecx
movl %ecx, 0x10(%rsp)
cltd
pushq $0x2
popq %rcx
idivl %ecx
movl %eax, %r12d
movl %r15d, 0x18(%rsp)
movl %r15d, %r14d
negl %r14d
movzbl 0x20(%rsp), %r15d
movl %r15d, %edi
movl %ebx, %esi
movl %ebp, %edx
callq 0x277fe
cmpl 0x1c(%rsp), %ebx
jne 0x26ba9
cmpl 0xc(%rsp), %ebp
je 0x26be6
cmpl %r14d, %r12d
movl $0x0, %eax
cmovgl %r13d, %eax
movl $0x0, %ecx
cmovgl 0x14(%rsp), %ecx
movl %r12d, %edx
subl %eax, %edx
addl %ecx, %ebx
cmpl %r13d, %r12d
movl $0x0, %eax
cmovll 0x10(%rsp), %eax
movl $0x0, %r12d
cmovll 0x18(%rsp), %r12d
addl %eax, %ebp
addl %edx, %r12d
jmp 0x26b91
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xb0c0
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xb053
cvttsd2si %xmm0, %r12d
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xb053
cvttsd2si %xmm0, %r14d
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0xb053
cvttsd2si %xmm0, %ebp
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x78dd
movl %eax, %edi
leal -0x1(%rbp), %r8d
imull %r8d, %r8d
movl %ebp, %eax
imull %ebp, %eax
movl %eax, 0xc(%rsp)
movl %r14d, %ebx
subl %ebp, %ebx
movq %r14, 0x18(%rsp)
leal (%r14,%rbp), %eax
movl %eax, (%rsp)
leal (%r12,%rbp), %r9d
movq %rbp, 0x10(%rsp)
subl %ebp, %r12d
movq %r12, 0x20(%rsp)
movzbl %r15b, %eax
movl %eax, 0x8(%rsp)
movl %edi, 0x4(%rsp)
cmpl (%rsp), %ebx
jg 0x26d06
movq 0x18(%rsp), %rax
movl %eax, %r13d
subl %ebx, %r13d
imull %r13d, %r13d
movq 0x10(%rsp), %rax
movl %eax, %r12d
movq 0x20(%rsp), %rax
movl %eax, %r15d
cmpl %r9d, %r15d
jg 0x26d02
testl %edi, %edi
setne %cl
movl %r12d, %eax
imull %r12d, %eax
addl %r13d, %eax
cmpl %eax, %r8d
setbe %sil
orb %cl, %sil
cmpb $0x1, %sil
jne 0x26cfa
cmpl 0xc(%rsp), %eax
jae 0x26cfa
movl 0x8(%rsp), %edi
movl %r15d, %esi
movl %ebx, %edx
movl %r8d, %r14d
movl %r9d, %ebp
callq 0x277fe
movl %ebp, %r9d
movl %r14d, %r8d
movl 0x4(%rsp), %edi
incl %r15d
decl %r12d
jmp 0x26cb2
incl %ebx
jmp 0x26c8e
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x6b35
cmpl $0x2, %eax
jne 0x26d5f
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xb053
movapd %xmm0, (%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xb053
movapd (%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
cvttpd2dq %xmm1, %xmm0
movlpd %xmm0, 0x1147a7(%rip)   # 0x13b500
movd %xmm0, %eax
jmp 0x26d65
movl 0x11479b(%rip), %eax    # 0x13b500
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x7d27
movslq 0x11478d(%rip), %rsi    # 0x13b504
movq %rbx, %rdi
callq 0x7d27
pushq $0x2
popq %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
pushq $0x1
popq %rsi
callq 0xb053
movsd %xmm0, 0x8(%rsp)
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0xb053
movsd %xmm0, (%rsp)
pushq $0x3
popq %rsi
leaq 0x10(%rsp), %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0xafc5
movq %rax, %rbx
pushq $0x4
popq %rsi
pushq $-0x1
popq %rdx
movq %r15, %rdi
callq 0xb117
movq %rax, %r14
movq (%r12), %rax
cmpq $0x40, %rax
je 0x26e15
cmpq $0x400, %rax            # imm = 0x400
je 0x26e08
cmpq $0x180, %rax            # imm = 0x180
je 0x26e0c
cmpq $0x100, %rax            # imm = 0x100
jne 0x26e85
pushq $0x10
jmp 0x26e17
pushq $0x20
jmp 0x26e17
pushq $0x18
popq %rax
pushq $0x10
popq %r12
jmp 0x26e1c
pushq $0x8
popq %r12
movl %r12d, %eax
cvttsd2si 0x8(%rsp), %ecx
cvttsd2si (%rsp), %ebp
addl %ebp, %eax
movl %ecx, (%rsp)
addl %ecx, %r12d
leaq 0x50da(%rip), %r13      # 0x2bf10
movl %eax, 0x8(%rsp)
cmpl %eax, %ebp
jge 0x26e74
movl (%rsp), %r15d
cmpl %r12d, %r15d
jge 0x26e6c
movzbl (%rbx), %eax
andl $0x7f, %eax
movzbl (%rax,%r13), %eax
cmpl %r14d, %eax
je 0x26e64
movzbl %al, %edi
movl %r15d, %esi
movl %ebp, %edx
callq 0x277fe
incq %rbx
incl %r15d
jmp 0x26e42
incl %ebp
movl 0x8(%rsp), %eax
jmp 0x26e3a
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x56a4(%rip), %rdx      # 0x2c530
pushq $0x3
popq %rsi
movq %r15, %rdi
callq 0xa986
jmp 0x26e76
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xb0c0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xb053
cvttsd2si %xmm0, %r15d
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xb053
cvttsd2si %xmm0, %eax
movq %rax, 0x8(%rsp)
pushq $0x4
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xafc5
movzbl %r14b, %ebp
cmpb $0x0, (%rax)
je 0x26f4f
xorl %r13d, %r13d
movq %rax, 0x10(%rsp)
cmpq $0x8, %r13
je 0x26f46
movzbl (%rax), %eax
andl $0x7f, %eax
leaq 0x5086(%rip), %rcx      # 0x2bf90
leaq (%rcx,%rax,8), %rax
movzbl (%r13,%rax), %r12d
movq 0x8(%rsp), %rax
leal (%rax,%r13), %r14d
xorl %ebx, %ebx
cmpl $0x8, %ebx
je 0x26f3c
btl %ebx, %r12d
jae 0x26f38
leal (%r15,%rbx), %esi
movl %ebp, %edi
movl %r14d, %edx
callq 0x277fe
incl %ebx
jmp 0x26f1f
incq %r13
movq 0x10(%rsp), %rax
jmp 0x26ef7
incq %rax
addl $0x8, %r15d
jmp 0x26eea
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xb0c0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xafc5
movq %rax, %r15
testl $0xfffffff8, %r14d      # imm = 0xFFFFFFF8
je 0x26fa1
leaq 0x55b5(%rip), %rdx      # 0x2c54b
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xa986
movl 0x14541(%rip), %edi     # 0x3b4e8
testl %edi, %edi
je 0x26ff3
callq 0x64b0
movslq %r14d, %rax
imulq $0x38, %rax, %r14
leaq 0x114552(%rip), %r12    # 0x13b510
leaq (%r12,%r14), %rdi
callq 0x27835
movq %r15, %rdi
callq 0x61b0
movq %rax, 0x8(%r14,%r12)
movq %rax, (%r14,%r12)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x78dd
movl %eax, 0x10(%r14,%r12)
movl 0x144fa(%rip), %edi     # 0x3b4e8
callq 0x6770
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rsi
callq 0xb0c0
movq %rax, %rbx
testl $0xfffffff8, %ebx       # imm = 0xFFFFFFF8
je 0x2702d
leaq 0x5529(%rip), %rdx      # 0x2c54b
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0xa986
movl 0x144b5(%rip), %edi     # 0x3b4e8
testl %edi, %edi
je 0x2705d
callq 0x64b0
movslq %ebx, %rax
imulq $0x38, %rax, %rax
leaq 0x1144c6(%rip), %rdi    # 0x13b510
addq %rax, %rdi
callq 0x27835
movl 0x14490(%rip), %edi     # 0x3b4e8
callq 0x6770
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x27871
cltq
imulq $0xc, %rax, %r14
leaq 0x1149cc(%rip), %r15    # 0x13bae0
movslq 0x4(%r14,%r15), %rax
movslq 0x1143e0(%rip), %rsi    # 0x13b500
addq %rax, %rsi
movq %rbx, %rdi
callq 0x7d27
movslq 0x8(%r14,%r15), %rax
movslq 0x1143cd(%rip), %rsi    # 0x13b504
addq %rax, %rsi
movq %rbx, %rdi
callq 0x7d27
pushq $0x2
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/pixl.c
// Function: f_clipboard
static int f_clipboard(lua_State *L) {
  if (lua_gettop(L) > 0) {
    const char *text = luaL_checkstring(L, 1);
    if (SDL_SetClipboardText(text)) luaL_error(L, "SDL_SetClipboardText() failed: %s", SDL_GetError());
    lua_pushstring(L, text);
    return 1;
  }
  else {
    lua_pushstring(L, SDL_GetClipboardText());
    return 1;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6b35
testl %eax, %eax
jle 0x27192
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xafc5
movq %rax, %r14
movq %rax, %rdi
callq 0x67d0
testl %eax, %eax
je 0x2719a
callq 0x6380
leaq 0x5405(%rip), %rsi      # 0x2c588
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xaa53
jmp 0x2719a
callq 0x6220
movq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7e73
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/pixl.c
// Function: f_randomseed
static int f_randomseed(lua_State *L) {
  if (lua_gettop(L) > 0) {
    Uint32 x = (Uint32)luaL_checkinteger(L, 1);
    px_randomseed(x);
  }
  lua_pushinteger(L, (lua_Integer)seed);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x6b35
testl %eax, %eax
jle 0x271cf
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xb0c0
movl %eax, %edi
callq 0x278c4
movl 0x114973(%rip), %esi    # 0x13bb48
movq %rbx, %rdi
callq 0x7d27
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/pixl.c
// Function: f_random
static int f_random(lua_State *L) {
  lua_Integer low, up;
  double r = (double)(px_rand() % 100000) / 100000.0;
  switch (lua_gettop(L)) {
  case 0: lua_pushnumber(L, (lua_Number)r); return 1;
  case 1: low = 1; up = luaL_checkinteger(L, 1); break;
  case 2: low = luaL_checkinteger(L, 1); up = luaL_checkinteger(L, 2); break;
  default: return luaL_error(L, "wrong number of arguments");
  }
  luaL_argcheck(L, low <= up, 1, "interval is empty");
  luaL_argcheck(L, low >= 0 || up <= LUA_MAXINTEGER + low, 1, "interval too large");
  r *= (double)(up - low) + 1.0;
  lua_pushinteger(L, (lua_Integer)r + low);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x278e6
movl $0x186a0, %ecx          # imm = 0x186A0
xorl %edx, %edx
divl %ecx
cvtsi2sd %edx, %xmm0
divsd 0x4bb9(%rip), %xmm0     # 0x2bdc0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6b35
movl %eax, %r15d
cmpl $0x2, %eax
je 0x2723e
movq %r15, %r14
cmpl $0x1, %eax
je 0x2724c
testl %eax, %eax
jne 0x272de
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x7d12
jmp 0x272cf
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xb0c0
movq %rax, %r14
movq %rbx, %rdi
movl %r15d, %esi
callq 0xb0c0
movq %rax, %r15
movq %rax, %r12
subq %r14, %r12
jge 0x27274
leaq 0x3e60(%rip), %rdx      # 0x2b0c9
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xa986
testq %r14, %r14
sets %al
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
addq %r14, %rcx
cmpq %rcx, %r15
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x272a6
leaq 0x3e40(%rip), %rdx      # 0x2b0db
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xa986
cvtsi2sd %r12, %xmm0
addsd 0x2add(%rip), %xmm0     # 0x29d90
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
addq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7d27
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3dca(%rip), %rsi      # 0x2b0af
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xaa53
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/pixl.c
// Function: f_resolution
static int f_resolution(lua_State *L) {
  int width = (int)luaL_checkinteger(L, 1);
  int height = (int)luaL_checkinteger(L, 2);
  luaL_argcheck(L, width > 0 && width < PX_SCREEN_MAX_WIDTH, 1, "invalid width value");
  luaL_argcheck(L, height > 0 && height < PX_SCREEN_MAX_HEIGHT, 2, "invalid height value");
  px_create_texture(L, width, height);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xb0c0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xb0c0
movq %rax, %r15
leal -0x1(%r14), %eax
cmpl $0x3ff, %eax            # imm = 0x3FF
jb 0x27385
leaq 0x5230(%rip), %rdx      # 0x2c5aa
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xa986
leal -0x1(%r15), %eax
cmpl $0x3ff, %eax            # imm = 0x3FF
jb 0x273a2
leaq 0x5227(%rip), %rdx      # 0x2c5be
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xa986
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x27908
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/pixl.c
// Function: f_compress
static int f_compress(lua_State *L) {
  size_t source_size;
  luaL_Buffer buffer;
  const char *source = luaL_checklstring(L, 1, &source_size);
  int dest_size = LZ4_compressBound((int)source_size);
  char *dest = luaL_buffinitsize(L, &buffer, dest_size);
  dest_size = LZ4_compress_default(source, dest, (int)source_size, dest_size);
  if (!dest_size) luaL_error(L, "compression failed");
  luaL_pushresultsize(&buffer, dest_size);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2030, %rsp           # imm = 0x2030
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0xafc5
movq %rax, %r15
movl (%r14), %edi
callq 0x1fda2
movslq %eax, %r12
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0xb3eb
movl (%r14), %edx
movq %r15, %rdi
movq %rax, %rsi
movl %r12d, %ecx
callq 0x20a95
movl %eax, %ebp
testl %eax, %eax
jne 0x27420
leaq 0x522b(%rip), %rsi      # 0x2c641
movq %rbx, %rdi
xorl %eax, %eax
callq 0xaa53
movslq %ebp, %rsi
leaq 0x10(%rsp), %rdi
callq 0xb35b
pushq $0x1
popq %rax
addq $0x2030, %rsp           # imm = 0x2030
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/pixl.c
// Function: f_decompress
static int f_decompress(lua_State *L) {
  size_t source_size;
  luaL_Buffer buffer;
  const char *source = luaL_checklstring(L, 1, &source_size);
  int dest_size = (int)luaL_optinteger(L, 2, 64 * 1024);
  char *dest = luaL_buffinitsize(L, &buffer, dest_size);
  dest_size = LZ4_decompress_safe(source, dest, (int)source_size, dest_size);
  if (!dest_size) luaL_error(L, "decompression failed");
  luaL_pushresultsize(&buffer, dest_size);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2030, %rsp           # imm = 0x2030
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0xafc5
movq %rax, %r15
pushq $0x2
popq %rsi
movl $0x10000, %edx          # imm = 0x10000
movq %rbx, %rdi
callq 0xb117
movslq %eax, %r12
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0xb3eb
movl (%r14), %edx
movq %r15, %rdi
movq %rax, %rsi
movl %r12d, %ecx
callq 0x22944
movl %eax, %ebp
testl %eax, %eax
jne 0x274b0
leaq 0x5199(%rip), %rsi      # 0x2c63f
movq %rbx, %rdi
xorl %eax, %eax
callq 0xaa53
movslq %ebp, %rsi
leaq 0x10(%rsp), %rdi
callq 0xb35b
pushq $0x1
popq %rax
addq $0x2030, %rsp           # imm = 0x2030
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/pixl.c
// Function: f_bind
static int f_bind(lua_State *L) {
  struct sockaddr_in sin;
  Uint16 port = (Uint16)luaL_checkinteger(L, 1);
  // prepare addr
  SDL_zero(sin);
  sin.sin_family = AF_INET;
  sin.sin_port = htons(port);
  sin.sin_addr.s_addr = htonl(INADDR_ANY);
  // bind socket
  net_create_socket(L);
  if (bind(socket_fd, (struct sockaddr*)&sin, sizeof(sin))) luaL_error(L, "Cannot bind on port %d", port);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xb0c0
movq %rax, %r14
movq %rsp, %r15
pushq $0x10
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x6250
movw $0x2, (%r15)
movl %r14d, %eax
rolw $0x8, %ax
movw %ax, 0x2(%r15)
andl $0x0, 0x4(%r15)
movq %rbx, %rdi
callq 0x27a2c
movl 0x114630(%rip), %edi    # 0x13bb4c
pushq $0x10
popq %rdx
movq %r15, %rsi
callq 0x60f0
testl %eax, %eax
je 0x27540
movzwl %r14w, %edx
leaq 0x511e(%rip), %rsi      # 0x2c654
movq %rbx, %rdi
xorl %eax, %eax
callq 0xaa53
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/pixl.c
// Function: f_unbind
static int f_unbind(lua_State *L) {
  (void)L;
  if (socket_fd != INVALID_SOCKET) {
    closesocket(socket_fd);
    socket_fd = INVALID_SOCKET;
  }
  return 0;
}

// Assembly:
movl 0x1145fa(%rip), %edi    # 0x13bb4c
cmpl $-0x1, %edi
je 0x27568
pushq %rax
callq 0x6880
orl $-0x1, 0x1145e8(%rip)   # 0x13bb4c
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/pixl.c
// Function: f_recv
static int f_recv(lua_State *L) {
  struct sockaddr_in sin;
  int datalen = 1024 * 4;
  socklen_t sinlen;
  luaL_Buffer buffer;
  char *data;
  struct timeval tv;
  fd_set set;
  // check socket for data
  net_create_socket(L);
  FD_ZERO(&set); FD_SET(socket_fd, &set);
  tv.tv_sec = 0; tv.tv_usec = 0;
  if (select(socket_fd + 1, &set, NULL, NULL, &tv) <= 0) return 0;
  if (!FD_ISSET(socket_fd, &set)) return 0;
  // reset addr
  SDL_zero(sin);
  sin.sin_family = AF_INET;
  sin.sin_port = 0;
  sin.sin_addr.s_addr = INADDR_ANY;
  sinlen = sizeof(sin);
  // receive
  data = luaL_buffinitsize(L, &buffer, datalen);
  datalen = recvfrom(socket_fd, data, datalen, 0, (struct sockaddr*)&sin, &sinlen);
  if (datalen < 0) return 0;
  luaL_pushresultsize(&buffer, datalen);
  lua_pushinteger(L, ntohl(sin.sin_addr.s_addr));
  lua_pushinteger(L, ntohs(sin.sin_port));
  return 3;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20d0, %rsp           # imm = 0x20D0
movq %rdi, %rbx
callq 0x27a2c
xorl %eax, %eax
cmpq $0x10, %rax
je 0x27595
andq $0x0, 0x30(%rsp,%rax,8)
incq %rax
jmp 0x27584
movl 0x1145b1(%rip), %edi    # 0x13bb4c
pushq $0x40
popq %rbp
movl %edi, %eax
cltd
idivl %ebp
movslq %eax, %rdx
shll $0x6, %eax
movl %edi, %ecx
subl %eax, %ecx
pushq $0x1
popq %rax
shlq %cl, %rax
orq %rax, 0x30(%rsp,%rdx,8)
incl %edi
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r8
movaps %xmm0, (%r8)
xorl %r14d, %r14d
leaq 0x30(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6490
testl %eax, %eax
jle 0x27691
movl 0x114567(%rip), %eax    # 0x13bb4c
cltd
idivl %ebp
cltq
movq 0x30(%rsp,%rax,8), %rax
btq %rdx, %rax
jae 0x27691
leaq 0x10(%rsp), %r15
xorl %r14d, %r14d
pushq $0x10
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x6250
movq $0x2, (%r15)
leaq 0xc(%rsp), %r12
movl $0x10, (%r12)
leaq 0xb0(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rdi
callq 0xb3eb
movl 0x11450f(%rip), %edi    # 0x13bb4c
movl $0x1000, %edx           # imm = 0x1000
movq %rax, %rsi
xorl %ecx, %ecx
movq %r15, %r8
movq %r12, %r9
callq 0x6390
testl %eax, %eax
js 0x27691
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
leaq 0xb0(%rsp), %rdi
movq %rax, %rsi
callq 0xb35b
movl 0x14(%rsp), %esi
bswapl %esi
movq %rbx, %rdi
callq 0x7d27
movzwl 0x12(%rsp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x7d27
pushq $0x3
popq %r14
movl %r14d, %eax
addq $0x20d0, %rsp           # imm = 0x20D0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/pixl.c
// Function: f_send
static int f_send(lua_State *L) {
  struct sockaddr_in sin;
  size_t datalen;
  int sent;
  const char *data = luaL_checklstring(L, 1, &datalen);
  Uint32 host = (Uint32)luaL_checkinteger(L, 2);
  Uint16 port = (Uint16)luaL_checkinteger(L, 3);
  // prepare addr
  SDL_zero(sin);
  sin.sin_family = AF_INET;
  sin.sin_port = htons(port);
  sin.sin_addr.s_addr = htonl(host);
  // sned
  net_create_socket(L);
  sent = sendto(socket_fd, data, (int)datalen, 0, (struct sockaddr*)&sin, sizeof(sin));
  lua_pushboolean(L, sent == (int)datalen);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
pushq $0x1
popq %rsi
movq %rsp, %r15
movq %r15, %rdx
callq 0xafc5
movq %rax, %r12
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0xb0c0
movq %rax, %r13
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0xb0c0
movq %rax, %rbp
leaq 0x8(%rsp), %rbx
pushq $0x10
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6250
rolw $0x8, %bp
movw $0x2, (%rbx)
movw %bp, 0x2(%rbx)
bswapl %r13d
movl %r13d, 0x4(%rbx)
movq %r14, %rdi
callq 0x27a2c
movl 0x114436(%rip), %edi    # 0x13bb4c
movslq (%r15), %rdx
pushq $0x10
popq %r9
movq %r12, %rsi
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x6090
xorl %esi, %esi
cmpl (%r15), %eax
sete %sil
movq %r14, %rdi
callq 0x836d
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/pixl.c
// Function: f_resolve
static int f_resolve(lua_State *L) {
  struct addrinfo hints, *result;
  const char *hostname = luaL_checkstring(L, 1);
  SDL_zero(hints);
  hints.ai_family = AF_INET;
  if (getaddrinfo(hostname, NULL, &hints, &result) == 0) {
    if (result) {
      lua_pushinteger(L, ntohl(((struct sockaddr_in*)(result->ai_addr))->sin_addr.s_addr));
      freeaddrinfo(result);
      return 1;
    }
  }
  lua_pushnil(L);
  lua_pushfstring(L, "cannot resolve " LUA_QS, hostname);
  return 2;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
xorl %edx, %edx
callq 0xafc5
movq %rax, %r15
leaq 0x10(%rsp), %r12
pushq $0x30
popq %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x6250
movl $0x2, 0x4(%r12)
leaq 0x8(%rsp), %r13
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0x6600
testl %eax, %eax
sete %cl
movq (%r13), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x277cf
movq 0x18(%rax), %rax
movl 0x4(%rax), %esi
bswapl %esi
movq %r14, %rdi
callq 0x7d27
movq 0x8(%rsp), %rdi
callq 0x6620
jmp 0x277ee
movq %r14, %rdi
callq 0x7d01
leaq 0x4ea6(%rip), %rsi      # 0x2c684
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x822d
pushq $0x2
popq %rbx
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/pixl.c
// Function: mml_reset_channel
static void mml_reset_channel(AudioChannel *channel) {
  if (channel->source) SDL_free((void*)channel->source);
  SDL_zerop(channel);
  channel->tempo = 140;
  channel->octave = 3;
  channel->waveform = PX_WAVEFORM_PULSE_50;
  channel->default_length = 4;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x27846
callq 0x6280
pushq $0x38
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6250
movabsq $0x30000008c, %rax      # imm = 0x30000008C
movq %rax, 0x28(%rbx)
movl $0x3, 0x1c(%rbx)
movl $0x4, 0x30(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/pixl.c
// Function: px_rand
static Uint32 px_rand() {
  seed ^= seed << 13;
  seed ^= seed >> 17;
  seed ^= seed << 5;
  return seed;
}

// Assembly:
movl 0x11425c(%rip), %eax    # 0x13bb48
movl %eax, %ecx
shll $0xd, %ecx
xorl %eax, %ecx
movl %ecx, %edx
shrl $0x11, %edx
xorl %ecx, %edx
movl %edx, %eax
shll $0x5, %eax
xorl %edx, %eax
movl %eax, 0x114241(%rip)    # 0x13bb48
retq