LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/callbacks.c
// Function: WindowPosCallback
static void WindowPosCallback(GLFWwindow *window, int xpos, int ypos)
    {
    BEGIN(WindowPos);
    lua_pushinteger(L, xpos);
    lua_pushinteger(L, ypos);
    EXEC(2);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x1d4e0(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5080
movl %eax, 0x14(%rsp)
movq 0x1d4dd(%rip), %rax     # 0x23fe8
movq 0x150(%rax), %rax
movq 0x20(%rsp), %rdi
callq *%rax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %edi
callq 0x5410
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x6b55
movq 0x1d49e(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movslq 0x34(%rax), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x5280
cmpl $0x6, %eax
je 0x6b7e
movq 0x1d47c(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
leaq 0x156ee(%rip), %rsi     # 0x1c254
leaq 0x15701(%rip), %rdx     # 0x1c26e
movl $0xab, %ecx
movb $0x0, %al
callq 0x5590
jmp 0x6c03
movq 0x1d453(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x10(%rsp), %rsi
callq 0x5300
movq 0x1d43f(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x5300
movq 0x1d42b(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x18(%rsp), %rsi
callq 0x5300
movq 0x1d417(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl $0x3, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movq %r9, %r8
callq 0x5710
cmpl $0x0, %eax
je 0x6bf0
movq 0x1d3f2(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5560
jmp 0x6c03
movq 0x1d3e1(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x14(%rsp), %esi
callq 0x50d0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/callbacks.c
// Function: WindowSizeCallback
static void WindowSizeCallback(GLFWwindow *window, int width, int height)
    {
    BEGIN(WindowSize);
    lua_pushinteger(L, width);
    lua_pushinteger(L, height);
    EXEC(2);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x1d3b0(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5080
movl %eax, 0x14(%rsp)
movq 0x1d3ad(%rip), %rax     # 0x23fe8
movq 0x150(%rax), %rax
movq 0x20(%rsp), %rdi
callq *%rax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %edi
callq 0x5410
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x6c85
movq 0x1d36e(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movslq 0x38(%rax), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x5280
cmpl $0x6, %eax
je 0x6cae
movq 0x1d34c(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
leaq 0x155be(%rip), %rsi     # 0x1c254
leaq 0x155d1(%rip), %rdx     # 0x1c26e
movl $0xb3, %ecx
movb $0x0, %al
callq 0x5590
jmp 0x6d33
movq 0x1d323(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x10(%rsp), %rsi
callq 0x5300
movq 0x1d30f(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x5300
movq 0x1d2fb(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x18(%rsp), %rsi
callq 0x5300
movq 0x1d2e7(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl $0x3, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movq %r9, %r8
callq 0x5710
cmpl $0x0, %eax
je 0x6d20
movq 0x1d2c2(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5560
jmp 0x6d33
movq 0x1d2b1(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x14(%rsp), %esi
callq 0x50d0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/callbacks.c
// Function: WindowContentScaleCallback
static void WindowContentScaleCallback(GLFWwindow *window, float xscale, float yscale)
    {
    BEGIN(WindowContentScale);
    lua_pushnumber(L, xscale);
    lua_pushnumber(L, yscale);
    EXEC(2);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movss %xmm0, 0x1c(%rsp)
movss %xmm1, 0x18(%rsp)
movq 0x1cd4c(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5080
movl %eax, 0x14(%rsp)
movq 0x1cd49(%rip), %rax     # 0x23fe8
movq 0x150(%rax), %rax
movq 0x20(%rsp), %rdi
callq *%rax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %edi
callq 0x5410
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x72e9
movq 0x1cd0a(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movslq 0x50(%rax), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x5280
cmpl $0x6, %eax
je 0x7312
movq 0x1cce8(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
leaq 0x14f5a(%rip), %rsi     # 0x1c254
leaq 0x14f6d(%rip), %rdx     # 0x1c26e
movl $0xdc, %ecx
movb $0x0, %al
callq 0x5590
jmp 0x73a1
movq 0x1ccbf(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x10(%rsp), %rsi
callq 0x5300
movq 0x1ccab(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movss 0x1c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x5440
movq 0x1cc92(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movss 0x18(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x5440
movq 0x1cc79(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl $0x3, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movq %r9, %r8
callq 0x5710
cmpl $0x0, %eax
je 0x738e
movq 0x1cc54(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5560
jmp 0x73a1
movq 0x1cc43(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x14(%rsp), %esi
callq 0x50d0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/callbacks.c
// Function: FramebufferSizeCallback
static void FramebufferSizeCallback(GLFWwindow *window, int width, int height)
    {
    BEGIN(FramebufferSize);
    lua_pushinteger(L, width);
    lua_pushinteger(L, height);
    EXEC(2);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x1cc10(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5080
movl %eax, 0x14(%rsp)
movq 0x1cc0d(%rip), %rax     # 0x23fe8
movq 0x150(%rax), %rax
movq 0x20(%rsp), %rdi
callq *%rax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %edi
callq 0x5410
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x7425
movq 0x1cbce(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movslq 0x54(%rax), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x5280
cmpl $0x6, %eax
je 0x744e
movq 0x1cbac(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
leaq 0x14e1e(%rip), %rsi     # 0x1c254
leaq 0x14e31(%rip), %rdx     # 0x1c26e
movl $0xe4, %ecx
movb $0x0, %al
callq 0x5590
jmp 0x74d3
movq 0x1cb83(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x10(%rsp), %rsi
callq 0x5300
movq 0x1cb6f(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x5300
movq 0x1cb5b(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x18(%rsp), %rsi
callq 0x5300
movq 0x1cb47(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl $0x3, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movq %r9, %r8
callq 0x5710
cmpl $0x0, %eax
je 0x74c0
movq 0x1cb22(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5560
jmp 0x74d3
movq 0x1cb11(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x14(%rsp), %esi
callq 0x50d0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/callbacks.c
// Function: KeyCallback
static void KeyCallback(GLFWwindow *window, int key, int scancode, int action, int mods)
    {
    int n = 3;
    BEGIN(Key);
    pushkey(L, key);
    lua_pushinteger(L, scancode);
    pushaction(L, action);
    n += PushMods(L, mods);
    EXEC(n);
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movl %r8d, 0x20(%rsp)
movl $0x3, 0x1c(%rsp)
movq 0x1cacf(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5080
movl %eax, 0x18(%rsp)
movq 0x1cacc(%rip), %rax     # 0x23fe8
movq 0x150(%rax), %rax
movq 0x30(%rsp), %rdi
callq *%rax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %edi
callq 0x5410
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x7566
movq 0x1ca8d(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movslq 0x58(%rax), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x5280
cmpl $0x6, %eax
je 0x758f
movq 0x1ca6b(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
leaq 0x14cdd(%rip), %rsi     # 0x1c254
leaq 0x14cf0(%rip), %rdx     # 0x1c26e
movl $0xef, %ecx
movb $0x0, %al
callq 0x5590
jmp 0x764a
movq 0x1ca42(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x14(%rsp), %rsi
callq 0x5300
movq 0x1ca2e(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x2c(%rsp), %edx
movl $0x2, %esi
callq 0x55c0
movq 0x1ca16(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x28(%rsp), %rsi
callq 0x5300
movq 0x1ca02(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x24(%rsp), %edx
xorl %esi, %esi
callq 0x55c0
movq 0x1c9ed(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x20(%rsp), %esi
callq 0x7650
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x1c9d2(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movq %r9, %r8
callq 0x5710
cmpl $0x0, %eax
je 0x7637
movq 0x1c9ab(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5560
jmp 0x764a
movq 0x1c99a(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x18(%rsp), %esi
callq 0x50d0
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/callbacks.c
// Function: PushMods
static int PushMods(lua_State *L, int mods)
    {
    lua_pushboolean(L, mods & GLFW_MOD_SHIFT);
    lua_pushboolean(L, mods & GLFW_MOD_CONTROL);
    lua_pushboolean(L, mods & GLFW_MOD_ALT);
    lua_pushboolean(L, mods & GLFW_MOD_SUPER);
    return 4;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
andl $0x1, %esi
callq 0x5460
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
andl $0x2, %esi
callq 0x5460
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
andl $0x4, %esi
callq 0x5460
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
andl $0x8, %esi
callq 0x5460
movl $0x4, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/callbacks.c
// Function: CharModsCallback
static void CharModsCallback(GLFWwindow *window, unsigned int codepoint, int mods)
    {
    int n = 1;
    BEGIN(CharMods);
    lua_pushinteger(L, codepoint);
    n += PushMods(L, mods);
    EXEC(n);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl $0x1, 0x14(%rsp)
movq 0x1c7f8(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5080
movl %eax, 0x10(%rsp)
movq 0x1c7f5(%rip), %rax     # 0x23fe8
movq 0x150(%rax), %rax
movq 0x20(%rsp), %rdi
callq *%rax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edi
callq 0x5410
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x783a
movq 0x1c7b8(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movq (%rsp), %rax
movslq 0x60(%rax), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x5280
cmpl $0x6, %eax
je 0x7863
movq 0x1c797(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
leaq 0x14a09(%rip), %rsi     # 0x1c254
leaq 0x14a1c(%rip), %rdx     # 0x1c26e
movl $0x107, %ecx            # imm = 0x107
movb $0x0, %al
callq 0x5590
jmp 0x78f2
movq 0x1c76e(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0xc(%rsp), %rsi
callq 0x5300
movq 0x1c75a(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x5300
movq 0x1c745(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x18(%rsp), %esi
callq 0x7650
addl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x1c72a(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x14(%rsp), %esi
addl $0x1, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movq %r9, %r8
callq 0x5710
cmpl $0x0, %eax
je 0x78df
movq 0x1c703(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5560
jmp 0x78f2
movq 0x1c6f2(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x10(%rsp), %esi
callq 0x50d0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/callbacks.c
// Function: MouseButtonCallback
static void MouseButtonCallback(GLFWwindow *window, int button, int action, int mods)
    {
    int n = 2;
    BEGIN(MouseButton);
    pushbutton(L, button);
    pushaction(L, action);
    n += PushMods(L, mods);
    EXEC(n);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl $0x2, 0x10(%rsp)
movq 0x1c6b4(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5080
movl %eax, 0xc(%rsp)
movq 0x1c6b1(%rip), %rax     # 0x23fe8
movq 0x150(%rax), %rax
movq 0x20(%rsp), %rdi
callq *%rax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %edi
callq 0x5410
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x797e
movq 0x1c674(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movq (%rsp), %rax
movslq 0x64(%rax), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x5280
cmpl $0x6, %eax
je 0x79a7
movq 0x1c653(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
leaq 0x148c5(%rip), %rsi     # 0x1c254
leaq 0x148d8(%rip), %rdx     # 0x1c26e
movl $0x113, %ecx            # imm = 0x113
movb $0x0, %al
callq 0x5590
jmp 0x7a4e
movq 0x1c62a(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x8(%rsp), %rsi
callq 0x5300
movq 0x1c616(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x1c(%rsp), %edx
movl $0x1, %esi
callq 0x55c0
movq 0x1c5fe(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x18(%rsp), %edx
xorl %esi, %esi
callq 0x55c0
movq 0x1c5e9(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x14(%rsp), %esi
callq 0x7650
addl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x1c5ce(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x10(%rsp), %esi
addl $0x1, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movq %r9, %r8
callq 0x5710
cmpl $0x0, %eax
je 0x7a3b
movq 0x1c5a7(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5560
jmp 0x7a4e
movq 0x1c596(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0xc(%rsp), %esi
callq 0x50d0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/callbacks.c
// Function: CursorPosCallback
static void CursorPosCallback(GLFWwindow *window, double xpos, double ypos)
    {
    BEGIN(CursorPos);
    lua_pushnumber(L, xpos);
    lua_pushnumber(L, ypos);
    EXEC(2);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movq 0x1c55c(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5080
movl %eax, 0xc(%rsp)
movq 0x1c559(%rip), %rax     # 0x23fe8
movq 0x150(%rax), %rax
movq 0x20(%rsp), %rdi
callq *%rax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %edi
callq 0x5410
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x7ad6
movq 0x1c51c(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movq (%rsp), %rax
movslq 0x68(%rax), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x5280
cmpl $0x6, %eax
je 0x7aff
movq 0x1c4fb(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
leaq 0x1476d(%rip), %rsi     # 0x1c254
leaq 0x14780(%rip), %rdx     # 0x1c26e
movl $0x11f, %ecx            # imm = 0x11F
movb $0x0, %al
callq 0x5590
jmp 0x7b86
movq 0x1c4d2(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x8(%rsp), %rsi
callq 0x5300
movq 0x1c4be(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movsd 0x18(%rsp), %xmm0
callq 0x5440
movq 0x1c4a9(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x5440
movq 0x1c494(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl $0x3, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movq %r9, %r8
callq 0x5710
cmpl $0x0, %eax
je 0x7b73
movq 0x1c46f(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5560
jmp 0x7b86
movq 0x1c45e(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0xc(%rsp), %esi
callq 0x50d0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/callbacks.c
// Function: ScrollCallback
static void ScrollCallback(GLFWwindow *window, double xoffset, double yoffset)
    {
    BEGIN(Scroll);
    lua_pushnumber(L, xoffset);
    lua_pushnumber(L, yoffset);
    EXEC(2);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movq 0x1c31c(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5080
movl %eax, 0xc(%rsp)
movq 0x1c319(%rip), %rax     # 0x23fe8
movq 0x150(%rax), %rax
movq 0x20(%rsp), %rdi
callq *%rax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %edi
callq 0x5410
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x7d16
movq 0x1c2dc(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movq (%rsp), %rax
movslq 0x70(%rax), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x5280
cmpl $0x6, %eax
je 0x7d3f
movq 0x1c2bb(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
leaq 0x1452d(%rip), %rsi     # 0x1c254
leaq 0x14540(%rip), %rdx     # 0x1c26e
movl $0x134, %ecx            # imm = 0x134
movb $0x0, %al
callq 0x5590
jmp 0x7dc6
movq 0x1c292(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x8(%rsp), %rsi
callq 0x5300
movq 0x1c27e(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movsd 0x18(%rsp), %xmm0
callq 0x5440
movq 0x1c269(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x5440
movq 0x1c254(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl $0x3, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movq %r9, %r8
callq 0x5710
cmpl $0x0, %eax
je 0x7db3
movq 0x1c22f(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5560
jmp 0x7dc6
movq 0x1c21e(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0xc(%rsp), %esi
callq 0x50d0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/callbacks.c
// Function: DropCallback
static void DropCallback(GLFWwindow *window, int count, const char** paths)
    {
    int i;
    BEGIN(Drop);
    for(i = 0; i<count; i++)
        lua_pushstring(L, paths[i]);
    EXEC(count);
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x1c1ef(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5080
movl %eax, 0x18(%rsp)
movq 0x1c1ec(%rip), %rax     # 0x23fe8
movq 0x150(%rax), %rax
movq 0x30(%rsp), %rdi
callq *%rax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %edi
callq 0x5410
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x7e46
movq 0x1c1ad(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movslq 0x74(%rax), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x5280
cmpl $0x6, %eax
je 0x7e6f
movq 0x1c18b(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
leaq 0x143fd(%rip), %rsi     # 0x1c254
leaq 0x14410(%rip), %rdx     # 0x1c26e
movl $0x140, %ecx            # imm = 0x140
movb $0x0, %al
callq 0x5590
jmp 0x7f0c
movq 0x1c162(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x14(%rsp), %rsi
callq 0x5300
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x7ebf
movq 0x1c13c(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x5670
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x7e8b
jmp 0x7ec1
movq 0x1c110(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x2c(%rsp), %esi
addl $0x1, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movq %r9, %r8
callq 0x5710
cmpl $0x0, %eax
je 0x7ef9
movq 0x1c0e9(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5560
jmp 0x7f0c
movq 0x1c0d8(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x18(%rsp), %esi
callq 0x50d0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/callbacks.c
// Function: MonitorCallback
static void MonitorCallback(GLFWmonitor *monitor, int event)
    {
    BEGIN(Monitor);
    lua_pushinteger(L, MonitorId(monitor));
    lua_pushstring(L, event==GLFW_CONNECTED ? "connected" : "disconnected");
    EXEC(2);
    /* always call the default callback: */
    monitorCallback(monitor, event);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x1c0a4(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5080
movl %eax, 0x8(%rsp)
movq 0x1c091(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x1c463(%rip), %rdx     # 0x243b4
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x5280
cmpl $0x6, %eax
je 0x7f89
movq 0x1c071(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
leaq 0x142e3(%rip), %rsi     # 0x1c254
leaq 0x142f6(%rip), %rdx     # 0x1c26e
movl $0x55, %ecx
movb $0x0, %al
callq 0x5590
jmp 0x8031
jmp 0x7f8b
movq 0x1c046(%rip), %rax     # 0x23fd8
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x8040
movq (%rsp), %rdi
movslq %eax, %rsi
callq 0x5300
movq 0x1c022(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0xc(%rsp), %ecx
leaq 0x14318(%rip), %rsi     # 0x1c2dc
leaq 0x14314(%rip), %rax     # 0x1c2df
cmpl $0x40001, %ecx          # imm = 0x40001
cmoveq %rax, %rsi
callq 0x5670
movq 0x1bff7(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl $0x2, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movq %r9, %r8
callq 0x5710
cmpl $0x0, %eax
je 0x8010
movq 0x1bfd2(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5560
jmp 0x8031
movq 0x1bfc1(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x8(%rsp), %esi
callq 0x50d0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x5750
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/callbacks.c
// Function: MonitorId
static int MonitorId(GLFWmonitor *monitor)
    {
    mon_t *mon = mon_first(0);
    while(mon)
        {
        if(mon->monitor == monitor)
            return mon->id;
        mon = mon_next(mon);
        }
    return -1; /* should not happen */
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
xorl %edi, %edi
callq 0x5170
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x8086
movq (%rsp), %rax
movq 0x28(%rax), %rax
cmpq 0x8(%rsp), %rax
jne 0x8077
movq (%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x808e
movq (%rsp), %rdi
callq 0x51b0
movq %rax, (%rsp)
jmp 0x8054
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/callbacks.c
// Function: JoystickCallback
static void JoystickCallback(int jid, int event)
    {
    BEGIN(Joystick);
    PushJoystick(L, jid);
    lua_pushstring(L, event==GLFW_CONNECTED ? "connected" : "disconnected");
    EXEC(2);
   /* always call the default callback: */
    joystickCallback(jid, event);
    }

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movq 0x1bf15(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5080
movl %eax, 0xc(%rsp)
movq 0x1bf02(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x1c2d8(%rip), %rdx     # 0x243b8
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x5280
cmpl $0x6, %eax
je 0x8118
movq 0x1bee2(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
leaq 0x14154(%rip), %rsi     # 0x1c254
leaq 0x14167(%rip), %rdx     # 0x1c26e
movl $0x69, %ecx
movb $0x0, %al
callq 0x5590
jmp 0x81b4
jmp 0x811a
movq 0x1beb7(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x14(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x5300
movq 0x1be9e(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x10(%rsp), %ecx
leaq 0x14194(%rip), %rsi     # 0x1c2dc
leaq 0x14190(%rip), %rax     # 0x1c2df
cmpl $0x40001, %ecx          # imm = 0x40001
cmoveq %rax, %rsi
callq 0x5670
movq 0x1be73(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl $0x2, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movq %r9, %r8
callq 0x5710
cmpl $0x0, %eax
je 0x8194
movq 0x1be4e(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5560
jmp 0x81b4
movq 0x1be3d(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0xc(%rsp), %esi
callq 0x50d0
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
callq 0x80a0
addq $0x18, %rsp
retq
nopl (%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/cur.c
// Function: moonglfw_cur_new
cur_t *cur_new(void)
    {
    cur_t *cur;
    int id = id_new();
    if(id == -1)
        return NULL;
    if((cur = (cur_t*)malloc(sizeof(cur_t))) == NULL) 
        { id_free(id); return NULL; }
    memset(cur, 0, sizeof(cur_t));
    cur->id = id;
    if(cur_search(cur->id))
        { free(cur); id_free(id); return NULL; }
    //cur->Zzz = LUA_NOREF;
    cur_insert(cur);
    return cur;
    }

// Assembly:
subq $0x18, %rsp
callq 0x5510
movl %eax, 0x4(%rsp)
cmpl $-0x1, 0x4(%rsp)
jne 0x85a2
movq $0x0, 0x10(%rsp)
jmp 0x862d
movl $0x30, %edi
callq 0x5490
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x85cb
movl 0x4(%rsp), %edi
callq 0x55a0
movq $0x0, 0x10(%rsp)
jmp 0x862d
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x52f0
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x8(%rsp), %rax
movl 0x20(%rax), %edi
callq 0x5150
cmpq $0x0, %rax
je 0x8619
movq 0x8(%rsp), %rdi
callq 0x50b0
movl 0x4(%rsp), %edi
callq 0x55a0
movq $0x0, 0x10(%rsp)
jmp 0x862d
movq 0x8(%rsp), %rdi
callq 0x8640
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/cur.c
// Function: moonglfw_cur_free
void cur_free(cur_t* cur)
    {
    if(cur_search(cur->id) == cur)
        {
        /* release callback references */
        //CALLBACK_UNREF(cur->Zzz);
        cur_remove(cur);
        }
    id_free(cur->id);
    free(cur);
    }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl 0x20(%rax), %edi
callq 0x5150
cmpq (%rsp), %rax
jne 0x8680
movq (%rsp), %rdi
callq 0x86a0
movq (%rsp), %rax
movl 0x20(%rax), %edi
callq 0x55a0
movq (%rsp), %rdi
callq 0x50b0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/cur.c
// Function: moonglfw_cur_check
cur_t* cur_check(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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x53c0
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %edi
callq 0x5150
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x8726
movq 0x10(%rsp), %rdi
leaq 0x13c79(%rip), %rsi     # 0x1c398
movb $0x0, %al
callq 0x5590
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/enums.c
// Function: moonglfw_enums_test
int enums_test(lua_State *L, int domain, int arg, int *err)
    {
    rec_t *rec;
    const char *s = luaL_optstring(L, arg, NULL);

    if(!s)
        { *err = ERR_NOTPRESENT; return 0; }

    rec = str_search(domain, s);
    if(!rec)
        { *err = ERR_VALUE; return 0; }
    
    *err = ERR_SUCCESS;
    return rec->code;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x5250
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x995d
movq 0x18(%rsp), %rax
movl $0x1, (%rax)
movl $0x0, 0x34(%rsp)
jmp 0x99a4
movl 0x24(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x99b0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x998d
movq 0x18(%rsp), %rax
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
movl $0x0, 0x34(%rsp)
jmp 0x99a4
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x10(%rsp), %rax
movl 0x44(%rax), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/enums.c
// Function: moonglfw_enums_check
int enums_check(lua_State *L, int domain, int arg)
    {
    rec_t *rec;
    const char *s = luaL_checkstring(L, arg);

    rec = str_search(domain, s);
    if(!rec)
        return luaL_argerror(L, arg, badvalue(L, s));
    
    return rec->code;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x5330
movq %rax, 0x10(%rsp)
movl 0x24(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x99b0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x9a72
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x12955(%rip), %rsi     # 0x1c3aa
movb $0x0, %al
callq 0x5360
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movq %rax, %rdx
callq 0x5140
movl %eax, 0x34(%rsp)
jmp 0x9a7e
movq 0x18(%rsp), %rax
movl 0x44(%rax), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/enums.c
// Function: moonglfw_enums_push
int enums_push(lua_State *L, int domain, int code)
    {
    rec_t *rec = code_search(domain, code);

    if(!rec)
        return unexpected(L);

    lua_pushstring(L, rec->str);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
callq 0x9b10
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x9ae0
movq 0x18(%rsp), %rdi
leaq 0x1278d(%rip), %rsi     # 0x1c254
leaq 0x128ef(%rip), %rdx     # 0x1c3bd
movl $0xc9, %ecx
movb $0x0, %al
callq 0x5590
movl %eax, 0x24(%rsp)
jmp 0x9afb
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rsi
callq 0x5670
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/enums.c
// Function: moonglfw_enums_checklist
int* enums_checklist(lua_State *L, int domain, int arg, int *count, int *err)
    {
    int* list;
    int i;

    *count = 0;
    *err = 0;
    if(lua_isnoneornil(L, arg))
        { *err = ERR_NOTPRESENT; return NULL; }
    if(lua_type(L, arg) != LUA_TTABLE)
        { *err = ERR_TABLE; return NULL; }

    *count = luaL_len(L, arg);
    if(*count == 0)
        { *err = ERR_NOTPRESENT; return NULL; }

    list = (int*)MallocNoErr(L, sizeof(int) * (*count));
    if(!list)
        { *count = 0; *err = ERR_MEMORY; return NULL; }

    for(i=0; i<*count; i++)
        {
        lua_rawgeti(L, arg, i+1);
        list[i] = enums_test(L, domain, -1, err);
        lua_pop(L, 1);
        if(*err)
            { Free(L, list); *count = 0; return NULL; }
        }
    return list;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x5610
cmpl $0x0, %eax
jg 0x9c3d
movq 0x10(%rsp), %rax
movl $0x1, (%rax)
movq $0x0, 0x30(%rsp)
jmp 0x9d9c
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x5610
cmpl $0x5, %eax
je 0x9c69
movq 0x10(%rsp), %rax
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movq $0x0, 0x30(%rsp)
jmp 0x9d9c
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x5630
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x9ca3
movq 0x10(%rsp), %rax
movl $0x1, (%rax)
movq $0x0, 0x30(%rsp)
jmp 0x9d9c
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movslq (%rax), %rsi
shlq $0x2, %rsi
callq 0x5030
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x9cea
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x10(%rsp), %rax
movl $0xfffffffa, (%rax)     # imm = 0xFFFFFFFA
movq $0x0, 0x30(%rsp)
jmp 0x9d9c
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x9d92
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
movl 0x4(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x5280
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x10(%rsp), %rcx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5520
movl %eax, %edx
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x50d0
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
je 0x9d80
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x52e0
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq $0x0, 0x30(%rsp)
jmp 0x9d9c
jmp 0x9d82
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x9cf2
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/hint.c
// Function: VersionHint
static int VersionHint(lua_State *L) /* NONGLFW */
    {
    int major = luaL_checkinteger(L, 1);
    int minor = luaL_checkinteger(L, 2);
    int profile = checkprofile(L, 3);
    glfw.WindowHint(GLFW_CONTEXT_VERSION_MAJOR, major);
    glfw.WindowHint(GLFW_CONTEXT_VERSION_MINOR, minor);
    glfw.WindowHint(GLFW_OPENGL_PROFILE, profile);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x53c0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x53c0
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x7, %esi
movl $0x3, %edx
callq 0x5430
movl %eax, 0x4(%rsp)
movq 0x134ca(%rip), %rax     # 0x23fe8
movq 0x88(%rax), %rax
movl 0xc(%rsp), %esi
movl $0x22002, %edi          # imm = 0x22002
callq *%rax
movq 0x134b1(%rip), %rax     # 0x23fe8
movq 0x88(%rax), %rax
movl 0x8(%rsp), %esi
movl $0x22003, %edi          # imm = 0x22003
callq *%rax
movq 0x13498(%rip), %rax     # 0x23fe8
movq 0x88(%rax), %rax
movl 0x4(%rsp), %esi
movl $0x22008, %edi          # imm = 0x22008
callq *%rax
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/hint.c
// Function: SetWindowAttrib
static int SetWindowAttrib(lua_State *L)
    {
    win_t *win = checkwindow(L, 1);
    int attrib = checktarget(L, 2);
    switch(attrib)
        {
        case GLFW_RESIZABLE:
        case GLFW_DECORATED:
        case GLFW_FLOATING:
        case GLFW_AUTO_ICONIFY:
        case GLFW_FOCUS_ON_SHOW:
        case GLFW_MOUSE_PASSTHROUGH:
            return SetBoolean(L, win->window, attrib);
        default:
            return luaL_error(L, "invalid attribute '%s'", lua_tostring(L, 2));
        }
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x5550
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x3, %esi
movl $0x2, %edx
callq 0x5430
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
subl $0x20003, %eax          # imm = 0x20003
je 0x10ee6
jmp 0x10ec6
movl 0x8(%rsp), %eax
addl $0xfffdfffb, %eax       # imm = 0xFFFDFFFB
subl $0x3, %eax
jb 0x10ee6
jmp 0x10ed6
movl 0x8(%rsp), %eax
addl $0xfffdfff4, %eax       # imm = 0xFFFDFFF4
subl $0x1, %eax
ja 0x10f03
jmp 0x10ee6
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rsi
movl 0xc(%rsp), %edx
callq 0x11270
movl %eax, 0x24(%rsp)
jmp 0x10f38
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x51d0
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0xccc4(%rip), %rsi      # 0x1dbf1
movb $0x0, %al
callq 0x5590
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/hint.c
// Function: Integer
static int Integer(lua_State *L, int target)
    {
    int hint = GLFW_DONT_CARE;
    const char *s;
    if(lua_type(L, 2) == LUA_TSTRING)
        {
        s = lua_tostring(L, 2);
        if(strncmp(s, "don't care", strlen(s)) != 0)
            return luaL_argerror(L, 2, "expected integer or \"don't care\"");
        }
    else
        {
        hint = luaL_checkinteger(L, 2);
#if 0
        if(hint < -1)
            return luaL_argerror(L, 2, "invalid value");
#endif
        }
    glfw.WindowHint( target, hint);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x5610
cmpl $0x4, %eax
jne 0x1102a
movq 0x18(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x51d0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x5210
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0xcb4b(%rip), %rsi      # 0x1db4d
callq 0x50e0
cmpl $0x0, %eax
je 0x11028
movq 0x18(%rsp), %rdi
movl $0x2, %esi
leaq 0xcb3b(%rip), %rdx      # 0x1db58
callq 0x5140
movl %eax, 0x24(%rsp)
jmp 0x1105d
jmp 0x1103d
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x53c0
movl %eax, 0x10(%rsp)
movq 0x12fa4(%rip), %rax     # 0x23fe8
movq 0x88(%rax), %rax
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/hint.c
// Function: Position
static int Position(lua_State *L, int target)
    {
    int hint = GLFW_ANY_POSITION;
    const char *s;
    if(lua_type(L, 2) == LUA_TSTRING)
        {
        s = lua_tostring(L, 2);
        if(strncmp(s, "any", strlen(s)) != 0)
            return luaL_argerror(L, 2, "expected integer or \"any\"");
        }
    else
        hint = luaL_checkinteger(L, 2);
    glfw.WindowHint( target, hint);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl $0x80000000, 0x10(%rsp) # imm = 0x80000000
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x5610
cmpl $0x4, %eax
jne 0x110fa
movq 0x18(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x51d0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x5210
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0xb85a(%rip), %rsi      # 0x1c92c
callq 0x50e0
cmpl $0x0, %eax
je 0x110f8
movq 0x18(%rsp), %rdi
movl $0x2, %esi
leaq 0xca8c(%rip), %rdx      # 0x1db79
callq 0x5140
movl %eax, 0x24(%rsp)
jmp 0x1112d
jmp 0x1110d
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x53c0
movl %eax, 0x10(%rsp)
movq 0x12ed4(%rip), %rax     # 0x23fe8
movq 0x88(%rax), %rax
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/hint.c
// Function: String
static int String(lua_State *L, int target)
    {
    const char* hint = luaL_checkstring(L, 2);
    CheckPfn(L, WindowHintString, 3, 3, 0);
    glfw.WindowHintString(target, hint);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x5330
movq %rax, 0x8(%rsp)
movq 0x12e7c(%rip), %rax     # 0x23fe8
cmpq $0x0, 0x2f8(%rax)
jne 0x111c5
movl $0x3, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x5680
cmpl $0x0, %eax
jne 0x111ac
movq 0x18(%rsp), %rdi
leaq 0xc9fe(%rip), %rsi      # 0x1db93
movl $0x3, %ecx
xorl %r8d, %r8d
movl %ecx, %edx
movb $0x0, %al
callq 0x5590
movl %eax, 0x24(%rsp)
jmp 0x111e8
movq 0x18(%rsp), %rdi
leaq 0xca12(%rip), %rsi      # 0x1dbca
movb $0x0, %al
callq 0x5590
movl %eax, 0x24(%rsp)
jmp 0x111e8
jmp 0x111c7
movq 0x12e1a(%rip), %rax     # 0x23fe8
movq 0x2f8(%rax), %rax
movl 0x14(%rsp), %edi
movq 0x8(%rsp), %rsi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/hint.c
// Function: SetBoolean
static int SetBoolean(lua_State *L, GLFWwindow* window, int attrib)
    {
    int value = checkboolean(L, 3);
    CheckPfn(L, SetWindowAttrib, 3, 3, 0);
    glfw.SetWindowAttrib(window, attrib, value);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl $0x3, %esi
callq 0x5070
movzbl %al, %eax
movl %eax, 0x8(%rsp)
movq 0x12d49(%rip), %rax     # 0x23fe8
cmpq $0x0, 0x320(%rax)
jne 0x112f8
movl $0x3, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x5680
cmpl $0x0, %eax
jne 0x112df
movq 0x18(%rsp), %rdi
leaq 0xc940(%rip), %rsi      # 0x1dc08
movl $0x3, %ecx
xorl %r8d, %r8d
movl %ecx, %edx
movb $0x0, %al
callq 0x5590
movl %eax, 0x24(%rsp)
jmp 0x1131f
movq 0x18(%rsp), %rdi
leaq 0xc953(%rip), %rsi      # 0x1dc3e
movb $0x0, %al
callq 0x5590
movl %eax, 0x24(%rsp)
jmp 0x1131f
jmp 0x112fa
movq 0x12ce7(%rip), %rax     # 0x23fe8
movq 0x320(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/id.c
// Function: moonglfw_id_new
int id_new(void)
    {
    id_t *id;
    int key =  key_new(); /* allocate a free key */
    if(key == -1)
        return -1;
    if((id = (id_t*)malloc(sizeof(id_t))) == NULL) return -1;
    id->key = key;
    id_insert(id);
    return id->key;
    }

// Assembly:
subq $0x18, %rsp
callq 0x113a0
movl %eax, 0x4(%rsp)
cmpl $-0x1, 0x4(%rsp)
jne 0x1134e
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x1138f
movl $0x28, %edi
callq 0x5490
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x1136d
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x1138f
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x8(%rsp), %rdi
callq 0x11450
movq 0x8(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/id.c
// Function: key_new
static int key_new(void)
/* returns a free key or -1 if none are found (unlikely) */
    {
    static int keyfree = 0;
    int guard = keyfree-1;
    if((keyfree==-1)||(keyfree==0)||(keyfree==1))
        { keyfree=1; guard=-1; }
    while(1)
        {
        if(keyfree==guard) /* we made a complete round */
            return -1;
        if(keyfree==-1) keyfree=1;
        if(id_search(keyfree)==NULL) return keyfree++;
        keyfree++;
        }
    return -1;
    }

// Assembly:
pushq %rax
movl 0x134d1(%rip), %eax     # 0x24878
subl $0x1, %eax
movl %eax, (%rsp)
cmpl $-0x1, 0x134c4(%rip)    # 0x24878
je 0x113c8
cmpl $0x0, 0x134bb(%rip)     # 0x24878
je 0x113c8
cmpl $0x1, 0x134b2(%rip)     # 0x24878
jne 0x113d9
movl $0x1, 0x134a6(%rip)     # 0x24878
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
jmp 0x113db
movl 0x13497(%rip), %eax     # 0x24878
cmpl (%rsp), %eax
jne 0x113f0
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x1143c
cmpl $-0x1, 0x13481(%rip)    # 0x24878
jne 0x11403
movl $0x1, 0x13475(%rip)     # 0x24878
movl 0x1346f(%rip), %edi     # 0x24878
callq 0x114b0
cmpq $0x0, %rax
jne 0x1142b
movl 0x1345e(%rip), %eax     # 0x24878
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x13453(%rip)     # 0x24878
movl %eax, 0x4(%rsp)
jmp 0x1143c
movl 0x13447(%rip), %eax     # 0x24878
addl $0x1, %eax
movl %eax, 0x1343e(%rip)     # 0x24878
jmp 0x113db
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/id.c
// Function: moonglfw_id_free
void id_free(int key)
    {
    id_t* id = id_search(key);
    if(id)
        {
        id_remove(id);
        free(id);
        }
    }

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl 0x14(%rsp), %edi
callq 0x114b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x114a2
movq 0x8(%rsp), %rdi
callq 0x114e0
movq 0x8(%rsp), %rdi
callq 0x50b0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/id.c
// Function: moonglfw_id_free_all
void id_free_all(void)
    {
    id_t *id;
    while((id = id_first(0)))
        {
        id_remove(id);
        free(id);
        }
    }

// Assembly:
pushq %rax
xorl %edi, %edi
callq 0x11530
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x11526
movq (%rsp), %rdi
callq 0x114e0
movq (%rsp), %rdi
callq 0x50b0
jmp 0x11501
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/input.c
// Function: GetInputMode
static int GetInputMode(lua_State *L)
    {
    int val;
    win_t *win = checkwindow(L, 1);
    int mode = checkinputmode(L, 2);
    val = glfw.GetInputMode(win->window,mode);
    switch(mode)
        {
        case GLFW_CURSOR:   pushcursormode(L, val); return 1;
        case GLFW_STICKY_KEYS:
        case GLFW_STICKY_MOUSE_BUTTONS:
        case GLFW_LOCK_KEY_MODS:
        case GLFW_RAW_MOUSE_MOTION:
                            lua_pushboolean(L, val); return 1;
        default:
            return unexpected(L);
        }
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x5550
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x8, %esi
movl $0x2, %edx
callq 0x5430
movl %eax, 0x4(%rsp)
movq 0x117ec(%rip), %rax     # 0x23fe8
movq 0x1b0(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x28(%rcx), %rdi
movl 0x4(%rsp), %esi
callq *%rax
movl %eax, 0x14(%rsp)
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
subl $0x33001, %eax          # imm = 0x33001
je 0x12835
jmp 0x12826
movl (%rsp), %eax
addl $0xfffccffe, %eax       # imm = 0xFFFCCFFE
subl $0x4, %eax
jb 0x12852
jmp 0x1286a
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %edx
movl $0x9, %esi
callq 0x55c0
movl $0x1, 0x24(%rsp)
jmp 0x1288d
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x5460
movl $0x1, 0x24(%rsp)
jmp 0x1288d
movq 0x18(%rsp), %rdi
leaq 0x99de(%rip), %rsi      # 0x1c254
leaq 0xb60f(%rip), %rdx      # 0x1de8c
movl $0x2f, %ecx
movb $0x0, %al
callq 0x5590
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/input.c
// Function: SetInputMode
static int SetInputMode(lua_State *L)
    {
    int value;
    win_t *win = checkwindow(L, 1);
    int mode = checkinputmode(L, 2);
    switch(mode)
        {
        case GLFW_CURSOR:   value = checkcursormode(L, 3); break;
        case GLFW_STICKY_KEYS:
        case GLFW_STICKY_MOUSE_BUTTONS:
        case GLFW_LOCK_KEY_MODS:
        case GLFW_RAW_MOUSE_MOTION:
                            value = checkboolean(L, 3); break;
        default:
            return unexpected(L);
        }
    glfw.SetInputMode(win->window, mode, value);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x5550
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x8, %esi
movl $0x2, %edx
callq 0x5430
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
subl $0x33001, %eax          # imm = 0x33001
je 0x128f4
jmp 0x128e5
movl (%rsp), %eax
addl $0xfffccffe, %eax       # imm = 0xFFFCCFFE
subl $0x4, %eax
jb 0x1290e
jmp 0x12926
movq 0x18(%rsp), %rdi
movl $0x9, %esi
movl $0x3, %edx
callq 0x5430
movl %eax, 0x14(%rsp)
jmp 0x1294b
movq 0x18(%rsp), %rdi
movl $0x3, %esi
callq 0x5070
movzbl %al, %eax
movl %eax, 0x14(%rsp)
jmp 0x1294b
movq 0x18(%rsp), %rdi
leaq 0x9922(%rip), %rsi      # 0x1c254
leaq 0xb553(%rip), %rdx      # 0x1de8c
movl $0x42, %ecx
movb $0x0, %al
callq 0x5590
movl %eax, 0x24(%rsp)
jmp 0x12974
movq 0x11696(%rip), %rax     # 0x23fe8
movq 0x1b8(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x28(%rcx), %rdi
movl 0x4(%rsp), %esi
movl 0x14(%rsp), %edx
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/input.c
// Function: GetKey
static int GetKey(lua_State *L)
    {
    win_t *win = checkwindow(L, 1);
    int key = checkkey(L, 2);
    int state = glfw.GetKey(win->window, key);
    lua_pushstring(L, state==GLFW_PRESS ? "press" : "release");
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x5550
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %edx
movl %edx, %esi
callq 0x5430
movl %eax, 0x4(%rsp)
movq 0x1158f(%rip), %rax     # 0x23fe8
movq 0x1c8(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x28(%rcx), %rdi
movl 0x4(%rsp), %esi
callq *%rax
movl %eax, (%rsp)
movq 0x10(%rsp), %rdi
movl (%rsp), %ecx
leaq 0x9951(%rip), %rsi      # 0x1c3d2
leaq 0x993d(%rip), %rax      # 0x1c3c5
cmpl $0x1, %ecx
cmoveq %rax, %rsi
callq 0x5670
movl $0x1, %eax
addq $0x18, %rsp
retq
nop