LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/draw.c
// Function: MultiDrawArrays
static int MultiDrawArrays(lua_State *L)
/* multi_draw_arrays(mode, first1, count1 [, first2, count2, ...]) */
    {
    GLsizei arg, i, drawcount;
    GLint *first;
    GLsizei *count;
    GLenum mode = checkdrawmode(L, 1);
    arg = 2;
    while(!lua_isnoneornil(L, arg))
        luaL_checkinteger(L, arg++);
    drawcount = arg - 2;
    if((arg<4) || (drawcount%2 != 0))
        return luaL_error(L, NARGS_ERROR);
    drawcount /= 2;
    first = (GLint*)Malloc2(L, drawcount*sizeof(GLint), (void**)&count, drawcount*sizeof(GLsizei));
    arg = 2;
    for(i=0; i < drawcount; i++)
        {
        first[i] = lua_tointeger(L, arg++);
        count[i] = lua_tointeger(L, arg++);
        }
    glMultiDrawArrays(mode, first, count, drawcount);
    Free(L, first); 
    Free(L, count); 
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x2c
popq %rsi
pushq $0x1
popq %rdx
callq 0x11150
movl %eax, %r15d
pushq $0x2
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x11850
testl %eax, %eax
jle 0x1377e
leal 0x1(%r14), %ebp
movq %rbx, %rdi
movl %r14d, %esi
callq 0x11af0
movl %ebp, %r14d
jmp 0x1375b
cmpl $0x4, %r14d
setae %al
testb $0x1, %r14b
sete %cl
testb %cl, %al
je 0x13802
movl %r15d, 0x14(%rsp)
addl $-0x2, %r14d
sarl %r14d
movslq %r14d, %r12
leaq (,%r12,4), %rcx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x116f0
movq %rax, %r15
xorl %r13d, %r13d
testl %r12d, %r12d
movl $0x0, %ebp
cmovgl %r14d, %ebp
addl %ebp, %ebp
cmpq %r13, %rbp
je 0x13821
leaq 0x2(%r13), %r12
movq %rbx, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x11040
movl %eax, (%r15,%r13,2)
leal 0x1(%r12), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11040
movq 0x8(%rsp), %rcx
movl %eax, (%rcx,%r13,2)
movq %r12, %r13
jmp 0x137cb
leaq 0x27d75(%rip), %rsi     # 0x3b57e
movq %rbx, %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11ae0
movq 0x42128(%rip), %rax     # 0x55950
movq 0x8(%rsp), %rdx
movl 0x14(%rsp), %edi
movq %r15, %rsi
movl %r14d, %ecx
callq *(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11360
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x11360
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/draw.c
// Function: MultiDrawArraysIndirect
static int MultiDrawArraysIndirect(lua_State *L)
/* multi_draw_arrays_indirect(mode, indirect, drawcount, stride)
 */
    {
    GLenum mode = checkdrawmode(L, 1);
    GLintptr indirect = luaL_checkinteger(L, 2);
    GLsizei drawcount = luaL_checkinteger(L, 3);
    GLsizei stride = luaL_checkinteger(L, 4);
    glMultiDrawArraysIndirect(mode, (const void *)indirect, drawcount, stride);
    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 0x11af0
movq 0x41ae9(%rip), %r8      # 0x55398
movl %ebp, %edi
movq %r14, %rsi
movl %r15d, %edx
movl %eax, %ecx
callq *(%r8)
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/draw.c
// Function: MultiDrawArraysIndirectCount
static int MultiDrawArraysIndirectCount(lua_State *L) //GL_VERSION_4_6
    {
    GLenum mode = checkdrawmode(L, 1);
    GLintptr indirect = luaL_checkinteger(L, 2);
    GLintptr drawcount = luaL_checkinteger(L, 3);
    GLsizei maxdrawcount = luaL_checkinteger(L, 4);
    GLsizei stride = luaL_checkinteger(L, 5);
    glMultiDrawArraysIndirectCount(mode, (void*)indirect, drawcount, maxdrawcount, stride);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
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 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
movq 0x41eb3(%rip), %r9      # 0x557d8
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
movl %r12d, %ecx
movl %eax, %r8d
callq *(%r9)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/draw.c
// Function: DrawElements
static int DrawElements(lua_State *L)
/* draw_elements(mode, count, type, indices [, instancecount [, baseinstance]])
 */
    {
    GLsizei instancecount;
    GLuint baseinstance;
    GLenum mode = checkdrawmode(L, 1);
    GLsizei count = luaL_checkinteger(L, 2);
    GLenum type = checkdrawtype(L, 3);
    GLintptr indices = luaL_checkinteger(L, 4);
    if(lua_isnoneornil(L, 5))
        {
        glDrawElements(mode, count, type, (const void*)indices);
        CheckError(L);
        return 0;
        }
    instancecount = luaL_checkinteger(L, 5);
    if(lua_isnoneornil(L, 6))
        {
        glDrawElementsInstanced(mode, count, type, (const void*)indices, instancecount);
        CheckError(L);
        return 0;
        }
    baseinstance = luaL_checkinteger(L, 6);
    glDrawElementsInstancedBaseInstance(mode, count, type, (const void*)indices, 
                            instancecount, baseinstance);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
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 $0x2d
popq %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r15d
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r12
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x11850
testl %eax, %eax
jle 0x139e5
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r13
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x11850
testl %eax, %eax
jle 0x139f7
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x41c21(%rip), %r10     # 0x555f0
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
movq %r12, %rcx
movl %r13d, %r8d
movl %eax, %r9d
callq *(%r10)
jmp 0x13a0e
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
movq %r12, %rcx
callq 0x117b0
jmp 0x13a0e
movq 0x41a32(%rip), %rax     # 0x55430
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
movq %r12, %rcx
movl %r13d, %r8d
callq *(%rax)
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/draw.c
// Function: DrawElementsIndirect
static int DrawElementsIndirect(lua_State *L)
/* draw_elements_indirect(mode, type, indirect)
 */
    {
    GLenum mode = checkdrawmode(L, 1);
    GLenum type = checkdrawtype(L, 2);
    GLintptr indirect = luaL_checkinteger(L, 3);
    glDrawElementsIndirect(mode, type, (const void *)indirect);
    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 $0x2d
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r14d
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x41882(%rip), %rcx     # 0x552e0
movl %ebp, %edi
movl %r14d, %esi
movq %rax, %rdx
callq *(%rcx)
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/draw.c
// Function: MultiDrawElements
static int MultiDrawElements(lua_State *L)
/* multi_draw_elements(mode, type, count1, indices1 [, count2, indices2, ...]) 
 */
    {
    GLsizei *count, drawcount, i, arg;
    GLintptr *indices;
    GLenum mode = checkdrawmode(L, 1);
    GLenum type = checkdrawtype(L, 2);
    arg = 3;
    while(!lua_isnoneornil(L, arg))
        luaL_checkinteger(L, arg++);
    drawcount = arg - 3;
    if(((arg<4) || (drawcount%2) != 0))
        return luaL_error(L, NARGS_ERROR);
    drawcount /= 2;
    indices = (GLintptr*)Malloc2(L, drawcount*sizeof(GLintptr), 
                    (void**)&count, drawcount*sizeof(GLsizei));
    arg = 3;
    for(i=0; i<drawcount; i++)
        {
        indices[i] = lua_tointeger(L, arg++);
        count[i] = lua_tointeger(L, arg++);
        }
    glMultiDrawElements(mode, count, type, (const void**)indices, drawcount);
    Free(L, indices); 
    Free(L, count);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x2c
popq %rsi
pushq $0x1
popq %rdx
callq 0x11150
movl %eax, %r14d
pushq $0x2d
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, 0x14(%rsp)
pushq $0x3
popq %r12
movq %rbx, %rdi
movl %r12d, %esi
callq 0x11850
testl %eax, %eax
jle 0x13ad0
leal 0x1(%r12), %ebp
movq %rbx, %rdi
movl %r12d, %esi
callq 0x11af0
movl %ebp, %r12d
jmp 0x13aac
leal -0x3(%r12), %r15d
cmpl $0x4, %r12d
setae %al
testb $0x1, %r15b
sete %cl
testb %cl, %al
je 0x13b5c
movl %r14d, 0x10(%rsp)
sarl %r15d
movslq %r15d, %r14
leaq (,%r14,8), %rsi
leaq (,%r14,4), %rcx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x116f0
movq %rax, %r12
xorl %ebp, %ebp
testl %r14d, %r14d
movl $0x0, %r14d
cmovgl %r15d, %r14d
addl %r14d, %r14d
cmpq %rbp, %r14
je 0x13b7b
leaq 0x3(%rbp), %r13
movq %rbx, %rdi
movl %r13d, %esi
xorl %edx, %edx
callq 0x11040
movq %rax, (%r12,%rbp,4)
incl %r13d
movq %rbx, %rdi
movl %r13d, %esi
xorl %edx, %edx
callq 0x11040
movq 0x8(%rsp), %rcx
movl %eax, (%rcx,%rbp,2)
addq $0x2, %rbp
jmp 0x13b24
leaq 0x27a1b(%rip), %rsi     # 0x3b57e
movq %rbx, %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11ae0
movq 0x41ebe(%rip), %rax     # 0x55a40
movq 0x8(%rsp), %rsi
movl 0x10(%rsp), %edi
movl 0x14(%rsp), %edx
movq %r12, %rcx
movl %r15d, %r8d
callq *(%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x11360
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x11360
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/draw.c
// Function: MultiDrawElementsIndirect
static int MultiDrawElementsIndirect(lua_State *L)
/* draw_elements_indirect(mode, type, indirect, drawcount, stride)
 */
    {
    GLenum mode = checkdrawmode(L, 1);
    GLenum type = checkdrawtype(L, 2);
    GLintptr indirect = luaL_checkinteger(L, 3);
    GLsizei drawcount = luaL_checkinteger(L, 4);
    GLsizei stride = luaL_checkinteger(L, 5);
    glMultiDrawElementsIndirect(mode, type, (const void *)indirect, drawcount, stride);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x2c
popq %rsi
pushq $0x1
popq %rdx
callq 0x11150
movl %eax, %ebp
pushq $0x2d
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
movq 0x41df1(%rip), %r9      # 0x55a10
movl %ebp, %edi
movl %r14d, %esi
movq %r15, %rdx
movl %r12d, %ecx
movl %eax, %r8d
callq *(%r9)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/draw.c
// Function: MultiDrawElementsIndirectCount
static int MultiDrawElementsIndirectCount(lua_State *L) //GL_VERSION_4_6
    {
    GLenum mode = checkdrawmode(L, 1);
    GLenum type = checkdrawtype(L, 2);
    GLintptr indirect = luaL_checkinteger(L, 3);
    GLintptr drawcount = luaL_checkinteger(L, 4);
    GLsizei maxdrawcount = luaL_checkinteger(L, 5);
    GLsizei stride = luaL_checkinteger(L, 6);
    glMultiDrawElementsIndirectCount(mode, type, (const void *)indirect, drawcount, maxdrawcount, stride);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2c
popq %rsi
pushq $0x1
popq %rdx
callq 0x11150
movl %eax, %ebp
pushq $0x2d
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
movq %rax, %r13
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x41bcd(%rip), %r10     # 0x55878
movl %ebp, %edi
movl %r14d, %esi
movq %r15, %rdx
movq %r12, %rcx
movl %r13d, %r8d
movl %eax, %r9d
callq *(%r10)
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/draw.c
// Function: DrawElementsBaseVertex
static int DrawElementsBaseVertex(lua_State *L)
/* draw_elements_base_vertex(mode,count, type, indices, basevertex [, instancecount, baseinstance]) 
 */
    {
    GLsizei instancecount;
    GLuint baseinstance;
    GLenum mode = checkdrawmode(L, 1);
    GLsizei count = luaL_checkinteger(L, 2);
    GLenum type = checkdrawtype(L, 3);
    GLintptr indices = luaL_checkinteger(L, 4);
    GLsizei basevertex = luaL_checkinteger(L, 5);
    if(lua_isnoneornil(L, 6))
        {
        glDrawElementsBaseVertex(mode, count, type, (void*)indices, basevertex);
        CheckError(L);
        return 0;
        }
    instancecount = luaL_checkinteger(L, 6);
    if(lua_isnoneornil(L, 7))
        {
        glDrawElementsInstancedBaseVertex(mode, count, type, (void*)indices,
                instancecount, basevertex);
        CheckError(L);
        return 0;
        }
    baseinstance = luaL_checkinteger(L, 7);
    glDrawElementsInstancedBaseVertexBaseInstance(mode, count, type, (void*)indices,
            instancecount, basevertex, baseinstance);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
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 $0x2d
popq %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r15d
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r12
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r13
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x11850
testl %eax, %eax
jle 0x13d8f
movq %r14, 0x10(%rsp)
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r14
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x11850
testl %eax, %eax
jle 0x13da8
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x42034(%rip), %r10     # 0x55da8
movl %eax, (%rsp)
movl %ebp, %edi
movq 0x10(%rsp), %rsi
movl %r15d, %edx
movq %r12, %rcx
movl %r14d, %r8d
movl %r13d, %r9d
callq *(%r10)
jmp 0x13dc4
movq 0x41f22(%rip), %rax     # 0x55cb8
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
movq %r12, %rcx
movl %r13d, %r8d
callq *(%rax)
jmp 0x13dc4
movq 0x415c1(%rip), %rax     # 0x55370
movl %ebp, %edi
movq 0x10(%rsp), %rsi
movl %r15d, %edx
movq %r12, %rcx
movl %r14d, %r8d
movl %r13d, %r9d
callq *(%rax)
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/draw.c
// Function: DrawRangeElements
static int DrawRangeElements(lua_State *L)
    {
    GLenum mode = checkdrawmode(L, 1);
    GLuint start = luaL_checkinteger(L, 2);
    GLuint end = luaL_checkinteger(L, 3);
    GLsizei count = luaL_checkinteger(L, 4);
    GLenum type = checkdrawtype(L, 5);
    GLintptr indices = luaL_checkinteger(L, 6);
    glDrawRangeElements(mode, start, end, count, type, (void*)indices);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
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 0x11af0
movq %rax, %r12
pushq $0x2d
popq %rsi
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r13d
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x41986(%rip), %r10     # 0x55958
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
movl %r12d, %ecx
movl %r13d, %r8d
movq %rax, %r9
callq *(%r10)
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/draw.c
// Function: DrawRangeElementsBaseVertex
static int DrawRangeElementsBaseVertex(lua_State *L)
    {
    GLenum mode = checkdrawmode(L, 1);
    GLuint start = luaL_checkinteger(L, 2);
    GLuint end = luaL_checkinteger(L, 3);
    GLsizei count = luaL_checkinteger(L, 4);
    GLenum type = checkdrawtype(L, 5);
    GLintptr indices = luaL_checkinteger(L, 6);
    GLint basevertex = luaL_checkinteger(L, 7);
    glDrawRangeElementsBaseVertex(mode, start, end, count, type, (void*)indices, basevertex);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x2c
popq %rsi
pushq $0x1
popq %rdx
callq 0x11150
movl %eax, 0x14(%rsp)
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 0x11af0
movq %rax, %r12
pushq $0x2d
popq %rsi
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r13d
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %rbp
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x41a16(%rip), %r10     # 0x55a90
movl %eax, (%rsp)
movl 0x14(%rsp), %edi
movl %r14d, %esi
movl %r15d, %edx
movl %r12d, %ecx
movl %r13d, %r8d
movq %rbp, %r9
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/draw.c
// Function: PrimitiveRestartIndex
static int PrimitiveRestartIndex(lua_State *L)
    {
    GLuint index = luaL_checkinteger(L, 1);
    glPrimitiveRestartIndex(index);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x11af0
movq 0x41e21(%rip), %rcx     # 0x55ee0
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/draw.c
// Function: BeginConditionalRender
static int BeginConditionalRender(lua_State *L)
    {
    GLuint id = luaL_checkinteger(L, 1);
    GLenum mode = checkconditionalrendermode(L, 2);
    glBeginConditionalRender(id, mode);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x11af0
movq %rax, %r14
pushq $0x2e
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x11150
movq 0x41b02(%rip), %rcx     # 0x55bf8
movl %r14d, %edi
movl %eax, %esi
callq *(%rcx)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/framebuffer.c
// Function: FramebufferParameter
static int FramebufferParameter(lua_State *L)
    {
    GLenum target;
    GLuint framebuffer = checktargetorname(L, 1, &target, DOMAIN_FRAMEBUFFER_TARGET);
    GLenum pname = checkframebufferpname(L, 2);
    GLint param = luaL_checkinteger(L, 3);
    if(framebuffer==0)
        glFramebufferParameteri(target, pname, param);
    else
        glNamedFramebufferParameteri(framebuffer, pname, param);
    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 $0x24
popq %rcx
callq 0x11420
movl %eax, %ebp
pushq $0x25
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 0x294f8
movq 0x2c72c(%rip), %rcx     # 0x55c20
movl %ebp, %edi
jmp 0x29503
movq 0x2c409(%rip), %rcx     # 0x55908
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/framebuffer.c
// Function: GetFramebufferParameter
static int GetFramebufferParameter(lua_State *L)
    {
    GLenum target;
    GLuint framebuffer = checktargetorname(L, 1, &target, DOMAIN_FRAMEBUFFER_TARGET);
    GLenum pname = checkframebuffergpname(L, 2);
    switch(pname)
        {
        case GL_FRAMEBUFFER_DEFAULT_WIDTH:
        case GL_FRAMEBUFFER_DEFAULT_HEIGHT:
        case GL_FRAMEBUFFER_DEFAULT_LAYERS:
        case GL_FRAMEBUFFER_DEFAULT_SAMPLES:
        case GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS:
        case GL_SAMPLES:
        case GL_SAMPLE_BUFFERS:
                return GetInt(L, target, framebuffer, pname);
        case GL_DOUBLEBUFFER:
        case GL_STEREO:
                return GetBoolean(L, target, framebuffer, pname);
        case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
                return GetEnum(L, target, framebuffer, pname, DOMAIN_FORMAT);
        case GL_IMPLEMENTATION_COLOR_READ_TYPE:
                return GetEnum(L, target, framebuffer, pname, DOMAIN_TYPE);
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
        }
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
pushq $0x1
popq %rbx
leaq 0xc(%rsp), %rdx
pushq $0x24
popq %rcx
movl %ebx, %esi
callq 0x11420
movl %eax, %ebp
pushq $0x27
popq %rsi
pushq $0x2
popq %rdx
movq %r14, %rdi
callq 0x11150
leal -0x9310(%rax), %ecx
cmpl $0x5, %ecx
jb 0x2958d
leal -0xc32(%rax), %ecx
cmpl $0x2, %ecx
jb 0x2959d
leal -0x80a8(%rax), %ecx
cmpl $0x2, %ecx
jb 0x2958d
cmpl $0x8b9a, %eax           # imm = 0x8B9A
je 0x295b2
cmpl $0x8b9b, %eax           # imm = 0x8B9B
jne 0x295cb
movl 0xc(%rsp), %esi
pushq $0x12
popq %r8
movq %r14, %rdi
movl %ebp, %edx
movl $0x8b9b, %ecx           # imm = 0x8B9B
jmp 0x295c4
movl 0xc(%rsp), %esi
movq %r14, %rdi
movl %ebp, %edx
movl %eax, %ecx
xorl %r8d, %r8d
jmp 0x295ab
movl 0xc(%rsp), %esi
movq %r14, %rdi
movl %ebp, %edx
movl %eax, %ecx
movl %ebx, %r8d
callq 0x29c38
jmp 0x295e8
movl 0xc(%rsp), %esi
pushq $0x7
popq %r8
movq %r14, %rdi
movl %ebp, %edx
movl $0x8b9a, %ecx           # imm = 0x8B9A
callq 0x29c8f
jmp 0x295e6
leaq 0x11cb3(%rip), %rsi     # 0x3b285
leaq 0x1e8fe(%rip), %rdx     # 0x47ed7
pushq $0x65
popq %rcx
movq %r14, %rdi
xorl %eax, %eax
callq 0x11ae0
movl %eax, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/framebuffer.c
// Function: CheckFramebufferStatus
static int CheckFramebufferStatus(lua_State *L)
    {
    GLuint framebuffer;
    GLenum status;
    GLuint target = checkframebuffertarget(L, 1);
    if(lua_isnoneornil(L, 2))
        status = glCheckFramebufferStatus(target);
    else 
        {
        framebuffer = luaL_checkinteger(L, 2);
        status = glCheckNamedFramebufferStatus(framebuffer, target);
        }
    CheckError(L);
    pushframebufferstatus(L, status);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x24
popq %rsi
pushq $0x1
popq %rdx
callq 0x11150
movl %eax, %ebp
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11850
testl %eax, %eax
jle 0x29780
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x2c638(%rip), %rcx     # 0x55db0
movl %eax, %edi
movl %ebp, %esi
callq *(%rcx)
jmp 0x2978b
movq 0x2bb29(%rip), %rax     # 0x552b0
movl %ebp, %edi
callq *(%rax)
movl %eax, %ebp
movq %rbx, %rdi
callq 0x11870
pushq $0x26
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x11110
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/framebuffer.c
// Function: FramebufferRenderbuffer
static int FramebufferRenderbuffer(lua_State *L)
    {
    GLenum target;
    GLuint framebuffer = checktargetorname(L, 1, &target, DOMAIN_FRAMEBUFFER_TARGET);
    GLenum attachment = checkbuffer(L, 2);
    GLenum rbtarget = checkrenderbuffertarget(L, 3);
    GLuint renderbuffer = luaL_checkinteger(L, 4);
    if(framebuffer == 0)
        glFramebufferRenderbuffer(target, attachment, rbtarget, renderbuffer);
    else
        glNamedFramebufferRenderbuffer(framebuffer, attachment, rbtarget, renderbuffer);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0x4(%rsp), %rdx
pushq $0x24
popq %rcx
callq 0x11420
movl %eax, %ebp
pushq $0x4f
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r14d
pushq $0xf
popq %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r15d
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x11af0
testl %ebp, %ebp
je 0x29804
movq 0x2bb90(%rip), %r8      # 0x55390
movl %ebp, %edi
jmp 0x2980f
movq 0x2bc3d(%rip), %r8      # 0x55448
movl 0x4(%rsp), %edi
movl %r14d, %esi
movl %r15d, %edx
movl %eax, %ecx
callq *(%r8)
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/framebuffer.c
// Function: FramebufferTexture
static int FramebufferTexture(lua_State *L)
    {
    GLenum target;
    GLuint framebuffer = checktargetorname(L, 1, &target, DOMAIN_FRAMEBUFFER_TARGET);
    GLenum attachment = checkbuffer(L, 2);
    GLuint texture = luaL_checkinteger(L, 3);
    GLint level = luaL_checkinteger(L, 4);
    if(framebuffer == 0)
        glFramebufferTexture(target, attachment, texture, level);
    else
        glNamedFramebufferTexture(framebuffer,attachment, texture, level);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0x4(%rsp), %rdx
pushq $0x24
popq %rcx
callq 0x11420
movl %eax, %ebp
pushq $0x4f
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
testl %ebp, %ebp
je 0x29884
movq 0x2c2d0(%rip), %r8      # 0x55b50
movl %ebp, %edi
jmp 0x2988f
movq 0x2ba75(%rip), %r8      # 0x55300
movl 0x4(%rsp), %edi
movl %r14d, %esi
movl %r15d, %edx
movl %eax, %ecx
callq *(%r8)
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/framebuffer.c
// Function: FramebufferTexture1D
static int FramebufferTexture1D(lua_State *L)
    {
    GLenum target = checkframebuffertarget(L, 1);
    GLenum attachment = checkbuffer(L, 2);
    GLenum textarget = checktexturetarget(L, 3);
    GLuint texture = luaL_checkinteger(L, 4);
    GLint level = luaL_checkinteger(L, 5);
    glFramebufferTexture1D(target, attachment, textarget, texture, level);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x24
popq %rsi
pushq $0x1
popq %rdx
callq 0x11150
movl %eax, %ebp
pushq $0x4f
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r14d
pushq $0x13
popq %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r15d
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r12
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x2bbdf(%rip), %r9      # 0x554e8
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
movl %r12d, %ecx
movl %eax, %r8d
callq *(%r9)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/framebuffer.c
// Function: FramebufferTexture2D
static int FramebufferTexture2D(lua_State *L)
    {
    GLenum target = checkframebuffertarget(L, 1);
    GLenum attachment = checkbuffer(L, 2);
    GLenum textarget = checktexturetarget(L, 3);
    GLuint texture = luaL_checkinteger(L, 4);
    GLint level = luaL_checkinteger(L, 5);
    glFramebufferTexture2D(target, attachment, textarget, texture, level);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x24
popq %rsi
pushq $0x1
popq %rdx
callq 0x11150
movl %eax, %ebp
pushq $0x4f
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r14d
pushq $0x13
popq %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r15d
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r12
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x2bdf9(%rip), %r9      # 0x55780
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
movl %r12d, %ecx
movl %eax, %r8d
callq *(%r9)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/framebuffer.c
// Function: FramebufferTexture3D
static int FramebufferTexture3D(lua_State *L)
    {
    GLenum target = checkframebuffertarget(L, 1);
    GLenum attachment = checkbuffer(L, 2);
    GLenum textarget = checktexturetarget(L, 3);
    GLuint texture = luaL_checkinteger(L, 4);
    GLint level = luaL_checkinteger(L, 5);
    GLint layer = luaL_checkinteger(L, 6);
    glFramebufferTexture3D(target, attachment, textarget, texture, level, layer);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x24
popq %rsi
pushq $0x1
popq %rdx
callq 0x11150
movl %eax, %ebp
pushq $0x4f
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r14d
pushq $0x13
popq %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x11150
movl %eax, %r15d
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r12
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, %r13
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x2bfe2(%rip), %r10     # 0x559f8
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
movl %r12d, %ecx
movl %r13d, %r8d
movl %eax, %r9d
callq *(%r10)
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/framebuffer.c
// Function: FramebufferTextureLayer
static int FramebufferTextureLayer(lua_State *L)
    {
    GLenum target;
    GLuint framebuffer = checktargetorname(L, 1, &target, DOMAIN_FRAMEBUFFER_TARGET);
    GLenum attachment = checkbuffer(L, 2);
    GLuint texture = luaL_checkinteger(L, 3);
    GLint level = luaL_checkinteger(L, 4);
    GLint layer = luaL_checkinteger(L, 5);
    if(framebuffer == 0)
        glFramebufferTextureLayer(target, attachment, texture, level, layer);
    else
        glNamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);
    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 $0x24
popq %rcx
callq 0x11420
movl %eax, %ebp
pushq $0x4f
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 0x29aab
movq 0x2bec1(%rip), %r9      # 0x55968
movl %ebp, %edi
jmp 0x29ab6
movq 0x2bc1e(%rip), %r9      # 0x556d0
movl 0xc(%rsp), %edi
movl %r14d, %esi
movl %r15d, %edx
movl %r12d, %ecx
movl %eax, %r8d
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/framebuffer.c
// Function: InvalidateSubFramebuffer
static int InvalidateSubFramebuffer(lua_State *L)
/* invalidate_sub_framebuffer(target, x, y, w, h, attachm1 [, attachm2, ...]) 
 */
    {
    GLsizei count;
    GLenum target;
    GLuint framebuffer = checktargetorname(L, 1, &target, DOMAIN_FRAMEBUFFER_TARGET);
    GLuint x = luaL_checkinteger(L, 2);
    GLuint y = luaL_checkinteger(L, 3);
    GLuint width = luaL_checkinteger(L, 4);
    GLuint height = luaL_checkinteger(L, 5);
    GLenum *attachments = CheckAttachments(L, 6, &count);
    if(framebuffer)
        glInvalidateNamedFramebufferSubData(framebuffer, count, attachments, x, y, width, height);
    else
        glInvalidateSubFramebuffer(target, count, attachments, x, y, width, height);
    Free(L, attachments);
    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
leaq 0xc(%rsp), %rdx
pushq $0x24
popq %rcx
callq 0x11420
movl %eax, %ebp
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq %rax, 0x10(%rsp)
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
movq %rax, %r14
pushq $0x6
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x29d79
movq %rax, %r13
testl %ebp, %ebp
je 0x29b7c
movq 0x2b9b0(%rip), %rax     # 0x55520
movl 0x8(%rsp), %esi
movl %r14d, (%rsp)
movl %ebp, %edi
jmp 0x29b8f
movq 0x2b7dd(%rip), %rax     # 0x55360
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movl %r14d, (%rsp)
movq %r13, %rdx
movq 0x10(%rsp), %rcx
movl %r15d, %r8d
movl %r12d, %r9d
callq *(%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x11360
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/framebuffer.c
// Function: InvalidateFramebuffer
static int InvalidateFramebuffer(lua_State *L)
    {
    GLsizei count;
    GLenum target;
    GLuint framebuffer = checktargetorname(L, 1, &target, DOMAIN_FRAMEBUFFER_TARGET);
    GLenum *attachments = CheckAttachments(L, 2, &count);
    if(framebuffer)
        glInvalidateNamedFramebufferData(framebuffer, count, attachments);
    else
        glInvalidateFramebuffer(target, count, attachments);
    Free(L, attachments);
    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 $0x24
popq %rcx
callq 0x11420
movl %eax, %ebp
pushq $0x2
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x29d79
movq %rax, %r14
testl %ebp, %ebp
je 0x29c06
movq 0x2b8fa(%rip), %rax     # 0x554f8
movl 0x8(%rsp), %esi
movl %ebp, %edi
jmp 0x29c15
movq 0x2c00b(%rip), %rax     # 0x55c18
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movq %r14, %rdx
callq *(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11360
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/framebuffer.c
// Function: CheckAttachments
static GLenum *CheckAttachments(lua_State *L, int argfirst, GLsizei *count)
    {
    GLsizei i, arg = argfirst;
    GLenum *attachments;
    while(!lua_isnoneornil(L, arg))
        luaL_checkstring(L, arg++);
    if(arg == argfirst)
        checkbuffer(L, argfirst); /* raise an error */
    *count = arg - argfirst;
    attachments = (GLenum*)Malloc(L, (*count)*sizeof(GLenum));
    arg = argfirst;
    for(i = 0; i < *count; i++)
        attachments[i] = checkbuffer(L, arg++);
    return attachments;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
xorl %r13d, %r13d
xorl %r12d, %r12d
leal (%r15,%r13), %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x11850
testl %eax, %eax
jle 0x29dba
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x11440
addq $0x4, %r12
incl %r13d
jmp 0x29d93
testl %r13d, %r13d
jne 0x29dcd
pushq $0x4f
popq %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x11150
movl %r13d, (%rbx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x111f0
movq %rax, %r12
movl %r15d, %r15d
xorl %r13d, %r13d
pushq $0x4f
popq %rbp
movslq (%rbx), %rax
cmpq %rax, %r13
jge 0x29e06
leaq (%r15,%r13), %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x11150
movl %eax, (%r12,%r13,4)
incq %r13
jmp 0x29de7
movq %r12, %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/func.c
// Function: moongl_Malloc2
void* Malloc2(lua_State *L, size_t size, void **ptr2, size_t size2)
    {
    void *ptr;
    if((size==0) || (size2 == 0))
        { luaL_error(L, "malloc request with size = 0"); return NULL; }
    if((ptr = malloc(size)) == NULL)
        { luaL_error(L, "cannot allocate memory"); return NULL; }
    if((*ptr2 = malloc(size2)) == NULL)
        { Free(L, ptr); luaL_error(L, "cannot allocate memory"); return NULL; }
    return ptr;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r13
movq %rdi, %rbx
testq %rsi, %rsi
sete %al
testq %rcx, %rcx
sete %cl
orb %al, %cl
je 0x29e84
leaq 0x1b965(%rip), %r14     # 0x457e7
jmp 0x29eb7
movq %rdx, %r12
movq %rsi, %rdi
callq 0x11260
leaq 0x1b96e(%rip), %r14     # 0x45804
testq %rax, %rax
je 0x29eb7
movq %rax, %r15
movq %r13, %rdi
callq 0x11260
movq %rax, (%r12)
testq %rax, %rax
jne 0x29ec7
movq %r15, %rdi
callq 0x11490
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x11ae0
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/func.c
// Function: moongl_Malloc3
void* Malloc3(lua_State *L, size_t size, void **ptr2, size_t size2, void **ptr3, size_t size3)
    {
    void *ptr;
    if((size==0) || (size2 == 0) || (size3 == 0))
        { luaL_error(L, "malloc request with size = 0"); return NULL; }
    if((ptr = malloc(size)) == NULL)
        { luaL_error(L, "cannot allocate memory"); return NULL; }
    if((*ptr2 = malloc(size2)) == NULL)
        { 
        Free(L, ptr); 
        luaL_error(L, "cannot allocate memory"); return NULL; 
        }
    if((*ptr3 = malloc(size3)) == NULL)
        { 
        Free(L, ptr); 
        Free(L, *ptr2); 
        luaL_error(L, "cannot allocate memory"); return NULL; 
        }
    return ptr;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movq %rdi, %rbx
testq %rsi, %rsi
sete %al
testq %rcx, %rcx
sete %cl
orb %al, %cl
testq %r9, %r9
sete %al
orb %cl, %al
je 0x29f0e
leaq 0x1b8db(%rip), %r14     # 0x457e7
jmp 0x29f68
movq %r9, %rbp
movq %rdx, %r15
movq %r8, (%rsp)
movq %rsi, %rdi
callq 0x11260
leaq 0x1b8dd(%rip), %r14     # 0x45804
testq %rax, %rax
je 0x29f68
movq %rax, %r12
movq %r13, %rdi
callq 0x11260
movq %rax, (%r15)
testq %rax, %rax
je 0x29f60
movq %rbp, %rdi
callq 0x11260
movq (%rsp), %rcx
movq %rax, (%rcx)
testq %rax, %rax
jne 0x29f78
movq %r12, %rdi
callq 0x11490
movq (%r15), %rdi
jmp 0x29f63
movq %r12, %rdi
callq 0x11490
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x11ae0
movq %r12, %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/func.c
// Function: moongl_CheckErrorFree
int CheckErrorFree(lua_State *L, void *ptr)
/* On error, free ptr before raising the error */
    {
    int rc = glGetError();
    if(rc != 0) 
        {
        Free(L, ptr);
        return luaL_error(L, (char*)ErrorString(rc));
        }
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x11240
testl %eax, %eax
je 0x2a066
movl %eax, %ebp
movq %r14, %rdi
callq 0x11490
movl %ebp, %edi
callq 0x2a003
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x11ae0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/func.c
// Function: moongl_CheckErrorFree2
int CheckErrorFree2(lua_State *L, void *ptr1, void *ptr2)
/* On error, free ptr1 and ptr2 before raising the error */
    {
    int rc = glGetError();
    if(rc != 0) 
        {
        Free(L, ptr1);
        Free(L, ptr2);
        return luaL_error(L, (char*)ErrorString(rc));
        }
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x11240
testl %eax, %eax
je 0x2a0b6
movl %eax, %ebp
movq %r15, %rdi
callq 0x11490
movq %r14, %rdi
callq 0x11490
movl %ebp, %edi
callq 0x2a003
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11ae0
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/func.c
// Function: moongl_CheckErrorFree3
int CheckErrorFree3(lua_State *L, void *ptr1, void *ptr2, void *ptr3)
    {
    int rc = glGetError();
    if(rc != 0) 
        {
        Free(L, ptr1);
        Free(L, ptr2);
        Free(L, ptr3);
        return luaL_error(L, (char*)ErrorString(rc));
        }
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x11240
testl %eax, %eax
je 0x2a116
movl %eax, %ebp
movq %r12, %rdi
callq 0x11490
movq %r15, %rdi
callq 0x11490
movq %r14, %rdi
callq 0x11490
movl %ebp, %edi
callq 0x2a003
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x11ae0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/get.c
// Function: GetInt
static int GetInt(lua_State *L, GLenum pname)
    {
    GLint64 data;
    glGetInteger64v(pname, &data);
    CheckError(L);
    lua_pushinteger(L, data);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x29c4b(%rip), %rax     # 0x55808
movq %rsp, %r14
movl %esi, %edi
movq %r14, %rsi
callq *(%rax)
movq %rbx, %rdi
callq 0x11870
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x113b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/get.c
// Function: GetIntOptIndex
static int GetIntOptIndex(lua_State *L, GLenum pname) /* index is optional */
    {
    GLint64 data;
    GLuint index;
    if(!lua_isnoneornil(L, 2))
        {
        index = luaL_checkinteger(L, 2);
        glGetInteger64i_v(pname, index, &data);
        }
    else
        glGetInteger64v(pname, &data);
    CheckError(L);
    lua_pushinteger(L, data);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x2
popq %rsi
callq 0x11850
testl %eax, %eax
jle 0x2bc13
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x11af0
movq 0x2a0c0(%rip), %rcx     # 0x55cc8
movq %rsp, %rdx
movl %ebp, %edi
movl %eax, %esi
callq *(%rcx)
jmp 0x2bc21
movq 0x29bee(%rip), %rax     # 0x55808
movq %rsp, %rsi
movl %ebp, %edi
callq *(%rax)
movq %rbx, %rdi
callq 0x11870
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x113b0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/get.c
// Function: GetIntIndex
static int GetIntIndex(lua_State *L, GLenum pname)
    {
    GLint64 data;
    GLuint index = luaL_checkinteger(L, 2);
    glGetInteger64i_v(pname, index, &data);
    CheckError(L);
    lua_pushinteger(L, data);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
pushq $0x2
popq %rsi
callq 0x11af0
movq 0x2a06f(%rip), %rcx     # 0x55cc8
leaq 0x8(%rsp), %r15
movl %ebx, %edi
movl %eax, %esi
movq %r15, %rdx
callq *(%rcx)
movq %r14, %rdi
callq 0x11870
movq (%r15), %rsi
movq %r14, %rdi
callq 0x113b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/get.c
// Function: GetBoolean
static int GetBoolean(lua_State *L, GLenum pname)
    {
    GLboolean data;
    glGetBooleanv(pname, &data);
    CheckError(L);
    lua_pushboolean(L, (data == GL_TRUE));
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7(%rsp), %r14
movl %esi, %edi
movq %r14, %rsi
callq 0x11980
movq %rbx, %rdi
callq 0x11870
xorl %esi, %esi
cmpb $0x1, (%r14)
sete %sil
movq %rbx, %rdi
callq 0x117e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/get.c
// Function: GetFloat4
static int GetFloat4(lua_State *L, GLenum pname)
    {
    GLfloat data[4];
    glGetFloatv(pname, data);
    CheckError(L);
    lua_pushnumber(L, data[0]);
    lua_pushnumber(L, data[1]);
    lua_pushnumber(L, data[2]);
    lua_pushnumber(L, data[3]);
    return 4;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movl %esi, %edi
movq %r14, %rsi
callq 0x11aa0
movq %rbx, %rdi
callq 0x11870
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x11370
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x11370
cvtss2sd 0x8(%r14), %xmm0
movq %rbx, %rdi
callq 0x11370
cvtss2sd 0xc(%r14), %xmm0
movq %rbx, %rdi
callq 0x11370
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/get.c
// Function: GetFloat
static int GetFloat(lua_State *L, GLenum pname)
    {
    GLfloat data;
    glGetFloatv(pname, &data);
    CheckError(L);
    lua_pushnumber(L, data);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl %esi, %edi
movq %r14, %rsi
callq 0x11aa0
movq %rbx, %rdi
callq 0x11870
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x11370
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moongl/src/get.c
// Function: GetEnumOptIndex
static int GetEnumOptIndex(lua_State *L, GLenum pname, uint32_t domain) /* index is optional */
    {
    GLint data;
    GLuint index;
    if(!lua_isnoneornil(L, 2))
        {
        index = luaL_checkinteger(L, 2);
        glGetIntegeri_v(pname, index, &data);
        }
    else
        glGetIntegerv(pname, &data);
    CheckError(L);
    return enums_push(L, domain, data);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x2
popq %rsi
callq 0x11850
testl %eax, %eax
jle 0x2bdc3
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x11af0
movq 0x296b2(%rip), %rcx     # 0x55468
leaq 0xc(%rsp), %rdx
movl %ebp, %edi
movl %eax, %esi
callq *(%rcx)
jmp 0x2bdcf
leaq 0xc(%rsp), %rsi
movl %ebp, %edi
callq 0x116d0
movq %r14, %rdi
callq 0x11870
movl 0xc(%rsp), %edx
movq %r14, %rdi
movl %ebx, %esi
callq 0x11110
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq