LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/texture.c
// Function: GetEnum
static int GetEnum(lua_State *L, GLuint texture, GLenum target, GLenum pname, uint32_t domain)
    {
    GLint param;
    if(texture==0)
        glGetTexParameteriv(target, pname, &param);
    else
        glGetTextureParameteriv(texture, pname, &param);
    CheckError(L);
    enums_push(L, domain, param);
    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)
cmpl $0x0, 0x1c(%rsp)
jne 0x49605
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
leaq 0xc(%rsp), %rdx
callq 0x119a0
jmp 0x4961e
movq 0x1ddbc(%rip), %rax     # 0x673c8
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x14(%rsp), %esi
leaq 0xc(%rsp), %rdx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
callq 0x11120
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/texture.c
// Function: GetFloat4
static int GetFloat4(lua_State *L, GLuint texture, GLenum target, GLenum pname)
    {
    GLfloat param[4];
    if(texture==0)
        glGetTexParameterfv(target, pname, param);
    else
        glGetTextureParameterfv(texture, pname, param);
    CheckError(L);
    lua_pushnumber(L, param[0]); 
    lua_pushnumber(L, param[1]); 
    lua_pushnumber(L, param[2]); 
    lua_pushnumber(L, param[3]); 
    return 4;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x4970e
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
movq %rsp, %rdx
callq 0x11360
jmp 0x49725
movq 0x1de1b(%rip), %rax     # 0x67530
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x14(%rsp), %esi
movq %rsp, %rdx
callq *%rax
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,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/texture.c
// Function: GetFloat
static int GetFloat(lua_State *L, GLuint texture, GLenum target, GLenum pname)
    {
    GLfloat param;
    if(texture==0)
        glGetTexParameterfv(target, pname, &param);
    else
        glGetTextureParameterfv(texture, pname, &param);
    CheckError(L);
    lua_pushnumber(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, 0xc(%rsp)
jne 0x497be
movl 0x8(%rsp), %edi
movl 0x4(%rsp), %esi
movq %rsp, %rdx
callq 0x11360
jmp 0x497d5
movq 0x1dd6b(%rip), %rax     # 0x67530
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x4(%rsp), %esi
movq %rsp, %rdx
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movss (%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11380
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/texture.c
// Function: GetEnum4
static int GetEnum4(lua_State *L, GLuint texture, GLenum target, GLenum pname, uint32_t domain)
    {
    GLint param[4];
    if(texture==0)
        glGetTexParameteriv(target, pname, param);
    else
        glGetTextureParameteriv(texture, pname, param);
    CheckError(L);
    enums_push(L, domain, param[0]);
    enums_push(L, domain, param[1]);
    enums_push(L, domain, param[2]);
    enums_push(L, domain, param[3]);
    return 4;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x49833
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
movq %rsp, %rdx
callq 0x119a0
jmp 0x4984a
movq 0x1db8e(%rip), %rax     # 0x673c8
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x14(%rsp), %esi
movq %rsp, %rdx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
movl (%rsp), %edx
callq 0x11120
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
movl 0x4(%rsp), %edx
callq 0x11120
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
movl 0x8(%rsp), %edx
callq 0x11120
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
callq 0x11120
movl $0x4, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/texture.c
// Function: LGetEnum
static int LGetEnum(lua_State *L, GLuint texture, GLenum target, GLint level, GLenum pname, uint32_t domain)
    {
    GLint param;
    if(texture==0)
        glGetTexLevelParameteriv(target, level, pname, &param);
    else
        glGetTextureLevelParameteriv(texture, level, pname, &param);
    CheckError(L);
    enums_push(L, domain, param);
    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)
movl %r9d, 0xc(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x4998e
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
leaq 0x8(%rsp), %rcx
callq 0x11a10
jmp 0x499ab
movq 0x1e313(%rip), %rax     # 0x67ca8
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
leaq 0x8(%rsp), %rcx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
callq 0x11120
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/transform.c
// Function: TransformFeedbackBufferRange
static int TransformFeedbackBufferRange(lua_State *L)
    {
    GLuint xfb = luaL_checkinteger(L, 1);
    GLuint index = luaL_checkinteger(L, 2);
    GLuint buffer = luaL_checkinteger(L, 3);
    GLintptr offset = luaL_checkinteger(L, 4);
    GLsizei size = luaL_checkinteger(L, 5);
    glTransformFeedbackBufferRange(xfb, index, buffer, offset, size);
    CheckError(L);
    return 0;
    }

// 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
callq 0x11af0
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x5, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x1d4a8(%rip), %rax     # 0x67418
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %edx
movq 0x8(%rsp), %rcx
movslq 0x4(%rsp), %r8
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/transform.c
// Function: DrawTransformFeedback
static int DrawTransformFeedback(lua_State *L)
    {
    GLsizei instancecount;
    GLenum mode = checkdrawmode(L, 1);
    GLuint id = luaL_checkinteger(L, 2);
    if(lua_isnoneornil(L, 3))
        glDrawTransformFeedback(mode, id);
    else
        {
        instancecount = luaL_checkinteger(L, 3);
        glDrawTransformFeedbackInstanced(mode, id, instancecount);
        }
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x11860
cmpl $0x0, %eax
jg 0x49ffe
movq 0x1d229(%rip), %rax     # 0x67218
movq (%rax), %rax
movl 0x8(%rsp), %edi
movl 0x4(%rsp), %esi
callq *%rax
jmp 0x4a029
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x1da78(%rip), %rax     # 0x67a90
movq (%rax), %rax
movl 0x8(%rsp), %edi
movl 0x4(%rsp), %esi
movl 0xc(%rsp), %edx
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/transform.c
// Function: DrawTransformFeedbackStream
static int DrawTransformFeedbackStream(lua_State *L)
    {
    GLsizei instancecount;
    GLenum mode = checkdrawmode(L, 1);
    GLuint id = luaL_checkinteger(L, 2);
    GLuint stream = luaL_checkinteger(L, 3);
    if(lua_isnoneornil(L, 4))
        glDrawTransformFeedbackStream(mode, id, stream);
    else
        {
        instancecount = luaL_checkinteger(L, 4);
        glDrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
        }
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, (%rsp)
movq 0x10(%rsp), %rdi
movl $0x4, %esi
callq 0x11860
cmpl $0x0, %eax
jg 0x4a0b3
movq 0x1d767(%rip), %rax     # 0x67808
movq (%rax), %rax
movl 0x8(%rsp), %edi
movl 0x4(%rsp), %esi
movl (%rsp), %edx
callq *%rax
jmp 0x4a0e1
movq 0x10(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x1d82b(%rip), %rax     # 0x678f8
movq (%rax), %rax
movl 0x8(%rsp), %edi
movl 0x4(%rsp), %esi
movl (%rsp), %edx
movl 0xc(%rsp), %ecx
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/transform.c
// Function: TransformFeedbackVaryings
static int TransformFeedbackVaryings(lua_State *L)
/* transform_feedback_varyings(program, mode, varying1 [, varying2, ...])
 */
    {
    GLsizei count, arg, i;
    const GLchar **varyings;
    GLuint program = luaL_checkinteger(L, 1);
    GLenum mode = checkbuffermode(L, 2);
    arg = 3;
    while(!lua_isnoneornil(L, arg))
        luaL_checkstring(L, arg++);
    if(arg == 3)
        luaL_checkstring(L, arg); /* raise an error */
    count = arg - 3;
    varyings = (const GLchar**)Malloc(L, count*sizeof(GLchar*));
    arg = 3;
    for(i=0; i<count; i++)
        varyings[i] = lua_tostring(L, arg++);
    glTransformFeedbackVaryings(program, count, varyings, mode);
    Free(L, varyings);  
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movl $0x57, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, (%rsp)
movl $0x3, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x11860
cmpl $0x0, %eax
setle %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4a157
jmp 0x4a174
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x11450
jmp 0x4a13b
cmpl $0x3, 0x18(%rsp)
jne 0x4a18d
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x11450
movl 0x18(%rsp), %eax
subl $0x3, %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
shlq $0x3, %rsi
callq 0x11200
movq %rax, 0x8(%rsp)
movl $0x3, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x4a203
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x11950
movq %rax, %rdx
movq 0x8(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4a1c0
movq 0x1d7ce(%rip), %rax     # 0x679d8
movq (%rax), %rax
movl 0x4(%rsp), %edi
movl 0x1c(%rsp), %esi
movq 0x8(%rsp), %rdx
movl (%rsp), %ecx
callq *%rax
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11370
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/transform.c
// Function: GetTransformFeedbackVarying
static int GetTransformFeedbackVarying(lua_State *L)
/* get_transform_feedback_varying(program, index)
 * -> name, type, size
 */
    {
    GLchar *name;
    GLenum type;
    GLsizei bufsz, length, size;
    GLuint program = luaL_checkinteger(L, 1);
    GLuint index = luaL_checkinteger(L, 2);
    bufsz = programGet(L, program, GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH);
    name = (GLchar*)Malloc(L, bufsz*sizeof(GLchar));
    glGetTransformFeedbackVarying(program, index, bufsz, &length, &size, &type, name);
    CheckErrorFree(L, name);
    if(length == 0)
        { Free(L, name); return 0; }
    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
movl $0x8c76, %edx           # imm = 0x8C76
callq 0x11850
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x18(%rsp), %rsi
shlq $0x0, %rsi
callq 0x11200
movq %rax, 0x20(%rsp)
movq 0x1ce53(%rip), %rax     # 0x670f8
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movl 0x18(%rsp), %edx
movq 0x20(%rsp), %r10
leaq 0x14(%rsp), %rcx
leaq 0x10(%rsp), %r8
leaq 0x1c(%rsp), %r9
movq %r10, (%rsp)
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11550
cmpl $0x0, 0x14(%rsp)
jne 0x4a2fd
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11370
movl $0x0, 0x34(%rsp)
jmp 0x4a345
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x110c0
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl $0xe, %esi
callq 0x11120
movq 0x28(%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0x113c0
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11370
movl $0x3, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/transform.c
// Function: GetTransformFeedback
static int GetTransformFeedback(lua_State *L)
    {
    GLuint index;
    GLint param;
    GLint64 param64;
    GLuint xfb = luaL_checkinteger(L, 1);
    GLenum pname = checktransformpname(L, 2);
    switch(pname)
        {
        case GL_TRANSFORM_FEEDBACK_PAUSED:
        case GL_TRANSFORM_FEEDBACK_ACTIVE:
                    glGetTransformFeedbackiv(xfb, pname, &param);
                    CheckError(L);
                    lua_pushboolean(L, param);
                    return 1;
        case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
                    index = luaL_checkinteger(L, 3);
                    glGetTransformFeedbacki_v(xfb, pname, index, &param);
                    CheckError(L);
                    lua_pushinteger(L, param);
                    return 1;
        case GL_TRANSFORM_FEEDBACK_BUFFER_START:
        case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
                    index = luaL_checkinteger(L, 3);
                    glGetTransformFeedbacki64_v(xfb, pname, index, &param64);
                    CheckError(L);
                    lua_pushinteger(L, param64);
                    return 1;
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
        }
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl $0xd, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
addl $0xffff737c, %eax       # imm = 0xFFFF737C
subl $0x2, %eax
jb 0x4a44e
jmp 0x4a39c
movl 0xc(%rsp), %eax
subl $0x8c8f, %eax           # imm = 0x8C8F
je 0x4a3fb
jmp 0x4a3a9
movl 0xc(%rsp), %eax
addl $0xffff71dd, %eax       # imm = 0xFFFF71DD
subl $0x1, %eax
ja 0x4a4a1
jmp 0x4a3bd
movq 0x1d28c(%rip), %rax     # 0x67650
movq (%rax), %rax
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
leaq 0x20(%rsp), %rdx
callq *%rax
movq 0x28(%rsp), %rdi
callq 0x11880
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x117f0
movl $0x1, 0x34(%rsp)
jmp 0x4a4c4
movq 0x28(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x24(%rsp)
movq 0x1d8d3(%rip), %rax     # 0x67ce8
movq (%rax), %rax
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
movl 0x24(%rsp), %edx
leaq 0x20(%rsp), %rcx
callq *%rax
movq 0x28(%rsp), %rdi
callq 0x11880
movq 0x28(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0x113c0
movl $0x1, 0x34(%rsp)
jmp 0x4a4c4
movq 0x28(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x24(%rsp)
movq 0x1cdc0(%rip), %rax     # 0x67228
movq (%rax), %rax
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
movl 0x24(%rsp), %edx
leaq 0x18(%rsp), %rcx
callq *%rax
movq 0x28(%rsp), %rdi
callq 0x11880
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x113c0
movl $0x1, 0x34(%rsp)
jmp 0x4a4c4
movq 0x28(%rsp), %rdi
leaq 0x7dd8(%rip), %rsi      # 0x52285
leaq 0x13c45(%rip), %rdx     # 0x5e0f9
movl $0xb9, %ecx
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/transform.c
// Function: ProvokingVertex
static int ProvokingVertex(lua_State *L)
    {
    GLenum mode = checkprovokemode(L, 1);
    glProvokingVertex(mode);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0xa, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movq 0x1d880(%rip), %rax     # 0x67d78
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/transform.c
// Function: ClipControl
static int ClipControl(lua_State *L)
    {
    GLenum origin = checkorigin(L, 1);
    GLenum depth = checkdepth(L, 2);
    glClipControl(origin, depth);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0xb, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0xc, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x8(%rsp)
movq 0x1d5c0(%rip), %rax     # 0x67b20
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/transform.c
// Function: DepthRange
static int DepthRange(lua_State *L)
    {
    GLuint index;
    GLdouble near = luaL_checknumber(L, 1);
    GLdouble far = luaL_checknumber(L, 2);
    if(lua_isnoneornil(L, 3))
        glDepthRange(near, far);
    else
        {
        index = luaL_checkinteger(L, 3);
        glDepthRangeIndexed(index, near, far);
        }
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x11a80
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x11a80
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x11860
cmpl $0x0, %eax
jg 0x4a5da
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x115f0
jmp 0x4a609
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x1c(%rsp)
movq 0x1d794(%rip), %rax     # 0x67d88
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/transform.c
// Function: DepthRangeArray
static int DepthRangeArray(lua_State *L)
    {
    GLdouble *v;
    GLsizei count, i, arg;
    GLuint first = luaL_checkinteger(L, 1);
    arg=2;
    while(!lua_isnoneornil(L, arg)) 
        luaL_checknumber(L, arg++);
    count = arg - 2;    
    if((count==0) || ((count % 2) != 0))
        return luaL_error(L, NARGS_ERROR);
    v = (GLdouble*)Malloc(L, count*sizeof(GLdouble));
    arg=2;
    for(i = 0; i < count; i++)
        v[i] = lua_tonumber(L, arg++);
    glDepthRangeArrayv(first, count/2, v);
    Free(L, v);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0x10(%rsp)
movl $0x2, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x11860
cmpl $0x0, %eax
setle %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4a660
jmp 0x4a679
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
callq 0x11a80
jmp 0x4a644
movl 0x14(%rsp), %eax
subl $0x2, %eax
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x4a69c
movl 0x1c(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x4a6b8
movq 0x28(%rsp), %rdi
leaq 0x7ed6(%rip), %rsi      # 0x5257e
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x34(%rsp)
jmp 0x4a76f
movq 0x28(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
shlq $0x3, %rsi
callq 0x11200
movq %rax, 0x20(%rsp)
movl $0x2, 0x14(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x4a721
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x11790
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x4a6e0
movq 0x1cdb8(%rip), %rax     # 0x674e0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x10(%rsp), %edi
movl 0x1c(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rdx
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x20(%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/transform.c
// Function: Viewport
static int Viewport(lua_State *L)
    {
    GLuint index;
    GLfloat  v[4];
    GLint x, y;
    GLsizei w, h;
    if(lua_isnoneornil(L, 5))
        {
        x = luaL_checkinteger(L, 1);
        y = luaL_checkinteger(L, 2);
        w = luaL_checkinteger(L, 3);
        h = luaL_checkinteger(L, 4);
        glViewport(x, y, w, h);
        }
    else
        {
        index = luaL_checkinteger(L, 5);
        v[0] = luaL_checknumber(L, 1);
        v[1] = luaL_checknumber(L, 2);
        v[2] = luaL_checknumber(L, 3);
        v[3] = luaL_checknumber(L, 4);
        glViewportIndexedfv(index, v);
        }
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl $0x5, %esi
callq 0x11860
cmpl $0x0, %eax
jg 0x4a801
movq 0x30(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x30(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movl %eax, (%rsp)
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movl 0x4(%rsp), %edx
movl (%rsp), %ecx
callq 0x11a50
jmp 0x4a88d
movq 0x30(%rsp), %rdi
movl $0x5, %esi
callq 0x11af0
movl %eax, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
callq 0x11a80
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x11a80
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movl $0x3, %esi
callq 0x11a80
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl $0x4, %esi
callq 0x11a80
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rsp)
movq 0x1d5f9(%rip), %rax     # 0x67e78
movq (%rax), %rax
movl 0x2c(%rsp), %edi
leaq 0x10(%rsp), %rsi
callq *%rax
movq 0x30(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/transform.c
// Function: ViewportArray
static int ViewportArray(lua_State *L)
    {
    GLfloat *v;
    GLsizei count, i, arg;
    GLuint first = luaL_checkinteger(L, 1);
    arg=2;
    count=0;
    while(lua_isnumber(L,arg++)) count++;
    if((count==0) || ((count % 4) != 0))
        return luaL_error(L, NARGS_ERROR);
    v = (GLfloat*)Malloc(L, count*sizeof(GLfloat));
    i=0; arg=2;
    while(i<count)
        v[i++] = lua_tonumber(L, arg++);
    glViewportArrayv(first, count/4, v);
    Free(L, v);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0x10(%rsp)
movl $0x2, 0x14(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
callq 0x113a0
cmpl $0x0, %eax
je 0x4a8f5
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4a8cc
cmpl $0x0, 0x1c(%rsp)
je 0x4a90d
movl 0x1c(%rsp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x4a929
movq 0x28(%rsp), %rdi
leaq 0x7c65(%rip), %rsi      # 0x5257e
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x34(%rsp)
jmp 0x4a9e4
movq 0x28(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
shlq $0x2, %rsi
callq 0x11200
movq %rax, 0x20(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x2, 0x14(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x4a996
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x11790
cvtsd2ss %xmm0, %xmm0
movq 0x20(%rsp), %rax
movl 0x18(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x18(%rsp)
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0x4a951
movq 0x1ca43(%rip), %rax     # 0x673e0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x10(%rsp), %edi
movl 0x1c(%rsp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %esi
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rdx
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11370
movq 0x28(%rsp), %rdi
callq 0x11880
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/uniform.c
// Function: Uniform
static int Uniform(lua_State *L)
    {
    GLint location = luaL_checkinteger(L, 1);
    GLenum type = checkuniformtype(L, 2);
#define arg_first 3
    switch(type)
        {
        case NONGL_BOOLEAN: return Uniform_b(L, location, arg_first);
        case GL_INT: return Uniform_i(L, location, arg_first);
        case GL_UNSIGNED_INT: return Uniform_ui(L, location, arg_first);
        case GL_FLOAT: return Uniform_f(L, location, arg_first);
        case GL_DOUBLE: return Uniform_d(L, location, arg_first);
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
        }
    return 0;
#undef arg_first
    }

// 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 $0x34, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x4aa89
jmp 0x4aa52
movl 0xc(%rsp), %eax
subl $0x1404, %eax           # imm = 0x1404
je 0x4aaa5
jmp 0x4aa5f
movl 0xc(%rsp), %eax
subl $0x1405, %eax           # imm = 0x1405
je 0x4aabe
jmp 0x4aa6c
movl 0xc(%rsp), %eax
subl $0x1406, %eax           # imm = 0x1406
je 0x4aad7
jmp 0x4aa79
movl 0xc(%rsp), %eax
subl $0x140a, %eax           # imm = 0x140A
je 0x4aaf0
jmp 0x4ab09
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl $0x3, %edx
callq 0x4b530
movl %eax, 0x24(%rsp)
jmp 0x4ab2c
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl $0x3, %edx
callq 0x4b6a0
movl %eax, 0x24(%rsp)
jmp 0x4ab2c
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl $0x3, %edx
callq 0x4b810
movl %eax, 0x24(%rsp)
jmp 0x4ab2c
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl $0x3, %edx
callq 0x4b980
movl %eax, 0x24(%rsp)
jmp 0x4ab2c
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl $0x3, %edx
callq 0x4baf0
movl %eax, 0x24(%rsp)
jmp 0x4ab2c
movq 0x18(%rsp), %rdi
leaq 0x7770(%rip), %rsi      # 0x52285
leaq 0x12069(%rip), %rdx     # 0x5cb85
movl $0x57, %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/uniform.c
// Function: Uniformv
static int Uniformv(lua_State *L)
/* uniformv(location, count, type, val1 [, val2 ... val4]) */
    {
    GLint location = luaL_checkinteger(L, 1);
    GLsizei count = luaL_checkinteger(L, 2);
    GLenum type = checkuniformtype(L, 3);
    if(count<=0)
        return luaL_error(L, "count should be positive");
#define arg_first 4
    switch(type)
        {
        case NONGL_BOOLEAN: return Uniformv_b(L, location, count, arg_first);
        case GL_INT: return Uniformv_i(L, location, count, arg_first);
        case GL_UNSIGNED_INT: return Uniformv_ui(L, location, count, arg_first);
        case GL_FLOAT: return Uniformv_f(L, location, count, arg_first);
        case GL_DOUBLE: return Uniformv_d(L, location, count, arg_first);
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
        }
    return 0;
#undef arg_first
    }

// 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)
cmpl $0x0, 0x10(%rsp)
jg 0x4abaa
movq 0x18(%rsp), %rdi
leaq 0x136fe(%rip), %rsi     # 0x5e298
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
jmp 0x4aca6
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x4abef
jmp 0x4abb8
movl 0x8(%rsp), %eax
subl $0x1404, %eax           # imm = 0x1404
je 0x4ac0f
jmp 0x4abc5
movl 0x8(%rsp), %eax
subl $0x1405, %eax           # imm = 0x1405
je 0x4ac2c
jmp 0x4abd2
movl 0x8(%rsp), %eax
subl $0x1406, %eax           # imm = 0x1406
je 0x4ac49
jmp 0x4abdf
movl 0x8(%rsp), %eax
subl $0x140a, %eax           # imm = 0x140A
je 0x4ac66
jmp 0x4ac83
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl $0x4, %ecx
callq 0x4bcd0
movl %eax, 0x24(%rsp)
jmp 0x4aca6
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl $0x4, %ecx
callq 0x4bec0
movl %eax, 0x24(%rsp)
jmp 0x4aca6
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl $0x4, %ecx
callq 0x4c0b0
movl %eax, 0x24(%rsp)
jmp 0x4aca6
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl $0x4, %ecx
callq 0x4c2a0
movl %eax, 0x24(%rsp)
jmp 0x4aca6
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl $0x4, %ecx
callq 0x4c490
movl %eax, 0x24(%rsp)
jmp 0x4aca6
movq 0x18(%rsp), %rdi
leaq 0x75f6(%rip), %rsi      # 0x52285
leaq 0x11eef(%rip), %rdx     # 0x5cb85
movl $0x97, %ecx
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/uniform.c
// Function: UniformMatrix
static int UniformMatrix(lua_State *L)
/* uniform_matrix(location, type, dim, transpose, dim values) */
    {
    GLint location = luaL_checkinteger(L, 1);
    GLenum type = checkuniformtype(L, 2);
    GLenum dim = checkmatrixdimensions(L, 3);
    GLboolean transpose = checkboolean(L, 4);
    switch(type)
        {
#define arg_first 5
        case GL_FLOAT: return UniformMatrixv_f(L, location, 1, dim, transpose, arg_first);
        case GL_DOUBLE: return UniformMatrixv_d(L, location, 1, dim, transpose, arg_first);
        case NONGL_BOOLEAN:
        case GL_INT:
        case GL_UNSIGNED_INT:
            return luaL_error(L, "operation not supported for this type");
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
#undef arg_first
        }
    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 $0x34, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x35, %esi
movl $0x3, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl $0x4, %esi
callq 0x11510
movb %al, 0xb(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x4ad99
jmp 0x4ad1d
movl 0x4(%rsp), %eax
addl $0xffffebfc, %eax       # imm = 0xFFFFEBFC
subl $0x2, %eax
jb 0x4ad99
jmp 0x4ad2d
movl 0x4(%rsp), %eax
subl $0x1406, %eax           # imm = 0x1406
je 0x4ad47
jmp 0x4ad3a
movl 0x4(%rsp), %eax
subl $0x140a, %eax           # imm = 0x140A
je 0x4ad70
jmp 0x4adb2
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0xc(%rsp), %ecx
movl $0x1, %edx
movl $0x5, %r9d
movzbl 0xb(%rsp), %r8d
callq 0x4c680
movl %eax, 0x24(%rsp)
jmp 0x4add5
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0xc(%rsp), %ecx
movl $0x1, %edx
movl $0x5, %r9d
movzbl 0xb(%rsp), %r8d
callq 0x4c990
movl %eax, 0x24(%rsp)
jmp 0x4add5
movq 0x18(%rsp), %rdi
leaq 0x1350c(%rip), %rsi     # 0x5e2b1
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
jmp 0x4add5
movq 0x18(%rsp), %rdi
leaq 0x74c7(%rip), %rsi      # 0x52285
leaq 0x11dc0(%rip), %rdx     # 0x5cb85
movl $0x16a, %ecx            # imm = 0x16A
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/uniform.c
// Function: UniformMatrixv
static int UniformMatrixv(lua_State *L)
/* uniform_matrixv(location, count, type, dim, transpose, dim values) */
    {
    GLint location = luaL_checkinteger(L, 1);
    GLsizei count = luaL_checkinteger(L, 2);
    GLenum type = checkuniformtype(L, 3);
    GLenum dim = checkmatrixdimensions(L, 4);
    GLboolean transpose = checkboolean(L, 5);
    if(count<=0)
        return luaL_error(L, "count should be positive");
    switch(type)
        {
#define arg_first 6
        case GL_FLOAT: return UniformMatrixv_f(L, location, count, dim, transpose, arg_first);
        case GL_DOUBLE: return UniformMatrixv_d(L, location, count, dim, transpose, arg_first);
        case NONGL_BOOLEAN:
        case GL_INT:
        case GL_UNSIGNED_INT:
            return luaL_error(L, "operation not supported for this type");
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
#undef arg_first
        }
    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 $0x35, %esi
movl $0x4, %edx
callq 0x11160
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x5, %esi
callq 0x11510
movb %al, 0x7(%rsp)
cmpl $0x0, 0x10(%rsp)
jg 0x4ae75
movq 0x18(%rsp), %rdi
leaq 0x13433(%rip), %rsi     # 0x5e298
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
jmp 0x4af35
movl 0xc(%rsp), %eax
movl %eax, (%rsp)
testl %eax, %eax
je 0x4aef9
jmp 0x4ae82
movl (%rsp), %eax
addl $0xffffebfc, %eax       # imm = 0xFFFFEBFC
subl $0x2, %eax
jb 0x4aef9
jmp 0x4ae91
movl (%rsp), %eax
subl $0x1406, %eax           # imm = 0x1406
je 0x4aea9
jmp 0x4ae9d
movl (%rsp), %eax
subl $0x140a, %eax           # imm = 0x140A
je 0x4aed1
jmp 0x4af12
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0x8(%rsp), %ecx
movl $0x6, %r9d
movzbl 0x7(%rsp), %r8d
callq 0x4c680
movl %eax, 0x24(%rsp)
jmp 0x4af35
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0x8(%rsp), %ecx
movl $0x6, %r9d
movzbl 0x7(%rsp), %r8d
callq 0x4c990
movl %eax, 0x24(%rsp)
jmp 0x4af35
movq 0x18(%rsp), %rdi
leaq 0x133ac(%rip), %rsi     # 0x5e2b1
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
jmp 0x4af35
movq 0x18(%rsp), %rdi
leaq 0x7367(%rip), %rsi      # 0x52285
leaq 0x11c60(%rip), %rdx     # 0x5cb85
movl $0x153, %ecx            # imm = 0x153
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/uniform.c
// Function: ProgramUniform
static int ProgramUniform(lua_State *L)
/* program_uniform(program, location, type, val1 [, val2 ... val4]) */
    {
    GLuint program = luaL_checkinteger(L, 1);
    GLint location = luaL_checkinteger(L, 2);
    GLenum type = checkuniformtype(L, 3);
#define arg_first 4
    switch(type)
        {
        case NONGL_BOOLEAN: return ProgramUniform_b(L, program, location, arg_first);
        case GL_INT: return ProgramUniform_i(L, program, location, arg_first);
        case GL_UNSIGNED_INT: return ProgramUniform_ui(L, program, location, arg_first);
        case GL_FLOAT: return ProgramUniform_f(L, program, location, arg_first);
        case GL_DOUBLE: return ProgramUniform_d(L, program, location, arg_first);
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
        }
    return 0;
#undef arg_first
    }

// 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)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x4afcc
jmp 0x4af95
movl 0x8(%rsp), %eax
subl $0x1404, %eax           # imm = 0x1404
je 0x4afec
jmp 0x4afa2
movl 0x8(%rsp), %eax
subl $0x1405, %eax           # imm = 0x1405
je 0x4b009
jmp 0x4afaf
movl 0x8(%rsp), %eax
subl $0x1406, %eax           # imm = 0x1406
je 0x4b026
jmp 0x4afbc
movl 0x8(%rsp), %eax
subl $0x140a, %eax           # imm = 0x140A
je 0x4b043
jmp 0x4b060
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl $0x4, %ecx
callq 0x4cca0
movl %eax, 0x24(%rsp)
jmp 0x4b083
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl $0x4, %ecx
callq 0x4ce20
movl %eax, 0x24(%rsp)
jmp 0x4b083
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl $0x4, %ecx
callq 0x4cfa0
movl %eax, 0x24(%rsp)
jmp 0x4b083
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl $0x4, %ecx
callq 0x4d120
movl %eax, 0x24(%rsp)
jmp 0x4b083
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl $0x4, %ecx
callq 0x4d2a0
movl %eax, 0x24(%rsp)
jmp 0x4b083
movq 0x18(%rsp), %rdi
leaq 0x7219(%rip), %rsi      # 0x52285
leaq 0x11b12(%rip), %rdx     # 0x5cb85
movl $0xce, %ecx
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/uniform.c
// Function: ProgramUniformv
static int ProgramUniformv(lua_State *L)
/* program_uniformv(program, location, count, type, val1 [, val2 ... val4]) */
    {
    GLuint program = luaL_checkinteger(L, 1);
    GLint location = luaL_checkinteger(L, 2);
    GLsizei count = luaL_checkinteger(L, 3);
    GLenum type = checkuniformtype(L, 4);
    if(count<=0)
        return luaL_error(L, "count should be positive");
#define arg_first 5
    switch(type)
        {
        case NONGL_BOOLEAN: return ProgramUniformv_b(L, program, location, count, arg_first);
        case GL_INT: return ProgramUniformv_i(L, program, location, count, arg_first);
        case GL_UNSIGNED_INT: return ProgramUniformv_ui(L, program, location, count, arg_first);
        case GL_FLOAT: return ProgramUniformv_f(L, program, location, count, arg_first);
        case GL_DOUBLE: return ProgramUniformv_d(L, program, location, count, arg_first);
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
        }
    return 0;
#undef arg_first
    }

// 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 $0x3, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl $0x34, %esi
movl $0x4, %edx
callq 0x11160
movl %eax, 0x8(%rsp)
cmpl $0x0, 0xc(%rsp)
jg 0x4b10d
movq 0x18(%rsp), %rdi
leaq 0x1319b(%rip), %rsi     # 0x5e298
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
jmp 0x4b22d
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x4b15a
jmp 0x4b11b
movl 0x4(%rsp), %eax
subl $0x1404, %eax           # imm = 0x1404
je 0x4b17f
jmp 0x4b128
movl 0x4(%rsp), %eax
subl $0x1405, %eax           # imm = 0x1405
je 0x4b1a4
jmp 0x4b135
movl 0x4(%rsp), %eax
subl $0x1406, %eax           # imm = 0x1406
je 0x4b1c6
jmp 0x4b146
movl 0x4(%rsp), %eax
subl $0x140a, %eax           # imm = 0x140A
je 0x4b1e8
jmp 0x4b20a
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movl $0x5, %r8d
callq 0x4d420
movl %eax, 0x24(%rsp)
jmp 0x4b22d
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movl $0x5, %r8d
callq 0x4d620
movl %eax, 0x24(%rsp)
jmp 0x4b22d
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movl $0x5, %r8d
callq 0x4d820
movl %eax, 0x24(%rsp)
jmp 0x4b22d
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movl $0x5, %r8d
callq 0x4da20
movl %eax, 0x24(%rsp)
jmp 0x4b22d
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movl $0x5, %r8d
callq 0x4dc30
movl %eax, 0x24(%rsp)
jmp 0x4b22d
movq 0x18(%rsp), %rdi
leaq 0x706f(%rip), %rsi      # 0x52285
leaq 0x11968(%rip), %rdx     # 0x5cb85
movl $0x111, %ecx            # imm = 0x111
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/uniform.c
// Function: ProgramUniformMatrix
static int ProgramUniformMatrix(lua_State *L)
/* program_uniform_matrix(program, location, type, dim, transpose, dim values) */
    {
    GLuint program = luaL_checkinteger(L, 1);
    GLint location = luaL_checkinteger(L, 2);
    GLenum type = checkuniformtype(L, 3);
    GLenum dim = checkmatrixdimensions(L, 4);
    GLboolean transpose = checkboolean(L, 5);
    switch(type)
        {
#define arg_first 6
        case GL_FLOAT: 
            return ProgramUniformMatrixv_f(L, program, location, 1, dim, transpose, arg_first);
        case GL_DOUBLE: 
            return ProgramUniformMatrixv_d(L, program, location, 1, dim, transpose, arg_first);
        case NONGL_BOOLEAN:
        case GL_INT:
        case GL_UNSIGNED_INT:
            return luaL_error(L, "operation not supported for this type");
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
#undef arg_first
        }
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl $0x34, %esi
movl $0x3, %edx
callq 0x11160
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movl $0x35, %esi
movl $0x4, %edx
callq 0x11160
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x5, %esi
callq 0x11510
movb %al, 0x17(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x10(%rsp)
testl %eax, %eax
je 0x4b34c
jmp 0x4b2c4
movl 0x10(%rsp), %eax
addl $0xffffebfc, %eax       # imm = 0xFFFFEBFC
subl $0x2, %eax
jb 0x4b34c
jmp 0x4b2d4
movl 0x10(%rsp), %eax
subl $0x1406, %eax           # imm = 0x1406
je 0x4b2ee
jmp 0x4b2e1
movl 0x10(%rsp), %eax
subl $0x140a, %eax           # imm = 0x140A
je 0x4b31d
jmp 0x4b365
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movl 0x18(%rsp), %r8d
movl $0x1, %ecx
movzbl 0x17(%rsp), %r9d
movl $0x6, (%rsp)
callq 0x4de30
movl %eax, 0x34(%rsp)
jmp 0x4b388
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movl 0x18(%rsp), %r8d
movl $0x1, %ecx
movzbl 0x17(%rsp), %r9d
movl $0x6, (%rsp)
callq 0x4e170
movl %eax, 0x34(%rsp)
jmp 0x4b388
movq 0x28(%rsp), %rdi
leaq 0x12f59(%rip), %rsi     # 0x5e2b1
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x34(%rsp)
jmp 0x4b388
movq 0x28(%rsp), %rdi
leaq 0x6f14(%rip), %rsi      # 0x52285
leaq 0x1180d(%rip), %rdx     # 0x5cb85
movl $0x1d3, %ecx            # imm = 0x1D3
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/uniform.c
// Function: ProgramUniformMatrixv
static int ProgramUniformMatrixv(lua_State *L)
/* program_uniform_matrixv(program, location, count, type, dim, transpose, dim values) */
    {
    GLuint program = luaL_checkinteger(L, 1);
    GLint location = luaL_checkinteger(L, 2);
    GLsizei count = luaL_checkinteger(L, 3);
    GLenum type = checkuniformtype(L, 4);
    GLenum dim = checkmatrixdimensions(L, 5);
    GLboolean transpose = checkboolean(L, 6);
    if(count<=0)
        return luaL_error(L, "count should be positive");
    switch(type)
        {
#define arg_first 7
        case GL_FLOAT: 
            return ProgramUniformMatrixv_f(L, program, location, count, dim, transpose, arg_first);
        case GL_DOUBLE: 
            return ProgramUniformMatrixv_d(L, program, location, count, dim, transpose, arg_first);
        case NONGL_BOOLEAN:
        case GL_INT:
        case GL_UNSIGNED_INT:
            return luaL_error(L, "operation not supported for this type");
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
#undef arg_first
        }
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movl $0x34, %esi
movl $0x4, %edx
callq 0x11160
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x35, %esi
movl $0x5, %edx
callq 0x11160
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl $0x6, %esi
callq 0x11510
movb %al, 0x13(%rsp)
cmpl $0x0, 0x1c(%rsp)
jg 0x4b448
movq 0x28(%rsp), %rdi
leaq 0x12e60(%rip), %rsi     # 0x5e298
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x34(%rsp)
jmp 0x4b51c
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x4b4e0
jmp 0x4b45a
movl 0xc(%rsp), %eax
addl $0xffffebfc, %eax       # imm = 0xFFFFEBFC
subl $0x2, %eax
jb 0x4b4e0
jmp 0x4b46a
movl 0xc(%rsp), %eax
subl $0x1406, %eax           # imm = 0x1406
je 0x4b484
jmp 0x4b477
movl 0xc(%rsp), %eax
subl $0x140a, %eax           # imm = 0x140A
je 0x4b4b2
jmp 0x4b4f9
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movl 0x1c(%rsp), %ecx
movl 0x14(%rsp), %r8d
movzbl 0x13(%rsp), %r9d
movl $0x7, (%rsp)
callq 0x4de30
movl %eax, 0x34(%rsp)
jmp 0x4b51c
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movl 0x1c(%rsp), %ecx
movl 0x14(%rsp), %r8d
movzbl 0x13(%rsp), %r9d
movl $0x7, (%rsp)
callq 0x4e170
movl %eax, 0x34(%rsp)
jmp 0x4b51c
movq 0x28(%rsp), %rdi
leaq 0x12dc5(%rip), %rsi     # 0x5e2b1
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x34(%rsp)
jmp 0x4b51c
movq 0x28(%rsp), %rdi
leaq 0x6d80(%rip), %rsi      # 0x52285
leaq 0x11679(%rip), %rdx     # 0x5cb85
movl $0x1b9, %ecx            # imm = 0x1B9
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/uniform.c
// Function: CheckN
static int CheckN(lua_State *L, int first)
    {
    int arg = first;
    while(!lua_isnoneornil(L, arg)) arg++;
    if(arg == first) return luaL_error(L, NARGS_ERROR);
    return arg - first;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
movq 0x8(%rsp), %rdi
movl (%rsp), %esi
callq 0x11860
cmpl $0x0, %eax
setle %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4bc8f
jmp 0x4bc9a
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x4bc74
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jne 0x4bcbc
movq 0x8(%rsp), %rdi
leaq 0x68cf(%rip), %rsi      # 0x5257e
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x14(%rsp)
jmp 0x4bcc7
movl (%rsp), %eax
subl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq