LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/draw.c
// Function: DrawArrays
static int DrawArrays(lua_State *L)
/* draw_arrays(mode, first, count [, instancecount [, baseinstance]])
 */
    {
    GLsizei instancecount;
    GLuint baseinstance;
    GLenum mode = checkdrawmode(L, 1);
    GLint first = luaL_checkinteger(L, 2);
    GLsizei count = luaL_checkinteger(L, 3);
    if(lua_isnoneornil(L, 4))
        {
        glDrawArrays(mode, first, count);
        CheckError(L);
        return 0;
        }
    instancecount = luaL_checkinteger(L, 4);
    if(lua_isnoneornil(L, 5))
        {
        glDrawArraysInstanced(mode, first, count, instancecount);
        CheckError(L);
        return 0;
        }
    baseinstance = luaL_checkinteger(L, 5);
    glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
movl $0x4, %esi
callq 0x11860
cmpl $0x0, %eax
jg 0x14483
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movl 0x4(%rsp), %edx
callq 0x118f0
movq 0x18(%rsp), %rdi
callq 0x11880
movl $0x0, 0x24(%rsp)
jmp 0x14520
movq 0x18(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0x5, %esi
callq 0x11860
cmpl $0x0, %eax
jg 0x144da
movq 0x52f07(%rip), %rax     # 0x673b8
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movl 0x4(%rsp), %edx
movl 0x14(%rsp), %ecx
callq *%rax
movq 0x18(%rsp), %rdi
callq 0x11880
movl $0x0, 0x24(%rsp)
jmp 0x14520
movq 0x18(%rsp), %rdi
movl $0x5, %esi
callq 0x11af0
movl %eax, 0x10(%rsp)
movq 0x531e4(%rip), %rax     # 0x676d8
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movl 0x4(%rsp), %edx
movl 0x14(%rsp), %ecx
movl 0x10(%rsp), %r8d
callq *%rax
movq 0x18(%rsp), %rdi
callq 0x11880
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/draw.c
// Function: DrawArraysIndirect
static int DrawArraysIndirect(lua_State *L)
/* draw_arrays_indirect(mode, indirect)
 */
    {
    GLenum mode = checkdrawmode(L, 1);
    GLintptr indirect = luaL_checkinteger(L, 2);
    glDrawArraysIndirect(mode, (const void *)indirect);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movq %rax, (%rsp)
movq 0x535c5(%rip), %rax     # 0x67b30
movq (%rax), %rax
movl 0xc(%rsp), %edi
movq (%rsp), %rsi
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x4(%rsp)
movl $0x2, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x11860
cmpl $0x0, %eax
setle %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x145d5
jmp 0x145ee
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
callq 0x11af0
jmp 0x145b9
movl 0x24(%rsp), %eax
subl $0x2, %eax
movl %eax, 0x1c(%rsp)
cmpl $0x4, 0x24(%rsp)
jl 0x14611
movl 0x1c(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x1462d
movq 0x28(%rsp), %rdi
leaq 0x3df61(%rip), %rsi     # 0x5257e
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x34(%rsp)
jmp 0x1472c
movl 0x1c(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
shlq $0x2, %rsi
movslq 0x1c(%rsp), %rcx
shlq $0x2, %rcx
leaq 0x8(%rsp), %rdx
callq 0x11700
movq %rax, 0x10(%rsp)
movl $0x2, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x146de
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x11040
movl %eax, %edx
movq 0x10(%rsp), %rax
movslq 0x20(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x11040
movl %eax, %edx
movq 0x8(%rsp), %rax
movslq 0x20(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x14673
movq 0x5317b(%rip), %rax     # 0x67860
movq (%rax), %rax
movl 0x4(%rsp), %edi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl 0x1c(%rsp), %ecx
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11370
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11370
movq 0x28(%rsp), %rdi
callq 0x11880
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movl %eax, 0x8(%rsp)
movq 0x52a56(%rip), %rax     # 0x671f8
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movl $0x5, %esi
callq 0x11af0
movl %eax, (%rsp)
movq 0x52e5b(%rip), %rax     # 0x676a0
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %ecx
movl (%rsp), %r8d
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2d, %esi
movl $0x3, %edx
callq 0x11160
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl $0x5, %esi
callq 0x11860
cmpl $0x0, %eax
jg 0x14921
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %edx
movq 0x8(%rsp), %rcx
callq 0x117c0
movq 0x28(%rsp), %rdi
callq 0x11880
movl $0x0, 0x34(%rsp)
jmp 0x149ca
movq 0x28(%rsp), %rdi
movl $0x5, %esi
callq 0x11af0
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl $0x6, %esi
callq 0x11860
cmpl $0x0, %eax
jg 0x1497e
movq 0x52949(%rip), %rax     # 0x67298
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %edx
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %r8d
callq *%rax
movq 0x28(%rsp), %rdi
callq 0x11880
movl $0x0, 0x34(%rsp)
jmp 0x149ca
movq 0x28(%rsp), %rdi
movl $0x6, %esi
callq 0x11af0
movl %eax, 0x20(%rsp)
movq 0x52ae0(%rip), %rax     # 0x67478
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %edx
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %r8d
movl 0x20(%rsp), %r9d
callq *%rax
movq 0x28(%rsp), %rdi
callq 0x11880
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2d, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movq %rax, (%rsp)
movq 0x526f5(%rip), %rax     # 0x67128
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x4(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2d, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, (%rsp)
movl $0x3, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x11860
cmpl $0x0, %eax
setle %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x14abc
jmp 0x14ad5
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
callq 0x11af0
jmp 0x14aa0
movl 0x14(%rsp), %eax
subl $0x3, %eax
movl %eax, 0x1c(%rsp)
cmpl $0x4, 0x14(%rsp)
jl 0x14af8
movl 0x1c(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x14b14
movq 0x28(%rsp), %rdi
leaq 0x3da7a(%rip), %rsi     # 0x5257e
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x34(%rsp)
jmp 0x14c19
movl 0x1c(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
shlq $0x3, %rsi
movslq 0x1c(%rsp), %rcx
shlq $0x2, %rcx
leaq 0x20(%rsp), %rdx
callq 0x11700
movq %rax, 0x8(%rsp)
movl $0x3, 0x14(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x14bc7
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x11040
movq %rax, %rdx
movq 0x8(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x11040
movl %eax, %edx
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x14b5a
movq 0x52d82(%rip), %rax     # 0x67950
movq (%rax), %rax
movl 0x4(%rsp), %edi
movq 0x20(%rsp), %rsi
movl (%rsp), %edx
movq 0x8(%rsp), %rcx
movl 0x1c(%rsp), %r8d
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11370
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11370
movq 0x28(%rsp), %rdi
callq 0x11880
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2d, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x5, %esi
callq 0x11af0
movl %eax, 0x8(%rsp)
movq 0x52c76(%rip), %rax     # 0x67920
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
movl 0x8(%rsp), %r8d
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2d, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x5, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movl $0x6, %esi
callq 0x11af0
movl %eax, (%rsp)
movq 0x529eb(%rip), %rax     # 0x67758
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movl 0x4(%rsp), %r8d
movl (%rsp), %r9d
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x2c(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2d, %esi
movl $0x3, %edx
callq 0x11160
movl %eax, 0x24(%rsp)
movq 0x38(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x5, %esi
callq 0x11af0
movl %eax, 0x14(%rsp)
movq 0x38(%rsp), %rdi
movl $0x6, %esi
callq 0x11860
cmpl $0x0, %eax
jg 0x14e60
movq 0x52dfa(%rip), %rax     # 0x67c28
movq (%rax), %rax
movl 0x2c(%rsp), %edi
movl 0x28(%rsp), %esi
movl 0x24(%rsp), %edx
movq 0x18(%rsp), %rcx
movl 0x14(%rsp), %r8d
callq *%rax
movq 0x38(%rsp), %rdi
callq 0x11880
movl $0x0, 0x44(%rsp)
jmp 0x14f17
movq 0x38(%rsp), %rdi
movl $0x6, %esi
callq 0x11af0
movl %eax, 0x34(%rsp)
movq 0x38(%rsp), %rdi
movl $0x7, %esi
callq 0x11860
cmpl $0x0, %eax
jg 0x14ec2
movq 0x52342(%rip), %rax     # 0x671d0
movq (%rax), %rax
movl 0x2c(%rsp), %edi
movl 0x28(%rsp), %esi
movl 0x24(%rsp), %edx
movq 0x18(%rsp), %rcx
movl 0x34(%rsp), %r8d
movl 0x14(%rsp), %r9d
callq *%rax
movq 0x38(%rsp), %rdi
callq 0x11880
movl $0x0, 0x44(%rsp)
jmp 0x14f17
movq 0x38(%rsp), %rdi
movl $0x7, %esi
callq 0x11af0
movl %eax, 0x30(%rsp)
movq 0x52e54(%rip), %rax     # 0x67d30
movq (%rax), %rax
movl 0x2c(%rsp), %edi
movl 0x28(%rsp), %esi
movl 0x24(%rsp), %edx
movq 0x18(%rsp), %rcx
movl 0x34(%rsp), %r8d
movl 0x14(%rsp), %r9d
movl 0x30(%rsp), %r10d
movl %r10d, (%rsp)
callq *%rax
movq 0x38(%rsp), %rdi
callq 0x11880
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2d, %esi
movl $0x5, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x6, %esi
callq 0x11af0
movq %rax, (%rsp)
movq 0x5269c(%rip), %rax     # 0x67868
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
movl 0xc(%rsp), %r8d
movq (%rsp), %r9
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2d, %esi
movl $0x5, %edx
callq 0x11160
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movl $0x6, %esi
callq 0x11af0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl $0x7, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x52718(%rip), %rax     # 0x679b8
movq (%rax), %rax
movl 0x2c(%rsp), %edi
movl 0x28(%rsp), %esi
movl 0x24(%rsp), %edx
movl 0x20(%rsp), %ecx
movl 0x1c(%rsp), %r8d
movq 0x10(%rsp), %r9
movl 0xc(%rsp), %r10d
movl %r10d, (%rsp)
callq *%rax
movq 0x30(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x52bad(%rip), %rax     # 0x67eb0
movq (%rax), %rax
movl 0xc(%rsp), %edi
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2e, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x8(%rsp)
movq 0x527e5(%rip), %rax     # 0x67b40
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0xc(%rsp), %rdx
movl $0x24, %ecx
callq 0x11430
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x25, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, (%rsp)
cmpl $0x0, 0x8(%rsp)
jne 0x31710
movq 0x36112(%rip), %rax     # 0x67810
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x4(%rsp), %esi
movl (%rsp), %edx
callq *%rax
jmp 0x31727
movq 0x36459(%rip), %rax     # 0x67b70
movq (%rax), %rax
movl 0x8(%rsp), %edi
movl 0x4(%rsp), %esi
movl (%rsp), %edx
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x14(%rsp), %rdx
movl $0x24, %ecx
callq 0x11430
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x27, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
addl $0xfffff3ce, %eax       # imm = 0xFFFFF3CE
subl $0x2, %eax
jb 0x317f6
jmp 0x31792
movl 0x8(%rsp), %eax
addl $0xffff7f58, %eax       # imm = 0xFFFF7F58
subl $0x2, %eax
jb 0x317d4
jmp 0x317a2
movl 0x8(%rsp), %eax
subl $0x8b9a, %eax           # imm = 0x8B9A
je 0x3183a
jmp 0x317b3
movl 0x8(%rsp), %eax
subl $0x8b9b, %eax           # imm = 0x8B9B
je 0x31818
jmp 0x317c0
movl 0x8(%rsp), %eax
addl $0xffff6cf0, %eax       # imm = 0xFFFF6CF0
subl $0x4, %eax
ja 0x3185c
jmp 0x317d4
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
xorl %r8d, %r8d
callq 0x32200
movl %eax, 0x24(%rsp)
jmp 0x3187f
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movl $0x1, %r8d
callq 0x32200
movl %eax, 0x24(%rsp)
jmp 0x3187f
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movl $0x12, %r8d
callq 0x32290
movl %eax, 0x24(%rsp)
jmp 0x3187f
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movl $0x7, %r8d
callq 0x32290
movl %eax, 0x24(%rsp)
jmp 0x3187f
movq 0x18(%rsp), %rdi
leaq 0x20a1d(%rip), %rsi     # 0x52285
leaq 0x2ce04(%rip), %rdx     # 0x5e673
movl $0x65, %ecx
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x24, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11860
cmpl $0x0, %eax
jg 0x31b3b
movq 0x355c4(%rip), %rax     # 0x670f0
movq (%rax), %rax
movl 0x4(%rsp), %edi
callq *%rax
movl %eax, 0x8(%rsp)
jmp 0x31b66
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x361fb(%rip), %rax     # 0x67d50
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x4(%rsp), %esi
callq *%rax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x11880
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %edx
movl $0x26, %esi
callq 0x11120
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x1c(%rsp), %rdx
movl $0x24, %ecx
callq 0x11430
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4f, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl $0xf, %esi
movl $0x3, %edx
callq 0x11160
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0x18(%rsp)
jne 0x31c1e
movq 0x356a9(%rip), %rax     # 0x672b0
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq *%rax
jmp 0x31c3a
movq 0x355cb(%rip), %rax     # 0x671f0
movq (%rax), %rax
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x1c(%rsp), %rdx
movl $0x24, %ecx
callq 0x11430
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4f, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0x18(%rsp)
jne 0x31cd9
movq 0x35486(%rip), %rax     # 0x67148
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq *%rax
jmp 0x31cf5
movq 0x35da8(%rip), %rax     # 0x67a88
movq (%rax), %rax
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x24, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4f, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x13, %esi
movl $0x3, %edx
callq 0x11160
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x5, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x355d2(%rip), %rax     # 0x67360
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
movl 0xc(%rsp), %r8d
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x24, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4f, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x13, %esi
movl $0x3, %edx
callq 0x11160
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x5, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x6, %esi
callq 0x11af0
movl %eax, 0x8(%rsp)
movq 0x35a07(%rip), %rax     # 0x67908
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
movl 0xc(%rsp), %r8d
movl 0x8(%rsp), %r9d
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x1c(%rsp), %rdx
movl $0x24, %ecx
callq 0x11430
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4f, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x5, %esi
callq 0x11af0
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x18(%rsp)
jne 0x31fe1
movq 0x355ab(%rip), %rax     # 0x67570
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movl 0x8(%rsp), %r8d
callq *%rax
jmp 0x32002
movq 0x35890(%rip), %rax     # 0x67878
movq (%rax), %rax
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movl 0x8(%rsp), %r8d
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
movl $0x24, %ecx
callq 0x11430
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movl $0x4, %esi
callq 0x11af0
movl %eax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl $0x5, %esi
callq 0x11af0
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movl $0x6, %esi
leaq 0x2c(%rsp), %rdx
callq 0x32440
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x32104
movq 0x352cf(%rip), %rax     # 0x673a8
movq (%rax), %rax
movl 0x24(%rsp), %edi
movl 0x2c(%rsp), %esi
movq 0x8(%rsp), %rdx
movl 0x20(%rsp), %ecx
movl 0x1c(%rsp), %r8d
movl 0x18(%rsp), %r9d
movl 0x14(%rsp), %r10d
movl %r10d, (%rsp)
callq *%rax
jmp 0x32134
movq 0x350ad(%rip), %rax     # 0x671b8
movq (%rax), %rax
movl 0x28(%rsp), %edi
movl 0x2c(%rsp), %esi
movq 0x8(%rsp), %rdx
movl 0x20(%rsp), %ecx
movl 0x1c(%rsp), %r8d
movl 0x18(%rsp), %r9d
movl 0x14(%rsp), %r10d
movl %r10d, (%rsp)
callq *%rax
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11370
movq 0x30(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
movl $0x24, %ecx
callq 0x11430
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
leaq 0x1c(%rsp), %rdx
callq 0x32440
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x321c1
movq 0x351c3(%rip), %rax     # 0x67370
movq (%rax), %rax
movl 0x14(%rsp), %edi
movl 0x1c(%rsp), %esi
movq 0x8(%rsp), %rdx
callq *%rax
jmp 0x321da
movq 0x35998(%rip), %rax     # 0x67b60
movq (%rax), %rax
movl 0x18(%rsp), %edi
movl 0x1c(%rsp), %esi
movq 0x8(%rsp), %rdx
callq *%rax
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11370
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/framebuffer.c
// Function: GetEnum
static int GetEnum(lua_State *L, GLenum target, GLuint framebuffer, GLenum pname, uint32_t domain)
    {
    GLint param;
    if(framebuffer==0)
        glGetFramebufferParameteriv(target, pname, &param);
    else
        glGetNamedFramebufferParameteriv(framebuffer, pname, &param);
    CheckError(L);
    return enums_push(L, domain, param);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
cmpl $0x0, 0x18(%rsp)
jne 0x322cc
movq 0x35070(%rip), %rax     # 0x67328
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x14(%rsp), %esi
leaq 0xc(%rsp), %rdx
callq *%rax
jmp 0x322e5
movq 0x35c2d(%rip), %rax     # 0x67f00
movq (%rax), %rax
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
leaq 0xc(%rsp), %rdx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
callq 0x11120
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/framebuffer.c
// Function: AGetEnum
static int AGetEnum(lua_State *L, GLenum target, GLuint framebuffer, GLenum attachment, GLenum pname, uint32_t domain)
    {
    GLint param;
    if(framebuffer==0)
        glGetFramebufferAttachmentParameteriv(target, attachment, pname, &param);
    else
        glGetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, &param);
    CheckError(L);
    return enums_push(L, domain, param);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
cmpl $0x0, 0x18(%rsp)
jne 0x32355
movq 0x35543(%rip), %rax     # 0x67880
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
leaq 0x8(%rsp), %rcx
callq *%rax
jmp 0x32372
movq 0x3535c(%rip), %rax     # 0x676b8
movq (%rax), %rax
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
leaq 0x8(%rsp), %rcx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
callq 0x11120
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x11860
cmpl $0x0, %eax
setle %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x32476
jmp 0x32493
movq 0x20(%rsp), %rdi
movl 0x8(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x11450
jmp 0x3245a
movl 0x8(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jne 0x324b0
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl $0x4f, %esi
callq 0x11160
movl 0x8(%rsp), %ecx
subl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movslq (%rax), %rsi
shlq $0x2, %rsi
callq 0x11200
movq %rax, (%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x3252d
movq 0x20(%rsp), %rdi
movl 0x8(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
movl $0x4f, %esi
callq 0x11160
movl %eax, %edx
movq (%rsp), %rax
movslq 0xc(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x324e9
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/func.c
// Function: moongl_Malloc
void *Malloc(lua_State *L, size_t size)
    {
    void *ptr;
    if(size==0)
        { luaL_error(L, "malloc request with size = 0"); return NULL; }
    if((ptr = malloc(size)) == NULL)
        { luaL_error(L, "cannot allocate memory"); return NULL; }
    return ptr;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x32574
movq 0x18(%rsp), %rdi
leaq 0x2a2a6(%rip), %rsi     # 0x5c808
movb $0x0, %al
callq 0x11ae0
movq $0x0, 0x20(%rsp)
jmp 0x325b1
movq 0x10(%rsp), %rdi
callq 0x11270
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x325a7
movq 0x18(%rsp), %rdi
leaq 0x2a290(%rip), %rsi     # 0x5c825
movb $0x0, %al
callq 0x11ae0
movq $0x0, 0x20(%rsp)
jmp 0x325b1
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x325e8
cmpq $0x0, 0x10(%rsp)
jne 0x32609
movq 0x28(%rsp), %rdi
leaq 0x2a214(%rip), %rsi     # 0x5c808
movb $0x0, %al
callq 0x11ae0
movq $0x0, 0x30(%rsp)
jmp 0x3268b
movq 0x20(%rsp), %rdi
callq 0x11270
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x3263c
movq 0x28(%rsp), %rdi
leaq 0x2a1fb(%rip), %rsi     # 0x5c825
movb $0x0, %al
callq 0x11ae0
movq $0x0, 0x30(%rsp)
jmp 0x3268b
movq 0x10(%rsp), %rdi
callq 0x11270
movq 0x18(%rsp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x32681
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11370
movq 0x28(%rsp), %rdi
leaq 0x2a1b6(%rip), %rsi     # 0x5c825
movb $0x0, %al
callq 0x11ae0
movq $0x0, 0x30(%rsp)
jmp 0x3268b
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)