LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moongl/src/buffer.c
// Function: MapCopyTo
static int MapCopyTo(lua_State *L) /* nongl */
/* bstring = mapped_buffer_copy_to(target|buffer, offset, length, dstptr, [dstoffset]) */
    {
    size_t buflen;
    GLenum target;
    GLuint buffer = checktargetorname(L, 1, &target, DOMAIN_BUFFER_TARGET);
    char *ptr = (char*)GetPointer(L, target, buffer);
    GLintptr offset = luaL_checkinteger(L, 2);
    size_t length =  luaL_checkinteger(L, 3);
    char *dstptr = (char*)checklightuserdata(L, 4);
    size_t dstoffset = luaL_optinteger(L, 5, 0);
    /* access and boundary checks */
    GLbitfield flags = GetAccessFlags(L, target, buffer);
    if(!(flags & GL_MAP_READ_BIT))
        return luaL_error(L, "no read access");
    buflen = GetMapLength(L, target, buffer);
    if(length > (buflen - offset))
        return luaL_error(L, "length is too large");
    memcpy(dstptr + dstoffset, ptr + offset, length);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
movl $0x36, %ecx
callq 0x11420
movl %eax, %ebp
movl (%r14), %esi
movq %rbx, %rdi
movl %eax, %edx
callq 0x1321d
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11af0
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11af0
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11770
movq %rax, %r13
movq %rbx, %rdi
movl $0x5, %esi
xorl %edx, %edx
callq 0x11b30
movq %rax, 0x10(%rsp)
testl %ebp, %ebp
movl (%r14), %edi
cmovnel %ebp, %edi
movq 0x43aa7(%rip), %rax     # 0x56af0
cmoveq 0x43ed7(%rip), %rax     # 0x56f28
leaq 0x20(%rsp), %r14
movl $0x911f, %esi           # imm = 0x911F
movq %r14, %rdx
callq *(%rax)
movq %rbx, %rdi
callq 0x11870
testb $0x1, (%r14)
jne 0x13077
leaq 0x2c2ce(%rip), %rsi     # 0x3f343
jmp 0x130b8
testl %ebp, %ebp
movl 0xc(%rsp), %edi
cmovnel %ebp, %edi
movq 0x43981(%rip), %rax     # 0x56a08
cmoveq 0x43c89(%rip), %rax     # 0x56d18
leaq 0x20(%rsp), %r14
movl $0x9120, %esi           # imm = 0x9120
movq %r14, %rdx
callq *(%rax)
movq %rbx, %rdi
callq 0x11870
movslq (%r14), %rax
subq %r15, %rax
cmpq %rax, %r12
jbe 0x130c4
leaq 0x2c258(%rip), %rsi     # 0x3f310
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11ae0
jmp 0x130de
addq 0x10(%rsp), %r13
movq 0x18(%rsp), %rsi
addq %r15, %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x11b10
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moongl/src/buffer.c
// Function: GetBoolean
static int GetBoolean(lua_State *L, GLenum target, GLuint buffer, GLenum pname)
    {
    GLint param;
    if(buffer==0)
        glGetBufferParameteriv(target, pname, &param);
    else
        glGetNamedBufferParameteriv(buffer, pname, &param);
    CheckError(L);
    lua_pushboolean(L, (param == GL_TRUE) );
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %edx, %edx
cmovnel %edx, %esi
movq 0x4390b(%rip), %rax     # 0x56af0
cmoveq 0x43d3b(%rip), %rax     # 0x56f28
leaq 0x4(%rsp), %r14
movl %esi, %edi
movl %ecx, %esi
movq %r14, %rdx
callq *(%rax)
movq %rbx, %rdi
callq 0x11870
xorl %esi, %esi
cmpl $0x1, (%r14)
sete %sil
movq %rbx, %rdi
callq 0x117e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moongl/src/buffer.c
// Function: GetPointer
static void *GetPointer(lua_State *L, GLenum target, GLuint buffer)
    {
    void *ptr = NULL;
    if(buffer == 0)
        glGetBufferPointerv(target, GL_BUFFER_MAP_POINTER, &ptr);
    else
        glGetNamedBufferPointerv(buffer, GL_BUFFER_MAP_POINTER, &ptr);
    CheckErrorp(L);
    if(ptr == NULL)
        { luaL_error(L, "cannot retrieve buffer pointer"); return NULL; }
    return ptr;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq $0x0, (%r14)
testl %edx, %edx
cmovnel %edx, %esi
movq 0x43846(%rip), %rax     # 0x56a80
cmoveq 0x43526(%rip), %rax     # 0x56768
movl %esi, %edi
movl $0x88bd, %esi           # imm = 0x88BD
movq %r14, %rdx
callq *(%rax)
movq %rbx, %rdi
callq 0x112c0
movq (%r14), %r14
testq %r14, %r14
jne 0x1326f
leaq 0x2c0bf(%rip), %rsi     # 0x3f324
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11ae0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moongl/src/capabilities.c
// Function: Enable
static int Enable(lua_State *L)
    {
    GLenum cap = checkcapability(L, 1);
    int indexed = lua_isinteger(L, 2);
    if(indexed)
        glEnablei(cap, lua_tointeger(L, 2));
    else
        glEnable(cap);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x44, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x115b0
testl %eax, %eax
je 0x132d5
movq 0x435fe(%rip), %rax     # 0x568b8
movq (%rax), %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x11040
movl %ebp, %edi
movl %eax, %esi
callq *%r14
jmp 0x132dc
movl %ebp, %edi
callq 0x11060
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moongl/src/capabilities.c
// Function: Disable
static int Disable(lua_State *L)
    {
    GLenum cap = checkcapability(L, 1);
    int indexed = lua_isinteger(L, 2);
    if(indexed)
        glDisablei(cap, lua_tointeger(L, 2));
    else
        glDisable(cap);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x44, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x115b0
testl %eax, %eax
je 0x13336
movq 0x43145(%rip), %rax     # 0x56460
movq (%rax), %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x11040
movl %ebp, %edi
movl %eax, %esi
callq *%r14
jmp 0x1333d
movl %ebp, %edi
callq 0x111a0
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moongl/src/capabilities.c
// Function: IsEnabled
static int IsEnabled(lua_State *L)
    {
    GLboolean res;
    GLenum cap = checkcapability(L, 1);
    int indexed = lua_isinteger(L, 2);
    if(indexed)
        res = glIsEnabledi(cap, lua_tointeger(L, 2));
    else
        res = glIsEnabled(cap);
    CheckError(L);
    lua_pushboolean(L, res);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x44, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x115b0
testl %eax, %eax
je 0x13397
movq 0x43514(%rip), %rax     # 0x56890
movq (%rax), %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x11040
movl %ebp, %edi
movl %eax, %esi
callq *%r14
jmp 0x1339e
movl %ebp, %edi
callq 0x11140
movl %eax, %ebp
movq %rbx, %rdi
callq 0x11870
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x117e0
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moongl/src/debug.c
// Function: DebugMessageCallback
static int DebugMessageCallback(lua_State *L)
/* debug_message_callback(func) 
 * func(source, type, id, severity, message)
 */
    {
    if(!lua_isfunction(L, 1))
        return luaL_argerror(L, 1, "function expected");
    lua_pushvalue(L, 1);
    lua_setfield(L, LUA_REGISTRYINDEX, CALLBACK);
    glDebugMessageCallback((GLDEBUGPROC)Callback, (void*)L);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x11850
cmpl $0x6, %eax
jne 0x13421
movq %rbx, %rdi
movl $0x1, %esi
callq 0x11720
leaq 0x2c028(%rip), %rdx     # 0x3f41d
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x11890
movq 0x43617(%rip), %rax     # 0x56a20
leaq 0x3c4(%rip), %rdi       # 0x137d4
movq %rbx, %rsi
callq *(%rax)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
popq %rbx
retq
leaq 0x2bfe3(%rip), %rdx     # 0x3f40b
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0x11930
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moongl/src/debug.c
// Function: DebugMessageControl
static int DebugMessageControl(lua_State *L)
/* debug_message_control(source, type, severity, enabled [, id1, ... ]) */
    {
    GLsizei arg, i, count;
    GLuint *ids;
    GLenum source = checkdebugsource(L, 1);
    GLenum type = checkdebugtype(L, 2);
    GLenum severity = checkdebugseverity(L, 3);
    GLboolean enabled = checkboolean(L, 4);
    arg = 5;
    while(!lua_isnoneornil(L, arg))
        luaL_checkinteger(L, arg++);
    if(arg == 5) /* no ids */
        glDebugMessageControl(source, type, severity, 0, NULL, enabled);
    else
        {
        count = arg - 5;
        ids = (GLuint*)Malloc(L, count*sizeof(GLuint));
        arg = 5;
        for(i=0; i<count; i++)
            ids[i] = lua_tointeger(L, arg++);
        glDebugMessageControl(source, type, severity, count, ids, enabled);
        Free(L,ids);
        }
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x58, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %r15d
movq %rbx, %rdi
movl $0x59, %esi
movl $0x2, %edx
callq 0x11150
movl %eax, 0x10(%rsp)
movq %rbx, %rdi
movl $0x5a, %esi
movl $0x3, %edx
callq 0x11150
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11500
movl %eax, %r12d
movq %rbx, %rdi
movl $0x5, %esi
callq 0x11850
testl %eax, %eax
jle 0x13544
xorl %ebp, %ebp
xorl %r13d, %r13d
leal 0x5(%r13), %esi
leal 0x6(%r13), %r14d
movq %rbx, %rdi
callq 0x11af0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x11850
incq %r13
addq $0x4, %rbp
testl %eax, %eax
jg 0x134af
testl %r13d, %r13d
je 0x13544
movl %r15d, 0x14(%rsp)
leaq 0x4(%r13), %r14
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x111f0
movq %rax, %rbp
cmpl $0x5, %r14d
jb 0x13518
xorl %r14d, %r14d
movq %r13, %r15
leal 0x5(%r14), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11040
movl %eax, (%rbp,%r14,4)
incq %r14
decq %r15
jne 0x134fd
movq 0x430c1(%rip), %rax     # 0x565e0
movzbl %r12b, %r9d
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
movl %r13d, %ecx
movq %rbp, %r8
callq *(%rax)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x11360
jmp 0x13561
movq 0x43095(%rip), %rax     # 0x565e0
movzbl %r12b, %r9d
movl %r15d, %edi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
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_O3/stetre[P]moongl/src/debug.c
// Function: DebugMessageInsert
static int DebugMessageInsert(lua_State *L)
    {
    size_t length;
    GLenum source = checkdebugsource(L, 1);
    GLenum type = checkdebugtype(L, 2);
    GLenum severity = checkdebugseverity(L, 3);
    GLuint id = luaL_checkinteger(L, 4);
    const GLchar *message = luaL_checklstring(L, 5, &length);
    glDebugMessageInsert(source, type, id, severity, (GLsizei)length, message);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x58, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x59, %esi
movl $0x2, %edx
callq 0x11150
movl %eax, %r14d
movq %rbx, %rdi
movl $0x5a, %esi
movl $0x3, %edx
callq 0x11150
movl %eax, %r15d
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11af0
movq %rax, %r12
movq %rsp, %r13
movq %rbx, %rdi
movl $0x5, %esi
movq %r13, %rdx
callq 0x11440
movq 0x4379b(%rip), %r10     # 0x56d88
movl (%r13), %r8d
movl %ebp, %edi
movl %r14d, %esi
movl %r12d, %edx
movl %r15d, %ecx
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_O3/stetre[P]moongl/src/debug.c
// Function: PushDebugGroup
static int PushDebugGroup(lua_State *L)
    {
    size_t length;
    GLenum source = checkdebugsource(L, 1);
    GLuint id = luaL_checkinteger(L, 2);
    const GLchar *message = luaL_checklstring(L, 3, &length);
    glPushDebugGroup(source, id, (GLsizei)length, message);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x58, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11af0
movq %rax, %r14
movq %rsp, %r15
movq %rbx, %rdi
movl $0x3, %esi
movq %r15, %rdx
callq 0x11440
movq 0x438e0(%rip), %r8      # 0x56f40
movl (%r15), %edx
movl %ebp, %edi
movl %r14d, %esi
movq %rax, %rcx
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_O3/stetre[P]moongl/src/debug.c
// Function: ObjectLabel
VOID_FUNC(PopDebugGroup)

static int ObjectLabel(lua_State *L)
    {
    size_t length;
    GLenum identifier = checkdebugidentifier(L, 1);
    GLuint name = luaL_checkinteger(L, 2);
    const GLchar *label= luaL_checklstring(L, 3, &length);
    glObjectLabel(identifier, name, (GLsizei)length, label);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x5b, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11af0
movq %rax, %r14
movq %rsp, %r15
movq %rbx, %rdi
movl $0x3, %esi
movq %r15, %rdx
callq 0x11440
movq 0x42d37(%rip), %r8      # 0x56418
movl (%r15), %edx
movl %ebp, %edi
movl %r14d, %esi
movq %rax, %rcx
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_O3/stetre[P]moongl/src/debug.c
// Function: GetObjectLabel
static int GetObjectLabel(lua_State *L)
    {
    GLsizei length, bufsz = MaxLabelLength(L);
    GLenum identifier = checkdebugidentifier(L, 1);
    GLuint name = luaL_checkinteger(L, 2);
    GLchar *label = (GLchar*)Malloc(L, bufsz*sizeof(GLchar));
    glGetObjectLabel(identifier, name, bufsz, &length, label);
    CheckErrorFree(L, label);
    lua_pushlstring(L, label, length);
    Free(L, label);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x82e8, %esi           # imm = 0x82E8
callq 0x11a70
movl %eax, %ebp
movq %rbx, %rdi
movl $0x5b, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %r14d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11af0
movq %rax, %r15
movslq %ebp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x111f0
movq %rax, %r13
movq 0x43031(%rip), %rax     # 0x567a8
leaq 0x4(%rsp), %rbp
movl %r14d, %edi
movl %r15d, %esi
movl %r12d, %edx
movq %rbp, %rcx
movq %r13, %r8
callq *(%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x11540
movslq (%rbp), %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x11ab0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x11360
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moongl/src/debug.c
// Function: Callback
static void Callback(GLenum source, GLenum type, GLuint id, GLenum severity,
            GLsizei length, const GLchar *message, void *userParam)
    {
#define L ((lua_State*)userParam)
    /* Retrieve the callback */
    lua_getfield(L, LUA_REGISTRYINDEX, CALLBACK);
    /* push arguments */
    pushdebugsource(L, source);
    pushdebugtype(L, type);
    lua_pushinteger(L, id);
    pushdebugseverity(L, severity);
    lua_pushlstring(L, message, length);
    /* Execute the callback */
    lua_call(L, 5, 0);
#undef L
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r12d
movl %esi, %r13d
movl %edi, %ebx
movq 0x40(%rsp), %r14
leaq 0x2bc20(%rip), %rdx     # 0x3f41d
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x11080
movq %r14, %rdi
movl $0x58, %esi
movl %ebx, %edx
callq 0x11110
movq %r14, %rdi
movl $0x59, %esi
movl %r13d, %edx
callq 0x11110
movl %r12d, %esi
movq %r14, %rdi
callq 0x113b0
movq %r14, %rdi
movl $0x5a, %esi
movl %r15d, %edx
callq 0x11110
movslq %ebp, %rdx
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x11ab0
movq %r14, %rdi
movl $0x5, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11280
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11af0
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11af0
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11850
testl %eax, %eax
jle 0x13945
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11af0
movq %rax, %r12
movq %rbx, %rdi
movl $0x5, %esi
callq 0x11850
testl %eax, %eax
jle 0x13954
movq %rbx, %rdi
movl $0x5, %esi
callq 0x11af0
movq 0x42ece(%rip), %r9      # 0x56800
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
movl %r12d, %ecx
movl %eax, %r8d
callq *(%r9)
jmp 0x13968
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
callq 0x118e0
jmp 0x13968
movq 0x42bd5(%rip), %rax     # 0x56530
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
movl %r12d, %ecx
callq *(%rax)
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_O3/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11af0
movq 0x43242(%rip), %rcx     # 0x56be8
movl %ebp, %edi
movq %rax, %rsi
callq *(%rcx)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11850
testl %eax, %eax
jle 0x13a95
xorl %r15d, %r15d
xorl %r13d, %r13d
leal 0x2(%r13), %esi
leal 0x3(%r13), %r14d
movq %rbx, %rdi
callq 0x11af0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x11850
incq %r13
addq $0x2, %r15
testl %eax, %eax
jg 0x139fb
leal 0x1(%r13), %eax
cmpl $0x3, %eax
jb 0x13a95
andl $0x1, %eax
je 0x13a95
movl %ebp, 0x14(%rsp)
movl %r13d, %r14d
shrl %r14d
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r15, %rcx
callq 0x116f0
movq %rax, %r15
testl %r13d, %r13d
je 0x13ab4
shrq %r13
movl $0x2, %r12d
xorl %ebp, %ebp
movq %rbx, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x11040
movl %eax, (%r15,%rbp,4)
leal 0x1(%r12), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11040
movq 0x8(%rsp), %rdx
movl %eax, (%rdx,%rbp,4)
incq %rbp
addl $0x2, %r12d
cmpq %rbp, %r13
jne 0x13a5f
jmp 0x13ab9
leaq 0x2bae2(%rip), %rsi     # 0x3f57e
movq %rbx, %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11ae0
movq 0x8(%rsp), %rdx
movq 0x42e90(%rip), %rax     # 0x56950
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_O3/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
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11af0
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11af0
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11af0
movq 0x4284c(%rip), %r8      # 0x56398
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_O3/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
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11af0
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11af0
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11af0
movq %rax, %r12
movq %rbx, %rdi
movl $0x5, %esi
callq 0x11af0
movq 0x42c0a(%rip), %r9      # 0x567d8
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_O3/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
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11af0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2d, %esi
movl $0x3, %edx
callq 0x11150
movl %eax, %r15d
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11af0
movq %rax, %r12
movq %rbx, %rdi
movl $0x5, %esi
callq 0x11850
testl %eax, %eax
jle 0x13ca2
movq %rbx, %rdi
movl $0x5, %esi
callq 0x11af0
movq %rax, %r13
movq %rbx, %rdi
movl $0x6, %esi
callq 0x11850
testl %eax, %eax
jle 0x13cb4
movq %rbx, %rdi
movl $0x6, %esi
callq 0x11af0
movq 0x42964(%rip), %r10     # 0x565f0
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
movq %r12, %rcx
movl %r13d, %r8d
movl %eax, %r9d
callq *(%r10)
jmp 0x13ccb
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
movq %r12, %rcx
callq 0x117b0
jmp 0x13ccb
movq 0x42775(%rip), %rax     # 0x56430
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_O3/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
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2d, %esi
movl $0x2, %edx
callq 0x11150
movl %eax, %r14d
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11af0
movq 0x425bb(%rip), %rcx     # 0x562e0
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_O3/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
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movl $0x2, %r14d
movq %rbx, %rdi
movl $0x2d, %esi
movl $0x2, %edx
callq 0x11150
movl %eax, %r15d
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11850
testl %eax, %eax
jle 0x13e34
movl %r14d, %r12d
leal 0x1(%r12), %r14d
addl $0x2, %r12d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x11af0
movq %rbx, %rdi
movl %r12d, %esi
callq 0x11850
testl %eax, %eax
jg 0x13d90
cmpl $0x3, %r14d
setae %al
testb $0x1, %r14b
sete %cl
testb %cl, %al
je 0x13e34
movl %ebp, 0x14(%rsp)
addl $-0x2, %r14d
sarl %r14d
movslq %r14d, %r13
leaq (,%r13,8), %rsi
leaq (,%r13,4), %rcx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x116f0
movq %rax, %r12
testl %r13d, %r13d
jle 0x13e53
movl %r14d, %r13d
addq %r13, %r13
xorl %ebp, %ebp
leal 0x3(%rbp), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11040
movq %rax, (%r12,%rbp,4)
leal 0x4(%rbp), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11040
movq 0x8(%rsp), %rsi
movl %eax, (%rsi,%rbp,2)
addq $0x2, %rbp
cmpq %rbp, %r13
jne 0x13e03
jmp 0x13e58
leaq 0x2b743(%rip), %rsi     # 0x3f57e
movq %rbx, %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11ae0
movq 0x8(%rsp), %rsi
movq 0x42be1(%rip), %rax     # 0x56a40
movl 0x14(%rsp), %edi
movl %r15d, %edx
movq %r12, %rcx
movl %r14d, %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_O3/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
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2d, %esi
movl $0x2, %edx
callq 0x11150
movl %eax, %r14d
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11af0
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11af0
movq %rax, %r12
movq %rbx, %rdi
movl $0x5, %esi
callq 0x11af0
movq 0x42b0c(%rip), %r9      # 0x56a10
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_O3/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
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2d, %esi
movl $0x2, %edx
callq 0x11150
movl %eax, %r14d
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11af0
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11af0
movq %rax, %r12
movq %rbx, %rdi
movl $0x5, %esi
callq 0x11af0
movq %rax, %r13
movq %rbx, %rdi
movl $0x6, %esi
callq 0x11af0
movq 0x428d8(%rip), %r10     # 0x56878
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_O3/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
movl $0x2c, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11af0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2d, %esi
movl $0x3, %edx
callq 0x11150
movl %eax, %r15d
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11af0
movq %rax, %r12
movq %rbx, %rdi
movl $0x5, %esi
callq 0x11af0
movq %rax, %r13
movq %rbx, %rdi
movl $0x6, %esi
callq 0x11850
testl %eax, %eax
jle 0x14097
movq %rbx, %rdi
movl $0x6, %esi
callq 0x11af0
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movl $0x7, %esi
callq 0x11850
testl %eax, %eax
jle 0x140b0
movq %rbx, %rdi
movl $0x7, %esi
callq 0x11af0
movq 0x42d2c(%rip), %r10     # 0x56da8
movl %eax, (%rsp)
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
movq %r12, %rcx
movq 0x10(%rsp), %r8
movl %r13d, %r9d
callq *(%r10)
jmp 0x140cc
movq 0x42c1a(%rip), %rax     # 0x56cb8
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
movq %r12, %rcx
movl %r13d, %r8d
callq *(%rax)
jmp 0x140cc
movq 0x422b9(%rip), %rax     # 0x56370
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
movq %r12, %rcx
movq 0x10(%rsp), %r8
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_O3/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
movl $0x1, %esi
callq 0x11af0
movq 0x42aaf(%rip), %rcx     # 0x56ee0
movl %eax, %edi
callq *(%rcx)
movq %rbx, %rdi
callq 0x11870
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x11af0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2e, %esi
movl $0x2, %edx
callq 0x11150
movq 0x4278a(%rip), %rcx     # 0x56bf8
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_O3/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
leaq 0xc(%rsp), %rdx
movl $0x1, %esi
movl $0x24, %ecx
callq 0x11420
movl %eax, %ebp
movq %rbx, %rdi
movl $0x25, %esi
movl $0x2, %edx
callq 0x11150
movl %eax, %r14d
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11af0
testl %ebp, %ebp
je 0x2b532
movq 0x2b6f2(%rip), %rcx     # 0x56c20
movl %ebp, %edi
jmp 0x2b53d
movq 0x2b3cf(%rip), %rcx     # 0x56908
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_O3/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, %rbx
leaq 0xc(%rsp), %rdx
movl $0x1, %esi
movl $0x24, %ecx
callq 0x11420
movl %eax, %ebp
movq %rbx, %rdi
movl $0x27, %esi
movl $0x2, %edx
callq 0x11150
cmpl $0x8b9a, %eax           # imm = 0x8B9A
jle 0x2b5bd
leal -0x9310(%rax), %ecx
cmpl $0x5, %ecx
jb 0x2b5d3
cmpl $0x8b9b, %eax           # imm = 0x8B9B
jne 0x2b62e
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x8b9b, %ecx           # imm = 0x8B9B
movl $0x12, %r8d
jmp 0x2b627
leal -0xc32(%rax), %ecx
cmpl $0x2, %ecx
jb 0x2b5ee
leal -0x80a8(%rax), %ecx
cmpl $0x2, %ecx
jae 0x2b60c
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x2bd32
movl $0x1, %r14d
jmp 0x2b64e
movl 0xc(%rsp), %esi
movl $0x1, %r14d
movq %rbx, %rdi
movl %ebp, %edx
movl %eax, %ecx
movl $0x1, %r8d
callq 0x2bd32
jmp 0x2b64e
cmpl $0x8b9a, %eax           # imm = 0x8B9A
jne 0x2b62e
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x8b9a, %ecx           # imm = 0x8B9A
movl $0x7, %r8d
callq 0x2bd89
jmp 0x2b64b
leaq 0x13c50(%rip), %rsi     # 0x3f285
leaq 0x20873(%rip), %rdx     # 0x4beaf
movq %rbx, %rdi
movl $0x65, %ecx
xorl %eax, %eax
callq 0x11ae0
movl %eax, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x24, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11850
testl %eax, %eax
jle 0x2b808
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11af0
movq 0x2b5b0(%rip), %rcx     # 0x56db0
movl %eax, %edi
movl %ebp, %esi
callq *(%rcx)
jmp 0x2b813
movq 0x2aaa1(%rip), %rax     # 0x562b0
movl %ebp, %edi
callq *(%rax)
movl %eax, %ebp
movq %rbx, %rdi
callq 0x11870
movq %rbx, %rdi
movl $0x26, %esi
movl %ebp, %edx
callq 0x11110
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
leaq 0x4(%rsp), %rdx
movl $0x1, %esi
movl $0x24, %ecx
callq 0x11420
movl %eax, %ebp
movq %rbx, %rdi
movl $0x4f, %esi
movl $0x2, %edx
callq 0x11150
movl %eax, %r14d
movq %rbx, %rdi
movl $0xf, %esi
movl $0x3, %edx
callq 0x11150
movl %eax, %r15d
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11af0
testl %ebp, %ebp
je 0x2b89e
movq 0x2aaf6(%rip), %r8      # 0x56390
movl %ebp, %edi
jmp 0x2b8a9
movq 0x2aba3(%rip), %r8      # 0x56448
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_O3/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
leaq 0x4(%rsp), %rdx
movl $0x1, %esi
movl $0x24, %ecx
callq 0x11420
movl %eax, %ebp
movq %rbx, %rdi
movl $0x4f, %esi
movl $0x2, %edx
callq 0x11150
movl %eax, %r14d
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11af0
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11af0
testl %ebp, %ebp
je 0x2b92a
movq 0x2b22a(%rip), %r8      # 0x56b50
movl %ebp, %edi
jmp 0x2b935
movq 0x2a9cf(%rip), %r8      # 0x56300
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_O3/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
movl $0x24, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x4f, %esi
movl $0x2, %edx
callq 0x11150
movl %eax, %r14d
movq %rbx, %rdi
movl $0x13, %esi
movl $0x3, %edx
callq 0x11150
movl %eax, %r15d
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11af0
movq %rax, %r12
movq %rbx, %rdi
movl $0x5, %esi
callq 0x11af0
movq 0x2ab29(%rip), %r9      # 0x564e8
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_O3/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
movl $0x24, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x4f, %esi
movl $0x2, %edx
callq 0x11150
movl %eax, %r14d
movq %rbx, %rdi
movl $0x13, %esi
movl $0x3, %edx
callq 0x11150
movl %eax, %r15d
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11af0
movq %rax, %r12
movq %rbx, %rdi
movl $0x5, %esi
callq 0x11af0
movq 0x2ad33(%rip), %r9      # 0x56780
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_O3/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
movl $0x24, %esi
movl $0x1, %edx
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
movl $0x4f, %esi
movl $0x2, %edx
callq 0x11150
movl %eax, %r14d
movq %rbx, %rdi
movl $0x13, %esi
movl $0x3, %edx
callq 0x11150
movl %eax, %r15d
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11af0
movq %rax, %r12
movq %rbx, %rdi
movl $0x5, %esi
callq 0x11af0
movq %rax, %r13
movq %rbx, %rdi
movl $0x6, %esi
callq 0x11af0
movq 0x2af0a(%rip), %r10     # 0x569f8
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_O3/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
leaq 0xc(%rsp), %rdx
movl $0x1, %esi
movl $0x24, %ecx
callq 0x11420
movl %eax, %ebp
movq %rbx, %rdi
movl $0x4f, %esi
movl $0x2, %edx
callq 0x11150
movl %eax, %r14d
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11af0
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11af0
movq %rax, %r12
movq %rbx, %rdi
movl $0x5, %esi
callq 0x11af0
testl %ebp, %ebp
je 0x2bb91
movq 0x2addb(%rip), %r9      # 0x56968
movl %ebp, %edi
jmp 0x2bb9c
movq 0x2ab38(%rip), %r9      # 0x566d0
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