LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/func.c
// Function: moongl_Malloc3
void* Malloc3(lua_State *L, size_t size, void **ptr2, size_t size2, void **ptr3, size_t size3)
    {
    void *ptr;
    if((size==0) || (size2 == 0) || (size3 == 0))
        { luaL_error(L, "malloc request with size = 0"); return NULL; }
    if((ptr = malloc(size)) == NULL)
        { luaL_error(L, "cannot allocate memory"); return NULL; }
    if((*ptr2 = malloc(size2)) == NULL)
        { 
        Free(L, ptr); 
        luaL_error(L, "cannot allocate memory"); return NULL; 
        }
    if((*ptr3 = malloc(size3)) == NULL)
        { 
        Free(L, ptr); 
        Free(L, *ptr2); 
        luaL_error(L, "cannot allocate memory"); return NULL; 
        }
    return ptr;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x3270a
cmpq $0x0, 0x20(%rsp)
je 0x3270a
cmpq $0x0, 0x10(%rsp)
jne 0x3272b
movq 0x38(%rsp), %rdi
leaq 0x2a0f2(%rip), %rsi     # 0x5c808
movb $0x0, %al
callq 0x11ae0
movq $0x0, 0x40(%rsp)
jmp 0x32807
movq 0x30(%rsp), %rdi
callq 0x11270
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x32761
movq 0x38(%rsp), %rdi
leaq 0x2a0d9(%rip), %rsi     # 0x5c825
movb $0x0, %al
callq 0x11ae0
movq $0x0, 0x40(%rsp)
jmp 0x32807
movq 0x20(%rsp), %rdi
callq 0x11270
movq 0x28(%rsp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x327a6
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11370
movq 0x38(%rsp), %rdi
leaq 0x2a091(%rip), %rsi     # 0x5c825
movb $0x0, %al
callq 0x11ae0
movq $0x0, 0x40(%rsp)
jmp 0x32807
movq 0x10(%rsp), %rdi
callq 0x11270
movq 0x18(%rsp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x327fd
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11370
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rsi
callq 0x11370
movq 0x38(%rsp), %rdi
leaq 0x2a03a(%rip), %rsi     # 0x5c825
movb $0x0, %al
callq 0x11ae0
movq $0x0, 0x40(%rsp)
jmp 0x32807
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/func.c
// Function: moongl_MallocNoErr
void *MallocNoErr(lua_State *L, size_t size) /* do not raise errors (check the retval) */
    {
    void *ptr = malloc(size);
    (void)L;
    if(ptr==NULL)
        return NULL;
    memset(ptr, 0, size);
    return ptr;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x11270
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x32850
movq $0x0, 0x20(%rsp)
jmp 0x3286b
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
xorl %esi, %esi
callq 0x110e0
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/func.c
// Function: ErrorString
static const char* ErrorString(int err) /* replaces gluErrorString */
    {
    switch(err)
        {
        case GL_NO_ERROR: return "no error";
        case GL_INVALID_ENUM: return "invalid enum";
        case GL_INVALID_VALUE: return "invalid value";
        case GL_INVALID_OPERATION: return "invalid operation";
        case GL_INVALID_FRAMEBUFFER_OPERATION: return "invalid framebuffer operation";
        case GL_OUT_OF_MEMORY: return "out of memory";
        case GL_STACK_UNDERFLOW: return "stack underflow";
        case GL_STACK_OVERFLOW: return "stack overflow";
        default:
            return "unknown gl error";
        }
    return NULL; /* unreachable */
    }

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x10(%rsp)
testl %eax, %eax
je 0x329c1
jmp 0x32962
movl -0x10(%rsp), %eax
subl $0x500, %eax            # imm = 0x500
je 0x329cf
jmp 0x3296f
movl -0x10(%rsp), %eax
subl $0x501, %eax            # imm = 0x501
je 0x329dd
jmp 0x3297c
movl -0x10(%rsp), %eax
subl $0x502, %eax            # imm = 0x502
je 0x329eb
jmp 0x32989
movl -0x10(%rsp), %eax
subl $0x503, %eax            # imm = 0x503
je 0x32a23
jmp 0x3299a
movl -0x10(%rsp), %eax
subl $0x504, %eax            # imm = 0x504
je 0x32a15
jmp 0x329a7
movl -0x10(%rsp), %eax
subl $0x505, %eax            # imm = 0x505
je 0x32a07
jmp 0x329b4
movl -0x10(%rsp), %eax
subl $0x506, %eax            # imm = 0x506
je 0x329f9
jmp 0x32a31
leaq 0x287e7(%rip), %rax     # 0x5b1af
movq %rax, -0x8(%rsp)
jmp 0x32a3d
leaq 0x29f26(%rip), %rax     # 0x5c8fc
movq %rax, -0x8(%rsp)
jmp 0x32a3d
leaq 0x29e85(%rip), %rax     # 0x5c869
movq %rax, -0x8(%rsp)
jmp 0x32a3d
leaq 0x29f17(%rip), %rax     # 0x5c909
movq %rax, -0x8(%rsp)
jmp 0x32a3d
leaq 0x29f1b(%rip), %rax     # 0x5c91b
movq %rax, -0x8(%rsp)
jmp 0x32a3d
leaq 0x29e71(%rip), %rax     # 0x5c87f
movq %rax, -0x8(%rsp)
jmp 0x32a3d
leaq 0x29f1d(%rip), %rax     # 0x5c939
movq %rax, -0x8(%rsp)
jmp 0x32a3d
leaq 0x29f1f(%rip), %rax     # 0x5c949
movq %rax, -0x8(%rsp)
jmp 0x32a3d
leaq 0x29f20(%rip), %rax     # 0x5c958
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/func.c
// Function: moongl_CheckErrorFree
int CheckErrorFree(lua_State *L, void *ptr)
/* On error, free ptr before raising the error */
    {
    int rc = glGetError();
    if(rc != 0) 
        {
        Free(L, ptr);
        return luaL_error(L, (char*)ErrorString(rc));
        }
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
callq 0x11250
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x32ac3
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11370
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl 0xc(%rsp), %edi
callq 0x32950
movq (%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
jmp 0x32acb
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]moongl/src/func.c
// Function: moongl_CheckErrorFree2
int CheckErrorFree2(lua_State *L, void *ptr1, void *ptr2)
/* On error, free ptr1 and ptr2 before raising the error */
    {
    int rc = glGetError();
    if(rc != 0) 
        {
        Free(L, ptr1);
        Free(L, ptr2);
        return luaL_error(L, (char*)ErrorString(rc));
        }
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
callq 0x11250
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x32b49
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11370
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11370
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %edi
callq 0x32950
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x34(%rsp)
jmp 0x32b51
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/func.c
// Function: moongl_CheckErrorFree3
int CheckErrorFree3(lua_State *L, void *ptr1, void *ptr2, void *ptr3)
    {
    int rc = glGetError();
    if(rc != 0) 
        {
        Free(L, ptr1);
        Free(L, ptr2);
        Free(L, ptr3);
        return luaL_error(L, (char*)ErrorString(rc));
        }
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
callq 0x11250
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x32bdb
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11370
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11370
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11370
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl 0xc(%rsp), %edi
callq 0x32950
movq (%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x34(%rsp)
jmp 0x32be3
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/get.c
// Function: GetInt
static int GetInt(lua_State *L, GLenum pname)
    {
    GLint64 data;
    glGetInteger64v(pname, &data);
    CheckError(L);
    lua_pushinteger(L, data);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x31b8c(%rip), %rax     # 0x676e0
movq (%rax), %rax
movl 0xc(%rsp), %edi
movq %rsp, %rsi
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x113c0
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/get.c
// Function: GetIntOptIndex
static int GetIntOptIndex(lua_State *L, GLenum pname) /* index is optional */
    {
    GLint64 data;
    GLuint index;
    if(!lua_isnoneornil(L, 2))
        {
        index = luaL_checkinteger(L, 2);
        glGetInteger64i_v(pname, index, &data);
        }
    else
        glGetInteger64v(pname, &data);
    CheckError(L);
    lua_pushinteger(L, data);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x11860
cmpl $0x0, %eax
jle 0x35bdf
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x32075(%rip), %rax     # 0x67c40
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0xc(%rsp), %esi
leaq 0x10(%rsp), %rdx
callq *%rax
jmp 0x35bf4
movq 0x31afa(%rip), %rax     # 0x676e0
movq (%rax), %rax
movl 0x1c(%rsp), %edi
leaq 0x10(%rsp), %rsi
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x113c0
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/get.c
// Function: GetIntIndex
static int GetIntIndex(lua_State *L, GLenum pname)
    {
    GLint64 data;
    GLuint index = luaL_checkinteger(L, 2);
    glGetInteger64i_v(pname, index, &data);
    CheckError(L);
    lua_pushinteger(L, data);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x31ff9(%rip), %rax     # 0x67c40
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0xc(%rsp), %esi
leaq 0x10(%rsp), %rdx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x113c0
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/get.c
// Function: GetBoolean
static int GetBoolean(lua_State *L, GLenum pname)
    {
    GLboolean data;
    glGetBooleanv(pname, &data);
    CheckError(L);
    lua_pushboolean(L, (data == GL_TRUE));
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %edi
leaq 0xb(%rsp), %rsi
callq 0x11980
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movzbl 0xb(%rsp), %eax
cmpl $0x1, %eax
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x117f0
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/get.c
// Function: GetFloat4
static int GetFloat4(lua_State *L, GLenum pname)
    {
    GLfloat data[4];
    glGetFloatv(pname, data);
    CheckError(L);
    lua_pushnumber(L, data[0]);
    lua_pushnumber(L, data[1]);
    lua_pushnumber(L, data[2]);
    lua_pushnumber(L, data[3]);
    return 4;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl 0x1c(%rsp), %edi
movq %rsp, %rsi
callq 0x11aa0
movq 0x20(%rsp), %rdi
callq 0x11880
movq 0x20(%rsp), %rdi
movss (%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11380
movq 0x20(%rsp), %rdi
movss 0x4(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11380
movq 0x20(%rsp), %rdi
movss 0x8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11380
movq 0x20(%rsp), %rdi
movss 0xc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11380
movl $0x4, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/get.c
// Function: GetBoolean4OptIndex
static int GetBoolean4OptIndex(lua_State *L, GLenum pname) /* index is optional */
    {
    GLboolean data[4];
    GLuint index;
    if(!lua_isnoneornil(L, 2))
        {
        index = luaL_checkinteger(L, 2);
        glGetBooleani_v(pname, index, data);
        }
    else
        glGetBooleanv(pname, data);
    CheckError(L);
    lua_pushboolean(L, data[0]);
    lua_pushboolean(L, data[1]);
    lua_pushboolean(L, data[2]);
    lua_pushboolean(L, data[3]);
    return 4;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11860
cmpl $0x0, %eax
jle 0x35d9f
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x31cb5(%rip), %rax     # 0x67a40
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x4(%rsp), %esi
leaq 0x8(%rsp), %rdx
callq *%rax
jmp 0x35dad
movl 0xc(%rsp), %edi
leaq 0x8(%rsp), %rsi
callq 0x11980
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movzbl 0x8(%rsp), %esi
callq 0x117f0
movq 0x10(%rsp), %rdi
movzbl 0x9(%rsp), %esi
callq 0x117f0
movq 0x10(%rsp), %rdi
movzbl 0xa(%rsp), %esi
callq 0x117f0
movq 0x10(%rsp), %rdi
movzbl 0xb(%rsp), %esi
callq 0x117f0
movl $0x4, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/get.c
// Function: GetFloat
static int GetFloat(lua_State *L, GLenum pname)
    {
    GLfloat data;
    glGetFloatv(pname, &data);
    CheckError(L);
    lua_pushnumber(L, data);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %edi
leaq 0x8(%rsp), %rsi
callq 0x11aa0
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movss 0x8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11380
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/get.c
// Function: GetBooleanOptIndex
static int GetBooleanOptIndex(lua_State *L, GLenum pname) /* index is optional */
    {
    GLboolean data;
    GLuint index;
    if(!lua_isnoneornil(L, 2))
        {
        index = luaL_checkinteger(L, 2);
        glGetBooleani_v(pname, index, &data);
        }
    else
        glGetBooleanv(pname, &data);
    CheckError(L);
    lua_pushboolean(L, data);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11860
cmpl $0x0, %eax
jle 0x35edf
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x31b75(%rip), %rax     # 0x67a40
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x4(%rsp), %esi
leaq 0xb(%rsp), %rdx
callq *%rax
jmp 0x35eed
movl 0xc(%rsp), %edi
leaq 0xb(%rsp), %rsi
callq 0x11980
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movzbl 0xb(%rsp), %esi
callq 0x117f0
movl $0x1, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/get.c
// Function: GetFloat4OptIndex
static int GetFloat4OptIndex(lua_State *L, GLenum pname) /* index is optional */
    {
    GLfloat data[4];
    GLuint index;
    if(!lua_isnoneornil(L, 2))
        {
        index = luaL_checkinteger(L, 2);
        glGetFloati_v(pname, index, data);
        }
    else
        glGetFloatv(pname, data);
    CheckError(L);
    lua_pushnumber(L, data[0]);
    lua_pushnumber(L, data[1]);
    lua_pushnumber(L, data[2]);
    lua_pushnumber(L, data[3]);
    return 4;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x11860
cmpl $0x0, %eax
jle 0x35f5f
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x31b9d(%rip), %rax     # 0x67ae8
movq (%rax), %rax
movl 0x2c(%rsp), %edi
movl 0xc(%rsp), %esi
leaq 0x10(%rsp), %rdx
callq *%rax
jmp 0x35f6d
movl 0x2c(%rsp), %edi
leaq 0x10(%rsp), %rsi
callq 0x11aa0
movq 0x30(%rsp), %rdi
callq 0x11880
movq 0x30(%rsp), %rdi
movss 0x10(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11380
movq 0x30(%rsp), %rdi
movss 0x14(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11380
movq 0x30(%rsp), %rdi
movss 0x18(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11380
movq 0x30(%rsp), %rdi
movss 0x1c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11380
movl $0x4, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/get.c
// Function: GetEnumOptIndex
static int GetEnumOptIndex(lua_State *L, GLenum pname, uint32_t domain) /* index is optional */
    {
    GLint data;
    GLuint index;
    if(!lua_isnoneornil(L, 2))
        {
        index = luaL_checkinteger(L, 2);
        glGetIntegeri_v(pname, index, &data);
        }
    else
        glGetIntegerv(pname, &data);
    CheckError(L);
    return enums_push(L, domain, data);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11860
cmpl $0x0, %eax
jle 0x36031
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, (%rsp)
movq 0x312ba(%rip), %rax     # 0x672d8
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl (%rsp), %esi
leaq 0x4(%rsp), %rdx
callq *%rax
jmp 0x3603f
movl 0xc(%rsp), %edi
leaq 0x4(%rsp), %rsi
callq 0x116e0
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
movl 0x4(%rsp), %edx
callq 0x11120
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/get.c
// Function: GetFloat4Index
static int GetFloat4Index(lua_State *L, GLenum pname)
    {
    GLfloat data[4];
    GLuint index;
    index = luaL_checkinteger(L, 2);
    glGetFloati_v(pname, index, data);
    CheckError(L);
    lua_pushnumber(L, data[0]);
    lua_pushnumber(L, data[1]);
    lua_pushnumber(L, data[2]);
    lua_pushnumber(L, data[3]);
    return 4;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x31a61(%rip), %rax     # 0x67ae8
movq (%rax), %rax
movl 0x2c(%rsp), %edi
movl 0xc(%rsp), %esi
leaq 0x10(%rsp), %rdx
callq *%rax
movq 0x30(%rsp), %rdi
callq 0x11880
movq 0x30(%rsp), %rdi
movss 0x10(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11380
movq 0x30(%rsp), %rdi
movss 0x14(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11380
movq 0x30(%rsp), %rdi
movss 0x18(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11380
movq 0x30(%rsp), %rdi
movss 0x1c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11380
movl $0x4, %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/get.c
// Function: GetBoolean4Index
static int GetBoolean4Index(lua_State *L, GLenum pname)
    {
    GLboolean data[4];
    GLuint index;
    index = luaL_checkinteger(L, 2);
    glGetBooleani_v(pname, index, data);
    CheckError(L);
    lua_pushboolean(L, data[0]);
    lua_pushboolean(L, data[1]);
    lua_pushboolean(L, data[2]);
    lua_pushboolean(L, data[3]);
    return 4;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x31919(%rip), %rax     # 0x67a40
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x4(%rsp), %esi
leaq 0x8(%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movzbl 0x8(%rsp), %esi
callq 0x117f0
movq 0x10(%rsp), %rdi
movzbl 0x9(%rsp), %esi
callq 0x117f0
movq 0x10(%rsp), %rdi
movzbl 0xa(%rsp), %esi
callq 0x117f0
movq 0x10(%rsp), %rdi
movzbl 0xb(%rsp), %esi
callq 0x117f0
movl $0x4, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/get.c
// Function: GetIntN
static int GetIntN(lua_State *L, GLenum pname, GLenum numpname)
    {
    GLint64 *data;
    GLsizei i, num = getSizei(L, numpname);
    if(num==0) return 0;
    data = (GLint64*)Malloc(L, num*sizeof(GLint64));
    glGetInteger64v(pname, data);
    CheckErrorFree(L, data);
    for(i = 0; i<num; i++)
        lua_pushinteger(L, data[i]);
    Free(L, data);
    return num;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x11a70
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
jne 0x361c5
movl $0x0, 0x24(%rsp)
jmp 0x3624c
movq 0x18(%rsp), %rdi
movslq (%rsp), %rsi
shlq $0x3, %rsi
callq 0x11200
movq %rax, 0x8(%rsp)
movq 0x314fd(%rip), %rax     # 0x676e0
movq (%rax), %rax
movl 0x14(%rsp), %edi
movq 0x8(%rsp), %rsi
callq *%rax
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11550
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
jge 0x36236
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x113c0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x36208
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11370
movl (%rsp), %eax
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/get.c
// Function: GetEnumN
static int GetEnumN(lua_State *L, GLenum pname, GLenum numpname, uint32_t domain)
    {
    GLint *val;
    GLsizei i, num = getSizei(L, numpname);
    if(num==0) return 0;
    val = (GLint*)Malloc(L, num*sizeof(GLint));
    glGetIntegerv(pname, val);
    CheckErrorFree(L, val);
    luaL_checkstack(L, num, NULL);
    for(i = 0; i<num; i++)
        enums_push(L, domain, val[i]);
    Free(L, val);
    return num;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x11a70
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jne 0x3629b
movl $0x0, 0x34(%rsp)
jmp 0x36333
movq 0x28(%rsp), %rdi
movslq 0x8(%rsp), %rsi
shlq $0x2, %rsi
callq 0x11200
movq %rax, 0x10(%rsp)
movl 0x24(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x116e0
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11550
movq 0x28(%rsp), %rdi
movl 0x8(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x11260
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x3631c
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %edx
callq 0x11120
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x362ea
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11370
movl 0x8(%rsp), %eax
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/get.c
// Function: GetFloat2
static int GetFloat2(lua_State *L, GLenum pname)
    {
    GLfloat data[2];
    glGetFloatv(pname, data);
    CheckError(L);
    lua_pushnumber(L, data[0]);
    lua_pushnumber(L, data[1]);
    return 2;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %edi
leaq 0x4(%rsp), %rsi
callq 0x11aa0
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movss 0x4(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11380
movq 0x10(%rsp), %rdi
movss 0x8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11380
movl $0x2, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/get.c
// Function: GetEnum2
static int GetEnum2(lua_State *L, GLenum pname, uint32_t domain)
    {
    GLint val[2];
    glGetIntegerv(pname, val);
    CheckError(L);
    enums_push(L, domain, val[0]);
    enums_push(L, domain, val[1]);
    return 2;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl 0xc(%rsp), %edi
movq %rsp, %rsi
callq 0x116e0
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
movl (%rsp), %edx
callq 0x11120
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
movl 0x4(%rsp), %edx
callq 0x11120
movl $0x2, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/get.c
// Function: GetInt4OptIndex
static int GetInt4OptIndex(lua_State *L, GLenum pname) /* index is optional */
    {
    GLint64 data[4];
    GLuint index;
    if(!lua_isnoneornil(L, 2))
        {
        index = luaL_checkinteger(L, 2);
        glGetInteger64i_v(pname, index, data);
        }
    else
        glGetInteger64v(pname, data);
    CheckError(L);
    lua_pushinteger(L, data[0]);
    lua_pushinteger(L, data[1]);
    lua_pushinteger(L, data[2]);
    lua_pushinteger(L, data[3]);
    return 4;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rdi
movl $0x2, %esi
callq 0x11860
cmpl $0x0, %eax
jle 0x3673f
movq 0x40(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x31515(%rip), %rax     # 0x67c40
movq (%rax), %rax
movl 0x3c(%rsp), %edi
movl 0xc(%rsp), %esi
leaq 0x10(%rsp), %rdx
callq *%rax
jmp 0x36754
movq 0x30f9a(%rip), %rax     # 0x676e0
movq (%rax), %rax
movl 0x3c(%rsp), %edi
leaq 0x10(%rsp), %rsi
callq *%rax
movq 0x40(%rsp), %rdi
callq 0x11880
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x113c0
movq 0x40(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x113c0
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x113c0
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x113c0
movl $0x4, %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/getintformat.c
// Function: GetN
static int GetN(lua_State *L, GLenum target, GLenum internalformat, GLenum pname, GLenum numpname)
    {
    GLint64 *params;
    GLsizei i, num = GetNum(L, target, internalformat, numpname);
    if(num==0) return 0;
    params = (GLint64*)Malloc(L, num*sizeof(GLint64));
    glGetInternalformati64v(target, internalformat, pname, num*sizeof(GLint64), params);
    CheckErrorFree(L, params);
    for(i = 0; i<num; i++)
        lua_pushinteger(L, params[i]);
    Free(L, params);
    return num;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movl 0x18(%rsp), %ecx
callq 0x36ee0
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jne 0x36e38
movl $0x0, 0x34(%rsp)
jmp 0x36ed3
movq 0x28(%rsp), %rdi
movslq 0x8(%rsp), %rsi
shlq $0x3, %rsi
callq 0x11200
movq %rax, 0x10(%rsp)
movq 0x30ad1(%rip), %rax     # 0x67928
movq (%rax), %rax
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
movl 0x1c(%rsp), %edx
movslq 0x8(%rsp), %rcx
shlq $0x3, %rcx
movq 0x10(%rsp), %r8
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11550
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x36ebc
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x113c0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x36e8d
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11370
movl 0x8(%rsp), %eax
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/getstring.c
// Function: GetExtensions
static int GetExtensions(lua_State *L)
    {
    GLsizei i, count;
    const GLubyte *s;
    GLboolean byname = optboolean(L, 1, 0);

    count = getSizei(L, GL_NUM_EXTENSIONS);
    CheckError(L);

    lua_newtable(L);

    for(i=0; i<count; i++)
        {
        s = glGetStringi(GL_EXTENSIONS, i);
        CheckError(L);
        if(s == NULL)
            return luaL_error(L, UNEXPECTED_ERROR);
        if(byname)
            {
            lua_pushboolean(L, 1);
            lua_setfield(L, -2, (char*)s);
            }
        else
            {
            lua_pushstring(L, (char*)s);
            lua_rawseti(L, -2, i+1);
            }
        }

    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x112e0
movb %al, 0x7(%rsp)
movq 0x18(%rsp), %rdi
movl $0x821d, %esi           # imm = 0x821D
callq 0x11a70
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x11880
movq 0x18(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x11330
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x372c6
movq 0x306a2(%rip), %rax     # 0x678b8
movq (%rax), %rax
movl 0x14(%rsp), %esi
movl $0x1f03, %edi           # imm = 0x1F03
callq *%rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x11880
cmpq $0x0, 0x8(%rsp)
jne 0x37260
movq 0x18(%rsp), %rdi
leaq 0x1b03e(%rip), %rsi     # 0x52285
leaq 0x25844(%rip), %rdx     # 0x5ca92
movl $0x5d, %ecx
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
jmp 0x372ce
cmpb $0x0, 0x7(%rsp)
je 0x3728c
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x117f0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x118a0
jmp 0x372b4
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x110c0
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x117a0
jmp 0x372b6
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x37201
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/getstring.c
// Function: GetSpirVExtensions
static int GetSpirVExtensions(lua_State *L)
    {
    GLsizei i, count;
    const GLubyte *s;
    GLboolean byname = optboolean(L, 1, 0);

    count = getSizei(L, GL_NUM_SPIR_V_EXTENSIONS);
    CheckError(L);

    lua_newtable(L);

    for(i=0; i<count; i++)
        {
        s = glGetStringi(GL_SPIR_V_EXTENSIONS, i);
        CheckError(L);
        if(s == NULL)
            return luaL_error(L, UNEXPECTED_ERROR);
        if(byname)
            {
            lua_pushboolean(L, 1);
            lua_setfield(L, -2, (char*)s);
            }
        else
            {
            lua_pushstring(L, (char*)s);
            lua_rawseti(L, -2, i+1);
            }
        }

    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x112e0
movb %al, 0x7(%rsp)
movq 0x18(%rsp), %rdi
movl $0x9554, %esi           # imm = 0x9554
callq 0x11a70
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x11880
movq 0x18(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x11330
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x373f6
movq 0x30572(%rip), %rax     # 0x678b8
movq (%rax), %rax
movl 0x14(%rsp), %esi
movl $0x9553, %edi           # imm = 0x9553
callq *%rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x11880
cmpq $0x0, 0x8(%rsp)
jne 0x37390
movq 0x18(%rsp), %rdi
leaq 0x1af0e(%rip), %rsi     # 0x52285
leaq 0x25714(%rip), %rdx     # 0x5ca92
movl $0x7d, %ecx
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
jmp 0x373fe
cmpb $0x0, 0x7(%rsp)
je 0x373bc
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x117f0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x118a0
jmp 0x373e4
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x110c0
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x117a0
jmp 0x373e6
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x37331
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/getuniform.c
// Function: GetUniform
static int GetUniform(lua_State *L)
/* get_uniform(program, location, type, size) */
    {
    GLuint program = luaL_checkinteger(L, 1);
    GLint location = luaL_checkinteger(L, 2);
    GLenum type = checkuniformtype(L, 3);
    GLsizei size = luaL_checkinteger(L, 4); 
    if((size < 1) || (size>16))
        return luaL_argerror(L, 4, "out of range");
    switch(type)
        {
        case NONGL_BOOLEAN: return GetUniform_b(L, program, location, size);
        case GL_INT: return GetUniform_i(L, program, location, size);
        case GL_UNSIGNED_INT: return GetUniform_ui(L, program, location, size);
        case GL_FLOAT:  return GetUniform_f(L, program, location, size);
        case GL_DOUBLE: return GetUniform_d(L, program, location, size);
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
        }

    CheckError(L);
    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 $0x2, %esi
callq 0x11af0
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x34, %esi
movl $0x3, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movl %eax, 0x8(%rsp)
cmpl $0x1, 0x8(%rsp)
jl 0x37498
cmpl $0x10, 0x8(%rsp)
jle 0x374b7
movq 0x18(%rsp), %rdi
movl $0x4, %esi
leaq 0x255dc(%rip), %rdx     # 0x5ca85
callq 0x11940
movl %eax, 0x24(%rsp)
jmp 0x375ae
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x374fc
jmp 0x374c5
movl 0x4(%rsp), %eax
subl $0x1404, %eax           # imm = 0x1404
je 0x3751b
jmp 0x374d2
movl 0x4(%rsp), %eax
subl $0x1405, %eax           # imm = 0x1405
je 0x37537
jmp 0x374df
movl 0x4(%rsp), %eax
subl $0x1406, %eax           # imm = 0x1406
je 0x37553
jmp 0x374ec
movl 0x4(%rsp), %eax
subl $0x140a, %eax           # imm = 0x140A
je 0x3756f
jmp 0x3758b
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0x8(%rsp), %ecx
callq 0x38130
movl %eax, 0x24(%rsp)
jmp 0x375ae
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0x8(%rsp), %ecx
callq 0x381a0
movl %eax, 0x24(%rsp)
jmp 0x375ae
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0x8(%rsp), %ecx
callq 0x38220
movl %eax, 0x24(%rsp)
jmp 0x375ae
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0x8(%rsp), %ecx
callq 0x382a0
movl %eax, 0x24(%rsp)
jmp 0x375ae
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0x8(%rsp), %ecx
callq 0x38320
movl %eax, 0x24(%rsp)
jmp 0x375ae
movq 0x18(%rsp), %rdi
leaq 0x1acee(%rip), %rsi     # 0x52285
leaq 0x255e4(%rip), %rdx     # 0x5cb82
movl $0x51, %ecx
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/getuniform.c
// Function: GetUniformLocation
static int GetUniformLocation(lua_State *L)
    {
    GLuint program = luaL_checkinteger(L, 1);
    const GLchar *name = luaL_checkstring(L, 2);
    GLint loc = glGetUniformLocation(program, name);
    CheckError(L);
    if(loc==-1)
        return luaL_error(L, "invalid name '%s'", name);
    lua_pushinteger(L, loc);
    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 $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x11450
movq %rax, 0x8(%rsp)
movq 0x2fe9d(%rip), %rax     # 0x67498
movq (%rax), %rax
movl 0x14(%rsp), %edi
movq 0x8(%rsp), %rsi
callq *%rax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
callq 0x11880
cmpl $-0x1, 0x4(%rsp)
jne 0x3763c
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x25560(%rip), %rsi     # 0x5cb8f
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
jmp 0x37653
movq 0x18(%rsp), %rdi
movslq 0x4(%rsp), %rsi
callq 0x113c0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/getuniform.c
// Function: GetActiveUniformName
static int GetActiveUniformName(lua_State *L)
    {
    GLsizei maxlen, length;
    GLchar *name;
    GLuint program = luaL_checkinteger(L, 1);
    GLuint index = luaL_checkinteger(L, 2);

    maxlen = ActiveUniformMaxLength(L, program);
    name = (GLchar*)Malloc(L, maxlen*sizeof(GLchar));
    glGetActiveUniformName(program, index, maxlen, &length, name);
    CheckErrorFree(L, name);
    if(length > 0) 
        lua_pushstring(L, name);
    Free(L, name);
    return (length > 0) ? 1 : luaL_error(L, "invalid index %d", index);
    }

// 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 $0x2, %esi
callq 0x11af0
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x383d0
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
shlq $0x0, %rsi
callq 0x11200
movq %rax, 0x10(%rsp)
movq 0x30630(%rip), %rax     # 0x67cf0
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %r8
leaq 0x18(%rsp), %rcx
callq *%rax
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11550
cmpl $0x0, 0x18(%rsp)
jle 0x37700
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x110c0
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11370
cmpl $0x0, 0x18(%rsp)
jle 0x37721
movl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3773c
movq 0x20(%rsp), %rdi
movl 0x8(%rsp), %edx
leaq 0x25470(%rip), %rsi     # 0x5cba1
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/getuniform.c
// Function: GetActiveUniform
static int GetActiveUniform(lua_State *L)
/* name, type, size = get_active_uniform(program, index) */
    {
    GLsizei maxlen, length;
    GLchar *name;
    GLsizei size;
    GLenum type;
    GLuint program = luaL_checkinteger(L, 1);
    GLuint index = luaL_checkinteger(L, 2);
    maxlen = ActiveUniformMaxLength(L, program);
    name = (GLchar*)Malloc(L, maxlen*sizeof(GLchar));
    glGetActiveUniform(program, index, maxlen, &length, &size, &type, name);
    CheckErrorFree(L, name);
    if(length == 0)
        {
        Free(L, name);
        return luaL_error(L, "invalid index %d", index);
        }
    lua_pushstring(L, name);
    pushglsltype(L, type);
    lua_pushinteger(L, size);
    Free(L, name);
    return 3;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x383d0
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x24(%rsp), %rsi
shlq $0x0, %rsi
callq 0x11200
movq %rax, 0x18(%rsp)
movq 0x300f8(%rip), %rax     # 0x67ac8
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movl 0x24(%rsp), %edx
movq 0x18(%rsp), %r10
leaq 0x20(%rsp), %rcx
leaq 0x14(%rsp), %r8
leaq 0x10(%rsp), %r9
movq %r10, (%rsp)
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11550
cmpl $0x0, 0x20(%rsp)
jne 0x37a3b
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11370
movq 0x28(%rsp), %rdi
movl 0x8(%rsp), %edx
leaq 0x25173(%rip), %rsi     # 0x5cba1
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x34(%rsp)
jmp 0x37a83
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x110c0
movq 0x28(%rsp), %rdi
movl 0x10(%rsp), %edx
movl $0xe, %esi
callq 0x11120
movq 0x28(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x113c0
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11370
movl $0x3, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/getuniform.c
// Function: GetUniformBlockIndex
static int GetUniformBlockIndex(lua_State *L)
    {
    GLuint program = luaL_checkinteger(L, 1);
    const char *name = luaL_checkstring(L, 2);
    GLuint index = glGetUniformBlockIndex(program, 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 $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x11450
movq %rax, 0x8(%rsp)
movq 0x2ff4d(%rip), %rax     # 0x67d68
movq (%rax), %rax
movl 0x14(%rsp), %edi
movq 0x8(%rsp), %rsi
callq *%rax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
callq 0x11880
cmpl $-0x1, 0x4(%rsp)
jne 0x37e66
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x24d40(%rip), %rsi     # 0x5cb8f
movb $0x0, %al
callq 0x11170
movq 0x18(%rsp), %rdi
callq 0x11640
movl %eax, 0x24(%rsp)
jmp 0x37e7e
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 (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/getuniform.c
// Function: GetActiveUniformBlockName
static int GetActiveUniformBlockName(lua_State *L)
    {
    GLsizei length;
    GLuint program = luaL_checkinteger(L, 1);
    GLuint index = luaL_checkinteger(L, 2);
    GLsizei bufsz = GetAUB_NameLength(L, program, index);
    GLchar *name = (GLchar*)Malloc(L, bufsz*sizeof(GLchar));
    glGetActiveUniformBlockName(program, 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, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %edx
callq 0x38650
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x10(%rsp), %rsi
shlq $0x0, %rsi
callq 0x11200
movq %rax, 0x8(%rsp)
movq 0x2f22c(%rip), %rax     # 0x67120
movq (%rax), %rax
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movq 0x8(%rsp), %r8
leaq 0x1c(%rsp), %rcx
callq *%rax
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11550
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x110c0
movq 0x20(%rsp), %rdi
movq 0x8(%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/getuniform.c
// Function: GetActiveUniformBlock
static int GetActiveUniformBlock(lua_State *L)
    {
    GLuint program = luaL_checkinteger(L, 1);
    GLuint index = luaL_checkinteger(L, 2);
    GLenum pname = checkblockpname(L, 3);
    switch(pname)
        {
        case GL_UNIFORM_BLOCK_BINDING:
        case GL_UNIFORM_BLOCK_DATA_SIZE:
        case GL_UNIFORM_BLOCK_NAME_LENGTH:
        case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
        case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES:
                        return GetAUB_Int(L, program, index, pname);
        case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
        case GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER:
        case GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER:
        case GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER:
        case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
        case GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER:
                        return GetAUB_Boolean(L, program, index, 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 $0x2, %esi
callq 0x11af0
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x4d, %esi
movl $0x3, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
addl $0xffff7b10, %eax       # imm = 0xFFFF7B10
subl $0x2, %eax
jb 0x37ff4
jmp 0x37fab
movl 0x8(%rsp), %eax
addl $0xffff75c1, %eax       # imm = 0xFFFF75C1
subl $0x5, %eax
jb 0x37fd8
jmp 0x37fbb
movl 0x8(%rsp), %eax
addl $0xffff75bc, %eax       # imm = 0xFFFF75BC
subl $0x3, %eax
jb 0x37ff4
jmp 0x37fcb
movl 0x8(%rsp), %eax
subl $0x90ec, %eax           # imm = 0x90EC
je 0x37ff4
jmp 0x38010
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x386a0
movl %eax, 0x24(%rsp)
jmp 0x38033
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x38700
movl %eax, 0x24(%rsp)
jmp 0x38033
movq 0x18(%rsp), %rdi
leaq 0x1a269(%rip), %rsi     # 0x52285
leaq 0x24b5f(%rip), %rdx     # 0x5cb82
movl $0x13f, %ecx            # imm = 0x13F
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/getuniform.c
// Function: GetActiveAtomicCounterBuffer
static int GetActiveAtomicCounterBuffer(lua_State *L)
    {
    GLuint program = luaL_checkinteger(L, 1);
    GLuint index = luaL_checkinteger(L, 2);
    GLenum pname = checkacbpname(L, 3);
    switch(pname)
        {
        case GL_ATOMIC_COUNTER_BUFFER_BINDING:
        case GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE:
        case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS:
        case GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES:
                            return GetACB_Int(L, program, index, pname);
        case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER:
        case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER:
        case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER:
        case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER:
        case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER:
        case GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER:
                            return GetACB_Boolean(L, program, index, 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 $0x2, %esi
callq 0x11af0
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x4e, %esi
movl $0x3, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
subl $0x90ed, %eax           # imm = 0x90ED
je 0x380e1
jmp 0x38098
movl 0x8(%rsp), %eax
subl $0x92c1, %eax           # imm = 0x92C1
je 0x380c5
jmp 0x380a5
movl 0x8(%rsp), %eax
addl $0xffff6d3c, %eax       # imm = 0xFFFF6D3C
subl $0x3, %eax
jb 0x380c5
jmp 0x380b5
movl 0x8(%rsp), %eax
addl $0xffff6d39, %eax       # imm = 0xFFFF6D39
subl $0x5, %eax
jb 0x380e1
jmp 0x380fd
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x38760
movl %eax, 0x24(%rsp)
jmp 0x38120
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x387c0
movl %eax, 0x24(%rsp)
jmp 0x38120
movq 0x18(%rsp), %rdi
leaq 0x1a17c(%rip), %rsi     # 0x52285
leaq 0x24a72(%rip), %rdx     # 0x5cb82
movl $0x189, %ecx            # imm = 0x189
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/getuniform.c
// Function: GetType
static int GetType(lua_State *L, GLuint program, GLsizei count, GLuint *indices, GLenum pname, GLint *params)
    {
    int i;
    glGetActiveUniformsiv(program, count, indices, pname, params);
    CheckErrorFree2(L, indices, params);
    for(i = 0; i<count; i++)
        pushglsltype(L, params[i]); /* this may raise an error, but it would be symptom of a bug */
    Free(L, indices);
    Free(L, params);
    return count;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
movq %r9, 0x10(%rsp)
movq 0x2f1b9(%rip), %rax     # 0x675f0
movq (%rax), %rax
movl 0x2c(%rsp), %edi
movl 0x28(%rsp), %esi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %r8
callq *%rax
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x111e0
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x28(%rsp), %eax
jge 0x384a1
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movl $0xe, %esi
callq 0x11120
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3846e
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11370
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11370
movl 0x28(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)