LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/teximage.c
// Function: ClearTextureImage
static int ClearTextureImage(lua_State *L)
    {
    int arg = 1;
    const void* data;
    size_t len;
    GLuint texture = luaL_checkinteger(L, arg++);
    GLint level = luaL_checkinteger(L, arg++);
    GLenum format = checkformat(L, arg++);
    GLenum type = checktype(L, arg++);
    if(lua_isnoneornil(L, arg))
        { data = 0; arg++; }
    else if(lua_isstring(L, arg))
        data = (void*)luaL_checkstring(L, arg++);
    else if(lua_istable(L, arg))
        data = (void*)checkdataptr(L, arg++, &len);
    else
        return luaL_argerror(L, arg, "invalid type");
    glClearTexImage(texture, level, format, type, data);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x11af0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r15
pushq $0x12
popq %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %ebp
pushq $0x7
popq %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r12d
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x11850
testl %eax, %eax
jle 0x35359
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x110b0
pushq $0x5
popq %rsi
movq %rbx, %rdi
testl %eax, %eax
je 0x3535e
xorl %edx, %edx
callq 0x11440
jmp 0x35378
xorl %r8d, %r8d
jmp 0x3537b
callq 0x11850
cmpl $0x5, %eax
jne 0x353a6
pushq $0x5
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x11b20
movq %rax, %r8
movq 0x201b6(%rip), %rax     # 0x55538
movl %r14d, %edi
movl %r15d, %esi
movl %ebp, %edx
movl %r12d, %ecx
callq *(%rax)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5e4b(%rip), %rdx      # 0x3b1f8
pushq $0x5
popq %rsi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x11930
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/teximage.c
// Function: ClearTextureSubImage
static int ClearTextureSubImage(lua_State *L)
    {
    int arg = 1;
    const void* data;
    size_t len;
    GLuint texture = luaL_checkinteger(L, arg++);
    GLint level = luaL_checkinteger(L, arg++);
    GLenum format = checkformat(L, arg++);
    GLenum type = checktype(L, arg++);
    if(lua_isnoneornil(L, arg))
        { data = 0; arg++; }
    else if(lua_isstring(L, arg))
        data = (void*)luaL_checkstring(L, arg++);
    else if(lua_istable(L, arg))
        data = (void*)checkdataptr(L, arg++, &len);
    else
        return luaL_argerror(L, arg, "invalid type");
    GLint xoffset = luaL_checkinteger(L, arg++);
    GLint yoffset = luaL_checkinteger(L, arg++);
    GLint zoffset = luaL_checkinteger(L, arg++);
    GLsizei width = luaL_checkinteger(L, arg++);
    GLsizei height = luaL_checkinteger(L, arg++);
    GLsizei depth = luaL_checkinteger(L, arg++);
    glClearTexSubImage(texture, level,xoffset,yoffset,zoffset,width,height,depth,format,type,data);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x11af0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r12
pushq $0x12
popq %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r15d
pushq $0x7
popq %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r13d
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x11850
testl %eax, %eax
jle 0x35451
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x110b0
testl %eax, %eax
je 0x35470
movq %r13, 0x10(%rsp)
movq %r12, 0x18(%rsp)
movq %r15, 0x20(%rsp)
movq %r14, 0x28(%rsp)
pushq $0x5
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11440
jmp 0x354a8
movq %r13, 0x10(%rsp)
movq %r12, 0x18(%rsp)
movq %r15, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq $0x0, 0x8(%rsp)
jmp 0x354ad
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x11850
cmpl $0x5, %eax
jne 0x3554d
movq %r13, 0x10(%rsp)
movq %r12, 0x18(%rsp)
movq %r15, 0x20(%rsp)
movq %r14, 0x28(%rsp)
pushq $0x5
popq %rsi
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x11b20
movq %rax, 0x8(%rsp)
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r14
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r15
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r12
pushq $0x9
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r13
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %rbp
pushq $0xb
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x20223(%rip), %r10     # 0x55728
subq $0x8, %rsp
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %r14d, %edx
movl %r15d, %ecx
movl %r12d, %r8d
movl %r13d, %r9d
pushq 0x10(%rsp)
pushq 0x20(%rsp)
pushq 0x38(%rsp)
pushq %rax
pushq %rbp
callq *(%r10)
addq $0x30, %rsp
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5ca4(%rip), %rdx      # 0x3b1f8
pushq $0x5
popq %rsi
movq %rbx, %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11930
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/teximage.c
// Function: TexBuffer
static int TexBuffer(lua_State *L)
    {
    int arg = 1;
    GLenum target;
    GLuint texture = checktargetorname(L, arg++, &target, DOMAIN_TEXTURE_TARGET);
    GLenum intfmt = checkinternalformat(L, arg++);
    GLuint buffer = luaL_checkinteger(L, arg++);
    if(texture==0)
        glTexBuffer(target, intfmt, buffer);
    else
        glTextureBuffer(texture, intfmt, buffer);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0xc(%rsp), %rdx
pushq $0x13
popq %rcx
callq 0x11420
movl %eax, %ebp
pushq $0x11
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r14d
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x11af0
testl %ebp, %ebp
je 0x355b5
movq 0x20167(%rip), %rcx     # 0x55718
movl %ebp, %edi
jmp 0x355c0
movq 0x2029c(%rip), %rcx     # 0x55858
movl 0xc(%rsp), %edi
movl %r14d, %esi
movl %eax, %edx
callq *(%rcx)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/teximage.c
// Function: TexBufferRange
static int TexBufferRange(lua_State *L)
    {
    int arg = 1;
    GLenum target;
    GLuint texture = checktargetorname(L, arg++, &target, DOMAIN_TEXTURE_TARGET);
    GLenum intfmt = checkinternalformat(L, arg++);
    GLuint buffer = luaL_checkinteger(L, arg++);
    GLintptr offset = luaL_checkinteger(L, arg++);
    GLsizei size = luaL_checkinteger(L, arg++);
    if(texture==0)
        glTexBufferRange(target, intfmt, buffer, offset, size);
    else
        glTextureBufferRange(texture, intfmt, buffer, offset, size);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0xc(%rsp), %rdx
pushq $0x13
popq %rcx
callq 0x11420
movl %eax, %ebp
pushq $0x11
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r14d
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r15
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r12
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x11af0
testl %ebp, %ebp
je 0x35645
movq 0x208c2(%rip), %r9      # 0x55f00
movslq %eax, %r8
movl %ebp, %edi
jmp 0x35653
movq 0x2004c(%rip), %r9      # 0x55698
movl 0xc(%rsp), %edi
movslq %eax, %r8
movl %r14d, %esi
movl %r15d, %edx
movq %r12, %rcx
callq *(%r9)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/teximage.c
// Function: GetTextureImage
static int GetTextureImage(lua_State *L)
/* get_texture_image(target|texture, lod, format, type, n)
 * -> bstring or nil
 */
    {
    intptr_t data = 0;
    GLsizei bufsz = 0;
    int arg = 1;
    GLenum target;
    GLuint texture = checktargetorname(L, arg++, &target, DOMAIN_TEXTURE_TARGET);
    GLint level = luaL_checkinteger(L, arg++);
    GLenum format = checkformat(L, arg++);
    GLenum type = checktype(L, arg++);
    intptr_t n = luaL_checkinteger(L, arg++);
    GLint64 bound_buffer = getUint(L, GL_PIXEL_PACK_BUFFER_BINDING);
    if(bound_buffer == 0)
        {
        /* no buffer is bound to GL_PIXEL_PACK_BUFFER, so treat n as the data size */
        bufsz = (GLsizei)n;
        data = (intptr_t)Malloc(L, bufsz *sizeof(char));
        if(texture==0)
            glGetTexImage(target, level, format, type, (void*)data);
        else
            glGetTextureImage(texture, level, format, type, bufsz, (void*)data);
        CheckErrorFree(L, (void*)data);
        lua_pushlstring(L, (char*)data, bufsz);
        Free(L, (void*)data);
        return 1;
        }
    else /* a buffer is bound to GL_PIXEL_PACK_BUFFER, so treat n as an offset */
        {
        if(texture==0)
            glGetTexImage(target, level, format, type, (void*)n);
        else
            glGetTextureImage(texture, level, format, type, 0, (void*)n);
        CheckError(L);
        }
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rbp
leaq 0x4(%rsp), %rdx
pushq $0x13
popq %rcx
movl %ebp, %esi
callq 0x11420
movl %eax, %r15d
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r12
pushq $0x12
popq %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, (%rsp)
pushq $0x7
popq %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r13d
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r14
movq %rbx, %rdi
movl $0x88ed, %esi           # imm = 0x88ED
callq 0x11a70
testl %eax, %eax
je 0x3570d
testl %r15d, %r15d
je 0x35749
movq 0x1fd81(%rip), %rax     # 0x55478
movl %r15d, %edi
movl %r12d, %esi
movl (%rsp), %edx
movl %r13d, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq *(%rax)
jmp 0x3575e
movq %r12, 0x8(%rsp)
movslq %r14d, %rsi
movq %rbx, %rdi
movq %rsi, 0x10(%rsp)
callq 0x111f0
movq %rax, %r12
testl %r15d, %r15d
je 0x3576a
movq 0x1fd47(%rip), %rax     # 0x55478
movl %r15d, %edi
movq 0x8(%rsp), %rsi
movl (%rsp), %edx
movl %r13d, %ecx
movl %r14d, %r8d
movq %r12, %r9
callq *(%rax)
jmp 0x35781
movl 0x4(%rsp), %edi
movl %r12d, %esi
movl (%rsp), %edx
movl %r13d, %ecx
movq %r14, %r8
callq 0x114f0
movq %rbx, %rdi
callq 0x11870
xorl %ebp, %ebp
jmp 0x357a7
movl 0x4(%rsp), %edi
movq 0x8(%rsp), %rsi
movl (%rsp), %edx
movl %r13d, %ecx
movq %r12, %r8
callq 0x114f0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x11540
movq %rbx, %rdi
movq %r12, %rsi
movq 0x10(%rsp), %rdx
callq 0x11ab0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x11360
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/teximage.c
// Function: GetCompressedTextureImage
static int GetCompressedTextureImage(lua_State *L)
    {
    int arg = 1;
    GLenum target;
    GLuint texture = checktargetorname(L, arg++, &target, DOMAIN_TEXTURE_TARGET);
    GLint level = luaL_checkinteger(L, arg++);
    GLsizei bufsz = luaL_checkinteger(L, arg++);
    char* data = (char*)Malloc(L, bufsz *sizeof(char));
    if(texture==0)
        glGetCompressedTexImage(target, level, (void*)data);
    else
        glGetCompressedTextureImage(texture, level, bufsz, (void*)data);
    CheckErrorFree(L, data);
    lua_pushlstring(L, data, bufsz);
    Free(L, data);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0x4(%rsp), %rdx
pushq $0x13
popq %rcx
callq 0x11420
movl %eax, %ebp
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r13
movslq %r13d, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x111f0
movq %rax, %r15
testl %ebp, %ebp
je 0x3581f
movq 0x20600(%rip), %rax     # 0x55e10
movl %ebp, %edi
movl %r12d, %esi
movl %r13d, %edx
movq %r15, %rcx
callq *(%rax)
jmp 0x35832
movq 0x2075a(%rip), %rax     # 0x55f80
movl 0x4(%rsp), %edi
movl %r12d, %esi
movq %r15, %rdx
callq *(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11540
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x11ab0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11360
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/teximage.c
// Function: GetTextureSubImage
static int GetTextureSubImage(lua_State *L)
    {
    int arg = 1;
    GLuint texture = luaL_checkinteger(L, arg++);
    GLint level = luaL_checkinteger(L, arg++);
    GLenum format = checkformat(L, arg++);
    GLenum type = checktype(L, arg++);
    GLint xoffset = luaL_checkinteger(L, arg++);
    GLint yoffset = luaL_checkinteger(L, arg++);
    GLint zoffset = luaL_checkinteger(L, arg++);
    GLsizei width = luaL_checkinteger(L, arg++);
    GLsizei height = luaL_checkinteger(L, arg++);
    GLsizei depth = luaL_checkinteger(L, arg++);
    GLsizei bufsz = luaL_checkinteger(L, arg++);
    char* data = (char*)Malloc(L, bufsz *sizeof(char));
    glGetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufsz, (void*)data);
    CheckErrorFree(L, data);
    lua_pushlstring(L, data, bufsz);
    Free(L, data);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
pushq $0x1
popq %rsi
callq 0x11af0
movq %rax, 0x30(%rsp)
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x11af0
movq %rax, 0x20(%rsp)
pushq $0x12
popq %rsi
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x11150
movq %rax, 0x28(%rsp)
pushq $0x7
popq %rbx
pushq $0x4
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x11150
movq %rax, 0x18(%rsp)
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x11af0
movq %rax, 0x10(%rsp)
pushq $0x6
popq %rsi
movq %r14, %rdi
callq 0x11af0
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movl %ebx, %esi
callq 0x11af0
movq %rax, %r13
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x11af0
movq %rax, %r15
pushq $0x9
popq %rsi
movq %r14, %rdi
callq 0x11af0
movq %rax, (%rsp)
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x11af0
movq %rax, %r12
pushq $0xb
popq %rsi
movq %r14, %rdi
callq 0x11af0
movslq %eax, %rbp
movq %r14, %rdi
movq %rbp, %rsi
callq 0x111f0
movq %rax, %rbx
movq 0x1fc27(%rip), %rax     # 0x55560
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movl %r13d, %r8d
movl %r15d, %r9d
pushq %rbx
pushq %rbp
pushq 0x28(%rsp)
pushq 0x40(%rsp)
pushq %r12
pushq 0x28(%rsp)
callq *(%rax)
addq $0x30, %rsp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11540
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x11ab0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11360
pushq $0x1
popq %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/teximage.c
// Function: GetCompressedTextureSubImage
static int GetCompressedTextureSubImage(lua_State *L)
    {
    int arg = 1;
    GLuint texture = luaL_checkinteger(L, arg++);
    GLint level = luaL_checkinteger(L, arg++);
    GLint xoffset = luaL_checkinteger(L, arg++);
    GLint yoffset = luaL_checkinteger(L, arg++);
    GLint zoffset = luaL_checkinteger(L, arg++);
    GLsizei width = luaL_checkinteger(L, arg++);
    GLsizei height = luaL_checkinteger(L, arg++);
    GLsizei depth = luaL_checkinteger(L, arg++);
    GLsizei bufsz = luaL_checkinteger(L, arg++);
    char* data = (char*)Malloc(L, bufsz *sizeof(char));
    glGetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufsz, (void*)data);
    CheckErrorFree(L, data);
    lua_pushlstring(L, data, bufsz);
    Free(L, data);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
pushq $0x1
popq %rsi
callq 0x11af0
movq %rax, 0x20(%rsp)
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x11af0
movq %rax, 0x18(%rsp)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x11af0
movq %rax, 0x10(%rsp)
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x11af0
movq %rax, 0x8(%rsp)
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x11af0
movq %rax, (%rsp)
pushq $0x6
popq %rsi
movq %r14, %rdi
callq 0x11af0
movq %rax, %r12
pushq $0x7
popq %rsi
movq %r14, %rdi
callq 0x11af0
movq %rax, %r15
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x11af0
movq %rax, %rbx
pushq $0x9
popq %rsi
movq %r14, %rdi
callq 0x11af0
movslq %eax, %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x111f0
movq %rax, %rbp
movq 0x201e7(%rip), %rax     # 0x55c30
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
movl %r12d, %r9d
pushq %rbp
pushq %r13
pushq %rbx
pushq %r15
callq *(%rax)
addq $0x20, %rsp
movq %r14, %rdi
movq %rbp, %rsi
callq 0x11540
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x11ab0
movq %r14, %rdi
movq %rbp, %rsi
callq 0x11360
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/teximage.c
// Function: GenerateMipmap
static int GenerateMipmap(lua_State *L)
    {
    int arg = 1;
    GLenum target;
    GLuint texture = checktargetorname(L, arg++, &target, DOMAIN_TEXTURE_TARGET);
    if(texture==0)
        glGenerateMipmap(target);
    else
        glGenerateTextureMipmap(texture);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0xc(%rsp), %rdx
pushq $0x13
popq %rcx
callq 0x11420
testl %eax, %eax
je 0x35acf
movq 0x204ef(%rip), %rcx     # 0x55fb8
movl %eax, %edi
callq *(%rcx)
jmp 0x35adc
movq 0x1f892(%rip), %rax     # 0x55368
movl 0xc(%rsp), %edi
callq *(%rax)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/teximage.c
// Function: TextureView
static int TextureView(lua_State *L)
    {
    int arg = 1;
    GLuint texture = luaL_checkinteger(L, arg++);
    GLenum target = checktexturetarget(L, arg++);
    GLuint origtexture = luaL_checkinteger(L, arg++);
    GLenum intfmt = checkinternalformat(L, arg++);
    GLuint minlevel = luaL_checkinteger(L, arg++);
    GLuint numlevels = luaL_checkinteger(L, arg++);
    GLuint minlayer = luaL_checkinteger(L, arg++);
    GLuint numlayers = luaL_checkinteger(L, arg++);
    glTextureView(texture, target, origtexture, intfmt, minlevel, numlevels, minlayer, numlayers);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x11af0
movq %rax, 0x10(%rsp)
pushq $0x13
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, 0xc(%rsp)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r15
pushq $0x11
popq %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r12d
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r13
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r14
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %rbp
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x20021(%rip), %r10     # 0x55b98
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl %r15d, %edx
movl %r12d, %ecx
movl %r13d, %r8d
movl %r14d, %r9d
pushq %rax
pushq %rbp
callq *(%r10)
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/teximage.c
// Function: BindImageTexture
static int BindImageTexture(lua_State *L)
    {
    int arg = 1;
    GLuint unit = luaL_checkinteger(L, arg++);
    GLuint texture = luaL_checkinteger(L, arg++);
    GLint level = luaL_checkinteger(L, arg++);
    GLboolean layered = checkboolean(L, arg++);
    GLint layer = luaL_checkinteger(L, arg++);
    GLenum access = checktextureaccess(L, arg++);
    GLenum format = checkinternalformat(L, arg++);
    glBindImageTexture(unit, texture, level, layered, layer, access, format);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x11af0
movq %rax, 0x10(%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r12
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x11500
movl %eax, %ebp
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r13
pushq $0x5c
popq %rsi
pushq $0x6
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r14d
pushq $0x11
popq %rsi
pushq $0x7
popq %rdx
movq %rbx, %rdi
callq 0x11150
movq 0x203c7(%rip), %r10     # 0x55ff0
movl %eax, (%rsp)
movzbl %bpl, %ecx
movq 0x10(%rsp), %rdi
movl %r15d, %esi
movl %r12d, %edx
movl %r13d, %r8d
movl %r14d, %r9d
callq *(%r10)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/teximage.c
// Function: BindImageTextures
static int BindImageTextures(lua_State *L)
    {
    GLsizei count, i, arg;
    GLuint *textures;
    GLuint first = luaL_checkinteger(L, 1);
    arg = 2;
    while(!lua_isnoneornil(L, arg))
        luaL_checkinteger(L, arg++);
    if(arg==2)
        luaL_checkinteger(L, arg); /* raise an error */
    count = arg - 2;
    textures = (GLuint*)Malloc(L, count*sizeof(GLuint));
    arg = 2;
    for(i=0; i < count; i++)
        textures[i]=lua_tointeger(L, arg++);
    glBindImageTextures(first, count, textures);
    Free(L, textures);  
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x11af0
movq %rax, %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
leaq 0x2(%r15), %r13
movq %rbx, %rdi
movl %r13d, %esi
callq 0x11850
testl %eax, %eax
jle 0x35ca3
movq %rbx, %rdi
movl %r13d, %esi
callq 0x11af0
incq %r15
addq $0x4, %r12
jmp 0x35c7c
testl %r15d, %r15d
jne 0x35cb3
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x111f0
movq %rax, %r12
xorl %r13d, %r13d
movq %r15, %rbp
subq $0x1, %rbp
jb 0x35ce4
leaq 0x2(%r13), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11040
movl %eax, (%r12,%r13,4)
incq %r13
jmp 0x35cc7
movq 0x202dd(%rip), %rax     # 0x55fc8
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq *(%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/texture.c
// Function: ActiveTexture
static int ActiveTexture(lua_State *L)
    {
    GLuint n = luaL_checkinteger(L, 1);
    GLenum texture;
    switch(n)
        {
#define C(i) case i: texture = GL_TEXTURE##i; break
        C(0); C(1); C(2); C(3); C(4); C(5); C(6); C(7); C(8); C(9); 
        C(10); C(11); C(12); C(13); C(14); C(15); C(16); C(17); C(18); C(19); C(20); 
        C(21); C(22); C(23); C(24); C(25); C(26); C(27); C(28); C(29); C(30); C(31); 
#undef C
        default: return luaL_argerror(L, 1, "out of range");
        }
    glActiveTexture(texture);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x11af0
cmpl $0x20, %eax
jae 0x36122
orl $0x84c0, %eax           # imm = 0x84C0
movq 0x1f3ae(%rip), %rcx     # 0x554c0
movl %eax, %edi
callq *(%rcx)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
popq %rbx
retq
leaq 0x10291(%rip), %rdx     # 0x463ba
pushq $0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x11930
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/texture.c
// Function: SetEnum
static int SetEnum(lua_State *L, GLuint texture, GLenum target, GLenum pname, int arg, uint32_t domain) 
    {
    GLint param = enums_check(L, domain, arg);
    if(texture==0)
        glTexParameteri(target, pname, param);
    else 
        glTextureParameteri(texture, pname, param);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
pushq $0x3
popq %rdx
movl %r8d, %esi
callq 0x11150
testl %r14d, %r14d
je 0x368c5
movq 0x1ea16(%rip), %rcx     # 0x552d0
movl %r14d, %edi
movl %ebp, %esi
movl %eax, %edx
callq *(%rcx)
jmp 0x368d1
movl %r15d, %edi
movl %ebp, %esi
movl %eax, %edx
callq 0x11b00
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11870
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/texture.c
// Function: SetFloat
static int SetFloat(lua_State *L, GLuint texture, GLenum target, GLenum pname, int arg)
    {
    GLfloat param = luaL_checkinteger(L, arg);
    if(texture==0)
        glTexParameterf(target, pname, param);
    else 
        glTextureParameterf(texture, pname, param);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
pushq $0x3
popq %rsi
callq 0x11af0
cvtsi2ss %rax, %xmm0
testl %r14d, %r14d
je 0x36917
movq 0x1f412(%rip), %rax     # 0x55d20
movl %r14d, %edi
movl %ebp, %esi
callq *(%rax)
jmp 0x36921
movl %r15d, %edi
movl %ebp, %esi
callq 0x111c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11870
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rdi, %r14
testl %esi, %esi
je 0x36955
movq 0x1ebf8(%rip), %rax     # 0x55540
leaq 0x4(%rsp), %rdx
movl %esi, %edi
movl %ecx, %esi
callq *(%rax)
jmp 0x36966
leaq 0x4(%rsp), %rax
movl %edx, %edi
movl %ecx, %esi
movq %rax, %rdx
callq 0x119a0
movq %r14, %rdi
callq 0x11870
movl 0x4(%rsp), %edx
movq %r14, %rdi
movl %ebx, %esi
callq 0x11110
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x369fd
movq 0x1eca0(%rip), %rax     # 0x55690
leaq 0xc(%rsp), %rdx
movl %esi, %edi
movl %ecx, %esi
callq *(%rax)
jmp 0x36a0e
leaq 0xc(%rsp), %rax
movl %edx, %edi
movl %ecx, %esi
movq %rax, %rdx
callq 0x11350
movq %rbx, %rdi
callq 0x11870
cvtss2sd 0xc(%rsp), %xmm0
movq %rbx, %rdi
callq 0x11370
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %rdi, %r14
testl %esi, %esi
je 0x36ab6
movq 0x1f286(%rip), %r9      # 0x55d28
leaq 0x4(%rsp), %rax
movl %esi, %edi
movl %ecx, %esi
movl %r8d, %edx
movq %rax, %rcx
callq *(%r9)
jmp 0x36aca
leaq 0x4(%rsp), %rax
movl %edx, %edi
movl %ecx, %esi
movl %r8d, %edx
movq %rax, %rcx
callq 0x11a10
movq %r14, %rdi
callq 0x11870
movl 0x4(%rsp), %edx
movq %r14, %rdi
movl %ebx, %esi
callq 0x11110
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x11af0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r12
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r13
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x1e6bf(%rip), %r9      # 0x55590
movslq %eax, %r8
movl %r14d, %edi
movl %r15d, %esi
movl %r12d, %edx
movq %r13, %rcx
callq *(%r9)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x2c
popq %rsi
pushq $0x1
popq %rdx
callq 0x11150
movl %eax, %ebp
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r14
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x11850
testl %eax, %eax
jle 0x36f45
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x1ec1e(%rip), %rcx     # 0x55b58
movl %ebp, %edi
movl %r14d, %esi
movl %eax, %edx
callq *(%rcx)
jmp 0x36f53
movq 0x1e46c(%rip), %rax     # 0x553b8
movl %ebp, %edi
movl %r14d, %esi
callq *(%rax)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2c
popq %rsi
pushq $0x1
popq %rdx
callq 0x11150
movl %eax, %ebp
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r14
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r15
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x11850
testl %eax, %eax
jle 0x36fc5
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x1ea32(%rip), %r8      # 0x559e8
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
movl %eax, %ecx
callq *(%r8)
jmp 0x36fd6
movq 0x1e934(%rip), %rax     # 0x55900
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
callq *(%rax)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x11af0
movq %rax, (%rsp)
pushq $0x57
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %ebp
xorl %r12d, %r12d
xorl %r14d, %r14d
leaq 0x3(%r14), %r13
movq %rbx, %rdi
movl %r13d, %esi
callq 0x11850
testl %eax, %eax
jle 0x37044
movq %rbx, %rdi
movl %r13d, %esi
xorl %edx, %edx
callq 0x11440
incq %r14
addq $0x8, %r12
jmp 0x3701b
testl %r14d, %r14d
jne 0x37056
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11440
movq %rbx, %rdi
movq %r12, %rsi
callq 0x111f0
movq %rax, %r12
xorl %r13d, %r13d
movq %r14, %r15
subq $0x1, %r15
jb 0x37087
leaq 0x3(%r13), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11940
movq %rax, (%r12,%r13,8)
incq %r13
jmp 0x3706a
movq 0x1ea22(%rip), %rax     # 0x55ab0
movq (%rsp), %rdi
movl %r14d, %esi
movq %r12, %rdx
movl %ebp, %ecx
callq *(%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x11af0
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r12
movq %rbx, %rdi
movl %r15d, %esi
movl $0x8c76, %edx           # imm = 0x8C76
callq 0x11840
movslq %eax, %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x111f0
movq %rax, %r14
movq 0x1e1a6(%rip), %rax     # 0x552b8
movq %r14, (%rsp)
leaq 0x14(%rsp), %rbp
leaq 0xc(%rsp), %r8
leaq 0x10(%rsp), %r9
movl %r15d, %edi
movl %r12d, %esi
movl %r13d, %edx
movq %rbp, %rcx
callq *(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11540
cmpl $0x0, (%rbp)
je 0x37170
movq %rbx, %rdi
movq %r14, %rsi
callq 0x110c0
movl 0x10(%rsp), %edx
pushq $0xe
popq %rsi
movq %rbx, %rdi
callq 0x11110
movslq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x113b0
pushq $0x3
popq %rbp
jmp 0x37172
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11360
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x11af0
movq %rax, %r14
pushq $0xd
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r15d
leal -0x8c84(%r15), %eax
cmpl $0x2, %eax
jb 0x371fd
leal -0x8e23(%r15), %eax
cmpl $0x2, %eax
jae 0x37230
movq 0x1e5b1(%rip), %rax     # 0x55788
leaq 0xc(%rsp), %r12
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq *(%rax)
movq %rbx, %rdi
callq 0x11870
movl (%r12), %esi
movq %rbx, %rdi
callq 0x117e0
jmp 0x37273
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x1e1b9(%rip), %r8      # 0x553c8
leaq 0x10(%rsp), %r12
movl %r14d, %edi
movl %r15d, %esi
movl %eax, %edx
movq %r12, %rcx
callq *(%r8)
movq %rbx, %rdi
callq 0x11870
movq (%r12), %rsi
jmp 0x3726b
cmpl $0x8c8f, %r15d          # imm = 0x8C8F
jne 0x37282
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x1eb15(%rip), %r8      # 0x55d60
leaq 0xc(%rsp), %r15
movl %r14d, %edi
movl $0x8c8f, %esi           # imm = 0x8C8F
movl %eax, %edx
movq %r15, %rcx
callq *(%r8)
movq %rbx, %rdi
callq 0x11870
movslq (%r15), %rsi
movq %rbx, %rdi
callq 0x113b0
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3ffc(%rip), %rsi      # 0x3b285
leaq 0x10798(%rip), %rdx     # 0x47a28
movq %rbx, %rdi
movl $0xb9, %ecx
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11ae0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
pushq $0xa
popq %rsi
pushq $0x1
popq %rdx
callq 0x11150
movq 0x1eb10(%rip), %rcx     # 0x55dd0
movl %eax, %edi
callq *(%rcx)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0xb
popq %rsi
pushq $0x1
popq %rdx
callq 0x11150
movl %eax, %ebp
pushq $0xc
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x11150
movq 0x1e8e0(%rip), %rcx     # 0x55bd8
movl %ebp, %edi
movl %eax, %esi
callq *(%rcx)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x11a80
movsd %xmm0, 0x8(%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11a80
movsd %xmm0, (%rsp)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x11850
testl %eax, %eax
jle 0x37367
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x1ea8a(%rip), %rcx     # 0x55de0
movl %eax, %edi
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq *(%rcx)
jmp 0x37377
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x115e0
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x11af0
movq %rax, %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
leaq 0x2(%r15), %r13
movq %rbx, %rdi
movl %r13d, %esi
callq 0x11850
testl %eax, %eax
jle 0x373cd
movq %rbx, %rdi
movl %r13d, %esi
callq 0x11a80
incq %r15
addq $0x8, %r12
jmp 0x373a6
testl %r15d, %r15d
je 0x3740e
leal 0x2(%r15), %eax
andl $0x1, %eax
jne 0x3740e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x111f0
movq %rax, %r12
xorl %r13d, %r13d
movq %r15, %rbp
subq $0x1, %rbp
jb 0x3742d
leaq 0x2(%r13), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11780
movsd %xmm0, (%r12,%r13,8)
incq %r13
jmp 0x373ef
leaq 0x4169(%rip), %rsi      # 0x3b57e
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11ae0
movq 0x1e214(%rip), %rax     # 0x55648
sarl %r15d
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq *(%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
pushq $0x5
popq %rsi
callq 0x11850
testl %eax, %eax
jle 0x37507
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x11a80
movapd %xmm0, 0x20(%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11a80
movapd %xmm0, 0x10(%rsp)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x11a80
movapd %xmm0, (%rsp)
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x11a80
movapd (%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movapd 0x20(%rsp), %xmm0
unpcklpd 0x10(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0]
cvtpd2ps %xmm0, %xmm0
cvtpd2ps %xmm1, %xmm1
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
leaq 0x30(%rsp), %rsi
movapd %xmm0, (%rsi)
movq 0x1e9b0(%rip), %rax     # 0x55eb0
movl %r14d, %edi
callq *(%rax)
jmp 0x3754c
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r12
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movl %r14d, %edi
movl %r15d, %esi
movl %r12d, %edx
movl %eax, %ecx
callq 0x11a50
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x11af0
movq %rax, %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
leal 0x2(%r15), %esi
movq %rbx, %rdi
callq 0x11390
testl %eax, %eax
je 0x3759a
incq %r15
addq $0x4, %r12
jmp 0x37581
testl %r15d, %r15d
setne %al
testb $0x3, %r15b
sete %cl
testb %cl, %al
je 0x375e2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x111f0
movq %rax, %r12
xorl %r13d, %r13d
movq %r15, %rbp
subq $0x1, %rbp
jb 0x37601
leaq 0x2(%r13), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11780
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r12,%r13,4)
incq %r13
jmp 0x375bf
leaq 0x3f95(%rip), %rsi      # 0x3b57e
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11ae0
movq 0x1df50(%rip), %rax     # 0x55558
shrl $0x2, %r15d
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq *(%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x11af0
movq %rax, %r14
pushq $0x34
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r15d
pushq $0x35
popq %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %ebp
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x11500
leal -0x1404(%r15), %ecx
cmpl $0x2, %ecx
jb 0x37d61
testl %r15d, %r15d
je 0x37d61
cmpl $0x140a, %r15d          # imm = 0x140A
je 0x37d7c
cmpl $0x1406, %r15d          # imm = 0x1406
jne 0x37d9e
movzbl %al, %r8d
pushq $0x1
popq %rdx
pushq $0x5
popq %r9
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x38844
leaq 0xfda5(%rip), %rsi      # 0x47b0d
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11ae0
movzbl %al, %r8d
pushq $0x1
popq %rdx
pushq $0x5
popq %r9
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x389ef
leaq 0x34e0(%rip), %rsi      # 0x3b285
leaq 0xe74b(%rip), %rdx      # 0x464f7
movq %rbx, %rdi
movl $0x16a, %ecx            # imm = 0x16A
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11ae0