LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/pipeline.c
// Function: GetProgramPipelineInfoLog
static int GetProgramPipelineInfoLog(lua_State *L)
    {
    char *buf;
    GLint bufsz;
    GLuint name = luaL_checkinteger(L, 1);

    glGetProgramPipelineiv(name, GL_INFO_LOG_LENGTH, &bufsz);
    CheckError(L);
    if(bufsz==0) return 0;
    buf = (char*)Malloc(L, bufsz * sizeof(char));
    glGetProgramPipelineInfoLog(name, bufsz, NULL, buf);
    CheckErrorFree(L, buf);
    lua_pushstring(L, buf);
    Free(L, buf);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0x8(%rsp)
movq 0x292d5(%rip), %rax     # 0x671e8
movq (%rax), %rax
movl 0x8(%rsp), %edi
movl $0x8b84, %esi           # imm = 0x8B84
leaq 0xc(%rsp), %rdx
callq *%rax
movq 0x18(%rsp), %rdi
callq 0x11880
cmpl $0x0, 0xc(%rsp)
jne 0x3df41
movl $0x0, 0x24(%rsp)
jmp 0x3dfa9
movq 0x18(%rsp), %rdi
movslq 0xc(%rsp), %rsi
shlq $0x0, %rsi
callq 0x11200
movq %rax, 0x10(%rsp)
movq 0x29528(%rip), %rax     # 0x67488
movq (%rax), %rax
movl 0x8(%rsp), %edi
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rcx
xorl %edx, %edx
callq *%rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11550
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x110c0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11370
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]moongl/src/pipeline.c
// Function: GetInteger
static int GetInteger(lua_State *L, GLuint pipeline, GLenum pname)
    {
    GLint params; 
    glGetProgramPipelineiv(pipeline, pname, &params);
    CheckError(L);
    lua_pushinteger(L, params); 
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x29210(%rip), %rax     # 0x671e8
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
leaq 0x4(%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movslq 0x4(%rsp), %rsi
callq 0x113c0
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/pixel.c
// Function: ReadBuffer
static int ReadBuffer(lua_State *L)
/* read_buffer(src)
 * read_buffer(framebuffer, src)
 */
    {
    GLuint framebuffer;
    GLenum src;
    if(lua_isstring(L, 1))
        {
        src = checkbuffer(L, 1);
        glReadBuffer(src);
        }
    else
        {
        framebuffer = luaL_checkinteger(L, 1);
        src = checkbuffer(L, 2);
        glNamedFramebufferReadBuffer(framebuffer, src);
        }
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x110b0
cmpl $0x0, %eax
je 0x3e070
movq 0x10(%rsp), %rdi
movl $0x4f, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %edi
callq 0x11220
jmp 0x3e0af
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x4f, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x8(%rsp)
movq 0x293be(%rip), %rax     # 0x67460
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/pixel.c
// Function: ReadPixels
static int ReadPixels(lua_State *L)
    {
    GLint x = luaL_checkinteger(L, 1);
    GLint y = luaL_checkinteger(L, 2);
    GLsizei width = luaL_checkinteger(L, 3);
    GLsizei height = luaL_checkinteger(L, 4);
    GLenum format = checkformat(L, 5);
    GLenum type = checktype(L, 6);
    GLsizei bufsz = width*height*sizeoftype(L, type);
    void *data = Malloc(L, bufsz);
#if 0 /* #ifdef GL_VERSION_4_5 */
    glReadnPixels(x, y, width, height, format, type, bufsz, data);
#else
    glReadPixels(x, y, width, height, format, type, data);
#endif
    CheckErrorFree(L, data);
    lua_pushlstring(L, (char*)data, bufsz);
    Free(L, data);
    return 1;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0x3c(%rsp)
movq 0x40(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x34(%rsp)
movq 0x40(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movl %eax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movl $0x12, %esi
movl $0x5, %edx
callq 0x11160
movl %eax, 0x2c(%rsp)
movq 0x40(%rsp), %rdi
movl $0x7, %esi
movl $0x6, %edx
callq 0x11160
movl %eax, 0x28(%rsp)
movl 0x34(%rsp), %eax
imull 0x30(%rsp), %eax
cltq
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x11600
movq %rax, %rcx
movq 0x10(%rsp), %rax
imulq %rcx, %rax
movl %eax, 0x24(%rsp)
movq 0x40(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x11200
movq %rax, 0x18(%rsp)
movl 0x3c(%rsp), %edi
movl 0x38(%rsp), %esi
movl 0x34(%rsp), %edx
movl 0x30(%rsp), %ecx
movl 0x2c(%rsp), %r8d
movl 0x28(%rsp), %r9d
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
callq 0x113e0
movq 0x40(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11550
movq 0x40(%rsp), %rdi
movq 0x18(%rsp), %rsi
movslq 0x24(%rsp), %rdx
callq 0x11ab0
movq 0x40(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11370
movl $0x1, %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/pixel.c
// Function: ClampColor
static int ClampColor(lua_State *L)
    {
    GLenum clamp;
    GLenum target = checkclamptarget(L, 1);
    if(lua_isboolean(L, 2))
        clamp = lua_toboolean(L, 2) ? GL_TRUE : GL_FALSE;
    else
        clamp = checkclamp(L, 2);
    glClampColor(target, clamp);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x30, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11860
cmpl $0x1, %eax
jne 0x3e249
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11710
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0xc(%rsp)
jmp 0x3e261
movq 0x10(%rsp), %rdi
movl $0x31, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movq 0x29920(%rip), %rax     # 0x67b88
movq (%rax), %rax
movl 0x8(%rsp), %edi
movl 0xc(%rsp), %esi
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/pixel.c
// Function: PixelStore
static int PixelStore(lua_State *L)
    {
    GLenum pname = checkpixelstorepname(L, 1);
    switch(pname)
        {
        case GL_UNPACK_SWAP_BYTES: 
        case GL_UNPACK_LSB_FIRST: return StoreBoolean(L, pname, 2);
        case GL_UNPACK_ROW_LENGTH: 
        case GL_UNPACK_SKIP_ROWS: 
        case GL_UNPACK_SKIP_PIXELS: 
        case GL_UNPACK_ALIGNMENT:
        case GL_UNPACK_IMAGE_HEIGHT:
        case GL_UNPACK_SKIP_IMAGES: 
        case GL_UNPACK_COMPRESSED_BLOCK_WIDTH: 
        case GL_UNPACK_COMPRESSED_BLOCK_HEIGHT: 
        case GL_UNPACK_COMPRESSED_BLOCK_DEPTH: 
        case GL_UNPACK_COMPRESSED_BLOCK_SIZE: return StoreInt(L, pname, 2);
        case GL_PACK_SWAP_BYTES: 
        case GL_PACK_LSB_FIRST: return StoreBoolean(L, pname, 2);
        case GL_PACK_ROW_LENGTH: 
        case GL_PACK_SKIP_ROWS: 
        case GL_PACK_SKIP_PIXELS: 
        case GL_PACK_ALIGNMENT:
        case GL_PACK_IMAGE_HEIGHT: 
        case GL_PACK_SKIP_IMAGES: 
        case GL_PACK_COMPRESSED_BLOCK_WIDTH: 
        case GL_PACK_COMPRESSED_BLOCK_HEIGHT: 
        case GL_PACK_COMPRESSED_BLOCK_DEPTH: 
        case GL_PACK_COMPRESSED_BLOCK_SIZE:     return StoreInt(L, pname, 2);
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
        }
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x33, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
addl $0xfffff310, %eax       # imm = 0xFFFFF310
subl $0x2, %eax
jb 0x3e8dd
jmp 0x3e864
movl (%rsp), %eax
addl $0xfffff30e, %eax       # imm = 0xFFFFF30E
subl $0x4, %eax
jb 0x3e8fb
jmp 0x3e877
movl (%rsp), %eax
addl $0xfffff300, %eax       # imm = 0xFFFFF300
subl $0x2, %eax
jb 0x3e916
jmp 0x3e88a
movl (%rsp), %eax
addl $0xfffff2fe, %eax       # imm = 0xFFFFF2FE
subl $0x4, %eax
jb 0x3e934
jmp 0x3e89d
movl (%rsp), %eax
addl $0xffff7f95, %eax       # imm = 0xFFFF7F95
subl $0x2, %eax
jb 0x3e934
jmp 0x3e8b0
movl (%rsp), %eax
addl $0xffff7f93, %eax       # imm = 0xFFFF7F93
subl $0x2, %eax
jb 0x3e8fb
jmp 0x3e8bf
movl (%rsp), %eax
addl $0xffff6ed9, %eax       # imm = 0xFFFF6ED9
subl $0x4, %eax
jb 0x3e8fb
jmp 0x3e8ce
movl (%rsp), %eax
addl $0xffff6ed5, %eax       # imm = 0xFFFF6ED5
subl $0x4, %eax
jb 0x3e934
jmp 0x3e94f
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movl $0x2, %edx
movl $0x1, %ecx
callq 0x3e980
movl %eax, 0x14(%rsp)
jmp 0x3e972
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x3e980
movl %eax, 0x14(%rsp)
jmp 0x3e972
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movl $0x2, %edx
movl $0x1, %ecx
callq 0x3e980
movl %eax, 0x14(%rsp)
jmp 0x3e972
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x3e980
movl %eax, 0x14(%rsp)
jmp 0x3e972
movq 0x8(%rsp), %rdi
leaq 0x1392a(%rip), %rsi     # 0x52285
leaq 0x1e88d(%rip), %rdx     # 0x5d1ef
movl $0xc3, %ecx
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/pixel.c
// Function: Storei_
static int Storei_(lua_State *L, GLenum pname, int arg, int boolean)
    {
    GLint param;
    if(boolean)
        param = checkboolean(L, arg);
    else
        param = luaL_checkinteger(L, arg);
    glPixelStorei(pname, param);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x3e9b2
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x11510
movzbl %al, %eax
movl %eax, (%rsp)
jmp 0x3e9c3
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x11af0
movl %eax, (%rsp)
movl 0xc(%rsp), %edi
movl (%rsp), %esi
callq 0x116d0
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/proginterface.c
// Function: GetProgramInterface
static int GetProgramInterface(lua_State *L)
    {
    GLuint prog = luaL_checkinteger(L, 1);
    GLenum itf = checkinterface(L, 2);
    GLenum pname = checkinterfacepname(L, 3);
    switch(pname)
        {
        case GL_ACTIVE_RESOURCES: return GetInt(L, prog, itf, pname);
        case GL_MAX_NAME_LENGTH: return GetInt(L, prog, itf, pname);
        case GL_MAX_NUM_ACTIVE_VARIABLES: return GetInt(L, prog, itf, pname);
        case GL_MAX_NUM_COMPATIBLE_SUBROUTINES: return GetInt(L, prog, itf, pname);
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
        }
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0x40, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x41, %esi
movl $0x3, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addl $0xffff6d0b, %eax       # imm = 0xFFFF6D0B
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x3, %eax
ja 0x3eae8
movq (%rsp), %rax
leaq 0x1e789(%rip), %rcx     # 0x5d1f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x3f2b0
movl %eax, 0x24(%rsp)
jmp 0x3eb0b
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x3f2b0
movl %eax, 0x24(%rsp)
jmp 0x3eb0b
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x3f2b0
movl %eax, 0x24(%rsp)
jmp 0x3eb0b
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x3f2b0
movl %eax, 0x24(%rsp)
jmp 0x3eb0b
movq 0x18(%rsp), %rdi
leaq 0x13791(%rip), %rsi     # 0x52285
leaq 0x1e947(%rip), %rdx     # 0x5d442
movl $0x3f, %ecx
movb $0x0, %al
callq 0x11ae0
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]moongl/src/proginterface.c
// Function: GetProgramResourceIndex
static int GetProgramResourceIndex(lua_State *L)
    {
    GLuint prog = luaL_checkinteger(L, 1);
    GLenum itf = checkinterface(L, 2);
    const char *name = luaL_checkstring(L, 3);
    GLuint index = glGetProgramResourceIndex(prog, itf, name);
    CheckError(L);
    if(index == GL_INVALID_INDEX)
        { lua_pushfstring(L, "invalid name '%s'", name); return lua_error(L); }
    lua_pushinteger(L, index);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0x40, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x11450
movq %rax, 0x8(%rsp)
movq 0x28cdd(%rip), %rax     # 0x67850
movq (%rax), %rax
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
movq 0x8(%rsp), %rdx
callq *%rax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
callq 0x11880
cmpl $-0x1, 0x4(%rsp)
jne 0x3ebc2
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x1dfe4(%rip), %rsi     # 0x5cb8f
movb $0x0, %al
callq 0x11170
movq 0x18(%rsp), %rdi
callq 0x11640
movl %eax, 0x24(%rsp)
jmp 0x3ebda
movq 0x18(%rsp), %rdi
movl 0x4(%rsp), %eax
movl %eax, %esi
callq 0x113c0
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]moongl/src/proginterface.c
// Function: GetProgramResourceName
static int GetProgramResourceName(lua_State *L)
    {
    GLsizei length;
    char *name;
    GLuint prog = luaL_checkinteger(L, 1);
    GLenum itf = checkinterface(L, 2);
    GLuint index = luaL_checkinteger(L, 3);
    GLsizei bufsz = GetMaxNameLength(L, prog, itf);
    name = (char*)Malloc(L, bufsz*sizeof(char));
    glGetProgramResourceName(prog, itf, index, bufsz, &length, name);
    CheckErrorFree(L, name);
    lua_pushstring(L, name);
    Free(L, name);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x40, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
movl $0x92f6, %ecx           # imm = 0x92F6
callq 0x3f310
movl %eax, (%rsp)
movq 0x20(%rsp), %rdi
movslq (%rsp), %rsi
shlq $0x0, %rsi
callq 0x11200
movq %rax, 0x10(%rsp)
movq 0x29311(%rip), %rax     # 0x67f80
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movl 0x4(%rsp), %edx
movl (%rsp), %ecx
movq 0x10(%rsp), %r9
leaq 0x1c(%rsp), %r8
callq *%rax
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11550
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x110c0
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11370
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/proginterface.c
// Function: GetProgramResourceLocation
static int GetProgramResourceLocation(lua_State *L)
    {
    GLuint prog = luaL_checkinteger(L, 1);
    GLenum itf = checkinterface(L, 2);
    const char *name = luaL_checkstring(L, 3);
    GLint loc = glGetProgramResourceLocation(prog, itf, name);
    CheckError(L);
    lua_pushinteger(L, loc);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x40, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x11450
movq %rax, 0x10(%rsp)
movq 0x28b25(%rip), %rax     # 0x67cc8
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movq 0x10(%rsp), %rdx
callq *%rax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11880
movq 0x20(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x113c0
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/proginterface.c
// Function: GetActiveVariables
static int GetActiveVariables(lua_State *L, GLuint prog, GLenum itf, GLuint index, GLenum prop)
    {
    GLsizei length, i;
    GLint *params;
    GLsizei n = GetNumActiveVariables(L, prog, itf);
    params = (GLint*)Malloc(L, n*sizeof(GLint));
    glGetProgramResourceiv(prog, itf, index, 1, &prop, n, &length, params);
    CheckErrorFree(L, params);
    for(i=0; i<n; i++)
        lua_pushinteger(L, params[i]);
    Free(L, params);
    return n;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movl %ecx, 0x34(%rsp)
movl %r8d, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %edx
movl $0x92f7, %ecx           # imm = 0x92F7
callq 0x3f310
movl %eax, 0x1c(%rsp)
movq 0x40(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
shlq $0x2, %rsi
callq 0x11200
movq %rax, 0x20(%rsp)
movq 0x2820c(%rip), %rax     # 0x675c0
movq (%rax), %rax
movl 0x3c(%rsp), %edi
movl 0x38(%rsp), %esi
movl 0x34(%rsp), %edx
movl 0x1c(%rsp), %r9d
movq 0x20(%rsp), %r10
movl $0x1, %ecx
leaq 0x30(%rsp), %r8
leaq 0x2c(%rsp), %r11
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
callq *%rax
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11550
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x3f42d
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rax
movslq 0x28(%rsp), %rcx
movslq (%rax,%rcx,4), %rsi
callq 0x113c0
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x3f3fe
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11370
movl 0x1c(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/proginterface.c
// Function: GetPropInt
static int GetPropInt(lua_State *L, GLuint prog, GLenum itf, GLuint index, GLenum prop)
    {
    GLsizei length;
    GLint param;
    glGetProgramResourceiv(prog, itf, index, 1, &prop, 1, &length, &param);
    CheckError(L);
    lua_pushinteger(L, param);
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movl %r8d, 0x20(%rsp)
movq 0x2814f(%rip), %rax     # 0x675c0
movq (%rax), %rax
movl 0x2c(%rsp), %edi
movl 0x28(%rsp), %esi
movl 0x24(%rsp), %edx
movl $0x1, %r9d
leaq 0x20(%rsp), %r8
leaq 0x1c(%rsp), %r11
leaq 0x18(%rsp), %r10
movl %r9d, %ecx
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
callq *%rax
movq 0x30(%rsp), %rdi
callq 0x11880
movq 0x30(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0x113c0
movl $0x1, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/proginterface.c
// Function: GetPropBoolean
static int GetPropBoolean(lua_State *L, GLuint prog, GLenum itf, GLuint index, GLenum prop)
    {
    GLsizei length;
    GLint param;
    glGetProgramResourceiv(prog, itf, index, 1, &prop, 1, &length, &param);
    CheckError(L);
    lua_pushboolean(L, param);
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movl %r8d, 0x20(%rsp)
movq 0x280cf(%rip), %rax     # 0x675c0
movq (%rax), %rax
movl 0x2c(%rsp), %edi
movl 0x28(%rsp), %esi
movl 0x24(%rsp), %edx
movl $0x1, %r9d
leaq 0x20(%rsp), %r8
leaq 0x1c(%rsp), %r11
leaq 0x18(%rsp), %r10
movl %r9d, %ecx
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
callq *%rax
movq 0x30(%rsp), %rdi
callq 0x11880
movq 0x30(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x117f0
movl $0x1, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/proginterface.c
// Function: GetPropType
static int GetPropType(lua_State *L, GLuint prog, GLenum itf, GLuint index, GLenum prop)
    {
    GLsizei length;
    GLint param;
    glGetProgramResourceiv(prog, itf, index, 1, &prop, 1, &length, &param);
    CheckError(L);
    pushglsltype(L, param);
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movl %r8d, 0x20(%rsp)
movq 0x2804f(%rip), %rax     # 0x675c0
movq (%rax), %rax
movl 0x2c(%rsp), %edi
movl 0x28(%rsp), %esi
movl 0x24(%rsp), %edx
movl $0x1, %r9d
leaq 0x20(%rsp), %r8
leaq 0x1c(%rsp), %r11
leaq 0x18(%rsp), %r10
movl %r9d, %ecx
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
callq *%rax
movq 0x30(%rsp), %rdi
callq 0x11880
movq 0x30(%rsp), %rdi
movl 0x18(%rsp), %edx
movl $0xe, %esi
callq 0x11120
movl $0x1, %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/program.c
// Function: CreateProgram
static int CreateProgram(lua_State *L)
    {
    GLuint ref;
    check_init_called(L);
    ref = glCreateProgram();
    CheckError(L);
    object_new(L, OTYPE_PROGRAM, ref);
    lua_pushinteger(L, ref);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x115e0
movq 0x282fe(%rip), %rax     # 0x67948
callq *(%rax)
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
movl $0x7, %esi
callq 0x11a90
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %esi
callq 0x113c0
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/program.c
// Function: CreateShaderProgram
static int CreateShaderProgram(lua_State *L)
    {
    GLenum type = checkshadertype(L, 1);
    const GLchar *string = luaL_checkstring(L, 2);
    GLuint program;
    check_init_called(L);
    program = glCreateShaderProgramv(type, 1, &string);
    CheckError(L);
    object_new(L, OTYPE_PROGRAM, program);
    lua_pushinteger(L, program);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x11160
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x11450
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x115e0
movq 0x27aa9(%rip), %rax     # 0x67180
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
callq *%rax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11880
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %edx
movl $0x7, %esi
callq 0x11a90
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %esi
callq 0x113c0
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/program.c
// Function: GetProgramInfoLog
static int GetProgramInfoLog(lua_State *L)
    {
    char *buf;
    GLint bufsz;
    GLuint program = luaL_checkinteger(L, 1);

    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufsz);
    CheckError(L);
    if(bufsz==0) return 0;
    buf = (char*)Malloc(L, bufsz*sizeof(char));
    glGetProgramInfoLog(program, bufsz, NULL, buf);
    CheckErrorFree(L, buf);
    lua_pushstring(L, buf);
    Free(L, buf);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0x8(%rsp)
movq 0x2823d(%rip), %rax     # 0x67cd0
movq (%rax), %rax
movl 0x8(%rsp), %edi
movl $0x8b84, %esi           # imm = 0x8B84
leaq 0xc(%rsp), %rdx
callq *%rax
movq 0x18(%rsp), %rdi
callq 0x11880
cmpl $0x0, 0xc(%rsp)
jne 0x3fac1
movl $0x0, 0x24(%rsp)
jmp 0x3fb29
movq 0x18(%rsp), %rdi
movslq 0xc(%rsp), %rsi
shlq $0x0, %rsi
callq 0x11200
movq %rax, 0x10(%rsp)
movq 0x27d08(%rip), %rax     # 0x677e8
movq (%rax), %rax
movl 0x8(%rsp), %edi
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rcx
xorl %edx, %edx
callq *%rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11550
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x110c0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11370
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]moongl/src/program.c
// Function: GetAttachedShaders
static int GetAttachedShaders(lua_State *L)
    {
    GLuint *shaders;
    GLsizei i, count;
    GLuint program = luaL_checkinteger(L, 1);

    glGetProgramiv(program, GL_ATTACHED_SHADERS, &count);
    CheckError(L);
    if(count==0) return 0;
    shaders = (GLuint*)Malloc(L, count*sizeof(GLuint));
    glGetAttachedShaders(program, count, NULL, shaders);
    CheckErrorFree(L, shaders);
    for(i=0; i<count; i++)
        lua_pushinteger(L, shaders[i]);
    Free(L, shaders);
    return count;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x2816d(%rip), %rax     # 0x67cd0
movq (%rax), %rax
movl 0x4(%rsp), %edi
movl $0x8b85, %esi           # imm = 0x8B85
leaq 0x8(%rsp), %rdx
callq *%rax
movq 0x18(%rsp), %rdi
callq 0x11880
cmpl $0x0, 0x8(%rsp)
jne 0x3fb94
movl $0x0, 0x24(%rsp)
jmp 0x3fc25
movq 0x18(%rsp), %rdi
movslq 0x8(%rsp), %rsi
shlq $0x2, %rsi
callq 0x11200
movq %rax, 0x10(%rsp)
movq 0x276cd(%rip), %rax     # 0x67280
movq (%rax), %rax
movl 0x4(%rsp), %edi
movl 0x8(%rsp), %esi
movq 0x10(%rsp), %rcx
xorl %edx, %edx
callq *%rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11550
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x3fc0e
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %esi
callq 0x113c0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3fbde
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11370
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/program.c
// Function: ProgramParameter
static int ProgramParameter(lua_State *L)
    {
    GLuint program = luaL_checkinteger(L, 1);
    GLenum pname = checkprogramparameterpname(L, 2);
    GLint value = checkboolean(L, 3);
    glProgramParameteri(program, pname, value);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x51, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x11510
movzbl %al, %eax
movl %eax, 0x4(%rsp)
movq 0x27abf(%rip), %rax     # 0x67c90
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movl 0x4(%rsp), %edx
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/program.c
// Function: GetProgramBinary
static int GetProgramBinary(lua_State *L)
/* get_program_binary(program)
 * -> format, binary  (or nil)
 */
    {
    GLsizei length;
    GLenum format;
    void *binary;
    GLuint program = luaL_checkinteger(L, 1);
    GLsizei bufsz = programGet(L, program, GL_PROGRAM_BINARY_LENGTH);
    if(bufsz==0)
        return 0;   
    binary = Malloc(L, bufsz);
    glGetProgramBinary(program, bufsz, &length, &format, binary);
    CheckErrorFree(L, binary);
    if(length==0)
        return 0;
    lua_pushinteger(L, format);
    lua_pushlstring(L, (char*)binary, length);
    Free(L, binary);
    return 2;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
movl 0x4(%rsp), %esi
movl $0x8741, %edx           # imm = 0x8741
callq 0x11850
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
jne 0x40245
movl $0x0, 0x24(%rsp)
jmp 0x402d5
movq 0x18(%rsp), %rdi
movslq (%rsp), %rsi
callq 0x11200
movq %rax, 0x8(%rsp)
movq 0x271f9(%rip), %rax     # 0x67458
movq (%rax), %rax
movl 0x4(%rsp), %edi
movl (%rsp), %esi
movq 0x8(%rsp), %r8
leaq 0x14(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *%rax
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11550
cmpl $0x0, 0x14(%rsp)
jne 0x4029a
movl $0x0, 0x24(%rsp)
jmp 0x402d5
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %eax
movl %eax, %esi
callq 0x113c0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movslq 0x14(%rsp), %rdx
callq 0x11ab0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11370
movl $0x2, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/program.c
// Function: ProgramBinary
static int ProgramBinary(lua_State *L)
/* program_binary(program, format, binary)
 */
    {
    size_t length;
    GLuint program = luaL_checkinteger(L, 1);
    GLenum format = luaL_checkinteger(L, 2);
    const void *binary = luaL_checklstring(L, 3, &length);
    glProgramBinary(program, format, binary, (GLsizei)length);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
leaq 0x18(%rsp), %rdx
callq 0x11450
movq %rax, 0x8(%rsp)
movq 0x278f1(%rip), %rax     # 0x67c20
movq (%rax), %rax
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/program.c
// Function: GetInteger
static int GetInteger(lua_State *L, GLuint program, GLenum pname)
    {
    GLint params; 
    glGetProgramiv(program, pname, &params);
    CheckError(L);
    lua_pushinteger(L, params); 
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x27958(%rip), %rax     # 0x67cd0
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
leaq 0x4(%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movslq 0x4(%rsp), %rsi
callq 0x113c0
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/program.c
// Function: GetBoolean
static int GetBoolean(lua_State *L, GLuint program, GLenum pname)
    {
    GLint params; 
    glGetProgramiv(program, pname, &params);
    CheckError(L);
    lua_pushboolean(L, params == GL_TRUE); 
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x27908(%rip), %rax     # 0x67cd0
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
leaq 0x4(%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
cmpl $0x1, 0x4(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x117f0
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/program.c
// Function: GetInteger3
static int GetInteger3(lua_State *L, GLuint program, GLenum pname)
    {
    GLint params[3]; 
    glGetProgramiv(program, pname, params);
    CheckError(L);
    lua_pushinteger(L, params[0]); 
    lua_pushinteger(L, params[1]); 
    lua_pushinteger(L, params[2]); 
    return 3;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x278a8(%rip), %rax     # 0x67cd0
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
leaq 0xc(%rsp), %rdx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
movq 0x20(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x113c0
movq 0x20(%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0x113c0
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x113c0
movl $0x3, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/query.c
// Function: CreateQueries
IS_FUNC(Query)

static int CreateQueries(lua_State *L)
    {
    GLsizei i;
    GLuint* names;
    GLenum target = checkquerytarget(L, 1);
    GLsizei n = luaL_optinteger(L, 2, 1);
    check_init_called(L);
    luaL_checkstack(L, n, NULL);
    names = (GLuint*)Malloc(L, n*sizeof(GLuint));
    glCreateQueries(target, n, names);
    CheckErrorFree(L, names);
    for(i = 0; i < n; i++)
        {
        object_new(L, OTYPE_QUERY, names[i]);
        lua_pushinteger(L, names[i]);
        }
    Free(L, names);
    return n;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x48, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x11b30
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x115e0
movq 0x20(%rsp), %rdi
movl 0x8(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x11260
movq 0x20(%rsp), %rdi
movslq 0x8(%rsp), %rsi
shlq $0x2, %rsi
callq 0x11200
movq %rax, 0x10(%rsp)
movq 0x26be4(%rip), %rax     # 0x67268
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movq 0x10(%rsp), %rdx
callq *%rax
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11550
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x406f9
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movl $0xb, %esi
callq 0x11a90
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %esi
callq 0x113c0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x406ad
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11370
movl 0x8(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/query.c
// Function: BeginQuery
static int BeginQuery(lua_State *L)
    {
    GLenum index;
    GLenum target = checkquerytarget(L, 1);
    GLuint name = luaL_checkinteger(L, 2);
    if(lua_isnoneornil(L, 3))
        glBeginQuery(target, name);
    else
        {
        index = luaL_checkinteger(L, 3);
        glBeginQueryIndexed(target, index, name);
        }
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x48, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x11860
cmpl $0x0, %eax
jg 0x4084e
movq 0x274c1(%rip), %rax     # 0x67d00
movq (%rax), %rax
movl 0x8(%rsp), %edi
movl 0x4(%rsp), %esi
callq *%rax
jmp 0x40879
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x26ca8(%rip), %rax     # 0x67510
movq (%rax), %rax
movl 0x8(%rsp), %edi
movl 0xc(%rsp), %esi
movl 0x4(%rsp), %edx
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/query.c
// Function: EndQuery
static int EndQuery(lua_State *L)
    {
    GLenum index;
    GLenum target = checkquerytarget(L, 1);
    if(lua_isnoneornil(L, 2))
        glEndQuery(target);
    else
        {
        index = luaL_checkinteger(L, 2);
        glEndQueryIndexed(target, index);
        }
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x48, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11860
cmpl $0x0, %eax
jg 0x408d7
movq 0x26e1c(%rip), %rax     # 0x676e8
movq (%rax), %rax
movl 0x8(%rsp), %edi
callq *%rax
jmp 0x408fe
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x2763f(%rip), %rax     # 0x67f30
movq (%rax), %rax
movl 0x8(%rsp), %edi
movl 0xc(%rsp), %esi
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/query.c
// Function: QueryCounter
static int QueryCounter(lua_State *L)
    {
    GLuint name = luaL_checkinteger(L, 1);
    GLenum target = GL_TIMESTAMP; /* checkquerytarget(L, 2); only TIMESTAMP */
    glQueryCounter(name, target);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movl $0x8e28, 0x8(%rsp)      # imm = 0x8E28
movq 0x27385(%rip), %rax     # 0x67cc0
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/query.c
// Function: GetTimestamp
static int GetTimestamp(lua_State *L)
    {
    GLint64 data;
    glGetInteger64v(GL_TIMESTAMP, &data);
    CheckError(L);
    lua_pushinteger(L, data);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x8e28, %edi           # imm = 0x8E28
leaq 0x8(%rsp), %rsi
movq 0x26d66(%rip), %rax     # 0x676e0
callq *(%rax)
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x113c0
movl $0x1, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/query.c
// Function: GetQuery
static int GetQuery(lua_State *L)
    {
    int indexed = 0;
    GLenum index;
    GLenum target = checkquerytarget(L, 1);
    GLenum pname = checkquerypname(L, 2);
    if(!lua_isnoneornil(L, 3))
        {
        indexed = 1;
        index = luaL_checkinteger(L, 3);
        }
    switch(pname)
        {
        case GL_CURRENT_QUERY:
        case GL_QUERY_COUNTER_BITS:
            return GetInt(L, target, pname, indexed == 1 ? &index : NULL);
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
        }
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl $0x48, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movl $0x49, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x3, %esi
callq 0x11860
cmpl $0x0, %eax
jle 0x40a10
movl $0x1, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x20(%rsp)
movl 0x18(%rsp), %eax
addl $0xffff779c, %eax       # imm = 0xFFFF779C
subl $0x1, %eax
ja 0x40a70
jmp 0x40a20
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
cmpl $0x1, 0x24(%rsp)
jne 0x40a4c
leaq 0x20(%rsp), %rax
movq %rax, (%rsp)
jmp 0x40a54
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x40a54
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %esi
movq 0x8(%rsp), %rdi
movq (%rsp), %rcx
callq 0x40ad0
movl %eax, 0x34(%rsp)
jmp 0x40a93
movq 0x28(%rsp), %rdi
leaq 0x11809(%rip), %rsi     # 0x52285
leaq 0x1cb60(%rip), %rdx     # 0x5d5e3
movl $0x84, %ecx
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/query.c
// Function: GetInt
static int GetInt(lua_State *L, GLenum target, GLenum pname, GLenum *index)
/* get_query(target, pname [, index]) */
    {
    GLint param;
    if(index!=NULL)
        glGetQueryIndexediv(target, *index, pname, &param);
    else
        glGetQueryiv(target, pname, &param);
    CheckError(L);
    lua_pushinteger(L, param);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x40b10
movq 0x2709b(%rip), %rax     # 0x67b90
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movq 0x10(%rsp), %rcx
movl (%rcx), %esi
movl 0x18(%rsp), %edx
leaq 0xc(%rsp), %rcx
callq *%rax
jmp 0x40b29
movq 0x26c69(%rip), %rax     # 0x67780
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
leaq 0xc(%rsp), %rdx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
movq 0x20(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x113c0
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/raster.c
// Function: PointParameter
static int PointParameter(lua_State *L)
    {
    GLenum pname = checkpointpname(L, 1);
    switch(pname)
        {
        case GL_POINT_FADE_THRESHOLD_SIZE: glPointParameterf(pname, luaL_checknumber(L, 2));
                                            break;
        case GL_POINT_SPRITE_COORD_ORIGIN: glPointParameteri(pname, checkorigin(L, 2)); 
                                            break;
        default: 
            return luaL_error(L, UNEXPECTED_ERROR);
        }
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x65, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x20(%rsp)
subl $0x8128, %eax           # imm = 0x8128
je 0x40bff
jmp 0x40bf2
movl 0x20(%rsp), %eax
subl $0x8ca0, %eax           # imm = 0x8CA0
je 0x40c36
jmp 0x40c70
movq 0x2661a(%rip), %rax     # 0x67220
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x11a80
movl 0x14(%rsp), %edi
movq 0x18(%rsp), %rax
cvtsd2ss %xmm0, %xmm0
callq *%rax
jmp 0x40c95
movq 0x268b3(%rip), %rax     # 0x674f0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x28(%rsp), %rdi
movl $0xb, %esi
movl $0x2, %edx
callq 0x11160
movl 0x4(%rsp), %edi
movl %eax, %esi
movq 0x8(%rsp), %rax
callq *%rax
jmp 0x40c95
movq 0x28(%rsp), %rdi
leaq 0x11609(%rip), %rsi     # 0x52285
leaq 0x1c9f7(%rip), %rdx     # 0x5d67a
movl $0x26, %ecx
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x34(%rsp)
jmp 0x40ca7
movq 0x28(%rsp), %rdi
callq 0x11880
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/raster.c
// Function: CullFace
static int CullFace(lua_State *L)
    {
    GLenum mode = checkcullfacemode(L, 1);
    glCullFace(mode);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x63, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edi
callq 0x116b0
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/raster.c
// Function: FrontFace
static int FrontFace(lua_State *L)
    {
    GLenum mode = checkfrontfacemode(L, 1);
    glFrontFace(mode);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x62, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edi
callq 0x11180
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/raster.c
// Function: PolygonMode
static int PolygonMode(lua_State *L)
    {
    GLenum face = checkpolygonmodeface(L, 1);
    GLenum mode = checkpolygonmodemode(L, 2);
    glPolygonMode(face, mode);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x60, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x61, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
callq 0x11610
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/renderbuffer.c
// Function: RenderbufferStorageMultisample
static int RenderbufferStorageMultisample(lua_State *L)
    {
    int arg = 1;
    GLenum target;
    GLuint renderbuffer = checktargetorname(L, arg++, &target, DOMAIN_RENDERBUFFER_TARGET);
    GLsizei samples = luaL_checkinteger(L, arg++);
    GLenum internalformat = checkinternalformat(L, arg++);
    GLsizei width = luaL_checkinteger(L, arg++);
    GLsizei height = luaL_checkinteger(L, arg++);
    if(renderbuffer==0)
        glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
    else
        glNamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x1, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
leaq 0x18(%rsp), %rdx
movl $0xf, %ecx
callq 0x11430
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
callq 0x11af0
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movl $0x11, %esi
callq 0x11160
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
callq 0x11af0
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
callq 0x11af0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x414a1
movq 0x265c3(%rip), %rax     # 0x67a48
movq (%rax), %rax
movl 0x18(%rsp), %edi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
movl 0x4(%rsp), %r8d
callq *%rax
jmp 0x414c2
movq 0x266b0(%rip), %rax     # 0x67b58
movq (%rax), %rax
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
movl 0x4(%rsp), %r8d
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/renderbuffer.c
// Function: RenderbufferStorage
static int RenderbufferStorage(lua_State *L)
    {
    int arg = 1;
    GLenum target;
    GLuint renderbuffer = checktargetorname(L, arg++, &target, DOMAIN_RENDERBUFFER_TARGET);
    GLenum internalformat = checkinternalformat(L, arg++);
    GLsizei width = luaL_checkinteger(L, arg++);
    GLsizei height = luaL_checkinteger(L, arg++);
    if(renderbuffer==0)
        glRenderbufferStorage(target, internalformat, width, height);
    else
        glNamedRenderbufferStorage(renderbuffer, internalformat, width, height);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x1, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
leaq 0x18(%rsp), %rdx
movl $0xf, %ecx
callq 0x11430
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movl $0x11, %esi
callq 0x11160
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
callq 0x11af0
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x41591
movq 0x2609e(%rip), %rax     # 0x67618
movq (%rax), %rax
movl 0x18(%rsp), %edi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
callq *%rax
jmp 0x415ad
movq 0x260e0(%rip), %rax     # 0x67678
movq (%rax), %rax
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nop