LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/renderbuffer.c
// Function: GetRenderbufferParameter
static int GetRenderbufferParameter(lua_State *L)
    {
    int arg = 1;
    GLenum target;
    GLuint renderbuffer = checktargetorname(L, arg++, &target, DOMAIN_RENDERBUFFER_TARGET);
    GLenum pname = checkrenderbufferpname(L, arg++);
    switch(pname)
        {   
        case GL_RENDERBUFFER_WIDTH:
        case GL_RENDERBUFFER_HEIGHT:
        case GL_RENDERBUFFER_SAMPLES:
        case GL_RENDERBUFFER_RED_SIZE: 
        case GL_RENDERBUFFER_GREEN_SIZE: 
        case GL_RENDERBUFFER_BLUE_SIZE: 
        case GL_RENDERBUFFER_ALPHA_SIZE: 
        case GL_RENDERBUFFER_DEPTH_SIZE:
        case GL_RENDERBUFFER_STENCIL_SIZE: return GetInt(L, target, renderbuffer, pname);
        case GL_RENDERBUFFER_INTERNAL_FORMAT: 
            return GetInternalFormat(L, target, renderbuffer, pname);
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
        }
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x1, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %esi, %eax
incl %eax
movl %eax, 0x14(%rsp)
leaq 0x10(%rsp), %rdx
movl $0xf, %ecx
callq 0x11430
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %edx
movl %edx, %eax
incl %eax
movl %eax, 0x14(%rsp)
movl $0x10, %esi
callq 0x11160
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
subl $0x8cab, %eax           # imm = 0x8CAB
je 0x41652
jmp 0x41625
movl 0x4(%rsp), %eax
addl $0xffff72be, %eax       # imm = 0xFFFF72BE
subl $0x2, %eax
jb 0x41652
jmp 0x41635
movl 0x4(%rsp), %eax
subl $0x8d44, %eax           # imm = 0x8D44
je 0x4166e
jmp 0x41642
movl 0x4(%rsp), %eax
addl $0xffff72b0, %eax       # imm = 0xFFFF72B0
subl $0x5, %eax
ja 0x4168a
jmp 0x41652
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
callq 0x416c0
movl %eax, 0x24(%rsp)
jmp 0x416ad
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
callq 0x41730
movl %eax, 0x24(%rsp)
jmp 0x416ad
movq 0x18(%rsp), %rdi
leaq 0x10bef(%rip), %rsi     # 0x52285
leaq 0x1c0a6(%rip), %rdx     # 0x5d743
movl $0x6a, %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/renderbuffer.c
// Function: GetInt
static int GetInt(lua_State *L, GLenum target, GLuint renderbuffer, GLenum pname)
    {
    GLint param;
    if(renderbuffer==0)
        glGetRenderbufferParameteriv(target, pname, &param);
    else
        glGetNamedRenderbufferParameteriv(renderbuffer, pname, &param);
    CheckError(L);
    lua_pushinteger(L, param);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
cmpl $0x0, 0x8(%rsp)
jne 0x416f5
movq 0x26735(%rip), %rax     # 0x67e18
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x4(%rsp), %esi
movq %rsp, %rdx
callq *%rax
jmp 0x4170c
movq 0x25b74(%rip), %rax     # 0x67270
movq (%rax), %rax
movl 0x8(%rsp), %edi
movl 0x4(%rsp), %esi
movq %rsp, %rdx
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movslq (%rsp), %rsi
callq 0x113c0
movl $0x1, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/renderbuffer.c
// Function: GetInternalFormat
static int GetInternalFormat(lua_State *L, GLenum target, GLuint renderbuffer, GLenum pname)
    {
    GLint param;
    if(renderbuffer==0)
        glGetRenderbufferParameteriv(target, pname, &param);
    else
        glGetNamedRenderbufferParameteriv(renderbuffer, pname, &param);
    CheckError(L);
    return pushinternalformat(L, param);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
cmpl $0x0, 0x8(%rsp)
jne 0x41765
movq 0x266c5(%rip), %rax     # 0x67e18
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x4(%rsp), %esi
movq %rsp, %rdx
callq *%rax
jmp 0x4177c
movq 0x25b04(%rip), %rax     # 0x67270
movq (%rax), %rax
movl 0x8(%rsp), %edi
movl 0x4(%rsp), %esi
movq %rsp, %rdx
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movl (%rsp), %edx
movl $0x11, %esi
callq 0x11120
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/sampler.c
// Function: NewSampler
static int NewSampler(lua_State *L)
    {
    GLuint sampler;
    GLuint unit = luaL_optinteger(L, 1, 0);
    check_init_called(L);
    glGenSamplers(1, &sampler);
    CheckError(L);
    object_new(L, OTYPE_SAMPLER, sampler);
    glBindSampler(unit, sampler);
    CheckError(L);
    lua_pushinteger(L, sampler);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x11b30
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x115e0
movl $0x1, %edi
leaq 0xc(%rsp), %rsi
movq 0x2608d(%rip), %rax     # 0x67888
callq *(%rax)
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
movl $0x3, %esi
callq 0x11a90
movq 0x25a87(%rip), %rax     # 0x672a8
movq (%rax), %rax
movl 0x8(%rsp), %edi
movl 0xc(%rsp), %esi
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %esi
callq 0x113c0
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/sampler.c
// Function: SetEnum
static int SetEnum(lua_State *L, GLuint sampler, GLenum pname, int arg, uint32_t domain)
    {
    GLenum param = enums_check(L, domain, arg);
    glSamplerParameteri(sampler, pname, param);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
movl 0x14(%rsp), %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movq 0x257d1(%rip), %rax     # 0x67988
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movl 0xc(%rsp), %edx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/sampler.c
// Function: SetColor
static int SetColor(lua_State *L, GLuint sampler, GLenum pname, int arg)
    {
    GLfloat params[4];
    checkcolor(L, arg, params);
    glSamplerParameterfv(sampler, pname, params);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
movq %rsp, %rdx
callq 0x11400
movq 0x259b3(%rip), %rax     # 0x67bc0
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movq %rsp, %rdx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/sampler.c
// Function: SetFloat
static int SetFloat(lua_State *L, GLuint sampler, GLenum pname, int arg)
    {
    GLfloat param = luaL_checknumber(L, arg);
    glSamplerParameterf(sampler, 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)
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x11a80
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rsp)
movq 0x25b4d(%rip), %rax     # 0x67db0
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movss (%rsp), %xmm0
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/sampler.c
// Function: GetEnum
static int GetEnum(lua_State *L, GLuint sampler, GLenum pname, uint32_t domain)
    {
    GLint param;
    glGetSamplerParameteriv(sampler, pname, &param);
    CheckError(L);
    enums_push(L, domain, param);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
movq 0x259c4(%rip), %rax     # 0x67c70
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movq %rsp, %rdx
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
movl (%rsp), %edx
callq 0x11120
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/sampler.c
// Function: GetFloat4
static int GetFloat4(lua_State *L, GLuint sampler, GLenum pname)
    {
    GLfloat params[4];
    CheckError(L);
    glGetSamplerParameterfv(sampler, pname, params);
    lua_pushnumber(L, params[0]);
    lua_pushnumber(L, params[1]);
    lua_pushnumber(L, params[2]);
    lua_pushnumber(L, params[3]);
    return 4;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11880
movq 0x2503e(%rip), %rax     # 0x67350
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movq %rsp, %rdx
callq *%rax
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,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/sampler.c
// Function: GetFloat
static int GetFloat(lua_State *L, GLuint sampler, GLenum pname)
    {
    GLfloat param;
    CheckError(L);
    glGetSamplerParameterfv(sampler, pname, &param);
    lua_pushnumber(L, param);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x24fae(%rip), %rax     # 0x67350
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
leaq 0x4(%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movss 0x4(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11380
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/shader.c
// Function: CreateShader
static int CreateShader(lua_State *L)
    {
    GLenum type = checkshadertype(L, 1);
    GLuint ref;
    check_init_called(L);
    ref = glCreateShader(type);
    CheckError(L);
    object_new(L, OTYPE_SHADER, ref);
    lua_pushinteger(L, ref);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x11160
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x115e0
movq 0x25509(%rip), %rax     # 0x67938
movq (%rax), %rax
movl 0xc(%rsp), %edi
callq *%rax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %edx
movl $0x8, %esi
callq 0x11a90
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %eax
movl %eax, %esi
callq 0x113c0
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/shader.c
// Function: ShaderSource
static int ShaderSource(lua_State *L)
/* shader_source(shader, string) */
    {
    size_t len;
    GLint length;
    GLuint shader = luaL_checkinteger(L, 1);
    const GLchar *string = luaL_checklstring(L, 2, &len);
    length = (GLint)len;
    glShaderSource(shader, 1, &string, &length);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
leaq 0x18(%rsp), %rdx
callq 0x11450
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl %eax, 0x14(%rsp)
movq 0x2554b(%rip), %rax     # 0x67a10
movq (%rax), %rax
movl 0x10(%rsp), %edi
movl $0x1, %esi
leaq 0x8(%rsp), %rdx
leaq 0x14(%rsp), %rcx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/shader.c
// Function: CompileShader
static int CompileShader(lua_State *L)
    {
    char *buf;
    GLint ok, bufsz;
    GLuint name = luaL_checkinteger(L, 1);
    int check = lua_toboolean(L, 2);

    glCompileShader(name);
    CheckError(L);

    if(check)
        {
        glGetShaderiv(name, GL_COMPILE_STATUS, &ok);
        if(!ok)
            {
            glGetShaderiv(name, GL_INFO_LOG_LENGTH, &bufsz);
            CheckError(L);
            buf = (char*)Malloc(L, bufsz*sizeof(char));
            glGetShaderInfoLog(name, bufsz, NULL, buf);
            CheckErrorFree(L, buf);
            lua_pushfstring(L, "shader compile error: %s",buf);
            Free(L, buf);
            return lua_error(L);
            }
        }   
    return 0;
    }

// 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 $0x2, %esi
callq 0x11710
movl %eax, (%rsp)
movq 0x252d3(%rip), %rax     # 0x677f8
movq (%rax), %rax
movl 0x4(%rsp), %edi
callq *%rax
movq 0x18(%rsp), %rdi
callq 0x11880
cmpl $0x0, (%rsp)
je 0x42606
movq 0x24bef(%rip), %rax     # 0x67138
movq (%rax), %rax
movl 0x4(%rsp), %edi
movl $0x8b81, %esi           # imm = 0x8B81
leaq 0xc(%rsp), %rdx
callq *%rax
cmpl $0x0, 0xc(%rsp)
jne 0x42604
movq 0x24bca(%rip), %rax     # 0x67138
movq (%rax), %rax
movl 0x4(%rsp), %edi
movl $0x8b84, %esi           # imm = 0x8B84
leaq 0x8(%rsp), %rdx
callq *%rax
movq 0x18(%rsp), %rdi
callq 0x11880
movq 0x18(%rsp), %rdi
movslq 0x8(%rsp), %rsi
shlq $0x0, %rsi
callq 0x11200
movq %rax, 0x10(%rsp)
movq 0x255fe(%rip), %rax     # 0x67ba8
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
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x1b32a(%rip), %rsi     # 0x5d908
movb $0x0, %al
callq 0x11170
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11370
movq 0x18(%rsp), %rdi
callq 0x11640
movl %eax, 0x24(%rsp)
jmp 0x4260e
jmp 0x42606
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/shader.c
// Function: GetShaderInfoLog
static int GetShaderInfoLog(lua_State *L)
    {
    char *buf;
    GLint bufsz;
    GLuint name = luaL_checkinteger(L, 1);

    glGetShaderiv(name, GL_INFO_LOG_LENGTH, &bufsz);
    CheckError(L);
    if(bufsz==0) return 0;
    buf = (char*)Malloc(L, bufsz*sizeof(char));
    glGetShaderInfoLog(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 0x245c5(%rip), %rax     # 0x67138
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 0x42ba1
movl $0x0, 0x24(%rsp)
jmp 0x42c09
movq 0x18(%rsp), %rdi
movslq 0xc(%rsp), %rsi
shlq $0x0, %rsi
callq 0x11200
movq %rax, 0x10(%rsp)
movq 0x24fe8(%rip), %rax     # 0x67ba8
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/shader.c
// Function: GetShaderSource
static int GetShaderSource(lua_State *L)
    {
    char *buf;
    GLint bufsz;
    GLuint name = luaL_checkinteger(L, 1);

    glGetShaderiv(name, GL_SHADER_SOURCE_LENGTH, &bufsz);
    CheckError(L);
    if(bufsz==0) return 0;
    buf = (char*)Malloc(L, bufsz*sizeof(char));
    glGetShaderSource(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 0x244f5(%rip), %rax     # 0x67138
movq (%rax), %rax
movl 0x8(%rsp), %edi
movl $0x8b88, %esi           # imm = 0x8B88
leaq 0xc(%rsp), %rdx
callq *%rax
movq 0x18(%rsp), %rdi
callq 0x11880
cmpl $0x0, 0xc(%rsp)
jne 0x42c71
movl $0x0, 0x24(%rsp)
jmp 0x42cd9
movq 0x18(%rsp), %rdi
movslq 0xc(%rsp), %rsi
shlq $0x0, %rsi
callq 0x11200
movq %rax, 0x10(%rsp)
movq 0x24f70(%rip), %rax     # 0x67c00
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/shader.c
// Function: GetShader
static int GetShader(lua_State *L)
    {
#define BOOLEAN return GetBoolean(L, shader, pname);
#define INTEGER return GetInteger(L, shader, pname);
    GLuint shader = luaL_checkinteger(L, 1);
    GLenum pname = checkshaderpname(L, 2);
    switch(pname)
        {
        case GL_SHADER_TYPE: return GetEnum(L, shader, pname, DOMAIN_SHADER_TYPE);
        case GL_DELETE_STATUS: BOOLEAN
        case GL_COMPILE_STATUS: BOOLEAN
        case GL_INFO_LOG_LENGTH: INTEGER
        case GL_SHADER_SOURCE_LENGTH: INTEGER
        case GL_SPIR_V_BINARY: BOOLEAN //GL_VERSION_4_6
        default: return luaL_error(L, UNEXPECTED_ERROR);
        }
    return 0;
#undef BOOLEAN
#undef INTEGER
    }

// 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 $0x3b, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
subl $0x8b4f, %eax           # imm = 0x8B4F
je 0x42d81
jmp 0x42d35
movl 0xc(%rsp), %eax
subl $0x8b80, %eax           # imm = 0x8B80
je 0x42da1
jmp 0x42d42
movl 0xc(%rsp), %eax
subl $0x8b81, %eax           # imm = 0x8B81
je 0x42dbc
jmp 0x42d4f
movl 0xc(%rsp), %eax
subl $0x8b84, %eax           # imm = 0x8B84
je 0x42dd4
jmp 0x42d5c
movl 0xc(%rsp), %eax
subl $0x8b88, %eax           # imm = 0x8B88
je 0x42dec
jmp 0x42d6d
movl 0xc(%rsp), %eax
subl $0x9552, %eax           # imm = 0x9552
je 0x42e04
jmp 0x42e1c
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl $0x1, %ecx
callq 0x43190
movl %eax, 0x24(%rsp)
jmp 0x42e3f
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x431e0
movl %eax, 0x24(%rsp)
jmp 0x42e3f
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x431e0
movl %eax, 0x24(%rsp)
jmp 0x42e3f
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x43240
movl %eax, 0x24(%rsp)
jmp 0x42e3f
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x43240
movl %eax, 0x24(%rsp)
jmp 0x42e3f
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x431e0
movl %eax, 0x24(%rsp)
jmp 0x42e3f
movq 0x18(%rsp), %rdi
leaq 0xf45d(%rip), %rsi      # 0x52285
leaq 0x1ab47(%rip), %rdx     # 0x5d976
movl $0xe9, %ecx
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/shader.c
// Function: GetShaderPrecisionFormat
static int GetShaderPrecisionFormat(lua_State *L)
/* get_shader_precision_format(shadertype, precisiontype)
 * -> range0, range1, precision
 */
    {
    GLint range[2];
    GLint precision;
    GLenum type = checkshadertype(L, 1);
    GLenum precisiontype = checkprecisionformat(L, 2);
    glGetShaderPrecisionFormat(type, precisiontype, range, &precision);
    CheckError(L);
    lua_pushinteger(L, range[0]);
    lua_pushinteger(L, range[1]);
    lua_pushinteger(L, precision);
    return 3;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x11160
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3c, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movq 0x24b5b(%rip), %rax     # 0x679e8
movq (%rax), %rax
movl 0x10(%rsp), %edi
movl 0xc(%rsp), %esi
leaq 0x18(%rsp), %rdx
leaq 0x14(%rsp), %rcx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
movq 0x20(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0x113c0
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x113c0
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x113c0
movl $0x3, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/shader.c
// Function: BindFragDataLocation
static int BindFragDataLocation(lua_State *L)
    {
    int indexed = 0;
    GLuint index;
    GLuint program = luaL_checkinteger(L, 1);
    GLuint color = luaL_checkinteger(L, 2);
    const GLchar *name = luaL_checkstring(L, 3);
    if(lua_isinteger(L, 4))
        {
        indexed = 1;
        index = luaL_checkinteger(L, 4);
        }
    if(indexed)
        glBindFragDataLocationIndexed(program, color, index, name);
    else
        glBindFragDataLocation(program, color, name);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%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
xorl %eax, %eax
movl %eax, %edx
callq 0x11450
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x115c0
cmpl $0x0, %eax
je 0x42f6e
movl $0x1, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x42f94
movq 0x247d4(%rip), %rax     # 0x67750
movq (%rax), %rax
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
movl 0x18(%rsp), %edx
movq 0x8(%rsp), %rcx
callq *%rax
jmp 0x42fad
movq 0x248d5(%rip), %rax     # 0x67870
movq (%rax), %rax
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
movq 0x8(%rsp), %rdx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/shader.c
// Function: GetFragDataLocation
static int GetFragDataLocation(lua_State *L)
    {
    GLuint program = luaL_checkinteger(L, 1);
    const GLchar *name = luaL_checkstring(L, 2);
    GLint loc = glGetFragDataLocation(program, 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 $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x11450
movq %rax, 0x10(%rsp)
movq 0x24e65(%rip), %rax     # 0x67e60
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movq 0x10(%rsp), %rsi
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
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/shader.c
// Function: GetFragDataIndex
static int GetFragDataIndex(lua_State *L)
    {
    GLuint program = luaL_checkinteger(L, 1);
    const GLchar *name = luaL_checkstring(L, 2);
    GLint index = glGetFragDataIndex(program, name);
    CheckError(L);
    if(index == -1) // 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 0x2493d(%rip), %rax     # 0x679a8
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 0x430b6
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x19af0(%rip), %rsi     # 0x5cb8f
movb $0x0, %al
callq 0x11170
movq 0x18(%rsp), %rdi
callq 0x11640
movl %eax, 0x24(%rsp)
jmp 0x430cd
movq 0x18(%rsp), %rdi
movslq 0x4(%rsp), %rsi
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/shader.c
// Function: DispatchComputeIndirect
UINT3_FUNC(DispatchCompute)

static int DispatchComputeIndirect(lua_State *L)
    {
    GLintptr indirect= luaL_checkinteger(L, 1);
    glDispatchComputeIndirect(indirect);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movq %rax, 0x8(%rsp)
movq 0x2401c(%rip), %rax     # 0x67190
movq (%rax), %rax
movq 0x8(%rsp), %rdi
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/shader.c
// Function: GetBoolean
static int GetBoolean(lua_State *L, GLuint shader, GLenum pname)
    {
    GLint params; 
    glGetShaderiv(shader, 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 0x23f40(%rip), %rax     # 0x67138
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/subroutine.c
// Function: UniformBlockBinding
static int UniformBlockBinding(lua_State *L)
    {
    GLuint program = luaL_checkinteger(L, 1);
    GLuint index = luaL_checkinteger(L, 2);
    GLuint binding = luaL_checkinteger(L, 3);
    glUniformBlockBinding(program, index, binding);
    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 $0x2, %esi
callq 0x11af0
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x2427f(%rip), %rax     # 0x67578
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
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/subroutine.c
// Function: ShaderStorageBlockBinding
static int ShaderStorageBlockBinding(lua_State *L)
    {
    GLuint program = luaL_checkinteger(L, 1);
    GLuint index = luaL_checkinteger(L, 2);
    GLuint binding = luaL_checkinteger(L, 3);
    glShaderStorageBlockBinding(program, index, binding);
    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 $0x2, %esi
callq 0x11af0
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x2406f(%rip), %rax     # 0x673d8
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
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/subroutine.c
// Function: UniformSubroutines
static int UniformSubroutines(lua_State *L)
    {
    GLsizei count, arg, i;
    GLuint *indices;
    GLenum shadertype = checkshadertype(L, 1);
    arg = 2;
    while(!lua_isnoneornil(L, arg))
        luaL_checkinteger(L, arg++);
    if(arg == 2)
        return luaL_argerror(L, 2, "integer expected");
    count = arg - 2;
    indices = (GLuint*)Malloc(L, count*sizeof(GLint));
    arg = 2;
    for(i=0; i< count; i++)
        indices[i] = lua_tointeger(L, arg++);
    glUniformSubroutinesuiv(shadertype, count, indices);
    Free(L, indices);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x11160
movl %eax, 0xc(%rsp)
movl $0x2, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x11860
cmpl $0x0, %eax
setle %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x433d2
jmp 0x433eb
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
callq 0x11af0
jmp 0x433b6
cmpl $0x2, 0x20(%rsp)
jne 0x43411
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x197af(%rip), %rdx     # 0x5cbb2
callq 0x11940
movl %eax, 0x34(%rsp)
jmp 0x434bf
movl 0x20(%rsp), %eax
subl $0x2, %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x24(%rsp), %rsi
shlq $0x2, %rsi
callq 0x11200
movq %rax, 0x10(%rsp)
movl $0x2, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x43485
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x11040
movl %eax, %edx
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x43444
movq 0x24614(%rip), %rax     # 0x67aa0
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x24(%rsp), %esi
movq 0x10(%rsp), %rdx
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11370
movq 0x28(%rsp), %rdi
callq 0x11880
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/subroutine.c
// Function: GetActiveSubroutineUniform
static int GetActiveSubroutineUniform(lua_State *L)
    {
    GLuint program = luaL_checkinteger(L, 1);
    GLenum shadertype = checkshadertype(L, 2);
    GLuint index = luaL_checkinteger(L, 3);
    GLenum pname = checksubroutinepname(L, 4);
    
    switch(pname)
        {
        case GL_NUM_COMPATIBLE_SUBROUTINES:
            return GetInt(L, program, shadertype, index, pname);
        case GL_COMPATIBLE_SUBROUTINES:
            return GetCompatibleSubroutines(L, program, shadertype, index);
        case GL_UNIFORM_SIZE:
            return GetInt(L, program, shadertype, index, pname);
        case GL_UNIFORM_NAME_LENGTH:
            return GetInt(L, program, shadertype, index, pname);
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
        }
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
movl %esi, 0xc(%rsp)
callq 0x11af0
movl 0xc(%rsp), %esi
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl $0x3, %esi
movl %esi, 0x10(%rsp)
callq 0x11af0
movl 0x10(%rsp), %esi
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movl $0x4, %edx
callq 0x11160
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
subl $0x8a38, %eax           # imm = 0x8A38
je 0x435b4
jmp 0x43546
movl 0x14(%rsp), %eax
subl $0x8a39, %eax           # imm = 0x8A39
je 0x435d5
jmp 0x43557
movl 0x14(%rsp), %eax
subl $0x8e4a, %eax           # imm = 0x8E4A
je 0x43574
jmp 0x43564
movl 0x14(%rsp), %eax
subl $0x8e4b, %eax           # imm = 0x8E4B
je 0x43598
jmp 0x435f6
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movl 0x1c(%rsp), %ecx
movl 0x18(%rsp), %r8d
callq 0x43bc0
movl %eax, 0x34(%rsp)
jmp 0x43619
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movl 0x1c(%rsp), %ecx
callq 0x43c20
movl %eax, 0x34(%rsp)
jmp 0x43619
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movl 0x1c(%rsp), %ecx
movl 0x18(%rsp), %r8d
callq 0x43bc0
movl %eax, 0x34(%rsp)
jmp 0x43619
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movl 0x1c(%rsp), %ecx
movl 0x18(%rsp), %r8d
callq 0x43bc0
movl %eax, 0x34(%rsp)
jmp 0x43619
movq 0x28(%rsp), %rdi
leaq 0xec83(%rip), %rsi      # 0x52285
leaq 0x1a49f(%rip), %rdx     # 0x5daa8
movl $0x79, %ecx
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/subroutine.c
// Function: GetUniformSubroutine
static int GetUniformSubroutine(lua_State *L)
    {
    GLuint value;
    GLenum shadertype = checkshadertype(L, 1);
    GLint location = luaL_checkinteger(L, 2);
    glGetUniformSubroutineuiv(shadertype, location, &value);
    CheckError(L);
    lua_pushinteger(L, value);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x11160
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x246a0(%rip), %rax     # 0x67d08
movq (%rax), %rax
movl 0x8(%rsp), %edi
movl 0x4(%rsp), %esi
leaq 0xc(%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %esi
callq 0x113c0
movl $0x1, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/subroutine.c
// Function: GetSubroutineUniformLocation
static int GetSubroutineUniformLocation(lua_State *L)
    {
    GLuint program = luaL_checkinteger(L, 1);
    GLenum shadertype = checkshadertype(L, 2);
    const GLchar *name = luaL_checkstring(L, 3);
    GLint loc = glGetSubroutineUniformLocation(program, shadertype, 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 $0x1, %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 0x245c5(%rip), %rax     # 0x67cb8
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/subroutine.c
// Function: GetSubroutineIndex
static int GetSubroutineIndex(lua_State *L) 
    {
    GLuint program = luaL_checkinteger(L, 1);
    GLenum shadertype = checkshadertype(L, 2);
    const GLchar *name = luaL_checkstring(L, 3);
    GLuint index = glGetSubroutineIndex(program, shadertype, 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 $0x1, %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 0x23bbd(%rip), %rax     # 0x67340
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 0x437d2
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x193d4(%rip), %rsi     # 0x5cb8f
movb $0x0, %al
callq 0x11170
movq 0x18(%rsp), %rdi
callq 0x11640
movl %eax, 0x24(%rsp)
jmp 0x437ea
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/subroutine.c
// Function: GetActiveSubroutineName
static int GetActiveSubroutineName(lua_State *L)
    {
    GLsizei length;
    GLuint program = luaL_checkinteger(L, 1);
    GLenum shadertype = checkshadertype(L, 2);
    GLuint index = luaL_checkinteger(L, 3);
    GLsizei bufsz = GetProgramStage_(L, program, shadertype, 
                            GL_ACTIVE_SUBROUTINE_MAX_LENGTH);
    GLchar *name = (GLchar*)Malloc(L, bufsz*sizeof(GLchar));
    glGetActiveSubroutineName(program, shadertype, 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 $0x1, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %edx
movl $0x8e48, %ecx           # imm = 0x8E48
callq 0x43d00
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movslq 0xc(%rsp), %rsi
shlq $0x0, %rsi
callq 0x11200
movq %rax, (%rsp)
movq 0x24060(%rip), %rax     # 0x678e0
movq (%rax), %rax
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movq (%rsp), %r9
leaq 0x1c(%rsp), %r8
callq *%rax
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0x11550
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0x110c0
movq 0x20(%rsp), %rdi
movq (%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/subroutine.c
// Function: GetActiveSubroutineUniformName
static int GetActiveSubroutineUniformName(lua_State *L)
    {
    GLsizei length;
    GLuint program = luaL_checkinteger(L, 1);
    GLenum shadertype = checkshadertype(L, 2);
    GLuint index = luaL_checkinteger(L, 3);
    GLsizei bufsz = GetProgramStage_(L, program, shadertype, 
                            GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH);
    GLchar *name = (GLchar*)Malloc(L, bufsz*sizeof(GLchar));
    glGetActiveSubroutineUniformName(program, shadertype, 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 $0x1, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %edx
movl $0x8e49, %ecx           # imm = 0x8E49
callq 0x43d00
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movslq 0xc(%rsp), %rsi
shlq $0x0, %rsi
callq 0x11200
movq %rax, (%rsp)
movq 0x23cd8(%rip), %rax     # 0x67638
movq (%rax), %rax
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movq (%rsp), %r9
leaq 0x1c(%rsp), %r8
callq *%rax
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0x11550
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0x110c0
movq 0x20(%rsp), %rdi
movq (%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/subroutine.c
// Function: GetProgramStage
static int GetProgramStage(lua_State *L)
    {
    GLuint program = luaL_checkinteger(L, 1);
    GLenum shadertype = checkshadertype(L, 2);
    GLenum pname = checkstagepname(L, 3);
    switch(pname)
        {
        case GL_ACTIVE_SUBROUTINES: 
                return GetStageInt(L,program,shadertype,pname);
        case GL_ACTIVE_SUBROUTINE_UNIFORMS: 
                return GetStageInt(L,program,shadertype,pname);
        case GL_ACTIVE_SUBROUTINE_MAX_LENGTH: 
                return GetStageInt(L,program,shadertype,pname);
        case GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS: 
                return GetStageInt(L,program,shadertype,pname);
        case GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH: 
                return GetStageInt(L,program,shadertype,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
movl %esi, (%rsp)
callq 0x11af0
movl (%rsp), %esi
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %edx
movl %edx, 0x4(%rsp)
callq 0x11160
movl 0x4(%rsp), %esi
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x3, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
subl $0x8de5, %eax           # imm = 0x8DE5
je 0x43a58
jmp 0x43a21
movl 0x8(%rsp), %eax
subl $0x8de6, %eax           # imm = 0x8DE6
je 0x43a77
jmp 0x43a2e
movl 0x8(%rsp), %eax
subl $0x8e47, %eax           # imm = 0x8E47
je 0x43aaf
jmp 0x43a3b
movl 0x8(%rsp), %eax
subl $0x8e48, %eax           # imm = 0x8E48
je 0x43a93
jmp 0x43a48
movl 0x8(%rsp), %eax
subl $0x8e49, %eax           # imm = 0x8E49
je 0x43acb
jmp 0x43ae7
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x43d50
movl %eax, 0x24(%rsp)
jmp 0x43b0a
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x43d50
movl %eax, 0x24(%rsp)
jmp 0x43b0a
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x43d50
movl %eax, 0x24(%rsp)
jmp 0x43b0a
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x43d50
movl %eax, 0x24(%rsp)
jmp 0x43b0a
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x43d50
movl %eax, 0x24(%rsp)
jmp 0x43b0a
movq 0x18(%rsp), %rdi
leaq 0xe792(%rip), %rsi      # 0x52285
leaq 0x19fae(%rip), %rdx     # 0x5daa8
movl $0xde, %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/subroutine.c
// Function: MemoryBarrier
static int MemoryBarrier(lua_State *L)
    {
    GLbitfield barriers = CheckBarrierBit(L, 1, 1);
    glMemoryBarrier(barriers);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %edx
leaq 0x24c96(%rip), %rcx     # 0x687d0
movl %edx, %esi
callq 0x11b50
movl %eax, 0xc(%rsp)
movq 0x237fc(%rip), %rax     # 0x67348
movq (%rax), %rax
movl 0xc(%rsp), %edi
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/subroutine.c
// Function: MemoryBarrierByRegion
static int MemoryBarrierByRegion(lua_State *L)
    {
    GLbitfield barriers = CheckBarrierBit(L, 1, 1);
    glMemoryBarrierByRegion(barriers);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %edx
leaq 0x24c46(%rip), %rcx     # 0x687d0
movl %edx, %esi
callq 0x11b50
movl %eax, 0xc(%rsp)
movq 0x243a4(%rip), %rax     # 0x67f40
movq (%rax), %rax
movl 0xc(%rsp), %edi
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/subroutine.c
// Function: GetInt
static int GetInt(lua_State *L, GLuint program, GLenum shadertype, GLuint index, GLenum pname)
    {
    GLint value;
    glGetActiveSubroutineUniformiv(program, shadertype, index, pname, &value);
    CheckError(L);
    lua_pushinteger(L, value);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movq 0x23d1f(%rip), %rax     # 0x67900
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
leaq 0xc(%rsp), %r8
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
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/subroutine.c
// Function: GetCompatibleSubroutines
static int GetCompatibleSubroutines(lua_State *L, GLuint program, GLenum shadertype, GLuint index)
    {
    GLint count, i;
    GLint *values;
    glGetActiveSubroutineUniformiv
        (program, shadertype, index, GL_NUM_COMPATIBLE_SUBROUTINES, &count);
    CheckError(L);
    values = (GLint*)Malloc(L, count*sizeof(GLint));
    glGetActiveSubroutineUniformiv
        (program, shadertype, index, GL_COMPATIBLE_SUBROUTINES, values);
    CheckErrorFree(L, values);
    for(i=0; i<count; i++)
        lua_pushinteger(L, values[i]);
    Free(L, values);
    return count;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x23cc4(%rip), %rax     # 0x67900
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %edx
movl $0x8e4a, %ecx           # imm = 0x8E4A
leaq 0x10(%rsp), %r8
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
movq 0x20(%rsp), %rdi
movslq 0x10(%rsp), %rsi
shlq $0x2, %rsi
callq 0x11200
movq %rax, (%rsp)
movq 0x23c81(%rip), %rax     # 0x67900
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %edx
movq (%rsp), %r8
movl $0x8e4b, %ecx           # imm = 0x8E4B
callq *%rax
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0x11550
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x43cdd
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movslq 0xc(%rsp), %rcx
movslq (%rax,%rcx,4), %rsi
callq 0x113c0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x43caf
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0x11370
movl 0x10(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/subroutine.c
// Function: GetStageInt
static int GetStageInt(lua_State *L, GLuint program, GLenum shadertype, GLenum pname)
    {
    GLint value;
    glGetProgramStageiv(program, shadertype, pname, &value);
    CheckError(L);
    lua_pushinteger(L, value);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
movq 0x23de4(%rip), %rax     # 0x67b50
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movl 0x4(%rsp), %edx
movq %rsp, %rcx
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movslq (%rsp), %rsi
callq 0x113c0
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/sync.c
// Function: FenceSync
static int FenceSync(lua_State *L)
    {
    node_t *node;
    GLsync sync; 
    GLbitfield flags = 0;
    GLenum condition = checkcondition(L, 1);
    sync = glFenceSync(condition, flags);
    CheckError(L);
    if(sync==0) /* paranoia... */
        return luaL_error(L, "cannot create sync");
    if((node=node_new(sync))==NULL)
        {
        glDeleteSync(sync);
        CheckError(L);
        return luaL_error(L, "cannot create sync");
        }
    lua_pushinteger(L, node->id);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x18(%rsp), %rdi
movl $0x3d, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, (%rsp)
movq 0x23441(%rip), %rax     # 0x67240
movq (%rax), %rax
movl (%rsp), %edi
movl 0x4(%rsp), %esi
callq *%rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x11880
cmpq $0x0, 0x8(%rsp)
jne 0x43e3b
movq 0x18(%rsp), %rdi
leaq 0x19d6c(%rip), %rsi     # 0x5db9a
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
jmp 0x43e9f
movq 0x8(%rsp), %rdi
callq 0x44240
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0x43e84
movq 0x24071(%rip), %rax     # 0x67ec8
movq (%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movq 0x18(%rsp), %rdi
callq 0x11880
movq 0x18(%rsp), %rdi
leaq 0x19d23(%rip), %rsi     # 0x5db9a
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
jmp 0x43e9f
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movslq 0x20(%rax), %rsi
callq 0x113c0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/sync.c
// Function: DeleteSync
static int DeleteSync(lua_State *L)
    {
    node_t *node = CheckSync(L, 1);
    GLsync sync = node->sync;
    node_free(node);
    glDeleteSync(sync);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x44ad0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x44b40
movq 0x23fdd(%rip), %rax     # 0x67ec8
movq (%rax), %rax
movq (%rsp), %rdi
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)