LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/native.c
// Function: GetGLXContext
static int GetGLXContext(lua_State *L)
    {
    void *what;
    win_t *win = checkwindow(L, 1);
    CheckNativePfn(L, GetGLXContext);
    what = glfw.GetGLXContext(win->window);
    if(!what) return 0;
    lua_pushlightuserdata(L, what);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq 0xcbd0(%rip), %rcx      # 0x1bfe8
movq 0x410(%rcx), %rcx
testq %rcx, %rcx
je 0xf441
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xf453
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54d0
movl $0x1, %eax
jmp 0xf455
leaq 0x66aa(%rip), %rsi      # 0x15af2
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/native.c
// Function: GetGLXWindow
static int GetGLXWindow(lua_State *L)
    {
    unsigned long what;
    win_t *win = checkwindow(L, 1);
    CheckNativePfn(L, GetGLXWindow);
    what = glfw.GetGLXWindow(win->window);
//  if(!what) return 0;
    lua_pushinteger(L, what);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq 0xcb7c(%rip), %rcx      # 0x1bfe8
movq 0x418(%rcx), %rcx
testq %rcx, %rcx
je 0xf490
movq 0x28(%rax), %rdi
callq *%rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5310
movl $0x1, %eax
popq %rbx
retq
leaq 0x667f(%rip), %rsi      # 0x15b16
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/native.c
// Function: GetWaylandDisplay
static int GetWaylandDisplay(lua_State *L)
    {
    void *what;
    CheckNativePfn(L, GetWaylandDisplay);
    what = glfw.GetWaylandDisplay();
    if(!what) return 0;
    lua_pushlightuserdata(L, what);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xcb3b(%rip), %rax      # 0x1bfe8
movq 0x420(%rax), %rax
testq %rax, %rax
je 0xf4d2
callq *%rax
testq %rax, %rax
je 0xf4e4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54d0
movl $0x1, %eax
jmp 0xf4e6
leaq 0x6660(%rip), %rsi      # 0x15b39
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/native.c
// Function: GetWaylandMonitor
static int GetWaylandMonitor(lua_State *L)
    {
    void *what;
    mon_t *mon = checkmonitor(L, 1);
    CheckNativePfn(L, GetWaylandMonitor);
    what = glfw.GetWaylandMonitor(mon->monitor);
    if(!what) return 0;
    lua_pushlightuserdata(L, what);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x56e0
movq 0xcaeb(%rip), %rcx      # 0x1bfe8
movq 0x428(%rcx), %rcx
testq %rcx, %rcx
je 0xf526
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xf538
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54d0
movl $0x1, %eax
jmp 0xf53a
leaq 0x6634(%rip), %rsi      # 0x15b61
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/native.c
// Function: GetWaylandWindow
static int GetWaylandWindow(lua_State *L)
    {
    void *what;
    win_t *win = checkwindow(L, 1);
    CheckNativePfn(L, GetWaylandWindow);
    what = glfw.GetWaylandWindow(win->window);
    if(!what) return 0;
    lua_pushlightuserdata(L, what);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq 0xca97(%rip), %rcx      # 0x1bfe8
movq 0x430(%rcx), %rcx
testq %rcx, %rcx
je 0xf57a
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xf58c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54d0
movl $0x1, %eax
jmp 0xf58e
leaq 0x6608(%rip), %rsi      # 0x15b89
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/native.c
// Function: GetMirDisplay
static int GetMirDisplay(lua_State *L)
    {
    void *what;
    CheckNativePfn(L, GetMirDisplay);
    what = glfw.GetMirDisplay();
    if(!what) return 0;
    lua_pushlightuserdata(L, what);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xca4d(%rip), %rax      # 0x1bfe8
movq 0x438(%rax), %rax
testq %rax, %rax
je 0xf5c0
callq *%rax
testq %rax, %rax
je 0xf5d2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54d0
movl $0x1, %eax
jmp 0xf5d4
leaq 0x65e9(%rip), %rsi      # 0x15bb0
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/native.c
// Function: GetMirMonitor
static int GetMirMonitor(lua_State *L)
    {
    int what;
    mon_t *mon = checkmonitor(L, 1);
    CheckNativePfn(L, GetMirMonitor);
    what = glfw.GetMirMonitor(mon->monitor);
//  if(!what) return 0;
    lua_pushinteger(L, what);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x56e0
movq 0xc9fd(%rip), %rcx      # 0x1bfe8
movq 0x440(%rcx), %rcx
testq %rcx, %rcx
je 0xf60f
movq 0x28(%rax), %rdi
callq *%rcx
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x5310
movl $0x1, %eax
popq %rbx
retq
leaq 0x65be(%rip), %rsi      # 0x15bd4
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/native.c
// Function: GetMirWindow
static int GetMirWindow(lua_State *L)
    {
    void *what;
    win_t *win = checkwindow(L, 1);
    CheckNativePfn(L, GetMirWindow);
    what = glfw.GetMirWindow(win->window);
    if(!what) return 0;
    lua_pushlightuserdata(L, what);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq 0xc9b2(%rip), %rcx      # 0x1bfe8
movq 0x448(%rcx), %rcx
testq %rcx, %rcx
je 0xf65f
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xf671
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54d0
movl $0x1, %eax
jmp 0xf673
leaq 0x6592(%rip), %rsi      # 0x15bf8
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/native.c
// Function: GetEGLDisplay
static int GetEGLDisplay(lua_State *L)
    {
    void *what;
    CheckNativePfn(L, GetEGLDisplay);
    what = glfw.GetEGLDisplay();
    if(!what) return 0;
    lua_pushlightuserdata(L, what);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xc968(%rip), %rax      # 0x1bfe8
movq 0x450(%rax), %rax
testq %rax, %rax
je 0xf6a5
callq *%rax
testq %rax, %rax
je 0xf6b7
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54d0
movl $0x1, %eax
jmp 0xf6b9
leaq 0x656f(%rip), %rsi      # 0x15c1b
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/native.c
// Function: GetEGLContext
static int GetEGLContext(lua_State *L)
    {
    void *what;
    win_t *win = checkwindow(L, 1);
    CheckNativePfn(L, GetEGLContext);
    what = glfw.GetEGLContext(win->window);
    if(!what) return 0;
    lua_pushlightuserdata(L, what);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq 0xc918(%rip), %rcx      # 0x1bfe8
movq 0x458(%rcx), %rcx
testq %rcx, %rcx
je 0xf6f9
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xf70b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54d0
movl $0x1, %eax
jmp 0xf70d
leaq 0x653f(%rip), %rsi      # 0x15c3f
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/native.c
// Function: GetEGLSurface
static int GetEGLSurface(lua_State *L)
    {
    void *what;
    win_t *win = checkwindow(L, 1);
    CheckNativePfn(L, GetEGLSurface);
    what = glfw.GetEGLSurface(win->window);
    if(!what) return 0;
    lua_pushlightuserdata(L, what);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq 0xc8c4(%rip), %rcx      # 0x1bfe8
movq 0x460(%rcx), %rcx
testq %rcx, %rcx
je 0xf74d
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xf75f
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54d0
movl $0x1, %eax
jmp 0xf761
leaq 0x650f(%rip), %rsi      # 0x15c63
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/native.c
// Function: GetOSMesaColorBuffer
static int GetOSMesaColorBuffer(lua_State *L) //@@ needs debug
    {
    int rc, width, height, format;
    void* buffer;
    win_t *win = checkwindow(L, 1);
    CheckNativePfn(L, GetOSMesaColorBuffer);
    rc = glfw.GetOSMesaColorBuffer(win->window, &width, &height, &format, &buffer);
    if(!rc) return 0;
    lua_pushinteger(L, width);
    lua_pushinteger(L, height);
    lua_pushinteger(L, format);
    lua_pushlightuserdata(L, buffer);
    return 4;
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq 0xc86c(%rip), %rcx      # 0x1bfe8
movq 0x478(%rcx), %r9
testq %r9, %r9
je 0xf7e2
movq 0x28(%rax), %rdi
leaq 0x14(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
leaq 0x18(%rsp), %r8
callq *%r9
testl %eax, %eax
je 0xf7f8
movslq 0x14(%rsp), %rsi
movq %rbx, %rdi
callq 0x5310
movslq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x5310
movslq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x5310
movq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x54d0
movl $0x4, %eax
jmp 0xf7fa
leaq 0x649e(%rip), %rsi      # 0x15c87
movq %rbx, %rdi
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
jmp 0x55b0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/native.c
// Function: GetOSMesaDepthBuffer
static int GetOSMesaDepthBuffer(lua_State *L) //@@ needs debug
    {
    int rc, width, height, bytespervalue;
    void* buffer;
    win_t *win = checkwindow(L, 1);
    CheckNativePfn(L, GetOSMesaDepthBuffer);
    rc = glfw.GetOSMesaDepthBuffer(win->window, &width, &height, &bytespervalue, &buffer);
    if(!rc) return 0;
    lua_pushinteger(L, width);
    lua_pushinteger(L, height);
    lua_pushinteger(L, bytespervalue);
    lua_pushlightuserdata(L, buffer);
    return 4;
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq 0xc7cf(%rip), %rcx      # 0x1bfe8
movq 0x480(%rcx), %r9
testq %r9, %r9
je 0xf87f
movq 0x28(%rax), %rdi
leaq 0x14(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
leaq 0x18(%rsp), %r8
callq *%r9
testl %eax, %eax
je 0xf895
movslq 0x14(%rsp), %rsi
movq %rbx, %rdi
callq 0x5310
movslq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x5310
movslq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x5310
movq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x54d0
movl $0x4, %eax
jmp 0xf897
leaq 0x642c(%rip), %rsi      # 0x15cb2
movq %rbx, %rdi
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
jmp 0x55b0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/native.c
// Function: GetOSMesaContext
static int GetOSMesaContext(lua_State *L)
    {
    void *what;
    win_t *win = checkwindow(L, 1);
    CheckNativePfn(L, GetOSMesaContext);
    what = glfw.GetOSMesaContext(win->window);
    if(!what) return 0;
    lua_pushlightuserdata(L, what);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq 0xc736(%rip), %rcx      # 0x1bfe8
movq 0x488(%rcx), %rcx
testq %rcx, %rcx
je 0xf8db
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xf8ed
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54d0
movl $0x1, %eax
jmp 0xf8ef
leaq 0x63fb(%rip), %rsi      # 0x15cdd
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/native.c
// Function: GetContext
static int GetContext(lua_State *L)
    {
    void *what = NULL;
    win_t *win = checkwindow(L, 1);

    if(glfw.GetWGLContext)
        {
        what = glfw.GetWGLContext(win->window);
        if(what)
            {
            lua_pushlightuserdata(L, what);
            lua_pushstring(L, "wgl");
            }
        }

    if(!what && glfw.GetGLXContext)
        {
        what = glfw.GetGLXContext(win->window);
        if(what)
            {
            lua_pushlightuserdata(L, what);
            lua_pushstring(L, "glx");
            }
        }

    if(!what && glfw.GetEGLContext)
        {
        what = glfw.GetEGLContext(win->window);
        if(what)
            {
            lua_pushlightuserdata(L, what);
            lua_pushstring(L, "egl");
            }
        }

    if(!what && glfw.GetOSMesaContext)
        {
        what = glfw.GetOSMesaContext(win->window);
        if(what)
            {
            lua_pushlightuserdata(L, what);
            lua_pushstring(L, "osmesa");
            }
        }

    if(!what) return 0;
    return 2;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq %rax, %r14
movq 0xc6d9(%rip), %r15      # 0x1bfe8
movq 0x3e8(%r15), %rax
testq %rax, %rax
je 0xf92f
movq 0x28(%r14), %rdi
callq *%rax
testq %rax, %rax
je 0xf92f
leaq 0x63d7(%rip), %r14      # 0x15d04
jmp 0xf98f
movq 0x410(%r15), %rax
testq %rax, %rax
je 0xf94f
movq 0x28(%r14), %rdi
callq *%rax
testq %rax, %rax
je 0xf94f
leaq 0x63bb(%rip), %r14      # 0x15d08
jmp 0xf98f
movq 0x458(%r15), %rax
testq %rax, %rax
je 0xf96f
movq 0x28(%r14), %rdi
callq *%rax
testq %rax, %rax
je 0xf96f
leaq 0x4094(%rip), %r14      # 0x13a01
jmp 0xf98f
movq 0x488(%r15), %rax
xorl %ebp, %ebp
testq %rax, %rax
je 0xf9aa
movq 0x28(%r14), %rdi
callq *%rax
testq %rax, %rax
je 0xf9aa
leaq 0x4076(%rip), %r14      # 0x13a05
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5690
movl $0x2, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/utils.c
// Function: moonglfw_testwindow
int testwindow(lua_State *L, int arg, win_t **win_)
    {
    int id;
    win_t *win;
    if(lua_isnoneornil(L, arg))
        return 0;
    id = luaL_checkinteger(L, arg);
    win = win_search(id);
    if(!win)
        luaL_error(L, "invalid window id");
    if(win_) *win_ = win;
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x5630
testl %eax, %eax
jle 0xfbed
movq %r14, %rdi
movl %ebp, %esi
callq 0x53e0
movl %eax, %edi
callq 0x5430
movq %rax, %r15
testq %rax, %rax
jne 0xfbde
leaq 0x6193(%rip), %rsi      # 0x15d67
movq %r14, %rdi
xorl %eax, %eax
callq 0x55b0
movl $0x1, %eax
testq %rbx, %rbx
je 0xfbef
movq %r15, (%rbx)
jmp 0xfbef
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/utils.c
// Function: moonglfw_checkwindow
win_t *checkwindow(lua_State *L, int arg)
    {
    int id = luaL_checkinteger(L, arg);
    win_t *win = win_search(id);
    if(!win)
        luaL_error(L, "invalid window id");
    return win;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x53e0
movl %eax, %edi
callq 0x5430
movq %rax, %r14
testq %rax, %rax
jne 0xfc26
leaq 0x614b(%rip), %rsi      # 0x15d67
movq %rbx, %rdi
xorl %eax, %eax
callq 0x55b0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/utils.c
// Function: moonglfw_testmonitor
int testmonitor(lua_State *L, int arg, mon_t **mon_)
    {
    int id;
    mon_t *mon;
    if(lua_isnoneornil(L, arg))
        return 0;
    id = luaL_checkinteger(L, arg);
    mon = mon_search(id);
    if(!mon)
        luaL_error(L, "invalid monitor id");
    if(mon_) *mon_ = mon;
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x5630
testl %eax, %eax
jle 0xfc82
movq %r14, %rdi
movl %ebp, %esi
callq 0x53e0
movl %eax, %edi
callq 0x5060
movq %rax, %r15
testq %rax, %rax
jne 0xfc73
leaq 0x5908(%rip), %rsi      # 0x15571
movq %r14, %rdi
xorl %eax, %eax
callq 0x55b0
movl $0x1, %eax
testq %rbx, %rbx
je 0xfc84
movq %r15, (%rbx)
jmp 0xfc84
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/utils.c
// Function: moonglfw_checkmonitor
mon_t *checkmonitor(lua_State *L, int arg)
    {
    int id = luaL_checkinteger(L, arg);
    mon_t *mon = mon_search(id);
    if(!mon)
        luaL_error(L, "invalid monitor id");
    return mon;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x53e0
movl %eax, %edi
callq 0x5060
movq %rax, %r14
testq %rax, %rax
jne 0xfcbb
leaq 0x58c0(%rip), %rsi      # 0x15571
movq %rbx, %rdi
xorl %eax, %eax
callq 0x55b0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/utils.c
// Function: moonglfw_testcursor
int testcursor(lua_State *L, int arg, cur_t **cur_)
    {
    int id;
    cur_t *cur;
    if(lua_isnoneornil(L, arg))
        return 0;
    id = luaL_checkinteger(L, arg);
    cur = cur_search(id);
    if(!cur)
        luaL_error(L, "invalid cursor id");
    if(cur_) *cur_ = cur;
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x5630
testl %eax, %eax
jle 0xfd17
movq %r14, %rdi
movl %ebp, %esi
callq 0x53e0
movl %eax, %edi
callq 0x5160
movq %rax, %r15
testq %rax, %rax
jne 0xfd08
leaq 0x369a(%rip), %rsi      # 0x13398
movq %r14, %rdi
xorl %eax, %eax
callq 0x55b0
movl $0x1, %eax
testq %rbx, %rbx
je 0xfd19
movq %r15, (%rbx)
jmp 0xfd19
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/utils.c
// Function: moonglfw_checkcursor
cur_t *checkcursor(lua_State *L, int arg)
    {
    int id = luaL_checkinteger(L, arg);
    cur_t *cur = cur_search(id);
    if(!cur)
        luaL_error(L, "invalid cursor id");
    return cur;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x53e0
movl %eax, %edi
callq 0x5160
movq %rax, %r14
testq %rax, %rax
jne 0xfd50
leaq 0x3652(%rip), %rsi      # 0x13398
movq %rbx, %rdi
xorl %eax, %eax
callq 0x55b0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/utils.c
// Function: moonglfw_pushgamepadaxes
int pushgamepadaxes(lua_State *L, const GLFWgamepadstate *state)
    {
    lua_newtable(L);
#define Setfield(x, name) do {  \
    lua_pushnumber(L, state->axes[GLFW_GAMEPAD_AXIS_##x]); \
    lua_setfield(L, -2, name);  \
} while(0)
    Setfield(LEFT_X, "left_x");
    Setfield(LEFT_Y, "left_y");
    Setfield(RIGHT_X, "right_x");
    Setfield(RIGHT_Y, "right_y");
    Setfield(LEFT_TRIGGER, "left_trigger");
    Setfield(RIGHT_TRIGGER, "right_trigger");
#undef Setfield
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x5210
cvtss2sd 0x10(%r14), %xmm0
movq %rbx, %rdi
callq 0x5460
leaq 0x5da7(%rip), %rdx      # 0x15ddc
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
xorps %xmm0, %xmm0
cvtss2sd 0x14(%r14), %xmm0
movq %rbx, %rdi
callq 0x5460
leaq 0x5d89(%rip), %rdx      # 0x15de3
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
xorps %xmm0, %xmm0
cvtss2sd 0x18(%r14), %xmm0
movq %rbx, %rdi
callq 0x5460
leaq 0x5d6b(%rip), %rdx      # 0x15dea
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
xorps %xmm0, %xmm0
cvtss2sd 0x1c(%r14), %xmm0
movq %rbx, %rdi
callq 0x5460
leaq 0x5d4e(%rip), %rdx      # 0x15df2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
xorps %xmm0, %xmm0
cvtss2sd 0x20(%r14), %xmm0
movq %rbx, %rdi
callq 0x5460
leaq 0x5d31(%rip), %rdx      # 0x15dfa
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
xorps %xmm0, %xmm0
cvtss2sd 0x24(%r14), %xmm0
movq %rbx, %rdi
callq 0x5460
leaq 0x5d19(%rip), %rdx      # 0x15e07
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/utils.c
// Function: moonglfw_pushvidmode
int pushvidmode(lua_State *L, const GLFWvidmode *mode)
    {
    int table;
    lua_newtable(L);
    table = lua_gettop(L);
#define Setfield(x, name) \
        do { lua_pushinteger(L, mode->x); lua_setfield(L, table, name); } while(0)
    Setfield(width, "width");
    Setfield(height, "height");
    Setfield(redBits,"red_bits");
    Setfield(greenBits,"green_bits");
    Setfield(blueBits,"blue_bits");
    Setfield(refreshRate,"refresh_rate");
#undef Setfield
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x5210
movq %rbx, %rdi
callq 0x5080
movl %eax, %ebp
movslq (%r14), %rsi
movq %rbx, %rdi
callq 0x5310
leaq 0x5cde(%rip), %rdx      # 0x15e15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
movslq 0x4(%r14), %rsi
movq %rbx, %rdi
callq 0x5310
leaq 0x5cc7(%rip), %rdx      # 0x15e1b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
movslq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x5310
leaq 0x5cb1(%rip), %rdx      # 0x15e22
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
movslq 0xc(%r14), %rsi
movq %rbx, %rdi
callq 0x5310
leaq 0x5c9d(%rip), %rdx      # 0x15e2b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
movslq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x5310
leaq 0x5c8b(%rip), %rdx      # 0x15e36
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
movslq 0x14(%r14), %rsi
movq %rbx, %rdi
callq 0x5310
leaq 0x5c78(%rip), %rdx      # 0x15e40
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/utils.c
// Function: moonglfw_pushhat
int pushhat(lua_State *L, unsigned int hat)
    {
    lua_newtable(L);
#define Setfield(name, val) do { lua_pushboolean(L, val); lua_setfield(L, -2, name); } while(0)
    Setfield("centered", hat == GLFW_HAT_CENTERED);
    Setfield("up", hat & GLFW_HAT_UP);
    Setfield("right", hat & GLFW_HAT_RIGHT);
    Setfield("down", hat & GLFW_HAT_DOWN);
    Setfield("left", hat & GLFW_HAT_LEFT);
#undef Setfield
    return 1;
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x5210
xorl %esi, %esi
testl %ebp, %ebp
sete %sil
movq %rbx, %rdi
callq 0x5480
leaq 0x5c49(%rip), %rdx      # 0x15e4d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
movl %ebp, %esi
andl $0x1, %esi
movq %rbx, %rdi
callq 0x5480
leaq 0x328b(%rip), %rdx      # 0x134b0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
movl %ebp, %esi
andl $0x2, %esi
movq %rbx, %rdi
callq 0x5480
leaq 0x5b7c(%rip), %rdx      # 0x15dc2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
movl %ebp, %esi
andl $0x4, %esi
movq %rbx, %rdi
callq 0x5480
leaq 0x3251(%rip), %rdx      # 0x134b8
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
andl $0x8, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5480
leaq 0x5b4f(%rip), %rdx      # 0x15dd7
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/utils.c
// Function: moonglfw_pushgammaramp
int pushgammaramp(lua_State *L, const GLFWgammaramp *ramp)
    {
    unsigned int i;
    int table;
#define Setfield(x, name)   do {            \
        lua_newtable(L);                    \
        table = lua_gettop(L);              \
        for(i=0; i<ramp->size; i++)         \
            {                               \
            lua_pushinteger(L, ramp->x[i]); \
            lua_seti(L, table, i+1);        \
            }                               \
} while(0)
    Setfield(red,"red");
    Setfield(green,"green");
    Setfield(blue,"blue");
#undef Setfield
    return 3;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x5210
movq %r14, %rdi
callq 0x5080
cmpl $0x0, 0x18(%rbx)
je 0x102f2
movl %eax, %ebp
xorl %r15d, %r15d
movq (%rbx), %rax
movzwl (%rax,%r15,2), %esi
movq %r14, %rdi
callq 0x5310
incq %r15
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x53a0
movl 0x18(%rbx), %eax
cmpq %rax, %r15
jb 0x102ca
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5210
movq %r14, %rdi
callq 0x5080
cmpl $0x0, 0x18(%rbx)
je 0x1033a
movl %eax, %ebp
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movzwl (%rax,%r15,2), %esi
movq %r14, %rdi
callq 0x5310
incq %r15
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x53a0
movl 0x18(%rbx), %eax
cmpq %rax, %r15
jb 0x10311
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5210
movq %r14, %rdi
callq 0x5080
cmpl $0x0, 0x18(%rbx)
je 0x10382
movl %eax, %ebp
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movzwl (%rax,%r15,2), %esi
movq %r14, %rdi
callq 0x5310
incq %r15
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x53a0
movl 0x18(%rbx), %eax
cmpq %rax, %r15
jb 0x10359
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/vulkan.c
// Function: GetRequiredInstanceExtensions
static int GetRequiredInstanceExtensions(lua_State *L)
    {
    uint32_t count, i;
    const char **names;
    CheckVulkanPfn(L, GetRequiredInstanceExtensions);
    names = glfw.GetRequiredInstanceExtensions(&count);
    lua_newtable(L);
    if((count == 0) || names==NULL)
        return 1;
    for(i=0; i< count; i++)
        {
        lua_pushstring(L, names[i]);
        lua_rawseti(L, -2, i+1);
        }
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0xb935(%rip), %rax      # 0x1bfe8
movq 0x3b0(%rax), %rax
testq %rax, %rax
je 0x10726
leaq 0xc(%rsp), %r15
movq %r15, %rdi
callq *%rax
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5210
cmpl $0x0, (%r15)
setne %al
testq %r14, %r14
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x10717
xorl %r15d, %r15d
movq (%r14,%r15,8), %rsi
movq %rbx, %rdi
callq 0x5690
incq %r15
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0x5410
movl 0xc(%rsp), %eax
cmpq %rax, %r15
jb 0x106ef
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x3, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x56a0
testl %eax, %eax
je 0x10755
leaq 0x597f(%rip), %rsi      # 0x160c1
movq %rbx, %rdi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x55b0
leaq 0x5921(%rip), %rsi      # 0x1607d
movq %rbx, %rdi
movl $0x3, %edx
movl $0x2, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/vulkan.c
// Function: GetPhysicalDevicePresentationSupport
static int GetPhysicalDevicePresentationSupport(lua_State *L)
    {
    int result;
    VkInstance instance = (VkInstance)checkhandle(L, 1);
    VkPhysicalDevice device = (VkPhysicalDevice)checkhandle(L, 2);
    uint32_t queuefamily = luaL_checkinteger(L, 3);
    CheckVulkanPfn(L, GetPhysicalDevicePresentationSupport);
    result = glfw.GetPhysicalDevicePresentationSupport(instance, device, queuefamily);
    lua_pushboolean(L, result);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x53e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x53e0
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x53e0
movq 0xb833(%rip), %rcx      # 0x1bfe8
movq 0x3c0(%rcx), %rcx
testq %rcx, %rcx
je 0x107e0
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
callq *%rcx
movq %rbx, %rdi
movl %eax, %esi
callq 0x5480
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
movl $0x3, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x56a0
testl %eax, %eax
je 0x1080b
leaq 0x5944(%rip), %rsi      # 0x16140
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x55b0
leaq 0x58e3(%rip), %rsi      # 0x160f5
movq %rbx, %rdi
movl $0x3, %edx
movl $0x2, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/win.c
// Function: moonglfw_win_check
win_t* win_check(lua_State *L, int arg)
    {
    int id = luaL_checkinteger(L, arg);
    win_t *win = win_search(id);
    if(!win)
        luaL_error(L, "invalid window id");
    return win;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x53e0
movq 0xb3f8(%rip), %rbx      # 0x1c8b8
testq %rbx, %rbx
je 0x114d5
cmpl %eax, 0x20(%rbx)
jg 0x114d0
jge 0x114e8
addq $0x8, %rbx
movq (%rbx), %rbx
jmp 0x114c0
leaq 0x488b(%rip), %rsi      # 0x15d67
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x55b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/window.c
// Function: CreateWindow
static int CreateWindow(lua_State *L)
    {
    win_t *win, *share_win=NULL;
    mon_t *mon;
    intptr_t id;
    int width = luaL_checkinteger(L, 1);
    int height = luaL_checkinteger(L, 2);
    const char* title = luaL_optstring(L, 3, "");
    GLFWmonitor* monitor = testmonitor(L, 4, &mon) ? mon->monitor : NULL;
    GLFWwindow* share = testwindow(L, 5, &share_win) ? share_win->window : NULL;

    win = win_new();
    if(!win)
        return luaL_error(L, "cannot create window");
    
#ifdef MACOS
     glfw.WindowHint(GLFW_OPENGL_FORWARD_COMPAT,GLFW_TRUE); 
     glfw.WindowHint(GLFW_OPENGL_PROFILE,GLFW_OPENGL_CORE_PROFILE); 
#endif
    win->window = glfw.CreateWindow(width, height, title, monitor, share);
    if(win->window == NULL)
        {
        win_free(win);
        return luaL_error(L, "cannot create window");
        }
    /* this will allow us to retrieve the win_t* from the GLFWwindow*: */
    id = win->id;
    win->share_id =  share_win ? share_win->id : -1;
    glfw.SetWindowUserPointer(win->window, (void*)id);
    lua_pushinteger(L, win->id);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq $0x0, (%rsp)
movl $0x1, %esi
callq 0x53e0
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x53e0
movq %rax, %r15
leaq 0x3e1c(%rip), %rdx      # 0x1537e
xorl %r12d, %r12d
movq %rbx, %rdi
movl $0x3, %esi
xorl %ecx, %ecx
callq 0x5260
movq %rax, %r13
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x54f0
testl %eax, %eax
je 0x11596
movq 0x10(%rsp), %rax
movq 0x28(%rax), %r12
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x5, %esi
callq 0x5550
testl %eax, %eax
je 0x115b4
movq (%rsp), %rax
movq 0x28(%rax), %r14
jmp 0x115b7
xorl %r14d, %r14d
callq 0x5400
testq %rax, %rax
je 0x11608
movq %rax, %rbp
movq 0xaa1d(%rip), %rax      # 0x1bfe8
movq 0x8(%rsp), %rdi
movl %r15d, %esi
movq %r13, %rdx
movq %r12, %rcx
movq %r14, %r8
movq %rax, %r14
callq *0x90(%rax)
movq %rax, 0x28(%rbp)
testq %rax, %rax
je 0x11600
movslq 0x20(%rbp), %rsi
movq (%rsp), %rcx
testq %rcx, %rcx
je 0x1161b
movl 0x20(%rcx), %ecx
jmp 0x11620
movq %rbp, %rdi
callq 0x5240
leaq 0x4fcb(%rip), %rsi      # 0x165da
movq %rbx, %rdi
xorl %eax, %eax
callq 0x55b0
jmp 0x1163e
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, 0x30(%rbp)
movq %rax, %rdi
callq *0x148(%r14)
movslq 0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x5310
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/window.c
// Function: FocusWindow
static int FocusWindow(lua_State *L)
    {
    win_t *win = checkwindow(L, 1);
    CheckPfn(L, FocusWindow, 3, 2, 0);
    glfw.FocusWindow(win->window);
    return 0;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq 0xa95b(%rip), %rcx      # 0x1bfe8
movq 0x128(%rcx), %rcx
testq %rcx, %rcx
je 0x116a3
movq 0x28(%rax), %rdi
callq *%rcx
xorl %eax, %eax
popq %rbx
retq
movl $0x3, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x56a0
testl %eax, %eax
je 0x116ca
leaq 0x4f62(%rip), %rsi      # 0x16621
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
leaq 0x4f1e(%rip), %rsi      # 0x165ef
movq %rbx, %rdi
movl $0x3, %edx
movl $0x2, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
popq %rbx
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/window.c
// Function: SetWindowAspectRatio
static int SetWindowAspectRatio(lua_State *L)
    {
    win_t *win = checkwindow(L, 1);
    int numer = luaL_optinteger(L, 2, GLFW_DONT_CARE);
    int denom = luaL_optinteger(L, 3, GLFW_DONT_CARE);
    CheckPfn(L, SetWindowAspectRatio, 3, 2, 0);
    glfw.SetWindowAspectRatio(win->window, numer, denom);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
movq $-0x1, %rdx
callq 0x5490
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
movq $-0x1, %rdx
callq 0x5490
movq 0xa8b8(%rip), %rcx      # 0x1bfe8
movq 0xe0(%rcx), %rcx
testq %rcx, %rcx
je 0x1174f
movq 0x28(%r14), %rdi
movl %r15d, %esi
movl %eax, %edx
callq *%rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movl $0x3, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x56a0
testl %eax, %eax
je 0x1177a
leaq 0x4f13(%rip), %rsi      # 0x1667e
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x55b0
leaq 0x4ec2(%rip), %rsi      # 0x16643
movq %rbx, %rdi
movl $0x3, %edx
movl $0x2, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/window.c
// Function: SetWindowSizeLimits
static int SetWindowSizeLimits(lua_State *L)
    {
    win_t *win = checkwindow(L, 1);
    int minwidth = luaL_optinteger(L, 2, GLFW_DONT_CARE);
    int minheight = luaL_optinteger(L, 3, GLFW_DONT_CARE);
    int maxwidth = luaL_optinteger(L, 4, GLFW_DONT_CARE);
    int maxheight = luaL_optinteger(L, 5, GLFW_DONT_CARE);
    CheckPfn(L, SetWindowSizeLimits, 3, 2, 0);
    glfw.SetWindowSizeLimits(win->window, minwidth, minheight, maxwidth, maxheight);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
movq $-0x1, %rdx
callq 0x5490
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
movq $-0x1, %rdx
callq 0x5490
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
movq $-0x1, %rdx
callq 0x5490
movq %rax, %r13
movq %rbx, %rdi
movl $0x5, %esi
movq $-0x1, %rdx
callq 0x5490
movq 0xa7d2(%rip), %rcx      # 0x1bfe8
movq 0xd8(%rcx), %r9
testq %r9, %r9
je 0x11841
movq 0x28(%r14), %rdi
movl %r15d, %esi
movl %r12d, %edx
movl %r13d, %ecx
movl %eax, %r8d
callq *%r9
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x3, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x56a0
testl %eax, %eax
je 0x11870
leaq 0x4e86(%rip), %rsi      # 0x166e3
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x55b0
leaq 0x4e32(%rip), %rsi      # 0x166a9
movq %rbx, %rdi
movl $0x3, %edx
movl $0x2, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/window.c
// Function: SetWindowIcon
static int SetWindowIcon(lua_State *L)
    {
    size_t len;
    int count, arg;
    GLFWimage images[32];
    win_t *win = checkwindow(L, 1);
    CheckPfn(L, SetWindowIcon, 3, 2, 0);
    count = 0;
    arg = 2;
    while(!lua_isnoneornil(L, arg))
        {
        images[count].width = luaL_checkinteger(L, arg++);
        images[count].height = luaL_checkinteger(L, arg++);
        images[count].pixels = (unsigned char*)luaL_checklstring(L, arg++, &len);
        count++;
        }
    if(count==0)
        luaL_checkinteger(L, arg); /* raises an error */
    glfw.SetWindowIcon(win->window, count, images);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq %rax, %r14
movq 0xa729(%rip), %rax      # 0x1bfe8
cmpq $0x0, 0xb8(%rax)
je 0x1193d
movl $0x2, %r15d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5630
testl %eax, %eax
jle 0x11974
xorl %ebp, %ebp
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movl %r15d, %esi
callq 0x53e0
movl %eax, -0x8(%r13)
leal 0x1(%r15), %esi
movq %rbx, %rdi
callq 0x53e0
movl %eax, -0x4(%r13)
leal 0x2(%r15), %esi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x5340
movq %rax, (%r13)
addl $0x3, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5630
addq $0x10, %r13
incl %ebp
testl %eax, %eax
jg 0x118f0
jmp 0x11983
movl $0x3, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x56a0
testl %eax, %eax
je 0x119af
leaq 0x4de8(%rip), %rsi      # 0x16741
movq %rbx, %rdi
xorl %eax, %eax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x55b0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x53e0
xorl %ebp, %ebp
movq 0x28(%r14), %rdi
leaq 0x10(%rsp), %rdx
movl %ebp, %esi
movq 0xa653(%rip), %rax      # 0x1bfe8
callq *0xb8(%rax)
xorl %eax, %eax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4d57(%rip), %rsi      # 0x1670d
movq %rbx, %rdi
movl $0x3, %edx
movl $0x2, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/window.c
// Function: SetWindowMonitor
static int SetWindowMonitor(lua_State *L)
    {
    mon_t *mon;
    win_t *win = checkwindow(L, 1);
    GLFWmonitor* monitor = testmonitor(L, 2, &mon) ? mon->monitor : NULL;
    int xpos = luaL_checkinteger(L, 3);
    int ypos = luaL_checkinteger(L, 4);
    int width = luaL_checkinteger(L, 5);
    int height = luaL_checkinteger(L, 6);
    int refreshRate = luaL_optinteger(L, 7, GLFW_DONT_CARE);
    CheckPfn(L, SetWindowMonitor, 3, 2, 0);
    glfw.SetWindowMonitor(win->window, monitor, xpos, ypos, width, height, refreshRate);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x54f0
testl %eax, %eax
je 0x11a1f
movq 0x10(%rsp), %rax
movq 0x28(%rax), %r15
jmp 0x11a22
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x3, %esi
callq 0x53e0
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
callq 0x53e0
movq %rax, %r13
movq %rbx, %rdi
movl $0x5, %esi
callq 0x53e0
movq %rax, %rbp
movq %rbx, %rdi
movl $0x6, %esi
callq 0x53e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x7, %esi
movq $-0x1, %rdx
callq 0x5490
movq 0xa56b(%rip), %rcx      # 0x1bfe8
movq 0x138(%rcx), %r10
testq %r10, %r10
je 0x11aab
movq 0x8(%rsp), %rcx
movq 0x28(%rcx), %rdi
movl %eax, (%rsp)
movq %r15, %rsi
movl %r12d, %edx
movl %r13d, %ecx
movl %ebp, %r8d
movl %r14d, %r9d
callq *%r10
xorl %eax, %eax
jmp 0x11af1
movl $0x3, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x56a0
testl %eax, %eax
je 0x11ad3
leaq 0x4cd5(%rip), %rsi      # 0x1679c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x55b0
jmp 0x11af1
leaq 0x4c8b(%rip), %rsi      # 0x16765
movq %rbx, %rdi
movl $0x3, %edx
movl $0x2, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x55b0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/window.c
// Function: WaitEventsTimeout
static int WaitEventsTimeout(lua_State *L)
    {
    double timeout = luaL_checknumber(L, 1);
    CheckPfn(L, WaitEventsTimeout, 3, 2, 0);
    glfw.WaitEventsTimeout(timeout);
    return 0;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5230
movq 0xa4af(%rip), %rax      # 0x1bfe8
movq 0x1a0(%rax), %rax
testq %rax, %rax
je 0x11b4b
callq *%rax
xorl %eax, %eax
popq %rbx
retq
movl $0x3, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x56a0
testl %eax, %eax
je 0x11b72
leaq 0x4c94(%rip), %rsi      # 0x167fb
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
leaq 0x4c4a(%rip), %rsi      # 0x167c3
movq %rbx, %rdi
movl $0x3, %edx
movl $0x2, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
popq %rbx
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/window.c
// Function: SetWindowShouldClose
static int SetWindowShouldClose(lua_State *L)
    {
    win_t *win = checkwindow(L, 1);
    int value = checkboolean(L, 2);
    glfw.SetWindowShouldClose(win->window, value);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5070
movzbl %al, %esi
movq 0xa3ca(%rip), %rax      # 0x1bfe8
movq 0x28(%r14), %rdi
callq *0xa8(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/window.c
// Function: SetWindowTitle
static int SetWindowTitle(lua_State *L)
    {
    win_t *win = checkwindow(L, 1);
    const char *title = luaL_optstring(L, 2, "");
    glfw.SetWindowTitle(win->window, title);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq %rax, %r14
leaq 0x3731(%rip), %rdx      # 0x1537e
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x5260
movq 0xa385(%rip), %rcx      # 0x1bfe8
movq 0x28(%r14), %rdi
movq %rax, %rsi
callq *0xb0(%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/window.c
// Function: GetWindowTitle
static int GetWindowTitle(lua_State *L)
    {
    const char *title;
    win_t *win = checkwindow(L, 1);
    CheckPfn(L, GetWindowTitle, 3, 4, 0);
    title = glfw.GetWindowTitle(win->window);
    lua_pushstring(L, title);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq 0xa359(%rip), %rcx      # 0x1bfe8
movq 0x388(%rcx), %rcx
testq %rcx, %rcx
je 0x11cb3
movq 0x28(%rax), %rdi
callq *%rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5690
movl $0x1, %eax
popq %rbx
retq
movl $0x3, %edi
movl $0x4, %esi
xorl %edx, %edx
callq 0x56a0
testl %eax, %eax
je 0x11cda
leaq 0x4b89(%rip), %rsi      # 0x16858
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
leaq 0x4b42(%rip), %rsi      # 0x16823
movq %rbx, %rdi
movl $0x3, %edx
movl $0x4, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
popq %rbx
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/window.c
// Function: SetWindowPos
static int SetWindowPos(lua_State *L)
    {
    win_t *win = checkwindow(L, 1);
    int xpos = luaL_checkinteger(L, 2);
    int ypos = luaL_checkinteger(L, 3);
    glfw.SetWindowPos(win->window, xpos, ypos);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x53e0
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x53e0
movq 0xa25a(%rip), %rcx      # 0x1bfe8
movq 0x28(%r14), %rdi
movl %r15d, %esi
movl %eax, %edx
callq *0xc8(%rcx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/window.c
// Function: SetWindowSize
static int SetWindowSize(lua_State *L)
    {
    win_t *win = checkwindow(L, 1);
    int width = luaL_checkinteger(L, 2);
    int height = luaL_checkinteger(L, 3);
    glfw.SetWindowSize(win->window, width, height);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x53e0
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x53e0
movq 0xa1ae(%rip), %rcx      # 0x1bfe8
movq 0x28(%r14), %rdi
movl %r15d, %esi
movl %eax, %edx
callq *0xe8(%rcx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/window.c
// Function: GetFramebufferSize
static int GetFramebufferSize(lua_State *L)
    {
    int width, height;
    win_t *win = checkwindow(L, 1);
    glfw.GetFramebufferSize(win->window, &width, &height);
    lua_pushinteger(L, width);
    lua_pushinteger(L, height);
    return 2;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq 0xa17a(%rip), %rcx      # 0x1bfe8
movq 0x28(%rax), %rdi
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq *0xf0(%rcx)
movslq (%r14), %rsi
movq %rbx, %rdi
callq 0x5310
movslq (%r15), %rsi
movq %rbx, %rdi
callq 0x5310
movl $0x2, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/window.c
// Function: MaximizeWindow
static int MaximizeWindow(lua_State *L)
    {
    win_t *win = checkwindow(L, 1);
    CheckPfn(L, MaximizeWindow, 3, 2, 0);
    glfw.MaximizeWindow(win->window);
    return 0;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq 0xa05b(%rip), %rcx      # 0x1bfe8
movq 0x110(%rcx), %rcx
testq %rcx, %rcx
je 0x11fa3
movq 0x28(%rax), %rdi
callq *%rcx
xorl %eax, %eax
popq %rbx
retq
movl $0x3, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x56a0
testl %eax, %eax
je 0x11fca
leaq 0x48f3(%rip), %rsi      # 0x168b2
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
leaq 0x48ac(%rip), %rsi      # 0x1687d
movq %rbx, %rdi
movl $0x3, %edx
movl $0x2, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
popq %rbx
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/window.c
// Function: GetWindowMonitor
static int GetWindowMonitor(lua_State *L)
    {
    int id;
    win_t *win = checkwindow(L, 1);
    GLFWmonitor *monitor = glfw.GetWindowMonitor(win->window);
    if(!monitor)
        return 0;
    id = monitorAdd(L, monitor);
    lua_pushinteger(L, id); 
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %ebx
movl $0x1, %esi
callq 0x5570
movq 0x9fa2(%rip), %rcx      # 0x1bfe8
movq 0x28(%rax), %rdi
callq *0x130(%rcx)
testq %rax, %rax
je 0x1206d
movq %r14, %rdi
movq %rax, %rsi
callq 0x53f0
movslq %eax, %rsi
movq %r14, %rdi
callq 0x5310
jmp 0x1206f
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/window.c
// Function: GetWindowContentScale
static int GetWindowContentScale(lua_State *L)
    {
    float xscale, yscale;
    win_t *win = checkwindow(L, 1);
    CheckPfn(L, GetWindowContentScale, 3, 3, 0);
    glfw.GetWindowContentScale(win->window, &xscale, &yscale);
    lua_pushnumber(L, xscale);
    lua_pushnumber(L, yscale);
    return 2;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq 0x9f52(%rip), %rcx      # 0x1bfe8
movq 0x300(%rcx), %rcx
testq %rcx, %rcx
je 0x120e4
movq 0x28(%rax), %rdi
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq *%rcx
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x5460
xorps %xmm0, %xmm0
cvtss2sd (%r15), %xmm0
movq %rbx, %rdi
callq 0x5460
movl $0x2, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x3, %edi
movl $0x3, %esi
xorl %edx, %edx
callq 0x56a0
testl %eax, %eax
je 0x12113
leaq 0x4813(%rip), %rsi      # 0x16913
movq %rbx, %rdi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x55b0
leaq 0x47bd(%rip), %rsi      # 0x168d7
movq %rbx, %rdi
movl $0x3, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglfw/src/window.c
// Function: GetWindowOpacity
static int GetWindowOpacity(lua_State *L)
    {
    win_t *win = checkwindow(L, 1);
    CheckPfn(L, GetWindowOpacity, 3, 3, 0);
    lua_pushnumber(L, glfw.GetWindowOpacity(win->window));
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5570
movq 0x9e99(%rip), %rcx      # 0x1bfe8
movq 0x308(%rcx), %rcx
testq %rcx, %rcx
je 0x12174
movq 0x28(%rax), %rdi
callq *%rcx
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x5460
movl $0x1, %eax
popq %rbx
retq
movl $0x3, %edi
movl $0x3, %esi
xorl %edx, %edx
callq 0x56a0
testl %eax, %eax
je 0x1219b
leaq 0x47e6(%rip), %rsi      # 0x16976
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
leaq 0x479d(%rip), %rsi      # 0x1693f
movq %rbx, %rdi
movl $0x3, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
popq %rbx
jmp 0x55b0