LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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, 0xeb94(%rip)      # 0x1c890
jne 0xdd0f
movq 0xe2e3(%rip), %rax      # 0x1bfe8
callq *0x8(%rax)
movb $0x0, 0xeb81(%rip)      # 0x1c890
movq 0xe2d2(%rip), %r15      # 0x1bfe8
cmpq $0x0, 0x2c8(%r15)
je 0xdd67
movq %rbx, %rdi
movl $0xe, %esi
movl $0x1, %edx
callq 0x5440
movl %eax, %r14d
cmpl $0x51000, %eax          # imm = 0x51000
jle 0xdd96
leal -0x51001(%r14), %eax
cmpl $0x2, %eax
jb 0xddd1
cmpl $0x53001, %r14d         # imm = 0x53001
je 0xde24
cmpl $0x52001, %r14d         # imm = 0x52001
je 0xddd1
jmp 0xddfc
cmpl $0xc02fff, 0xeb0f(%rip) # imm = 0xC02FFF
jg 0xdde6
leaq 0x76de(%rip), %rsi      # 0x15458
movq %rbx, %rdi
movl $0x3, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x55a0
cmpl $0x50001, %r14d         # imm = 0x50001
je 0xddd1
cmpl $0x50002, %r14d         # imm = 0x50002
je 0xde3d
cmpl $0x50003, %r14d         # imm = 0x50003
jne 0xddfc
movq %rbx, %rdi
movl $0xf, %esi
movl $0x2, %edx
callq 0x5440
movl $0x50003, %edi          # imm = 0x50003
jmp 0xde54
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5070
movzbl %al, %esi
movl %r14d, %edi
jmp 0xde56
leaq 0x769a(%rip), %rsi      # 0x15487
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x55a0
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x51e0
leaq 0x7694(%rip), %rsi      # 0x154a6
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x55a0
movq %rbx, %rdi
movl $0x10, %esi
movl $0x2, %edx
callq 0x5440
movl $0x53001, %edi          # imm = 0x53001
jmp 0xde54
movq %rbx, %rdi
movl $0x11, %esi
movl $0x2, %edx
callq 0x5440
movl $0x50002, %edi          # imm = 0x50002
movl %eax, %esi
callq *0x2c8(%r15)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe178(%rip), %rax      # 0x1bfe8
movq 0x390(%rax), %rax
testq %rax, %rax
je 0xde94
callq *%rax
movq %rbx, %rdi
movl $0xf, %esi
movl %eax, %edx
callq 0x55d0
movl $0x1, %eax
popq %rbx
retq
cmpl $0xc03fff, 0xe9e2(%rip) # imm = 0xC03FFF
jg 0xdebf
leaq 0x7616(%rip), %rsi      # 0x154bd
movq %rbx, %rdi
movl $0x3, %edx
movl $0x4, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
popq %rbx
jmp 0x55a0
leaq 0x7629(%rip), %rsi      # 0x154ef
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xe109(%rip), %r14      # 0x1bfe8
cmpq $0x0, 0x398(%r14)
je 0xdf1b
movq %rbx, %rdi
movl $0xf, %esi
movl $0x1, %edx
callq 0x5440
movl %eax, %edi
callq *0x398(%r14)
movq %rbx, %rdi
movl %eax, %esi
callq 0x5470
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0xc03fff, 0xe95b(%rip) # imm = 0xC03FFF
jg 0xdf4c
leaq 0x75e3(%rip), %rsi      # 0x15511
movq %rbx, %rdi
movl $0x3, %edx
movl $0x4, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55a0
leaq 0x75f6(%rip), %rsi      # 0x15549
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55a0
// File: /workspace/github_c_makefile_star2_O1/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 0xe06f(%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
movl $0x3, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x53d0
movq 0xe0fc(%rip), %r14      # 0x1c898
testq %r14, %r14
je 0xe7b2
cmpl %eax, 0x20(%r14)
jg 0xe7ad
jge 0xe7b5
addq $0x8, %r14
movq (%r14), %r14
jmp 0xe79c
xorl %r14d, %r14d
testq %r14, %r14
jne 0xe7cb
leaq 0x6db0(%rip), %rsi      # 0x15571
movq %rbx, %rdi
xorl %eax, %eax
callq 0x55a0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xe7fe
cmpq %r14, 0x28(%rax)
je 0xe80c
movq %rax, %rdi
callq 0x51c0
jmp 0xe7e9
callq 0x5380
testq %rax, %rax
je 0xe817
movq %r14, 0x28(%rax)
movl 0x20(%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6d66(%rip), %rsi      # 0x15584
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55a0
// File: /workspace/github_c_makefile_star2_O1/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 0xd78c(%rip), %rax      # 0x1bfe8
callq *0x30(%rax)
testq %rax, %rax
je 0xe881
movq %rbx, %rdi
movq %rax, %rsi
callq 0x53e0
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x5310
movl $0x1, %eax
jmp 0xe883
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd750(%rip), %rax      # 0x1bfe8
leaq 0xc(%rsp), %rdi
callq *0x28(%rax)
testq %rax, %rax
je 0xe8d9
movq %rax, %r14
movl 0xc(%rsp), %eax
testl %eax, %eax
jle 0xe8db
xorl %r15d, %r15d
movq (%r14,%r15,8), %rsi
movq %rbx, %rdi
callq 0x53e0
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x5310
incq %r15
movslq 0xc(%rsp), %rax
cmpq %rax, %r15
jl 0xe8b3
jmp 0xe8db
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x56d0
movq 0xd6e6(%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
movl $0x2, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x56d0
movq 0xd68d(%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
movl $0x2, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x56d0
movq 0xd63c(%rip), %rcx      # 0x1bfe8
movq 0x28(%rax), %rdi
callq *0x48(%rcx)
testq %rax, %rax
leaq 0x66f1(%rip), %rsi      # 0x150ae
cmovneq %rax, %rsi
movq %rbx, %rdi
callq 0x5680
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x56d0
movq 0xd5fb(%rip), %rcx      # 0x1bfe8
movq 0x28(%rax), %rdi
leaq 0xc(%rsp), %rsi
callq *0x58(%rcx)
testq %rax, %rax
je 0xea2a
movq %rax, %r14
movl 0xc(%rsp), %eax
testl %eax, %eax
jle 0xea2c
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x54b0
incq %r15
movslq 0xc(%rsp), %rax
addq $0x18, %r14
cmpq %rax, %r15
jl 0xea0c
jmp 0xea2c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %ebx
movl $0x1, %esi
callq 0x56d0
movq 0xd595(%rip), %rcx      # 0x1bfe8
movq 0x28(%rax), %rdi
callq *0x60(%rcx)
testq %rax, %rax
je 0xea6c
movq %r14, %rdi
movq %rax, %rsi
callq 0x54b0
jmp 0xea6e
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x56d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5230
cvtsd2ss %xmm0, %xmm0
movq 0xd544(%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_O1/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
movl $0x1, %esi
callq 0x56d0
movq 0xd51e(%rip), %rcx      # 0x1bfe8
movq 0x28(%rax), %rdi
callq *0x70(%rcx)
testq %rax, %rax
je 0xeae2
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x56a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x56d0
movq %rax, %r14
movq %rsp, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x5700
movq 0xd4cf(%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_O1/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
movl $0x1, %esi
callq 0x56d0
movq 0xd47e(%rip), %rcx      # 0x1bfe8
movq 0x2d8(%rcx), %r9
testq %r9, %r9
je 0xebdc
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
movl $0x4, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x3, %edi
movl $0x3, %esi
xorl %edx, %edx
callq 0x5690
testl %eax, %eax
je 0xec0f
leaq 0x6ab3(%rip), %rsi      # 0x156ab
movq %rbx, %rdi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x55a0
leaq 0x6a5c(%rip), %rsi      # 0x15672
movq %rbx, %rdi
movl $0x3, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x55a0
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x56d0
movq 0xd391(%rip), %rcx      # 0x1bfe8
movq 0x2e0(%rcx), %rcx
testq %rcx, %rcx
je 0xeca5
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 0x5450
xorps %xmm0, %xmm0
cvtss2sd (%r15), %xmm0
movq %rbx, %rdi
callq 0x5450
movl $0x2, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x3, %edi
movl $0x3, %esi
xorl %edx, %edx
callq 0x5690
testl %eax, %eax
je 0xecd4
leaq 0x6a50(%rip), %rsi      # 0x15711
movq %rbx, %rdi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x55a0
leaq 0x69f9(%rip), %rsi      # 0x156d4
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 0x55a0
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x56d0
movq 0xd06f(%rip), %rcx      # 0x1bfe8
movq 0x3d0(%rcx), %rcx
testq %rcx, %rcx
je 0xefa2
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xefb4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5680
movl $0x1, %eax
jmp 0xefb6
leaq 0x69cd(%rip), %rsi      # 0x15976
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x56d0
movq 0xd01b(%rip), %rcx      # 0x1bfe8
movq 0x3d8(%rcx), %rcx
testq %rcx, %rcx
je 0xeff6
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xf008
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5680
movl $0x1, %eax
jmp 0xf00a
leaq 0x699f(%rip), %rsi      # 0x1599c
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5560
movq 0xcfc7(%rip), %rcx      # 0x1bfe8
movq 0x3e0(%rcx), %rcx
testq %rcx, %rcx
je 0xf04a
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xf05c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54c0
movl $0x1, %eax
jmp 0xf05e
leaq 0x6971(%rip), %rsi      # 0x159c2
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5560
movq 0xcf73(%rip), %rcx      # 0x1bfe8
movq 0x3e8(%rcx), %rcx
testq %rcx, %rcx
je 0xf09e
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xf0b0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54c0
movl $0x1, %eax
jmp 0xf0b2
leaq 0x6942(%rip), %rsi      # 0x159e7
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcf29(%rip), %rax      # 0x1bfe8
movq 0x3f0(%rax), %rax
testq %rax, %rax
je 0xf0e4
callq *%rax
testq %rax, %rax
je 0xf0f6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54c0
movl $0x1, %eax
jmp 0xf0f8
leaq 0x6920(%rip), %rsi      # 0x15a0b
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x56d0
movq 0xced9(%rip), %rcx      # 0x1bfe8
movq 0x3f8(%rcx), %rcx
testq %rcx, %rcx
je 0xf133
movq 0x28(%rax), %rdi
callq *%rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5310
movl $0x1, %eax
popq %rbx
retq
leaq 0x68f5(%rip), %rsi      # 0x15a2f
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x56d0
movq 0xce8e(%rip), %rcx      # 0x1bfe8
movq 0x400(%rcx), %rcx
testq %rcx, %rcx
je 0xf17e
movq 0x28(%rax), %rdi
callq *%rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5310
movl $0x1, %eax
popq %rbx
retq
leaq 0x68ce(%rip), %rsi      # 0x15a53
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x5560
movq 0xce43(%rip), %rcx      # 0x1bfe8
movq 0x408(%rcx), %rcx
testq %rcx, %rcx
je 0xf1c9
movq 0x28(%rax), %rdi
callq *%rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5310
movl $0x1, %eax
popq %rbx
retq
leaq 0x68a7(%rip), %rsi      # 0x15a77
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
xorl %edx, %edx
callq 0x5340
movq 0xcdf6(%rip), %rcx      # 0x1bfe8
movq 0x468(%rcx), %rcx
testq %rcx, %rcx
je 0xf207
movq %rax, %rdi
callq *%rcx
xorl %eax, %eax
popq %rbx
retq
leaq 0x688c(%rip), %rsi      # 0x15a9a
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
// File: /workspace/github_c_makefile_star2_O1/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 0xcdc4(%rip), %rax      # 0x1bfe8
movq 0x470(%rax), %rax
testq %rax, %rax
je 0xf249
callq *%rax
testq %rax, %rax
je 0xf25b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5680
movl $0x1, %eax
jmp 0xf25d
leaq 0x6876(%rip), %rsi      # 0x15ac6
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5560
movq 0xcd74(%rip), %rcx      # 0x1bfe8
movq 0x410(%rcx), %rcx
testq %rcx, %rcx
je 0xf29d
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xf2af
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54c0
movl $0x1, %eax
jmp 0xf2b1
leaq 0x684e(%rip), %rsi      # 0x15af2
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5560
movq 0xcd20(%rip), %rcx      # 0x1bfe8
movq 0x418(%rcx), %rcx
testq %rcx, %rcx
je 0xf2ec
movq 0x28(%rax), %rdi
callq *%rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5310
movl $0x1, %eax
popq %rbx
retq
leaq 0x6823(%rip), %rsi      # 0x15b16
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
// File: /workspace/github_c_makefile_star2_O1/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 0xccdf(%rip), %rax      # 0x1bfe8
movq 0x420(%rax), %rax
testq %rax, %rax
je 0xf32e
callq *%rax
testq %rax, %rax
je 0xf340
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54c0
movl $0x1, %eax
jmp 0xf342
leaq 0x6804(%rip), %rsi      # 0x15b39
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x56d0
movq 0xcc8f(%rip), %rcx      # 0x1bfe8
movq 0x428(%rcx), %rcx
testq %rcx, %rcx
je 0xf382
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xf394
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54c0
movl $0x1, %eax
jmp 0xf396
leaq 0x67d8(%rip), %rsi      # 0x15b61
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5560
movq 0xcc3b(%rip), %rcx      # 0x1bfe8
movq 0x430(%rcx), %rcx
testq %rcx, %rcx
je 0xf3d6
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xf3e8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54c0
movl $0x1, %eax
jmp 0xf3ea
leaq 0x67ac(%rip), %rsi      # 0x15b89
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcbf1(%rip), %rax      # 0x1bfe8
movq 0x438(%rax), %rax
testq %rax, %rax
je 0xf41c
callq *%rax
testq %rax, %rax
je 0xf42e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54c0
movl $0x1, %eax
jmp 0xf430
leaq 0x678d(%rip), %rsi      # 0x15bb0
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x56d0
movq 0xcba1(%rip), %rcx      # 0x1bfe8
movq 0x440(%rcx), %rcx
testq %rcx, %rcx
je 0xf46b
movq 0x28(%rax), %rdi
callq *%rcx
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x5310
movl $0x1, %eax
popq %rbx
retq
leaq 0x6762(%rip), %rsi      # 0x15bd4
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
// File: /workspace/github_c_makefile_star2_O1/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 0x5560
movq 0xcb56(%rip), %rcx      # 0x1bfe8
movq 0x448(%rcx), %rcx
testq %rcx, %rcx
je 0xf4bb
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xf4cd
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54c0
movl $0x1, %eax
jmp 0xf4cf
leaq 0x6736(%rip), %rsi      # 0x15bf8
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcb0c(%rip), %rax      # 0x1bfe8
movq 0x450(%rax), %rax
testq %rax, %rax
je 0xf501
callq *%rax
testq %rax, %rax
je 0xf513
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54c0
movl $0x1, %eax
jmp 0xf515
leaq 0x6713(%rip), %rsi      # 0x15c1b
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5560
movq 0xcabc(%rip), %rcx      # 0x1bfe8
movq 0x458(%rcx), %rcx
testq %rcx, %rcx
je 0xf555
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xf567
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54c0
movl $0x1, %eax
jmp 0xf569
leaq 0x66e3(%rip), %rsi      # 0x15c3f
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5560
movq 0xca68(%rip), %rcx      # 0x1bfe8
movq 0x460(%rcx), %rcx
testq %rcx, %rcx
je 0xf5a9
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xf5bb
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54c0
movl $0x1, %eax
jmp 0xf5bd
leaq 0x66b3(%rip), %rsi      # 0x15c63
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5560
movq 0xca10(%rip), %rcx      # 0x1bfe8
movq 0x478(%rcx), %r9
testq %r9, %r9
je 0xf63e
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 0xf654
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 0x54c0
movl $0x4, %eax
jmp 0xf656
leaq 0x6642(%rip), %rsi      # 0x15c87
movq %rbx, %rdi
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
jmp 0x55a0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5560
movq 0xc973(%rip), %rcx      # 0x1bfe8
movq 0x480(%rcx), %r9
testq %r9, %r9
je 0xf6db
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 0xf6f1
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 0x54c0
movl $0x4, %eax
jmp 0xf6f3
leaq 0x65d0(%rip), %rsi      # 0x15cb2
movq %rbx, %rdi
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
jmp 0x55a0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5560
movq 0xc8da(%rip), %rcx      # 0x1bfe8
movq 0x488(%rcx), %rcx
testq %rcx, %rcx
je 0xf737
movq 0x28(%rax), %rdi
callq *%rcx
testq %rax, %rax
je 0xf749
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54c0
movl $0x1, %eax
jmp 0xf74b
leaq 0x659f(%rip), %rsi      # 0x15cdd
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x55a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x5560
movq %rax, %r14
movq 0xc87c(%rip), %r12      # 0x1bfe8
movq 0x3e8(%r12), %rax
testq %rax, %rax
je 0xf7a3
movq 0x28(%r14), %rdi
callq *%rax
testq %rax, %rax
je 0xf7a3
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54c0
leaq 0x656b(%rip), %rsi      # 0x15d04
movq %rbx, %rdi
callq 0x5680
jmp 0xf7a6
xorl %r15d, %r15d
testq %r15, %r15
sete %cl
movq 0x410(%r12), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xf7ee
movq 0x28(%r14), %rdi
callq *%rax
testq %rax, %rax
je 0xf7eb
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54c0
leaq 0x6527(%rip), %rsi      # 0x15d08
movq %rbx, %rdi
callq 0x5680
jmp 0xf7ee
xorl %r15d, %r15d
testq %r15, %r15
sete %cl
movq 0x458(%r12), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xf836
movq 0x28(%r14), %rdi
callq *%rax
testq %rax, %rax
je 0xf833
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54c0
leaq 0x41d8(%rip), %rsi      # 0x13a01
movq %rbx, %rdi
callq 0x5680
jmp 0xf836
xorl %r15d, %r15d
testq %r15, %r15
sete %cl
movq 0x488(%r12), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xf87e
movq 0x28(%r14), %rdi
callq *%rax
testq %rax, %rax
je 0xf87b
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54c0
leaq 0x4194(%rip), %rsi      # 0x13a05
movq %rbx, %rdi
callq 0x5680
jmp 0xf87e
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_O1/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 0x5620
testl %eax, %eax
jle 0xfad1
movq %r14, %rdi
movl %ebp, %esi
callq 0x53d0
movl %eax, %edi
callq 0x5420
movq %rax, %r15
testq %rax, %rax
jne 0xfac2
leaq 0x62af(%rip), %rsi      # 0x15d67
movq %r14, %rdi
xorl %eax, %eax
callq 0x55a0
movl $0x1, %eax
testq %rbx, %rbx
je 0xfad3
movq %r15, (%rbx)
jmp 0xfad3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x53d0
movl %eax, %edi
callq 0x5420
movq %rax, %r14
testq %rax, %rax
jne 0xfb0a
leaq 0x6267(%rip), %rsi      # 0x15d67
movq %rbx, %rdi
xorl %eax, %eax
callq 0x55a0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5620
testl %eax, %eax
jle 0xfb66
movq %r14, %rdi
movl %ebp, %esi
callq 0x53d0
movl %eax, %edi
callq 0x5060
movq %rax, %r15
testq %rax, %rax
jne 0xfb57
leaq 0x5a24(%rip), %rsi      # 0x15571
movq %r14, %rdi
xorl %eax, %eax
callq 0x55a0
movl $0x1, %eax
testq %rbx, %rbx
je 0xfb68
movq %r15, (%rbx)
jmp 0xfb68
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x53d0
movl %eax, %edi
callq 0x5060
movq %rax, %r14
testq %rax, %rax
jne 0xfb9f
leaq 0x59dc(%rip), %rsi      # 0x15571
movq %rbx, %rdi
xorl %eax, %eax
callq 0x55a0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5620
testl %eax, %eax
jle 0xfbfb
movq %r14, %rdi
movl %ebp, %esi
callq 0x53d0
movl %eax, %edi
callq 0x5160
movq %rax, %r15
testq %rax, %rax
jne 0xfbec
leaq 0x37b6(%rip), %rsi      # 0x13398
movq %r14, %rdi
xorl %eax, %eax
callq 0x55a0
movl $0x1, %eax
testq %rbx, %rbx
je 0xfbfd
movq %r15, (%rbx)
jmp 0xfbfd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x53d0
movl %eax, %edi
callq 0x5160
movq %rax, %r14
testq %rax, %rax
jne 0xfc34
leaq 0x376e(%rip), %rsi      # 0x13398
movq %rbx, %rdi
xorl %eax, %eax
callq 0x55a0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5450
leaq 0x5ec3(%rip), %rdx      # 0x15ddc
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
xorps %xmm0, %xmm0
cvtss2sd 0x14(%r14), %xmm0
movq %rbx, %rdi
callq 0x5450
leaq 0x5ea5(%rip), %rdx      # 0x15de3
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
xorps %xmm0, %xmm0
cvtss2sd 0x18(%r14), %xmm0
movq %rbx, %rdi
callq 0x5450
leaq 0x5e87(%rip), %rdx      # 0x15dea
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
xorps %xmm0, %xmm0
cvtss2sd 0x1c(%r14), %xmm0
movq %rbx, %rdi
callq 0x5450
leaq 0x5e6a(%rip), %rdx      # 0x15df2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
xorps %xmm0, %xmm0
cvtss2sd 0x20(%r14), %xmm0
movq %rbx, %rdi
callq 0x5450
leaq 0x5e4d(%rip), %rdx      # 0x15dfa
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
xorps %xmm0, %xmm0
cvtss2sd 0x24(%r14), %xmm0
movq %rbx, %rdi
callq 0x5450
leaq 0x5e35(%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_O1/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 0x5dfa(%rip), %rdx      # 0x15e15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
movslq 0x4(%r14), %rsi
movq %rbx, %rdi
callq 0x5310
leaq 0x5de3(%rip), %rdx      # 0x15e1b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
movslq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x5310
leaq 0x5dcd(%rip), %rdx      # 0x15e22
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
movslq 0xc(%r14), %rsi
movq %rbx, %rdi
callq 0x5310
leaq 0x5db9(%rip), %rdx      # 0x15e2b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
movslq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x5310
leaq 0x5da7(%rip), %rdx      # 0x15e36
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52d0
movslq 0x14(%r14), %rsi
movq %rbx, %rdi
callq 0x5310
leaq 0x5d94(%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_O1/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 0x5470
leaq 0x5d65(%rip), %rdx      # 0x15e4d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
movl %ebp, %esi
andl $0x1, %esi
movq %rbx, %rdi
callq 0x5470
leaq 0x33a7(%rip), %rdx      # 0x134b0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
movl %ebp, %esi
andl $0x2, %esi
movq %rbx, %rdi
callq 0x5470
leaq 0x5c98(%rip), %rdx      # 0x15dc2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
movl %ebp, %esi
andl $0x4, %esi
movq %rbx, %rdi
callq 0x5470
leaq 0x336d(%rip), %rdx      # 0x134b8
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
andl $0x8, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5470
leaq 0x5c6b(%rip), %rdx      # 0x15dd7
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x52d0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq