LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/main.c
// Function: InitHint
static int InitHint(lua_State *L)
    {
    int hint;
    if(Initialized)
        { glfw.Terminate(); Initialized = 0; }
    CheckPfn(L, InitHint, 3, 3, 0);
    hint = checkinithint(L, 1);
    switch(hint)
        {
        case GLFW_JOYSTICK_HAT_BUTTONS:
        case GLFW_COCOA_CHDIR_RESOURCES:
        case GLFW_COCOA_MENUBAR:
        case GLFW_X11_XCB_VULKAN_SURFACE: return Boolean(L, hint);
        case GLFW_ANGLE_PLATFORM_TYPE: ENUM(L, hint, checkangleplatformtype);
        case GLFW_PLATFORM: ENUM(L, hint, checkplatform);
        case GLFW_WAYLAND_LIBDECOR: ENUM(L, hint, checkwaylandlibdecor);
        default:
            return luaL_error(L, "invalid init hint '%s'", lua_tostring(L, 1));
        }
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0xf1c6(%rip)      # 0x1c8a8
jne 0xd6f5
movq 0xe8fd(%rip), %rax      # 0x1bfe8
callq *0x8(%rax)
movb $0x0, 0xf1b3(%rip)      # 0x1c8a8
movq 0xe8ec(%rip), %r15      # 0x1bfe8
cmpq $0x0, 0x2c8(%r15)
je 0xd76b
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x5450
movl %eax, %r14d
leal -0x51001(%r14), %eax
cmpl $0x2, %eax
jb 0xd758
cmpl $0x50001, %r14d         # imm = 0x50001
je 0xd758
cmpl $0x50002, %r14d         # imm = 0x50002
je 0xd7ab
cmpl $0x50003, %r14d         # imm = 0x50003
je 0xd7d5
cmpl $0x53001, %r14d         # imm = 0x53001
je 0xd7c0
cmpl $0x52001, %r14d         # imm = 0x52001
jne 0xd7f9
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x5070
movzbl %al, %esi
movl %r14d, %edi
jmp 0xd7ea
cmpl $0xc02fff, 0xf123(%rip) # imm = 0xC02FFF
jg 0xd795
leaq 0x6cda(%rip), %rsi      # 0x14458
pushq $0x3
popq %rcx
movq %rbx, %rdi
movl %ecx, %edx
xorl %r8d, %r8d
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x55b0
leaq 0x6ceb(%rip), %rsi      # 0x14487
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x55b0
pushq $0x11
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x5450
movl $0x50002, %edi          # imm = 0x50002
jmp 0xd7e8
pushq $0x10
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x5450
movl $0x53001, %edi          # imm = 0x53001
jmp 0xd7e8
pushq $0xf
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x5450
movl $0x50003, %edi          # imm = 0x50003
movl %eax, %esi
callq *0x2c8(%r15)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x51e0
leaq 0x6c99(%rip), %rsi      # 0x144a6
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/main.c
// Function: GetPlatform
static int GetPlatform(lua_State *L)
    {
    int platform;
    CheckPfn(L, GetPlatform, 3, 4, 0);
    platform = glfw.GetPlatform();
    pushplatform(L, platform);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xe7be(%rip), %rax      # 0x1bfe8
movq 0x390(%rax), %rax
testq %rax, %rax
je 0xd84a
callq *%rax
pushq $0xf
popq %rsi
movq %rbx, %rdi
movl %eax, %edx
callq 0x55e0
pushq $0x1
popq %rax
popq %rbx
retq
cmpl $0xc03fff, 0xf044(%rip) # imm = 0xC03FFF
jg 0xd871
leaq 0x6c60(%rip), %rsi      # 0x144bd
pushq $0x3
popq %rdx
pushq $0x4
popq %rcx
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
popq %rbx
jmp 0x55b0
leaq 0x6c77(%rip), %rsi      # 0x144ef
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/main.c
// Function: PlatformSupported
static int PlatformSupported(lua_State *L)
    {
    int platform;
    CheckPfn(L, PlatformSupported, 3, 4, 0);
    platform = checkplatform(L, 1);
    lua_pushboolean(L, glfw.PlatformSupported(platform));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xe757(%rip), %r14      # 0x1bfe8
cmpq $0x0, 0x398(%r14)
je 0xd8c5
pushq $0xf
popq %rsi
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x5450
movl %eax, %edi
callq *0x398(%r14)
movq %rbx, %rdi
movl %eax, %esi
callq 0x5480
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0xc03fff, 0xefc9(%rip) # imm = 0xC03FFF
jg 0xd8ef
leaq 0x6c39(%rip), %rsi      # 0x14511
pushq $0x3
popq %rdx
pushq $0x4
popq %rcx
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x55b0
leaq 0x6c53(%rip), %rsi      # 0x14549
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/main.c
// Function: GetVersion
static int GetVersion(lua_State *L) 
    {
    int major, minor, rev;
    glfw.GetVersion(&major, &minor, &rev);
    lua_pushinteger(L, major);
    lua_pushinteger(L, minor);
    lua_pushinteger(L, rev);
    return 3;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0xe6cf(%rip), %rax      # 0x1bfe8
leaq 0x14(%rsp), %r14
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x10(%rax)
movslq (%r14), %rsi
movq %rbx, %rdi
callq 0x5310
movslq (%r15), %rsi
movq %rbx, %rdi
callq 0x5310
movslq (%r12), %rsi
movq %rbx, %rdi
callq 0x5310
pushq $0x3
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/mon.c
// Function: moonglfw_mon_check
mon_t* mon_check(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 0xe0eb
leaq 0x6490(%rip), %rsi      # 0x14571
movq %rbx, %rdi
xorl %eax, %eax
callq 0x55b0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/monitor.c
// Function: moonglfw_monitorAdd
int monitorAdd(lua_State *L, GLFWmonitor *monitor)
    {
    mon_t *mon = mon_first(0);
    while(mon)
        {
        if(mon->monitor == monitor) /* already in */
            return mon->id;
        mon = mon_next(mon);
        }
    /* not found */
    mon = mon_new();
    if(!mon)
        return luaL_error(L, "cannot create monitor entry");
    mon->monitor = monitor;
    return mon->id;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %edi, %edi
callq 0x5180
testq %rax, %rax
je 0xe11e
cmpq %r14, 0x28(%rax)
je 0xe12c
movq %rax, %rdi
callq 0x51c0
jmp 0xe109
callq 0x5380
testq %rax, %rax
je 0xe137
movq %r14, 0x28(%rax)
movl 0x20(%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6446(%rip), %rsi      # 0x14584
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/monitor.c
// Function: GetPrimaryMonitor
static int GetPrimaryMonitor(lua_State *L)
    {
    int id;
    GLFWmonitor* monitor = glfw.GetPrimaryMonitor();
    if(!monitor)
        return 0;
    id = monitorAdd(L, monitor);
    lua_pushinteger(L, id);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xde6c(%rip), %rax      # 0x1bfe8
callq *0x30(%rax)
testq %rax, %rax
je 0xe19f
movq %rbx, %rdi
movq %rax, %rsi
callq 0x53f0
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x5310
pushq $0x1
popq %rax
jmp 0xe1a1
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/monitor.c
// Function: GetMonitors
static int GetMonitors(lua_State *L)
    {
    int i, id, count;
    GLFWmonitor** monitor;
    /* no mon_free_all(); */
    monitor = glfw.GetMonitors(&count);
    if(!monitor)
        return 0;
    for(i=0; i<count; i++)
        {
        id = monitorAdd(L, monitor[i]);
        lua_pushinteger(L, id);
        }
    return count;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0xde32(%rip), %rax      # 0x1bfe8
leaq 0xc(%rsp), %rdi
callq *0x28(%rax)
testq %rax, %rax
je 0xe1ef
movq %rax, %r14
xorl %r15d, %r15d
movslq 0xc(%rsp), %rax
cmpq %rax, %r15
jge 0xe1f1
movq (%r14,%r15,8), %rsi
movq %rbx, %rdi
callq 0x53f0
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x5310
incq %r15
jmp 0xe1c9
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/monitor.c
// Function: GetMonitorPos
static int GetMonitorPos(lua_State *L)
    {
    int xpos, ypos;
    mon_t *mon = checkmonitor(L, 1);
    glfw.GetMonitorPos(mon->monitor, &xpos, &ypos);
    lua_pushinteger(L, xpos);
    lua_pushinteger(L, ypos);
    return 2;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x56e0
movq 0xddd2(%rip), %rcx      # 0x1bfe8
movq 0x28(%rax), %rdi
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq *0x38(%rcx)
movslq (%r14), %rsi
movq %rbx, %rdi
callq 0x5310
movslq (%r15), %rsi
movq %rbx, %rdi
callq 0x5310
pushq $0x2
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/monitor.c
// Function: GetMonitorPhysicalSize
static int GetMonitorPhysicalSize(lua_State *L)
    {
    int widthmm, heightmm;
    mon_t *mon = checkmonitor(L, 1);
    glfw.GetMonitorPhysicalSize(mon->monitor, &widthmm, &heightmm);
    lua_pushinteger(L, widthmm);
    lua_pushinteger(L, heightmm);
    return 2;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x56e0
movq 0xdd7d(%rip), %rcx      # 0x1bfe8
movq 0x28(%rax), %rdi
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq *0x40(%rcx)
movslq (%r14), %rsi
movq %rbx, %rdi
callq 0x5310
movslq (%r15), %rsi
movq %rbx, %rdi
callq 0x5310
pushq $0x2
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/monitor.c
// Function: GetMonitorName
static int GetMonitorName(lua_State *L)
    {
    mon_t *mon = checkmonitor(L, 1);
    const char* name = glfw.GetMonitorName(mon->monitor);
    lua_pushstring(L, name ? name : "???");
    return 1;
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x56e0
movq 0xdd2c(%rip), %rcx      # 0x1bfe8
movq 0x28(%rax), %rdi
callq *0x48(%rcx)
testq %rax, %rax
leaq 0x5de1(%rip), %rsi      # 0x140ae
cmovneq %rax, %rsi
movq %rbx, %rdi
callq 0x5690
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/monitor.c
// Function: GetVideoModes
static int GetVideoModes(lua_State *L)
    {
    int i, count;
    mon_t *mon = checkmonitor(L, 1);
    const GLFWvidmode *mode = glfw.GetVideoModes(mon->monitor, &count);
    if(!mode) 
        return 0;
    for(i=0; i<count; i++)
        pushvidmode(L, &mode[i]);
    return count;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x56e0
movq 0xdceb(%rip), %rcx      # 0x1bfe8
movq 0x28(%rax), %rdi
leaq 0xc(%rsp), %rsi
callq *0x58(%rcx)
testq %rax, %rax
je 0xe332
movq %rax, %r14
xorl %r15d, %r15d
movslq 0xc(%rsp), %rax
cmpq %rax, %r15
jge 0xe334
movq %rbx, %rdi
movq %r14, %rsi
callq 0x54c0
incq %r15
addq $0x18, %r14
jmp 0xe314
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/monitor.c
// Function: GetVideoMode
static int GetVideoMode(lua_State *L)
    {
    mon_t *mon = checkmonitor(L, 1);
    const GLFWvidmode *mode = glfw.GetVideoMode(mon->monitor);
    if(!mode) 
        return 0;
    pushvidmode(L, mode);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x56e0
movq 0xdc92(%rip), %rcx      # 0x1bfe8
movq 0x28(%rax), %rdi
callq *0x60(%rcx)
testq %rax, %rax
je 0xe36f
movq %r14, %rdi
movq %rax, %rsi
callq 0x54c0
jmp 0xe371
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/monitor.c
// Function: SetGamma
static int SetGamma(lua_State *L)
    {
    mon_t *mon = checkmonitor(L, 1);
    float gamma = luaL_checknumber(L, 2);
    glfw.SetGamma(mon->monitor, gamma);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x56e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x5230
cvtsd2ss %xmm0, %xmm0
movq 0xdc45(%rip), %rax      # 0x1bfe8
movq 0x28(%r14), %rdi
callq *0x68(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/monitor.c
// Function: GetGammaRamp
static int GetGammaRamp(lua_State *L)
    {
    mon_t *mon = checkmonitor(L, 1);
    const GLFWgammaramp *ramp = glfw.GetGammaRamp(mon->monitor);
    if(!ramp) 
        return 0;
    return pushgammaramp(L, ramp);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x56e0
movq 0xdc21(%rip), %rcx      # 0x1bfe8
movq 0x28(%rax), %rdi
callq *0x70(%rcx)
testq %rax, %rax
je 0xe3df
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x56b0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/monitor.c
// Function: SetGammaRamp
static int SetGammaRamp(lua_State *L)
    {
    GLFWgammaramp ramp;
    mon_t *mon = checkmonitor(L, 1);
    checkgammaramp(L, 2, &ramp);
    glfw.SetGammaRamp(mon->monitor, &ramp);
    free(ramp.red);
    free(ramp.green);
    free(ramp.blue);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x56e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x5710
movq 0xdbd6(%rip), %rax      # 0x1bfe8
movq 0x28(%r14), %rdi
movq %r15, %rsi
callq *0x78(%rax)
movq (%r15), %rdi
callq 0x50b0
movq 0x8(%r15), %rdi
callq 0x50b0
movq 0x10(%r15), %rdi
callq 0x50b0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/monitor.c
// Function: GetMonitorWorkarea
static int GetMonitorWorkarea(lua_State *L)
    {
    int xpos, ypos, width, height;
    mon_t *mon = checkmonitor(L, 1);
    CheckPfn(L, GetMonitorWorkarea, 3, 3, 0);
    glfw.GetMonitorWorkarea(mon->monitor, &xpos, &ypos, &width, &height);
    lua_pushinteger(L, xpos);
    lua_pushinteger(L, ypos);
    lua_pushinteger(L, width);
    lua_pushinteger(L, height);
    return 4;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x56e0
movq 0xdb87(%rip), %rcx      # 0x1bfe8
movq 0x2d8(%rcx), %r9
testq %r9, %r9
je 0xe4d1
movq 0x28(%rax), %rdi
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %r12
movq %rsp, %r13
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %r8
callq *%r9
movslq (%r14), %rsi
movq %rbx, %rdi
callq 0x5310
movslq (%r15), %rsi
movq %rbx, %rdi
callq 0x5310
movslq (%r12), %rsi
movq %rbx, %rdi
callq 0x5310
movslq (%r13), %rsi
movq %rbx, %rdi
callq 0x5310
pushq $0x4
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x3
popq %rdi
movl %edi, %esi
xorl %edx, %edx
callq 0x56a0
testl %eax, %eax
je 0xe4ff
leaq 0x61c3(%rip), %rsi      # 0x146ab
movq %rbx, %rdi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x55b0
leaq 0x616c(%rip), %rsi      # 0x14672
pushq $0x3
popq %rcx
movq %rbx, %rdi
movl %ecx, %edx
xorl %r8d, %r8d
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/monitor.c
// Function: GetMonitorContentScale
static int GetMonitorContentScale(lua_State *L)
    {
    float xscale, yscale;
    mon_t *mon = checkmonitor(L, 1);
    CheckPfn(L, GetMonitorContentScale, 3, 3, 0);
    glfw.GetMonitorContentScale(mon->monitor, &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
pushq $0x1
popq %rsi
callq 0x56e0
movq 0xdaa8(%rip), %rcx      # 0x1bfe8
movq 0x2e0(%rcx), %rcx
testq %rcx, %rcx
je 0xe589
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
cvtss2sd (%r15), %xmm0
movq %rbx, %rdi
callq 0x5460
pushq $0x2
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
pushq $0x3
popq %rdi
movl %edi, %esi
xorl %edx, %edx
callq 0x56a0
testl %eax, %eax
je 0xe5b3
leaq 0x6171(%rip), %rsi      # 0x14711
movq %rbx, %rdi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x55b0
leaq 0x611a(%rip), %rsi      # 0x146d4
pushq $0x3
popq %rcx
movq %rbx, %rdi
movl %ecx, %edx
xorl %r8d, %r8d
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x55b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/native.c
// Function: GetWin32Adapter
static int GetWin32Adapter(lua_State *L)
    {
    const char *what;
    mon_t *mon = checkmonitor(L, 1);
    CheckNativePfn(L, GetWin32Adapter);
    what = glfw.GetWin32Adapter(mon->monitor);
    if(!what) return 0;
    lua_pushstring(L, what);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x56e0
movq 0xd7ae(%rip), %rcx      # 0x1bfe8
movq 0x3d0(%rcx), %rcx
testq %rcx, %rcx
je 0xe85e
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xe876
movq %r14, %rdi
movq %rax, %rsi
callq 0x5690
jmp 0xe878
leaq 0x6111(%rip), %rsi      # 0x14976
movq %r14, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55b0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/native.c
// Function: GetWin32Monitor
static int GetWin32Monitor(lua_State *L)
    {
    const char *what;
    mon_t *mon = checkmonitor(L, 1);
    CheckNativePfn(L, GetWin32Monitor);
    what = glfw.GetWin32Monitor(mon->monitor);
    if(!what) return 0;
    lua_pushstring(L, what);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x56e0
movq 0xd74e(%rip), %rcx      # 0x1bfe8
movq 0x3d8(%rcx), %rcx
testq %rcx, %rcx
je 0xe8be
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xe8d6
movq %r14, %rdi
movq %rax, %rsi
callq 0x5690
jmp 0xe8d8
leaq 0x60d7(%rip), %rsi      # 0x1499c
movq %r14, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55b0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/native.c
// Function: GetWin32Window
static int GetWin32Window(lua_State *L)
    {
    void *what;
    win_t *win = checkwindow(L, 1);
    CheckNativePfn(L, GetWin32Window);
    what = glfw.GetWin32Window(win->window);
    if(!what) return 0;
    lua_pushlightuserdata(L, what);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x5570
movq 0xd6ee(%rip), %rcx      # 0x1bfe8
movq 0x3e0(%rcx), %rcx
testq %rcx, %rcx
je 0xe91e
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xe936
movq %r14, %rdi
movq %rax, %rsi
callq 0x54d0
jmp 0xe938
leaq 0x609d(%rip), %rsi      # 0x149c2
movq %r14, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55b0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/native.c
// Function: GetWGLContext
static int GetWGLContext(lua_State *L)
    {
    void *what;
    win_t *win = checkwindow(L, 1);
    CheckNativePfn(L, GetWGLContext);
    what = glfw.GetWGLContext(win->window);
    if(!what) return 0;
    lua_pushlightuserdata(L, what);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x5570
movq 0xd68e(%rip), %rcx      # 0x1bfe8
movq 0x3e8(%rcx), %rcx
testq %rcx, %rcx
je 0xe97e
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xe996
movq %r14, %rdi
movq %rax, %rsi
callq 0x54d0
jmp 0xe998
leaq 0x6062(%rip), %rsi      # 0x149e7
movq %r14, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55b0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/native.c
// Function: GetX11Display
static int GetX11Display(lua_State *L)
    {
    void *what;
    CheckNativePfn(L, GetX11Display);
    what = glfw.GetX11Display();
    if(!what) return 0;
    lua_pushlightuserdata(L, what);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xd63b(%rip), %rax      # 0x1bfe8
movq 0x3f0(%rax), %rax
testq %rax, %rax
je 0xe9d0
callq *%rax
testq %rax, %rax
je 0xe9e2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54d0
pushq $0x1
popq %rax
jmp 0xe9e4
leaq 0x6034(%rip), %rsi      # 0x14a0b
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/native.c
// Function: GetX11Adapter
static int GetX11Adapter(lua_State *L)
    {
    unsigned long what;
    mon_t *mon = checkmonitor(L, 1);
    CheckNativePfn(L, GetX11Adapter);
    what = glfw.GetX11Adapter(mon->monitor);
//  if(!what) return 0;
    lua_pushinteger(L, what);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x56e0
movq 0xd5ef(%rip), %rcx      # 0x1bfe8
movq 0x3f8(%rcx), %rcx
testq %rcx, %rcx
je 0xea1b
movq 0x28(%rax), %rdi
callq *%rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5310
pushq $0x1
popq %rax
popq %rbx
retq
leaq 0x600d(%rip), %rsi      # 0x14a2f
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/native.c
// Function: GetX11Monitor
static int GetX11Monitor(lua_State *L)
    {
    unsigned long what;
    mon_t *mon = checkmonitor(L, 1);
    CheckNativePfn(L, GetX11Monitor);
    what = glfw.GetX11Monitor(mon->monitor);
//  if(!what) return 0;
    lua_pushinteger(L, what);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x56e0
movq 0xd5a8(%rip), %rcx      # 0x1bfe8
movq 0x400(%rcx), %rcx
testq %rcx, %rcx
je 0xea62
movq 0x28(%rax), %rdi
callq *%rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5310
pushq $0x1
popq %rax
popq %rbx
retq
leaq 0x5fea(%rip), %rsi      # 0x14a53
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/native.c
// Function: GetX11Window
static int GetX11Window(lua_State *L)
    {
    unsigned long what;
    win_t *win = checkwindow(L, 1);
    CheckNativePfn(L, GetX11Window);
    what = glfw.GetX11Window(win->window);
//  if(!what) return 0;
    lua_pushinteger(L, what);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x5570
movq 0xd561(%rip), %rcx      # 0x1bfe8
movq 0x408(%rcx), %rcx
testq %rcx, %rcx
je 0xeaa9
movq 0x28(%rax), %rdi
callq *%rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5310
pushq $0x1
popq %rax
popq %rbx
retq
leaq 0x5fc7(%rip), %rsi      # 0x14a77
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/native.c
// Function: SetX11SelectionString
static int SetX11SelectionString(lua_State *L)
    {
    const char *s = luaL_checkstring(L, 1);
    CheckNativePfn(L, SetX11SelectionString);
    glfw.SetX11SelectionString(s);
    return 0;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x5340
movq 0xd518(%rip), %rcx      # 0x1bfe8
movq 0x468(%rcx), %rcx
testq %rcx, %rcx
je 0xeae5
movq %rax, %rdi
callq *%rcx
xorl %eax, %eax
popq %rbx
retq
leaq 0x5fae(%rip), %rsi      # 0x14a9a
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglfw/src/native.c
// Function: GetX11SelectionString
static int GetX11SelectionString(lua_State *L)
    {
    const char *s;
    CheckNativePfn(L, GetX11SelectionString);
    s = glfw.GetX11SelectionString();
    if(!s) return 0;
    lua_pushstring(L, s);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xd4e6(%rip), %rax      # 0x1bfe8
movq 0x470(%rax), %rax
testq %rax, %rax
je 0xeb25
callq *%rax
testq %rax, %rax
je 0xeb37
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5690
pushq $0x1
popq %rax
jmp 0xeb39
leaq 0x5f9a(%rip), %rsi      # 0x14ac6
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x5570
movq 0xd495(%rip), %rcx      # 0x1bfe8
movq 0x410(%rcx), %rcx
testq %rcx, %rcx
je 0xeb77
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xeb8f
movq %r14, %rdi
movq %rax, %rsi
callq 0x54d0
jmp 0xeb91
leaq 0x5f74(%rip), %rsi      # 0x14af2
movq %r14, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55b0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x5570
movq 0xd43a(%rip), %rcx      # 0x1bfe8
movq 0x418(%rcx), %rcx
testq %rcx, %rcx
je 0xebd0
movq 0x28(%rax), %rdi
callq *%rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5310
pushq $0x1
popq %rax
popq %rbx
retq
leaq 0x5f3f(%rip), %rsi      # 0x14b16
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O2/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 0xd3fb(%rip), %rax      # 0x1bfe8
movq 0x420(%rax), %rax
testq %rax, %rax
je 0xec10
callq *%rax
testq %rax, %rax
je 0xec22
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54d0
pushq $0x1
popq %rax
jmp 0xec24
leaq 0x5f22(%rip), %rsi      # 0x14b39
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x56e0
movq 0xd3aa(%rip), %rcx      # 0x1bfe8
movq 0x428(%rcx), %rcx
testq %rcx, %rcx
je 0xec62
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xec7a
movq %r14, %rdi
movq %rax, %rsi
callq 0x54d0
jmp 0xec7c
leaq 0x5ef8(%rip), %rsi      # 0x14b61
movq %r14, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55b0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x5570
movq 0xd34a(%rip), %rcx      # 0x1bfe8
movq 0x430(%rcx), %rcx
testq %rcx, %rcx
je 0xecc2
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xecda
movq %r14, %rdi
movq %rax, %rsi
callq 0x54d0
jmp 0xecdc
leaq 0x5ec0(%rip), %rsi      # 0x14b89
movq %r14, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55b0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd2f7(%rip), %rax      # 0x1bfe8
movq 0x438(%rax), %rax
testq %rax, %rax
je 0xed14
callq *%rax
testq %rax, %rax
je 0xed26
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54d0
pushq $0x1
popq %rax
jmp 0xed28
leaq 0x5e95(%rip), %rsi      # 0x14bb0
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x56e0
movq 0xd2ab(%rip), %rcx      # 0x1bfe8
movq 0x440(%rcx), %rcx
testq %rcx, %rcx
je 0xed5f
movq 0x28(%rax), %rdi
callq *%rcx
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x5310
pushq $0x1
popq %rax
popq %rbx
retq
leaq 0x5e6e(%rip), %rsi      # 0x14bd4
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x5570
movq 0xd25f(%rip), %rcx      # 0x1bfe8
movq 0x448(%rcx), %rcx
testq %rcx, %rcx
je 0xedad
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xedc5
movq %r14, %rdi
movq %rax, %rsi
callq 0x54d0
jmp 0xedc7
leaq 0x5e44(%rip), %rsi      # 0x14bf8
movq %r14, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55b0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd20c(%rip), %rax      # 0x1bfe8
movq 0x450(%rax), %rax
testq %rax, %rax
je 0xedff
callq *%rax
testq %rax, %rax
je 0xee11
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54d0
pushq $0x1
popq %rax
jmp 0xee13
leaq 0x5e15(%rip), %rsi      # 0x14c1b
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55b0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x5570
movq 0xd1bb(%rip), %rcx      # 0x1bfe8
movq 0x458(%rcx), %rcx
testq %rcx, %rcx
je 0xee51
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xee69
movq %r14, %rdi
movq %rax, %rsi
callq 0x54d0
jmp 0xee6b
leaq 0x5de7(%rip), %rsi      # 0x14c3f
movq %r14, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55b0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x5570
movq 0xd15b(%rip), %rcx      # 0x1bfe8
movq 0x460(%rcx), %rcx
testq %rcx, %rcx
je 0xeeb1
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xeec9
movq %r14, %rdi
movq %rax, %rsi
callq 0x54d0
jmp 0xeecb
leaq 0x5dab(%rip), %rsi      # 0x14c63
movq %r14, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55b0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x5570
movq 0xd0fc(%rip), %rcx      # 0x1bfe8
movq 0x478(%rcx), %r9
testq %r9, %r9
je 0xef50
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 0xef66
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
pushq $0x4
popq %rax
jmp 0xef68
leaq 0x5d30(%rip), %rsi      # 0x14c87
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_O2/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
pushq $0x1
popq %rsi
callq 0x5570
movq 0xd063(%rip), %rcx      # 0x1bfe8
movq 0x480(%rcx), %r9
testq %r9, %r9
je 0xefe9
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 0xefff
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
pushq $0x4
popq %rax
jmp 0xf001
leaq 0x5cc2(%rip), %rsi      # 0x14cb2
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_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x5570
movq 0xcfc9(%rip), %rcx      # 0x1bfe8
movq 0x488(%rcx), %rcx
testq %rcx, %rcx
je 0xf043
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xf05b
movq %r14, %rdi
movq %rax, %rsi
callq 0x54d0
jmp 0xf05d
leaq 0x5c93(%rip), %rsi      # 0x14cdd
movq %r14, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55b0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x5570
movq %rax, %r14
movq 0xcf64(%rip), %r12      # 0x1bfe8
movq 0x3e8(%r12), %rax
testq %rax, %rax
je 0xf0bb
movq 0x28(%r14), %rdi
callq *%rax
testq %rax, %rax
je 0xf0bb
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54d0
leaq 0x5c53(%rip), %rsi      # 0x14d04
movq %rbx, %rdi
callq 0x5690
jmp 0xf0be
xorl %r15d, %r15d
testq %r15, %r15
sete %cl
movq 0x410(%r12), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xf106
movq 0x28(%r14), %rdi
callq *%rax
testq %rax, %rax
je 0xf103
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54d0
leaq 0x5c0f(%rip), %rsi      # 0x14d08
movq %rbx, %rdi
callq 0x5690
jmp 0xf106
xorl %r15d, %r15d
testq %r15, %r15
sete %cl
movq 0x458(%r12), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xf14e
movq 0x28(%r14), %rdi
callq *%rax
testq %rax, %rax
je 0xf14b
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54d0
leaq 0x38c0(%rip), %rsi      # 0x12a01
movq %rbx, %rdi
callq 0x5690
jmp 0xf14e
xorl %r15d, %r15d
testq %r15, %r15
sete %cl
movq 0x488(%r12), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xf196
movq 0x28(%r14), %rdi
callq *%rax
testq %rax, %rax
je 0xf193
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54d0
leaq 0x387c(%rip), %rsi      # 0x12a05
movq %rbx, %rdi
callq 0x5690
jmp 0xf196
xorl %r15d, %r15d
xorl %eax, %eax
testq %r15, %r15
setne %al
addl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf3d4
movq %r14, %rdi
movl %ebp, %esi
callq 0x53e0
movl %eax, %edi
callq 0x5430
movq %rax, %r15
testq %rax, %rax
jne 0xf3c7
leaq 0x59aa(%rip), %rsi      # 0x14d67
movq %r14, %rdi
xorl %eax, %eax
callq 0x55b0
pushq $0x1
popq %rax
testq %rbx, %rbx
je 0xf3d6
movq %r15, (%rbx)
jmp 0xf3d6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf40d
leaq 0x5964(%rip), %rsi      # 0x14d67
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_O2/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 0xf467
movq %r14, %rdi
movl %ebp, %esi
callq 0x53e0
movl %eax, %edi
callq 0x5060
movq %rax, %r15
testq %rax, %rax
jne 0xf45a
leaq 0x5121(%rip), %rsi      # 0x14571
movq %r14, %rdi
xorl %eax, %eax
callq 0x55b0
pushq $0x1
popq %rax
testq %rbx, %rbx
je 0xf469
movq %r15, (%rbx)
jmp 0xf469
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf4a0
leaq 0x50db(%rip), %rsi      # 0x14571
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_O2/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 0xf4fa
movq %r14, %rdi
movl %ebp, %esi
callq 0x53e0
movl %eax, %edi
callq 0x5160
movq %rax, %r15
testq %rax, %rax
jne 0xf4ed
leaq 0x2eb5(%rip), %rsi      # 0x12398
movq %r14, %rdi
xorl %eax, %eax
callq 0x55b0
pushq $0x1
popq %rax
testq %rbx, %rbx
je 0xf4fc
movq %r15, (%rbx)
jmp 0xf4fc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf533
leaq 0x2e6f(%rip), %rsi      # 0x12398
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_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x5210
cvtss2sd 0x10(%r14), %xmm0
movq %rbx, %rdi
callq 0x5460
leaq 0x55ec(%rip), %rdx      # 0x14ddc
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
cvtss2sd 0x14(%r14), %xmm0
movq %rbx, %rdi
callq 0x5460
leaq 0x55d1(%rip), %rdx      # 0x14de3
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
cvtss2sd 0x18(%r14), %xmm0
movq %rbx, %rdi
callq 0x5460
leaq 0x55b9(%rip), %rdx      # 0x14dea
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
cvtss2sd 0x1c(%r14), %xmm0
movq %rbx, %rdi
callq 0x5460
leaq 0x55a2(%rip), %rdx      # 0x14df2
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
cvtss2sd 0x20(%r14), %xmm0
movq %rbx, %rdi
callq 0x5460
leaq 0x558b(%rip), %rdx      # 0x14dfa
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
cvtss2sd 0x24(%r14), %xmm0
movq %rbx, %rdi
callq 0x5460
leaq 0x5579(%rip), %rdx      # 0x14e07
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5546(%rip), %rdx      # 0x14e15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
movslq 0x4(%r14), %rsi
movq %rbx, %rdi
callq 0x5310
leaq 0x552f(%rip), %rdx      # 0x14e1b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
movslq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x5310
leaq 0x5519(%rip), %rdx      # 0x14e22
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
movslq 0xc(%r14), %rsi
movq %rbx, %rdi
callq 0x5310
leaq 0x5505(%rip), %rdx      # 0x14e2b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
movslq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x5310
leaq 0x54f3(%rip), %rdx      # 0x14e36
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
movslq 0x14(%r14), %rsi
movq %rbx, %rdi
callq 0x5310
leaq 0x54e0(%rip), %rdx      # 0x14e40
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq