LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/PARKINHYO[P]BlackjackGame/mqueue/mqueue_client.c
// Function: main
int main() {

	char buffer[BUFFER_SIZE];
	int count = 0;
	pid = getpid();
	msg buf;

	msgid_Send_Main = msgget(KEY_VALUE_MAIN, IPC_CREAT | PERM);
	msgid_Recv_Main = msgget(KEY_VALUE_MAIN2, IPC_CREAT | PERM);

	// Signal 등록 ...
	(void)signal(SIGINT, (void(*)()) set_shutdown);

	printf("input data ==> ");
	fgets(buffer, BUFFER_SIZE, stdin);

	buf.type = 200;
	memset(buf.data, 0, sizeof(buf.data));
	strncpy(buf.data, buffer, BUFFER_SIZE);
	msgsnd(msgid_Send_Main, (void*)&buf, sizeof(msg), 0);

	// 쓴 데이터가 ‘quit’이면 while 문 벗어남...
	if (!strncmp(buf.data, "quit", 4)) {
		return 0;
	}

	// play_game 스레드 진입...
	pthread_create(&threads[0], NULL, play_game, NULL);
	// 스레드 종료 대기후 삭제...
	pthread_join(threads[0], NULL);
	printf("game end!\n");
	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
callq 0x1070
movl %eax, 0x267e(%rip)      # 0x4174
movl $0xeb8c, %edi           # imm = 0xEB8C
movl $0x3b6, %esi            # imm = 0x3B6
callq 0x1030
movl %eax, 0x2661(%rip)      # 0x416c
movl $0xeb8d, %edi           # imm = 0xEB8D
movl $0x3b6, %esi            # imm = 0x3B6
callq 0x1030
movl %eax, 0x2650(%rip)      # 0x4170
leaq -0x763(%rip), %rsi      # 0x13c4
movl $0x2, %edi
callq 0x10c0
leaq 0x5a7(%rip), %rdi       # 0x20df
xorl %eax, %eax
callq 0x1090
movq 0x2492(%rip), %rax      # 0x3fd8
movq (%rax), %rdx
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
movl $0x20, %esi
callq 0x10a0
leaq -0x28(%rbp), %rdi
movq $0xc8, -0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movl $0x20, %edx
movq %rbx, %rsi
callq 0x1050
movl 0x25e9(%rip), %edi      # 0x416c
leaq -0x30(%rbp), %rbx
movl $0x28, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x10b0
cmpl $0x74697571, 0x8(%rbx)  # imm = 0x74697571
je 0x1bd0
leaq 0x25da(%rip), %rdi      # 0x4180
leaq -0x10c(%rip), %rdx      # 0x1aa1
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1100
movq 0x25c3(%rip), %rdi      # 0x4180
xorl %esi, %esi
callq 0x1130
leaq 0x64f(%rip), %rdi       # 0x221a
callq 0x1060
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moongl/src/bitfield.c
// Function: moongl_bitfieldCheck
GLbitfield bitfieldCheck(lua_State *L, int arg, int mandatory, bitfield_t *b)
/* Assuming all args from arg to end are bitfield strings */
/* returns the OR of the corresponding codes */
        {
        int first = arg;
        GLbitfield val = 0;
        while(!lua_isnoneornil(L, arg))
            val |= b->codes[checkoption(L, arg++, NULL, b->strings)];
        if(mandatory && (arg==first))
            return luaL_argerror(L, first, "string expected");
        return val;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movl %edx, 0x4(%rsp)
movl %esi, %ebx
movq %rdi, %r14
callq 0x11860
xorl %r15d, %r15d
testl %eax, %eax
jle 0x11cb3
movl %ebx, %esi
movq (%r12), %rcx
movq 0x8(%r12), %rbp
leal 0x1(%rsi), %r13d
movq %r14, %rdi
xorl %edx, %edx
callq 0x11a60
cltq
orl (%rbp,%rax,4), %r15d
movq %r14, %rdi
movl %r13d, %esi
callq 0x11860
movl %r13d, %esi
testl %eax, %eax
jg 0x11c81
jmp 0x11cb6
movl %ebx, %r13d
cmpl $0x0, 0x4(%rsp)
sete %al
cmpl %ebx, %r13d
setne %cl
orb %al, %cl
jne 0x11ce7
leaq 0x2d331(%rip), %rdx     # 0x3f000
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11940
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moongl/src/bitfield.c
// Function: moongl_bitfieldPush
int bitfieldPush(lua_State *L, GLbitfield code, bitfield_t *b)
/* Pushes all the strings corresponding to bits contained in code */
    {
    size_t i;
    int nret = 0;
    for(i = 0; i < b->n; i++)
        {
        if((b->codes[i] & code) == b->codes[i])
            { lua_pushstring(L, b->strings[i]); nret++; }
        }
    return nret;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq $0x0, 0x10(%rdx)
je 0x11d3f
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
xorl %r14d, %r14d
notl %ebp
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
testl %ebp, (%rax,%r12,4)
jne 0x11d34
movq (%rbx), %rax
movq (%rax,%r12,8), %rsi
movq %r15, %rdi
callq 0x110c0
incl %r14d
incq %r12
cmpq 0x10(%rbx), %r12
jb 0x11d18
jmp 0x11d42
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moongl/src/buffer.c
// Function: BindBufferBase
static int BindBufferBase(lua_State *L)
    {
    GLenum target = checkbufferrangetarget(L, 1);
    GLuint index = luaL_checkinteger(L, 2);
    GLuint buffer = luaL_checkinteger(L, 3); 
    glBindBufferBase(target, index, buffer);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x37, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11af0
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11af0
movq 0x444e6(%rip), %rcx     # 0x565e8
movl %ebp, %edi
movl %r14d, %esi
movl %eax, %edx
callq *(%rcx)
movq %rbx, %rdi
callq 0x11880
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moongl/src/buffer.c
// Function: BufferStorage
static int BufferStorage(lua_State *L)
/* size = buffer_storage(target|buffer, data, flag1, flag2, ... ) */
    {
    size_t len;
    const char *data;
    GLsizeiptr size;
    GLbitfield flags;
    GLenum target;
    GLuint buffer = checktargetorname(L, 1, &target, DOMAIN_BUFFER_TARGET);
    if(lua_isnoneornil(L, 2))
        {
        data = NULL;
        size = 0;
        }
    else if(lua_isstring(L, 2))
        {
        data = lua_tolstring(L, 2, &len);
        size = len;
        }
    else if(lua_istable(L, 2))
        {
        data = checkdataptr(L, 2, &len);
        size = len;
        }
    else
        return luaL_argerror(L, 2, "invalid type");
    flags = CheckStorageFlags(L, 3, 0);

    if(buffer==0)
        glBufferStorage(target, size, data, flags);
    else
        glNamedBufferStorage(buffer, size, data, flags);
    CheckError(L);
    lua_pushinteger(L, size);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
movl $0x1, %esi
movl $0x36, %ecx
callq 0x11430
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11860
testl %eax, %eax
jle 0x12184
movq %rbx, %rdi
movl $0x2, %esi
callq 0x110b0
testl %eax, %eax
je 0x1218c
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x11950
jmp 0x121b3
xorl %r14d, %r14d
xorl %r15d, %r15d
jmp 0x121b9
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11860
cmpl $0x5, %eax
jne 0x12217
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x11b20
movq %rax, %r15
movq (%r14), %r14
leaq 0x45420(%rip), %rcx     # 0x575e0
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x11b50
testl %ebp, %ebp
je 0x121de
movq 0x44aa6(%rip), %r8      # 0x56c80
movl %ebp, %edi
jmp 0x121e9
movq 0x44213(%rip), %r8      # 0x563f8
movl 0xc(%rsp), %edi
movq %r14, %rsi
movq %r15, %rdx
movl %eax, %ecx
callq *(%r8)
movq %rbx, %rdi
callq 0x11880
movq %rbx, %rdi
movq %r14, %rsi
callq 0x113c0
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2cfda(%rip), %rdx     # 0x3f1f8
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11940
jmp 0x1220c
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moongl/src/buffer.c
// Function: BufferData
static int BufferData(lua_State *L)
/* size = buffer_data(target|buffer, data, usage) data = binary string (see string.pack())
 * size = buffer_data(target|buffer, size, usage) allocates memory only, without storing
 *                                              any data in it
 */
    {
    size_t len;
    const char *data;
    GLsizeiptr size;
    GLenum target, usage;
    GLuint buffer = checktargetorname(L, 1, &target, DOMAIN_BUFFER_TARGET);

    if(lua_type(L, 2)==LUA_TNUMBER)
        {
        data = NULL;
        size = luaL_checkinteger(L, 2);
        }
    else if(lua_isstring(L, 2))
        {
        data = lua_tolstring(L, 2, &len);
        size = len;
        }
    else if(lua_istable(L, 2))
        {
        data = checkdataptr(L, 2, &len);
        size = len;
        }
    else
        return luaL_argerror(L, 2, "invalid type");
    usage = checkbufferusage(L, 3);
    
    if(buffer == 0)
        glBufferData(target, size, data, usage);
    else
        glNamedBufferData(buffer, size, data, usage);
    CheckError(L);
    lua_pushinteger(L, size);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
movl $0x1, %esi
movl $0x36, %ecx
callq 0x11430
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11860
movq %rbx, %rdi
movl $0x2, %esi
cmpl $0x3, %eax
jne 0x12277
callq 0x11af0
movq %rax, %r14
xorl %r15d, %r15d
jmp 0x122c4
callq 0x110b0
testl %eax, %eax
je 0x12297
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x11950
jmp 0x122be
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11860
cmpl $0x5, %eax
jne 0x1231e
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x11b20
movq %rax, %r15
movq (%r14), %r14
movq %rbx, %rdi
movl $0x38, %esi
movl $0x3, %edx
callq 0x11160
testl %ebp, %ebp
je 0x122e5
movq 0x44c27(%rip), %r8      # 0x56f08
movl %ebp, %edi
jmp 0x122f0
movq 0x44aec(%rip), %r8      # 0x56dd8
movl 0xc(%rsp), %edi
movq %r14, %rsi
movq %r15, %rdx
movl %eax, %ecx
callq *(%r8)
movq %rbx, %rdi
callq 0x11880
movq %rbx, %rdi
movq %r14, %rsi
callq 0x113c0
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ced3(%rip), %rdx     # 0x3f1f8
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11940
jmp 0x12313
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moongl/src/buffer.c
// Function: BufferSubData
static int BufferSubData(lua_State *L)
/* size = buffer_sub_data(target|buffer, offset, data) 
 * data = binary string (see string.pack())
 */
    {
    size_t len;
    const char *data;
    GLsizeiptr size;
    GLenum target;
    GLuint buffer = checktargetorname(L, 1, &target, DOMAIN_BUFFER_TARGET);
    GLintptr offset = lua_tointeger(L, 2);
    if(lua_isstring(L, 3))
        {
        data = lua_tolstring(L, 3, &len);
        size = len;
        }
    else if(lua_istable(L, 3))
        {
        data = checkdataptr(L, 3, &len);
        size = len;
        }
    else
        return luaL_argerror(L, 3, "invalid type");
    
    if(buffer == 0)
        glBufferSubData(target, offset, size, data);
    else
        glNamedBufferSubData(buffer, offset, size, data);

    CheckError(L);
    lua_pushinteger(L, size);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
movl $0x1, %esi
movl $0x36, %ecx
callq 0x11430
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x11040
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x110b0
testl %eax, %eax
je 0x1238e
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11950
jmp 0x123b2
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11860
cmpl $0x5, %eax
jne 0x12400
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11b20
movq 0x10(%rsp), %r15
testl %ebp, %ebp
je 0x123c6
movq 0x4441e(%rip), %r8      # 0x567e0
movl %ebp, %edi
jmp 0x123d1
movq 0x445bb(%rip), %r8      # 0x56988
movl 0xc(%rsp), %edi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq *(%r8)
movq %rbx, %rdi
callq 0x11880
movq %rbx, %rdi
movq %r15, %rsi
callq 0x113c0
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2cdf1(%rip), %rdx     # 0x3f1f8
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11940
jmp 0x123f5
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moongl/src/buffer.c
// Function: ClearBufferData
static int ClearBufferData(lua_State *L)
    {
    size_t len;
    const void* data;
    int arg = 1;
    GLenum target;
    GLuint buffer = checktargetorname(L, arg++, &target, DOMAIN_BUFFER_TARGET);
    GLenum internalformat = checkinternalformat(L, arg++);
    GLenum format = checkformat(L, arg++);
    GLenum type = checktype(L, arg++);
    if(lua_isnoneornil(L, arg))
        data = NULL;
    else if(lua_isstring(L, arg))
        data = lua_tolstring(L, arg, &len);
    else if(lua_istable(L, arg))
        data = checkdataptr(L, arg, &len);
    else
        return luaL_argerror(L, arg, "invalid type");
    if(buffer == 0)
        glClearBufferData(target, internalformat, format, type, (void*)data);
    else
        glClearNamedBufferData(buffer, internalformat, format, type, (void*)data);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r12
leaq 0x4(%rsp), %rdx
movl $0x1, %esi
movl $0x36, %ecx
callq 0x11430
movl %eax, %ebx
movq %r12, %rdi
movl $0x11, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, %ebp
movq %r12, %rdi
movl $0x12, %esi
movl $0x3, %edx
callq 0x11160
movl %eax, %r14d
movq %r12, %rdi
movl $0x7, %esi
movl $0x4, %edx
callq 0x11160
movl %eax, %r15d
movq %r12, %rdi
movl $0x5, %esi
callq 0x11860
testl %eax, %eax
jle 0x124af
movq %r12, %rdi
movl $0x5, %esi
callq 0x110b0
testl %eax, %eax
je 0x124b4
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
movl $0x5, %esi
callq 0x11950
jmp 0x124d8
xorl %r8d, %r8d
jmp 0x124db
movq %r12, %rdi
movl $0x5, %esi
callq 0x11860
cmpl $0x5, %eax
jne 0x1250e
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
movl $0x5, %esi
callq 0x11b20
movq %rax, %r8
testl %ebx, %ebx
je 0x124ea
movq 0x4443a(%rip), %rax     # 0x56920
movl %ebx, %edi
jmp 0x124f5
movq 0x441ff(%rip), %rax     # 0x566f0
movl 0x4(%rsp), %edi
movl %ebp, %esi
movl %r14d, %edx
movl %r15d, %ecx
callq *(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2cce3(%rip), %rdx     # 0x3f1f8
movq %r12, %rdi
movl $0x5, %esi
callq 0x11940
jmp 0x12501
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moongl/src/buffer.c
// Function: ClearBufferSubData
static int ClearBufferSubData(lua_State *L)
    {
    int arg = 1;
    size_t len;
    const void* data;
    GLenum target;
    GLuint buffer = checktargetorname(L, arg++, &target, DOMAIN_BUFFER_TARGET);
    GLenum internalformat = checkinternalformat(L, arg++);
    GLintptr offset = luaL_checkinteger(L, arg++);
    GLsizei size = luaL_checkinteger(L, arg++);
    GLenum format = checkformat(L, arg++);
    GLenum type = checktype(L, arg++);
    if(lua_isnoneornil(L, arg))
        data = NULL;
    else if(lua_isstring(L, arg))
        data = lua_tolstring(L, arg, &len);
    else if(lua_istable(L, arg))
        data = checkdataptr(L, arg, &len);
    else
        return luaL_argerror(L, arg, "invalid type");
    if(buffer == 0)
        glClearBufferSubData(target, internalformat, offset, size, format, type, (void*)data);
    else
        glClearNamedBufferSubData(buffer,internalformat, offset, size, format, type, (void*)data);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
movl $0x1, %esi
movl $0x36, %ecx
callq 0x11430
movl %eax, %ebp
movq %rbx, %rdi
movl $0x11, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0x8(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11af0
movq %rax, %r14
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11af0
movq %rax, %r13
movq %rbx, %rdi
movl $0x12, %esi
movl $0x5, %edx
callq 0x11160
movl %eax, %r15d
movq %rbx, %rdi
movl $0x7, %esi
movl $0x6, %edx
callq 0x11160
movl %eax, %r12d
movq %rbx, %rdi
movl $0x7, %esi
callq 0x11860
testl %eax, %eax
jle 0x125e1
movq %rbx, %rdi
movl $0x7, %esi
callq 0x110b0
testl %eax, %eax
je 0x125e5
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x7, %esi
callq 0x11950
jmp 0x12609
xorl %eax, %eax
jmp 0x12609
movq %rbx, %rdi
movl $0x7, %esi
callq 0x11860
cmpl $0x5, %eax
jne 0x12652
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x7, %esi
callq 0x11b20
testl %ebp, %ebp
je 0x1261f
movq 0x44304(%rip), %r10     # 0x56918
movslq %r13d, %rcx
movq %rax, (%rsp)
movl %ebp, %edi
jmp 0x12631
movq 0x441f2(%rip), %r10     # 0x56818
movl 0xc(%rsp), %edi
movslq %r13d, %rcx
movq %rax, (%rsp)
movl 0x8(%rsp), %esi
movq %r14, %rdx
movl %r15d, %r8d
movl %r12d, %r9d
callq *(%r10)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2cb9f(%rip), %rdx     # 0x3f1f8
movq %rbx, %rdi
movl $0x7, %esi
callq 0x11940
jmp 0x12643
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moongl/src/buffer.c
// Function: GetBufferSubData
static int GetBufferSubData(lua_State *L)
/* data = get_buffer_sub_data(target|buffer, offset, size) */
    {
    char *data;
    GLenum target;
    GLuint buffer = checktargetorname(L, 1, &target, DOMAIN_BUFFER_TARGET);
    GLintptr offset = lua_tointeger(L, 2);
    GLsizeiptr size = lua_tointeger(L, 3);
    data = (char*)Malloc(L, size*sizeof(char));
    
    if(buffer == 0)
        glGetBufferSubData(target, offset, size, data);
    else
        glGetNamedBufferSubData(buffer, offset, size, data);
    CheckErrorFree(L, data);
    lua_pushlstring(L, data, size);
    Free(L, data);
    return 1;
    }

// 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 $0x36, %ecx
callq 0x11430
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x11040
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x11040
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11200
movq %rax, %r15
testl %ebp, %ebp
je 0x126ce
movq 0x444be(%rip), %rax     # 0x56b88
movl %ebp, %edi
jmp 0x126d9
movq 0x448a3(%rip), %rax     # 0x56f78
movl 0xc(%rsp), %edi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq *(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11550
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x11ab0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11370
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moongl/src/buffer.c
// Function: CopyBufferSubData
static int CopyBufferSubData(lua_State *L)
/* data = copy_buffer_sub_data(src, dst, src_offset, dst_offset, size) 
 * src,dst = target,target | buffer,buffer
 */
    {
    GLenum src_target, dst_target;
    GLuint src_buffer = checktargetorname(L, 1, &src_target, DOMAIN_BUFFER_TARGET);
    GLuint dst_buffer = checktargetorname(L, 2, &dst_target, DOMAIN_BUFFER_TARGET);
    GLintptr src_offset = lua_tointeger(L, 3);
    GLintptr dst_offset = lua_tointeger(L, 4);
    GLsizeiptr size = lua_tointeger(L, 5);
    if((src_buffer==0) &&(dst_buffer != 0))
        glCopyBufferSubData(src_target, dst_target, src_offset, dst_offset, size);
    else if((dst_buffer!=0) && (dst_buffer != 0))
        glCopyNamedBufferSubData(src_buffer, dst_buffer, src_offset, dst_offset, size); 
    else
        return luaL_error(L, "invalid arguments (can not mix names and targets)");
    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 $0x36, %ecx
callq 0x11430
movl %eax, %ebp
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
movl $0x36, %ecx
callq 0x11430
movl %eax, %r14d
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x11040
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x11040
movq %rax, %r12
movq %rbx, %rdi
movl $0x5, %esi
xorl %edx, %edx
callq 0x11040
testl %ebp, %ebp
sete %cl
testl %r14d, %r14d
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x127af
movq 0x443db(%rip), %r9      # 0x56b80
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
jmp 0x127c0
testl %r14d, %r14d
je 0x127e3
movq 0x4438d(%rip), %r9      # 0x56b48
movl %ebp, %edi
movl %r14d, %esi
movq %r15, %rdx
movq %r12, %rcx
movq %rax, %r8
callq *(%r9)
movq %rbx, %rdi
callq 0x11880
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ca69(%rip), %rsi     # 0x3f253
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11ae0
jmp 0x127d6
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moongl/src/buffer.c
// Function: InvalidateBufferData
static int InvalidateBufferData(lua_State *L)
    {
    GLuint buffer = luaL_checkinteger(L, 1);
    glInvalidateBufferData(buffer);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x11af0
movq 0x4461d(%rip), %rcx     # 0x56e28
movl %eax, %edi
callq *(%rcx)
movq %rbx, %rdi
callq 0x11880
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moongl/src/buffer.c
// Function: InvalidateBufferSubData
static int InvalidateBufferSubData(lua_State *L)
    {
    GLuint buffer = luaL_checkinteger(L, 1);
    GLintptr offset = luaL_checkinteger(L, 2);
    GLsizeiptr length = luaL_checkinteger(L, 3);
    glInvalidateBufferSubData(buffer, offset, length);
    CheckError(L);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x11af0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11af0
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11af0
movq 0x43c44(%rip), %rcx     # 0x56498
movl %r14d, %edi
movq %r15, %rsi
movq %rax, %rdx
callq *(%rcx)
movq %rbx, %rdi
callq 0x11880
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moongl/src/buffer.c
// Function: MapBuffer
static int MapBuffer(lua_State *L)
/* map_buffer(target|buffer, access) */
    {
    void *ptr;
    GLenum target;
    GLuint buffer = checktargetorname(L, 1, &target, DOMAIN_BUFFER_TARGET);
    GLenum access = checkbufferaccess(L, 2);
    if(buffer == 0)
        ptr = glMapBuffer(target, access);
    else
        ptr = glMapNamedBuffer(buffer, access);
    CheckError(L);
    if(ptr==NULL)
        return luaL_error(L, "cannot bind buffer");
    lua_pushlightuserdata(L, ptr);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
movl $0x1, %esi
movl $0x36, %ecx
callq 0x11430
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3a, %esi
movl $0x2, %edx
callq 0x11160
testl %ebp, %ebp
je 0x12a5a
movq 0x4419a(%rip), %rcx     # 0x56bf0
movl %ebp, %edi
jmp 0x12a65
movq 0x43dff(%rip), %rcx     # 0x56860
movl 0xc(%rsp), %edi
movl %eax, %esi
callq *(%rcx)
movq %rax, %r14
movq %rbx, %rdi
callq 0x11880
testq %r14, %r14
je 0x12a8b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x114b0
movl $0x1, %eax
jmp 0x12a9c
leaq 0x2c84e(%rip), %rsi     # 0x3f2e0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11ae0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moongl/src/buffer.c
// Function: MapBufferRange
static int MapBufferRange(lua_State *L)
/* map_buffer_range(target|buffer, offset, length, accessbit1, ...) */
    {
    void *ptr;
    GLenum target;
    GLuint buffer = checktargetorname(L, 1, &target, DOMAIN_BUFFER_TARGET);
    GLintptr offset = luaL_checkinteger(L, 2);
    GLsizei length = luaL_checkinteger(L, 3);
    GLbitfield access = CheckAccessFlags(L, 4, 0);
    if(buffer == 0)
        ptr = glMapBufferRange(target, offset, length, access);
    else
        ptr = glMapNamedBufferRange(buffer, offset, length, access);
    CheckError(L);
    if(ptr==NULL)
        return luaL_error(L, "cannot bind buffer");
    lua_pushlightuserdata(L, ptr);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %rdx
movl $0x1, %esi
movl $0x36, %ecx
callq 0x11430
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
leaq 0x44b6c(%rip), %rcx     # 0x57658
movq %rbx, %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x11b50
testl %ebp, %ebp
je 0x12b0d
movq 0x43a72(%rip), %r8      # 0x56578
movslq %r15d, %rdx
movl %ebp, %edi
jmp 0x12b1b
movq 0x43de4(%rip), %r8      # 0x568f8
movl 0x4(%rsp), %edi
movslq %r15d, %rdx
movq %r14, %rsi
movl %eax, %ecx
callq *(%r8)
movq %rax, %r14
movq %rbx, %rdi
callq 0x11880
testq %r14, %r14
je 0x12b45
movq %rbx, %rdi
movq %r14, %rsi
callq 0x114b0
movl $0x1, %eax
jmp 0x12b56
leaq 0x2c794(%rip), %rsi     # 0x3f2e0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11ae0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moongl/src/buffer.c
// Function: FlushMappedBufferRange
static int FlushMappedBufferRange(lua_State *L)
    {
    GLenum target;
    GLuint buffer = checktargetorname(L, 1, &target, DOMAIN_BUFFER_TARGET);
    GLintptr offset = luaL_checkinteger(L, 2);
    GLsizei length = luaL_checkinteger(L, 3);
    if(buffer == 0)
        glFlushMappedBufferRange(target, offset, length);
    else
        glFlushMappedNamedBufferRange(buffer, offset, length);
    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 $0x36, %ecx
callq 0x11430
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11af0
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11af0
testl %ebp, %ebp
je 0x12bb1
movq 0x44426(%rip), %rcx     # 0x56fd0
movslq %eax, %rdx
movl %ebp, %edi
jmp 0x12bbf
movq 0x44260(%rip), %rcx     # 0x56e18
movl 0xc(%rsp), %edi
movslq %eax, %rdx
movq %r14, %rsi
callq *(%rcx)
movq %rbx, %rdi
callq 0x11880
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moongl/src/buffer.c
// Function: UnmapBuffer
static int UnmapBuffer(lua_State *L)
/* unmap_buffer(targe|buffer)
 * -> boolean
 */
    {
    GLboolean res;
    GLenum target;
    GLuint buffer = checktargetorname(L, 1, &target, DOMAIN_BUFFER_TARGET);
    if(buffer == 0)
        res = glUnmapBuffer(target);
    else
        res = glUnmapNamedBuffer(buffer);
    CheckError(L);
    lua_pushboolean(L, res);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %rdx
movl $0x1, %esi
movl $0x36, %ecx
callq 0x11430
testl %eax, %eax
je 0x12c02
movq 0x43804(%rip), %rcx     # 0x56400
movl %eax, %edi
callq *(%rcx)
jmp 0x12c0f
movq 0x443cf(%rip), %rax     # 0x56fd8
movl 0x4(%rsp), %edi
callq *(%rax)
movl %eax, %ebp
movq %rbx, %rdi
callq 0x11880
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x117f0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moongl/src/buffer.c
// Function: MapWrite
static int MapWrite(lua_State *L) /* nongl */
/* mapped_buffer_write(target|buffer, offset, bstring) */
    {
    size_t length, buflen;
    const char *data;
    GLenum target;
    GLuint buffer = checktargetorname(L, 1, &target, DOMAIN_BUFFER_TARGET);
    char *ptr = (char*)GetPointer(L, target, buffer);
    GLintptr offset = luaL_checkinteger(L, 2);
    if(lua_isstring(L, 3))
        data = luaL_checklstring(L, 3, &length);
    else if(lua_istable(L, 3))
        data = checkdataptr(L, 3, &length);
    else
        return luaL_argerror(L, 3, "invalid data");
    /* access and boundary checks */
    GLbitfield flags = GetAccessFlags(L, target, buffer);
    if(!(flags & GL_MAP_WRITE_BIT))
        return luaL_error(L, "no write access");
    buflen = GetMapLength(L, target, buffer);
    if(length > (buflen - offset))
        return luaL_error(L, "length is too large");
    memcpy(ptr + offset, data, length);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
movl $0x36, %ecx
callq 0x11430
movl %eax, %ebp
movl (%r14), %esi
movq %rbx, %rdi
movl %eax, %edx
callq 0x1311b
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11af0
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x110b0
testl %eax, %eax
je 0x12c9e
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11450
jmp 0x12cc2
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11860
cmpl $0x5, %eax
jne 0x12d2c
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11b20
movq %rax, %r12
movl 0x4(%rsp), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x911f, %ecx           # imm = 0x911F
callq 0x130df
testb $0x2, %al
jne 0x12ce5
leaq 0x2c61d(%rip), %rsi     # 0x3f300
jmp 0x12d0e
movl 0x4(%rsp), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x9120, %ecx           # imm = 0x9120
callq 0x130a5
cltq
movq 0x8(%rsp), %rdx
subq %r15, %rax
cmpq %rax, %rdx
jbe 0x12d1a
leaq 0x2c602(%rip), %rsi     # 0x3f310
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11ae0
jmp 0x12d40
addq %r15, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x11b10
xorl %eax, %eax
jmp 0x12d40
leaq 0x2c5c0(%rip), %rdx     # 0x3f2f3
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11940
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moongl/src/buffer.c
// Function: MapRead
static int MapRead(lua_State *L) /* nongl */
/* bstring = mapped_buffer_read(target|buffer, offset, length) */
    {
    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);
    /* 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");
    lua_pushlstring(L, ptr+offset, length);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r13
movl $0x1, %esi
movq %r13, %rdx
movl $0x36, %ecx
callq 0x11430
movl %eax, %ebp
movl (%r13), %esi
movq %rbx, %rdi
movl %eax, %edx
callq 0x1311b
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11af0
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x11af0
movq %rax, %r12
movl (%r13), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x911f, %ecx           # imm = 0x911F
callq 0x130df
testb $0x1, %al
jne 0x12dc5
leaq 0x2c580(%rip), %rsi     # 0x3f343
jmp 0x12de9
movl 0x4(%rsp), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x9120, %ecx           # imm = 0x9120
callq 0x130a5
cltq
subq %r15, %rax
cmpq %rax, %r12
jbe 0x12df5
leaq 0x2c527(%rip), %rsi     # 0x3f310
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11ae0
jmp 0x12e0b
addq %r15, %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x11ab0
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_O1/stetre[P]moongl/src/buffer.c
// Function: MapCopyFrom
static int MapCopyFrom(lua_State *L) /* nongl */
/* mapped_buffer_copy_from(target|buffer, offset, length, srcptr, [srcoffset]) */
    {
    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 *srcptr = (char*)checklightuserdata(L, 4);
    size_t srcoffset = luaL_optinteger(L, 5, 0);
    /* access and boundary checks */
    GLbitfield flags = GetAccessFlags(L, target, buffer);
    if(!(flags & GL_MAP_WRITE_BIT))
        return luaL_error(L, "no write access");
    buflen = GetMapLength(L, target, buffer);
    if(length > (buflen - offset))
        return luaL_error(L, "length is too large");
    memcpy(ptr + offset, srcptr + srcoffset, length);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
movl $0x36, %ecx
callq 0x11430
movl %eax, %ebp
movl (%r14), %esi
movq %rbx, %rdi
movl %eax, %edx
callq 0x1311b
movq %rax, 0x10(%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 0x11780
movq %rax, %r13
movq %rbx, %rdi
movl $0x5, %esi
xorl %edx, %edx
callq 0x11b30
movq %rax, 0x8(%rsp)
movl (%r14), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x911f, %ecx           # imm = 0x911F
callq 0x130df
testb $0x2, %al
jne 0x12eb9
leaq 0x2c449(%rip), %rsi     # 0x3f300
jmp 0x12edd
movl 0x4(%rsp), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x9120, %ecx           # imm = 0x9120
callq 0x130a5
cltq
subq %r15, %rax
cmpq %rax, %r12
jbe 0x12ee9
leaq 0x2c433(%rip), %rsi     # 0x3f310
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11ae0
jmp 0x12f03
movq 0x10(%rsp), %rdi
addq %r15, %rdi
addq 0x8(%rsp), %r13
movq %r13, %rsi
movq %r12, %rdx
callq 0x11b10
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_O1/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 $0x18, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
movl $0x36, %ecx
callq 0x11430
movl %eax, %ebp
movl (%r14), %esi
movq %rbx, %rdi
movl %eax, %edx
callq 0x1311b
movq %rax, 0x10(%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 0x11780
movq %rax, %r13
movq %rbx, %rdi
movl $0x5, %esi
xorl %edx, %edx
callq 0x11b30
movq %rax, 0x8(%rsp)
movl (%r14), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x911f, %ecx           # imm = 0x911F
callq 0x130df
testb $0x1, %al
jne 0x12fb1
leaq 0x2c394(%rip), %rsi     # 0x3f343
jmp 0x12fd5
movl 0x4(%rsp), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x9120, %ecx           # imm = 0x9120
callq 0x130a5
cltq
subq %r15, %rax
cmpq %rax, %r12
jbe 0x12fe1
leaq 0x2c33b(%rip), %rsi     # 0x3f310
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11ae0
jmp 0x12ffb
addq 0x8(%rsp), %r13
movq 0x10(%rsp), %rsi
addq %r15, %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x11b10
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_O1/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 0x43a83(%rip), %rax     # 0x56af0
cmoveq 0x43eb3(%rip), %rax     # 0x56f28
leaq 0x4(%rsp), %r14
movl %esi, %edi
movl %ecx, %esi
movq %r14, %rdx
callq *(%rax)
movq %rbx, %rdi
callq 0x11880
xorl %esi, %esi
cmpl $0x1, (%r14)
sete %sil
movq %rbx, %rdi
callq 0x117f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x43948(%rip), %rax     # 0x56a80
cmoveq 0x43628(%rip), %rax     # 0x56768
movl %esi, %edi
movl $0x88bd, %esi           # imm = 0x88BD
movq %r14, %rdx
callq *(%rax)
movq %rbx, %rdi
callq 0x112d0
movq (%r14), %r14
testq %r14, %r14
jne 0x13170
leaq 0x2c1c1(%rip), %rsi     # 0x3f324
xorl %r14d, %r14d
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_O1/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 0x11160
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x115c0
testl %eax, %eax
je 0x131d5
movq 0x436fe(%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 0x131dc
movl %ebp, %edi
callq 0x11060
movq %rbx, %rdi
callq 0x11880
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11160
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x115c0
testl %eax, %eax
je 0x13236
movq 0x43245(%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 0x1323d
movl %ebp, %edi
callq 0x111b0
movq %rbx, %rdi
callq 0x11880
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11160
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x115c0
testl %eax, %eax
je 0x13297
movq 0x43614(%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 0x1329e
movl %ebp, %edi
callq 0x11150
movl %eax, %ebp
movq %rbx, %rdi
callq 0x11880
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x117f0
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x11860
cmpl $0x6, %eax
jne 0x13321
movq %rbx, %rdi
movl $0x1, %esi
callq 0x11730
leaq 0x2c128(%rip), %rdx     # 0x3f41d
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x118a0
movq 0x43717(%rip), %rax     # 0x56a20
leaq 0x3c8(%rip), %rdi       # 0x136d8
movq %rbx, %rsi
callq *(%rax)
movq %rbx, %rdi
callq 0x11880
xorl %eax, %eax
popq %rbx
retq
leaq 0x2c0e3(%rip), %rdx     # 0x3f40b
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0x11940
// File: /workspace/github_c_makefile_star2_O1/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 0x11160
movl %eax, %ebp
movq %rbx, %rdi
movl $0x59, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, %r14d
movq %rbx, %rdi
movl $0x5a, %esi
movl $0x3, %edx
callq 0x11160
movl %eax, %r15d
movq %rbx, %rdi
movl $0x4, %esi
callq 0x11510
movl %eax, %r12d
movl $0x5, %r13d
movq %rbx, %rdi
movl $0x5, %esi
callq 0x11860
testl %eax, %eax
jle 0x133cc
movl $0x5, %esi
leal 0x1(%rsi), %r13d
movq %rbx, %rdi
callq 0x11af0
movq %rbx, %rdi
movl %r13d, %esi
callq 0x11860
movl %r13d, %esi
testl %eax, %eax
jg 0x133ae
cmpl $0x5, %r13d
jne 0x133ee
movq 0x43207(%rip), %rax     # 0x565e0
movzbl %r12b, %r9d
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *(%rax)
jmp 0x13465
movl %r15d, 0xc(%rsp)
movl %r14d, 0x10(%rsp)
movl %ebp, 0x14(%rsp)
leal -0x5(%r13), %ebp
movslq %r13d, %rax
leaq -0x14(,%rax,4), %rsi
movq %rbx, %rdi
callq 0x11200
movq %rax, %r14
cmpl $0x6, %r13d
jl 0x1343c
movl %ebp, %r13d
xorl %r15d, %r15d
leal 0x5(%r15), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11040
movl %eax, (%r14,%r15,4)
incq %r15
cmpq %r15, %r13
jne 0x13422
movq 0x4319d(%rip), %rax     # 0x565e0
movzbl %r12b, %r9d
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
movl %ebp, %ecx
movq %r14, %r8
callq *(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11370
movq %rbx, %rdi
callq 0x11880
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_O1/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 0x11160
movl %eax, %ebp
movq %rbx, %rdi
movl $0x59, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, %r14d
movq %rbx, %rdi
movl $0x5a, %esi
movl $0x3, %edx
callq 0x11160
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 0x11450
movq 0x43897(%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 0x11880
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_O1/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 0x11160
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 0x11450
movq 0x439dc(%rip), %r8      # 0x56f40
movl (%r15), %edx
movl %ebp, %edi
movl %r14d, %esi
movq %rax, %rcx
callq *(%r8)
movq %rbx, %rdi
callq 0x11880
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11160
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 0x11450
movq 0x42e33(%rip), %r8      # 0x56418
movl (%r15), %edx
movl %ebp, %edi
movl %r14d, %esi
movq %rax, %rcx
callq *(%r8)
movq %rbx, %rdi
callq 0x11880
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11160
movl %eax, %r14d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x11af0
movq %rax, %r15
movslq %ebp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x11200
movq %rax, %r13
movq 0x4312d(%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 0x11550
movslq (%rbp), %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x11ab0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x11370
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq