LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/sync.c
// Function: IsSync
static int IsSync(lua_State *L)
    {
    int id = luaL_checkinteger(L, 1);
    node_t *node = node_search(id);
    if(node == NULL) 
        { lua_pushboolean(L, 0); return 1; }
    if(glIsSync(node->sync) == GL_FALSE)
        return luaL_error(L, UNEXPECTED_ERROR);
    CheckError(L);
    lua_pushboolean(L, 1);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %edi
callq 0x443a0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x43f58
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x117f0
movl $0x1, 0x24(%rsp)
jmp 0x43fbb
movq 0x23fb9(%rip), %rax     # 0x67f18
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x28(%rcx), %rdi
callq *%rax
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x43f9a
movq 0x18(%rsp), %rdi
leaq 0xe304(%rip), %rsi      # 0x52285
leaq 0x19c30(%rip), %rdx     # 0x5dbb8
movl $0xb9, %ecx
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
jmp 0x43fbb
movq 0x18(%rsp), %rdi
callq 0x11880
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x117f0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/sync.c
// Function: ClientWaitSync
static int ClientWaitSync(lua_State *L)
/* client_wait_sync(sync, timeout [, flag...]) */
    {
    GLenum status;
    node_t *node = CheckSync(L, 1);
    GLuint64 timeout = luaL_checknumber(L, 2); /* nanoseconds */
    GLbitfield flags = CheckFlag(L, 3, 0);
    status = glClientWaitSync(node->sync, flags, timeout);
    CheckError(L);
    pushsyncstatus(L, status);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x44ad0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x11a80
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x19b2d(%rip), %xmm1    # 0x5db40
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
xorl %edx, %edx
leaq 0x24886(%rip), %rcx     # 0x688c0
callq 0x11b50
movl %eax, 0x4(%rsp)
movq 0x23856(%rip), %rax     # 0x678a0
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x28(%rcx), %rdi
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdx
callq *%rax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11880
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl $0x3e, %esi
callq 0x11120
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/sync.c
// Function: WaitSync
static int WaitSync(lua_State *L)
/* wait_sync(sync) */
    {
    GLbitfield flags = 0;
    GLuint64 timeout = GL_TIMEOUT_IGNORED;
    node_t *node = CheckSync(L, 1);
    glWaitSync(node->sync, flags, timeout);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq $-0x1, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x44ad0
movq %rax, 0x8(%rsp)
movq 0x23b33(%rip), %rax     # 0x67bf8
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x28(%rcx), %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/sync.c
// Function: GetSync
static int GetSync(lua_State *L)
    {
    node_t *node = CheckSync(L, 1);
    GLenum pname = checksyncpname(L, 2);
    switch(pname)
        {
        case GL_OBJECT_TYPE: return GetObjectType(L, node->sync, pname);
        case GL_SYNC_STATUS: return GetSyncStatus(L, node->sync, pname);
        case GL_SYNC_CONDITION: return GetSyncCondition(L, node->sync, pname);
        case GL_SYNC_FLAGS: return GetSyncFlags(L, node->sync, pname);
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
        }
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x44ad0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x3f, %esi
movl $0x2, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addl $0xffff6eee, %eax       # imm = 0xFFFF6EEE
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x3, %eax
ja 0x441c5
movq (%rsp), %rax
leaq 0x19a00(%rip), %rcx     # 0x5db48
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rsi
movl 0xc(%rsp), %edx
callq 0x45600
movl %eax, 0x24(%rsp)
jmp 0x441e8
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rsi
movl 0xc(%rsp), %edx
callq 0x456d0
movl %eax, 0x24(%rsp)
jmp 0x441e8
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rsi
movl 0xc(%rsp), %edx
callq 0x457c0
movl %eax, 0x24(%rsp)
jmp 0x441e8
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rsi
movl 0xc(%rsp), %edx
callq 0x45860
movl %eax, 0x24(%rsp)
jmp 0x441e8
movq 0x18(%rsp), %rdi
leaq 0xe0b4(%rip), %rsi      # 0x52285
leaq 0x199e0(%rip), %rdx     # 0x5dbb8
movl $0x131, %ecx            # imm = 0x131
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/sync.c
// Function: node_new
static node_t *node_new(GLsync sync)
    {
    node_t *node;
    int id =  IdNew(); /* allocate a free id */
    if(id == -1)
        return NULL;
    if((node = (node_t*)malloc(sizeof(node_t))) == NULL) return NULL;
    memset(node, 0, sizeof(node_t));
    node->id = id;
    node->sync = sync;
    node_insert(node);
    return node;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
callq 0x442d0
movl %eax, 0xc(%rsp)
cmpl $-0x1, 0xc(%rsp)
jne 0x44264
movq $0x0, 0x20(%rsp)
jmp 0x442c3
movl $0x30, %edi
callq 0x11270
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0x44284
movq $0x0, 0x20(%rsp)
jmp 0x442c3
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x110e0
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rdi
callq 0x44380
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/sync.c
// Function: IdNew
static int IdNew(void)
/* returns a free id or -1 if none are found (unlikely) */
    {
    static int idfree = 0;
    int guard = idfree-1;
    if((idfree==-1)||(idfree==0)||(idfree==1))
        { idfree=1; guard=-1; }
    while(1)
        {
        if(idfree==guard) /* we made a complete round */
            return -1;
        if(idfree==-1) idfree=1;
        if(node_search(idfree)==NULL) return idfree++;
        idfree++;
        }
    return -1;
    }

// Assembly:
pushq %rax
movl 0x246b1(%rip), %eax     # 0x68988
subl $0x1, %eax
movl %eax, (%rsp)
cmpl $-0x1, 0x246a4(%rip)    # 0x68988
je 0x442f8
cmpl $0x0, 0x2469b(%rip)     # 0x68988
je 0x442f8
cmpl $0x1, 0x24692(%rip)     # 0x68988
jne 0x44309
movl $0x1, 0x24686(%rip)     # 0x68988
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
jmp 0x4430b
movl 0x24677(%rip), %eax     # 0x68988
cmpl (%rsp), %eax
jne 0x44320
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x4436c
cmpl $-0x1, 0x24661(%rip)    # 0x68988
jne 0x44333
movl $0x1, 0x24655(%rip)     # 0x68988
movl 0x2464f(%rip), %edi     # 0x68988
callq 0x443a0
cmpq $0x0, %rax
jne 0x4435b
movl 0x2463e(%rip), %eax     # 0x68988
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x24633(%rip)     # 0x68988
movl %eax, 0x4(%rsp)
jmp 0x4436c
movl 0x24627(%rip), %eax     # 0x68988
addl $0x1, %eax
movl %eax, 0x2461e(%rip)     # 0x68988
jmp 0x4430b
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/sync.c
// Function: CheckSync
static node_t *CheckSync(lua_State *L, int arg)
    {
    int id = luaL_checkinteger(L, arg);
    node_t *node = node_search(id);
    if(node == NULL) 
        { luaL_argerror(L, arg, "not a sync"); return NULL; }
    return node;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x11af0
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %edi
callq 0x443a0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x44b25
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
leaq 0x19098(%rip), %rdx     # 0x5dbad
callq 0x11940
movq $0x0, 0x20(%rsp)
jmp 0x44b2f
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/sync.c
// Function: GetObjectType
static int GetObjectType(lua_State *L, GLsync sync, GLenum pname)
    {
    GLsizei length = 0;
    GLint value;
    glGetSynciv(sync, pname, 1, &length, &value);
    CheckError(L);
    if(length==0)
        return luaL_error(L, UNEXPECTED_ERROR);
    switch(value)
        {
        case GL_SYNC_FENCE: lua_pushstring(L, "fence"); break;
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
        }
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movq 0x21ea7(%rip), %rax     # 0x674c8
movq (%rax), %rax
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x1, %edx
leaq 0x8(%rsp), %rcx
leaq 0x4(%rsp), %r8
callq *%rax
movq 0x18(%rsp), %rdi
callq 0x11880
cmpl $0x0, 0x8(%rsp)
jne 0x45674
movq 0x18(%rsp), %rdi
leaq 0xcc2a(%rip), %rsi      # 0x52285
leaq 0x18556(%rip), %rdx     # 0x5dbb8
movl $0xe2, %ecx
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
jmp 0x456c1
movl 0x4(%rsp), %eax
subl $0x9116, %eax           # imm = 0x9116
jne 0x45694
jmp 0x45681
movq 0x18(%rsp), %rdi
leaq 0x18541(%rip), %rsi     # 0x5dbce
callq 0x110c0
jmp 0x456b9
movq 0x18(%rsp), %rdi
leaq 0xcbe5(%rip), %rsi      # 0x52285
leaq 0x18511(%rip), %rdx     # 0x5dbb8
movl $0xe7, %ecx
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
jmp 0x456c1
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/sync.c
// Function: GetSyncStatus
static int GetSyncStatus(lua_State *L, GLsync sync, GLenum pname)
    {
    GLsizei length = 0;
    GLint value;
    glGetSynciv(sync, pname, 1, &length, &value);
    CheckError(L);
    if(length==0)
        return luaL_error(L, UNEXPECTED_ERROR);
    switch(value)
        {
        case GL_SIGNALED: lua_pushstring(L, "signaled"); break;
        case GL_UNSIGNALED: lua_pushstring(L, "unsignaled"); break;
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
        }
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movq 0x21dd7(%rip), %rax     # 0x674c8
movq (%rax), %rax
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x1, %edx
leaq 0x8(%rsp), %rcx
leaq 0x4(%rsp), %r8
callq *%rax
movq 0x18(%rsp), %rdi
callq 0x11880
cmpl $0x0, 0x8(%rsp)
jne 0x45744
movq 0x18(%rsp), %rdi
leaq 0xcb5a(%rip), %rsi      # 0x52285
leaq 0x18486(%rip), %rdx     # 0x5dbb8
movl $0xf3, %ecx
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
jmp 0x457b3
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
subl $0x9118, %eax           # imm = 0x9118
je 0x45773
jmp 0x45754
movl (%rsp), %eax
subl $0x9119, %eax           # imm = 0x9119
jne 0x45786
jmp 0x45760
movq 0x18(%rsp), %rdi
leaq 0x10992(%rip), %rsi     # 0x560fe
callq 0x110c0
jmp 0x457ab
movq 0x18(%rsp), %rdi
leaq 0x18455(%rip), %rsi     # 0x5dbd4
callq 0x110c0
jmp 0x457ab
movq 0x18(%rsp), %rdi
leaq 0xcaf3(%rip), %rsi      # 0x52285
leaq 0x1841f(%rip), %rdx     # 0x5dbb8
movl $0xf9, %ecx
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
jmp 0x457b3
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/sync.c
// Function: GetSyncCondition
static int GetSyncCondition(lua_State *L, GLsync sync, GLenum pname)
    {
    GLsizei length = 0;
    GLint value;
    glGetSynciv(sync, pname, 1, &length, &value);
    CheckError(L);
    if(length==0)
        return luaL_error(L, UNEXPECTED_ERROR);
    pushcondition(L, value);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movq 0x21ce7(%rip), %rax     # 0x674c8
movq (%rax), %rax
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x1, %edx
leaq 0x8(%rsp), %rcx
leaq 0x4(%rsp), %r8
callq *%rax
movq 0x18(%rsp), %rdi
callq 0x11880
cmpl $0x0, 0x8(%rsp)
jne 0x45834
movq 0x18(%rsp), %rdi
leaq 0xca6a(%rip), %rsi      # 0x52285
leaq 0x18396(%rip), %rdx     # 0x5dbb8
movl $0x105, %ecx            # imm = 0x105
movb $0x0, %al
callq 0x11ae0
movl %eax, 0x24(%rsp)
jmp 0x4584f
movq 0x18(%rsp), %rdi
movl 0x4(%rsp), %edx
movl $0x3d, %esi
callq 0x11120
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/teximage.c
// Function: TextureImageMultisample
static int TextureImageMultisample(lua_State *L)
/* texture_image_multisample(target, samples, intfmt, fslocs, width, depth [, height]) */
    {
    GLsizei depth;
    int arg = 1;
    GLenum target = checktexturetarget(L, arg++);
    GLsizei samples = luaL_checkinteger(L, arg++);
    GLenum intfmt = checkinternalformat(L, arg++);
    GLboolean fslocs = checkboolean(L, arg++);
    GLsizei width = luaL_checkinteger(L, arg++);
    GLsizei height = luaL_checkinteger(L, arg++);
    if(lua_isnoneornil(L, arg))
        {
        glTexImage2DMultisample(target, samples, intfmt, width, height, fslocs);
        CheckError(L);
        return 0;
        }
    depth = luaL_checkinteger(L, arg++);
    glTexImage3DMultisample(target, samples, intfmt, width, height, depth, fslocs);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl $0x1, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
movl $0x13, %esi
callq 0x11160
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
callq 0x11af0
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
movl $0x11, %esi
callq 0x11160
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
callq 0x11510
movb %al, 0x13(%rsp)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
callq 0x11af0
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x11860
cmpl $0x0, %eax
jg 0x4675b
movq 0x20a51(%rip), %rax     # 0x67178
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %edx
movl 0xc(%rsp), %ecx
movl 0x8(%rsp), %r8d
movzbl 0x13(%rsp), %r9d
callq *%rax
movq 0x28(%rsp), %rdi
callq 0x11880
movl $0x0, 0x34(%rsp)
jmp 0x467b8
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
callq 0x11af0
movl %eax, 0x24(%rsp)
movq 0x20ddb(%rip), %rax     # 0x67558
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %edx
movl 0xc(%rsp), %ecx
movl 0x8(%rsp), %r8d
movl 0x24(%rsp), %r9d
movzbl 0x13(%rsp), %r10d
movl %r10d, (%rsp)
callq *%rax
movq 0x28(%rsp), %rdi
callq 0x11880
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/teximage.c
// Function: CopyTextureImage
static int CopyTextureImage(lua_State *L)
/* copy_texture_image(target, level, intfmt, x, y, width)
 * copy_texture_image(target, level, intfmt, x, y, width, height)
 */
    {
    GLsizei height;
    int arg = 1;
    GLenum target = checktexturetarget(L, arg++);
    GLint level = luaL_checkinteger(L, arg++);
    GLenum intfmt = checkinternalformat(L, arg++);
    GLint x = luaL_checkinteger(L, arg++);
    GLint y = luaL_checkinteger(L, arg++);
    GLsizei width = luaL_checkinteger(L, arg++);
    if(lua_isnoneornil(L, arg))
        {
        glCopyTexImage1D(target, level, intfmt, x, y, width, border);
        CheckError(L);
        return 0;
        }
    height = luaL_checkinteger(L, arg++);
    glCopyTexImage2D(target, level, intfmt, x, y, width, height, border);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl $0x1, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movl 0x30(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
movl $0x13, %esi
callq 0x11160
movl %eax, 0x2c(%rsp)
movq 0x38(%rsp), %rdi
movl 0x30(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
callq 0x11af0
movl %eax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movl 0x30(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
movl $0x11, %esi
callq 0x11160
movl %eax, 0x24(%rsp)
movq 0x38(%rsp), %rdi
movl 0x30(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
callq 0x11af0
movl %eax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl 0x30(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
callq 0x11af0
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
movl 0x30(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
callq 0x11af0
movl %eax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl 0x30(%rsp), %esi
callq 0x11860
cmpl $0x0, %eax
jg 0x46cec
movl 0x2c(%rsp), %edi
movl 0x28(%rsp), %esi
movl 0x24(%rsp), %edx
movl 0x20(%rsp), %ecx
movl 0x1c(%rsp), %r8d
movl 0x18(%rsp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x11680
movq 0x38(%rsp), %rdi
callq 0x11880
movl $0x0, 0x44(%rsp)
jmp 0x46d4a
movq 0x38(%rsp), %rdi
movl 0x30(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
callq 0x11af0
movl %eax, 0x34(%rsp)
movl 0x2c(%rsp), %edi
movl 0x28(%rsp), %esi
movl 0x24(%rsp), %edx
movl 0x20(%rsp), %ecx
movl 0x1c(%rsp), %r8d
movl 0x18(%rsp), %r9d
movl 0x34(%rsp), %eax
xorl %r10d, %r10d
movl %eax, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x110a0
movq 0x38(%rsp), %rdi
callq 0x11880
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/teximage.c
// Function: InvalidateTextureImage
static int InvalidateTextureImage(lua_State *L)
    {
    int arg = 1;
    GLuint texture = luaL_checkinteger(L, arg++);
    GLint level = luaL_checkinteger(L, arg++);
    glInvalidateTexImage(texture, level);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
callq 0x11af0
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x2015a(%rip), %rax     # 0x671d8
movq (%rax), %rax
movl 0x8(%rsp), %edi
movl 0x4(%rsp), %esi
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/teximage.c
// Function: InvalidateTextureSubImage
static int InvalidateTextureSubImage(lua_State *L)
    {
    int arg = 1;
    GLuint texture = luaL_checkinteger(L, arg++);
    GLint level = luaL_checkinteger(L, arg++);
    GLint xoffset = luaL_checkinteger(L, arg++);
    GLint yoffset = luaL_checkinteger(L, arg++);
    GLint zoffset = luaL_checkinteger(L, arg++);
    GLsizei width = luaL_checkinteger(L, arg++);
    GLsizei height = luaL_checkinteger(L, arg++);
    GLsizei depth = luaL_checkinteger(L, arg++);
    glInvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl $0x1, 0x3c(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
callq 0x11af0
movl %eax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
callq 0x11af0
movl %eax, 0x34(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
callq 0x11af0
movl %eax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
callq 0x11af0
movl %eax, 0x2c(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
callq 0x11af0
movl %eax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
callq 0x11af0
movl %eax, 0x24(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
callq 0x11af0
movl %eax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
callq 0x11af0
movl %eax, 0x1c(%rsp)
movq 0x204d8(%rip), %rax     # 0x67668
movq (%rax), %rax
movl 0x38(%rsp), %edi
movl 0x34(%rsp), %esi
movl 0x30(%rsp), %edx
movl 0x2c(%rsp), %ecx
movl 0x28(%rsp), %r8d
movl 0x24(%rsp), %r9d
movl 0x20(%rsp), %r11d
movl 0x1c(%rsp), %r10d
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
callq *%rax
movq 0x40(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/teximage.c
// Function: ClearTextureImage
static int ClearTextureImage(lua_State *L)
    {
    int arg = 1;
    const void* data;
    size_t len;
    GLuint texture = luaL_checkinteger(L, arg++);
    GLint level = luaL_checkinteger(L, arg++);
    GLenum format = checkformat(L, arg++);
    GLenum type = checktype(L, arg++);
    if(lua_isnoneornil(L, arg))
        { data = 0; arg++; }
    else if(lua_isstring(L, arg))
        data = (void*)luaL_checkstring(L, arg++);
    else if(lua_istable(L, arg))
        data = (void*)checkdataptr(L, arg++, &len);
    else
        return luaL_argerror(L, arg, "invalid type");
    glClearTexImage(texture, level, format, type, data);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl $0x1, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
callq 0x11af0
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
movl $0x12, %esi
callq 0x11160
movl %eax, 0x4(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
movl $0x7, %esi
callq 0x11160
movl %eax, (%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x11860
cmpl $0x0, %eax
jg 0x47292
movq $0x0, 0x18(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x4731c
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x110b0
cmpl $0x0, %eax
je 0x472c7
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x11450
movq %rax, 0x18(%rsp)
jmp 0x4731a
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x11860
cmpl $0x5, %eax
jne 0x472fd
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
leaq 0x10(%rsp), %rdx
callq 0x11b20
movq %rax, 0x18(%rsp)
jmp 0x47318
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
leaq 0xaeeb(%rip), %rdx      # 0x521f8
callq 0x11940
movl %eax, 0x34(%rsp)
jmp 0x4734e
jmp 0x4731a
jmp 0x4731c
movq 0x2009d(%rip), %rax     # 0x673c0
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movl 0x4(%rsp), %edx
movl (%rsp), %ecx
movq 0x18(%rsp), %r8
callq *%rax
movq 0x28(%rsp), %rdi
callq 0x11880
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/teximage.c
// Function: TexBuffer
static int TexBuffer(lua_State *L)
    {
    int arg = 1;
    GLenum target;
    GLuint texture = checktargetorname(L, arg++, &target, DOMAIN_TEXTURE_TARGET);
    GLenum intfmt = checkinternalformat(L, arg++);
    GLuint buffer = luaL_checkinteger(L, arg++);
    if(texture==0)
        glTexBuffer(target, intfmt, buffer);
    else
        glTextureBuffer(texture, intfmt, buffer);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x1, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
leaq 0x18(%rsp), %rdx
movl $0x13, %ecx
callq 0x11430
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movl $0x11, %esi
callq 0x11160
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
callq 0x11af0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x47652
movq 0x200f9(%rip), %rax     # 0x67738
movq (%rax), %rax
movl 0x18(%rsp), %edi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
callq *%rax
jmp 0x4766a
movq 0x1ff77(%rip), %rax     # 0x675d0
movq (%rax), %rax
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/teximage.c
// Function: TexBufferRange
static int TexBufferRange(lua_State *L)
    {
    int arg = 1;
    GLenum target;
    GLuint texture = checktargetorname(L, arg++, &target, DOMAIN_TEXTURE_TARGET);
    GLenum intfmt = checkinternalformat(L, arg++);
    GLuint buffer = luaL_checkinteger(L, arg++);
    GLintptr offset = luaL_checkinteger(L, arg++);
    GLsizei size = luaL_checkinteger(L, arg++);
    if(texture==0)
        glTexBufferRange(target, intfmt, buffer, offset, size);
    else
        glTextureBufferRange(texture, intfmt, buffer, offset, size);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl $0x1, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
leaq 0x28(%rsp), %rdx
movl $0x13, %ecx
callq 0x11430
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
movl $0x11, %esi
callq 0x11160
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
callq 0x11af0
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
callq 0x11af0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
callq 0x11af0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x47753
movq 0x1fe02(%rip), %rax     # 0x67538
movq (%rax), %rax
movl 0x28(%rsp), %edi
movl 0x20(%rsp), %esi
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %rcx
movslq 0xc(%rsp), %r8
callq *%rax
jmp 0x47775
movq 0x2077e(%rip), %rax     # 0x67ed8
movq (%rax), %rax
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %rcx
movslq 0xc(%rsp), %r8
callq *%rax
movq 0x30(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/teximage.c
// Function: GetCompressedTextureImage
static int GetCompressedTextureImage(lua_State *L)
    {
    int arg = 1;
    GLenum target;
    GLuint texture = checktargetorname(L, arg++, &target, DOMAIN_TEXTURE_TARGET);
    GLint level = luaL_checkinteger(L, arg++);
    GLsizei bufsz = luaL_checkinteger(L, arg++);
    char* data = (char*)Malloc(L, bufsz *sizeof(char));
    if(texture==0)
        glGetCompressedTexImage(target, level, (void*)data);
    else
        glGetCompressedTextureImage(texture, level, bufsz, (void*)data);
    CheckErrorFree(L, data);
    lua_pushlstring(L, data, bufsz);
    Free(L, data);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x1, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
leaq 0x18(%rsp), %rdx
movl $0x13, %ecx
callq 0x11430
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
callq 0x11af0
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
callq 0x11af0
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movslq 0xc(%rsp), %rsi
shlq $0x0, %rsi
callq 0x11200
movq %rax, (%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x47a24
movq 0x20557(%rip), %rax     # 0x67f68
movq (%rax), %rax
movl 0x18(%rsp), %edi
movl 0x10(%rsp), %esi
movq (%rsp), %rdx
callq *%rax
jmp 0x47a40
movq 0x20395(%rip), %rax     # 0x67dc0
movq (%rax), %rax
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
movq (%rsp), %rcx
callq *%rax
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0x11550
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
movslq 0xc(%rsp), %rdx
callq 0x11ab0
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0x11370
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/teximage.c
// Function: GetCompressedTextureSubImage
static int GetCompressedTextureSubImage(lua_State *L)
    {
    int arg = 1;
    GLuint texture = luaL_checkinteger(L, arg++);
    GLint level = luaL_checkinteger(L, arg++);
    GLint xoffset = luaL_checkinteger(L, arg++);
    GLint yoffset = luaL_checkinteger(L, arg++);
    GLint zoffset = luaL_checkinteger(L, arg++);
    GLsizei width = luaL_checkinteger(L, arg++);
    GLsizei height = luaL_checkinteger(L, arg++);
    GLsizei depth = luaL_checkinteger(L, arg++);
    GLsizei bufsz = luaL_checkinteger(L, arg++);
    char* data = (char*)Malloc(L, bufsz *sizeof(char));
    glGetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufsz, (void*)data);
    CheckErrorFree(L, data);
    lua_pushlstring(L, data, bufsz);
    Free(L, data);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl $0x1, 0x4c(%rsp)
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
callq 0x11af0
movl %eax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
callq 0x11af0
movl %eax, 0x44(%rsp)
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
callq 0x11af0
movl %eax, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
callq 0x11af0
movl %eax, 0x3c(%rsp)
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
callq 0x11af0
movl %eax, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
callq 0x11af0
movl %eax, 0x34(%rsp)
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
callq 0x11af0
movl %eax, 0x30(%rsp)
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
callq 0x11af0
movl %eax, 0x2c(%rsp)
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
callq 0x11af0
movl %eax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x28(%rsp), %rsi
shlq $0x0, %rsi
callq 0x11200
movq %rax, 0x20(%rsp)
movq 0x1fdcb(%rip), %rax     # 0x67b80
movq (%rax), %rax
movl 0x48(%rsp), %edi
movl 0x44(%rsp), %esi
movl 0x40(%rsp), %edx
movl 0x3c(%rsp), %ecx
movl 0x38(%rsp), %r8d
movl 0x34(%rsp), %r9d
movl 0x30(%rsp), %ebp
movl 0x2c(%rsp), %ebx
movl 0x28(%rsp), %r11d
movq 0x20(%rsp), %r10
movl %ebp, (%rsp)
movl %ebx, 0x8(%rsp)
movl %r11d, 0x10(%rsp)
movq %r10, 0x18(%rsp)
callq *%rax
movq 0x50(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11550
movq 0x50(%rsp), %rdi
movq 0x20(%rsp), %rsi
movslq 0x28(%rsp), %rdx
callq 0x11ab0
movq 0x50(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11370
movl $0x1, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/teximage.c
// Function: GenerateMipmap
static int GenerateMipmap(lua_State *L)
    {
    int arg = 1;
    GLenum target;
    GLuint texture = checktargetorname(L, arg++, &target, DOMAIN_TEXTURE_TARGET);
    if(texture==0)
        glGenerateMipmap(target);
    else
        glGenerateTextureMipmap(texture);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
leaq 0x8(%rsp), %rdx
movl $0x13, %ecx
callq 0x11430
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x47e8f
movq 0x1f344(%rip), %rax     # 0x671c8
movq (%rax), %rax
movl 0x8(%rsp), %edi
callq *%rax
jmp 0x47e9f
movq 0x20122(%rip), %rax     # 0x67fb8
movq (%rax), %rax
movl 0x4(%rsp), %edi
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/teximage.c
// Function: TextureView
static int TextureView(lua_State *L)
    {
    int arg = 1;
    GLuint texture = luaL_checkinteger(L, arg++);
    GLenum target = checktexturetarget(L, arg++);
    GLuint origtexture = luaL_checkinteger(L, arg++);
    GLenum intfmt = checkinternalformat(L, arg++);
    GLuint minlevel = luaL_checkinteger(L, arg++);
    GLuint numlevels = luaL_checkinteger(L, arg++);
    GLuint minlayer = luaL_checkinteger(L, arg++);
    GLuint numlayers = luaL_checkinteger(L, arg++);
    glTextureView(texture, target, origtexture, intfmt, minlevel, numlevels, minlayer, numlayers);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl $0x1, 0x3c(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
callq 0x11af0
movl %eax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
movl $0x13, %esi
callq 0x11160
movl %eax, 0x34(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
callq 0x11af0
movl %eax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
movl $0x11, %esi
callq 0x11160
movl %eax, 0x2c(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
callq 0x11af0
movl %eax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
callq 0x11af0
movl %eax, 0x24(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
callq 0x11af0
movl %eax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
callq 0x11af0
movl %eax, 0x1c(%rsp)
movq 0x1fb26(%rip), %rax     # 0x67ad0
movq (%rax), %rax
movl 0x38(%rsp), %edi
movl 0x34(%rsp), %esi
movl 0x30(%rsp), %edx
movl 0x2c(%rsp), %ecx
movl 0x28(%rsp), %r8d
movl 0x24(%rsp), %r9d
movl 0x20(%rsp), %r11d
movl 0x1c(%rsp), %r10d
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
callq *%rax
movq 0x40(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/teximage.c
// Function: BindImageTexture
static int BindImageTexture(lua_State *L)
    {
    int arg = 1;
    GLuint unit = luaL_checkinteger(L, arg++);
    GLuint texture = luaL_checkinteger(L, arg++);
    GLint level = luaL_checkinteger(L, arg++);
    GLboolean layered = checkboolean(L, arg++);
    GLint layer = luaL_checkinteger(L, arg++);
    GLenum access = checktextureaccess(L, arg++);
    GLenum format = checkinternalformat(L, arg++);
    glBindImageTexture(unit, texture, level, layered, layer, access, format);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl $0x1, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
callq 0x11af0
movl %eax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
callq 0x11af0
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
callq 0x11af0
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
callq 0x11510
movb %al, 0x1f(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
callq 0x11af0
movl %eax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
movl $0x5c, %esi
callq 0x11160
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
movl $0x11, %esi
callq 0x11160
movl %eax, 0x10(%rsp)
movq 0x1ff21(%rip), %rax     # 0x67ff0
movq (%rax), %rax
movl 0x28(%rsp), %edi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movb 0x1f(%rsp), %cl
movl 0x18(%rsp), %r8d
movl 0x14(%rsp), %r9d
movl 0x10(%rsp), %r10d
movzbl %cl, %ecx
movl %r10d, (%rsp)
callq *%rax
movq 0x30(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/teximage.c
// Function: BindImageTextures
static int BindImageTextures(lua_State *L)
    {
    GLsizei count, i, arg;
    GLuint *textures;
    GLuint first = luaL_checkinteger(L, 1);
    arg = 2;
    while(!lua_isnoneornil(L, arg))
        luaL_checkinteger(L, arg++);
    if(arg==2)
        luaL_checkinteger(L, arg); /* raise an error */
    count = arg - 2;
    textures = (GLuint*)Malloc(L, count*sizeof(GLuint));
    arg = 2;
    for(i=0; i < count; i++)
        textures[i]=lua_tointeger(L, arg++);
    glBindImageTextures(first, count, textures);
    Free(L, textures);  
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movl $0x2, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x11860
cmpl $0x0, %eax
setle %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x48150
jmp 0x48169
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
callq 0x11af0
jmp 0x48134
cmpl $0x2, 0x14(%rsp)
jne 0x4817e
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x11af0
movl 0x14(%rsp), %eax
subl $0x2, %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
shlq $0x2, %rsi
callq 0x11200
movq %rax, 0x8(%rsp)
movl $0x2, 0x14(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x481f2
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x11040
movl %eax, %edx
movq 0x8(%rsp), %rax
movslq 0x18(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x481b1
movq 0x1fdcf(%rip), %rax     # 0x67fc8
movq (%rax), %rax
movl 0x4(%rsp), %edi
movl 0x1c(%rsp), %esi
movq 0x8(%rsp), %rdx
callq *%rax
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11370
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/texture.c
// Function: ActiveTexture
static int ActiveTexture(lua_State *L)
    {
    GLuint n = luaL_checkinteger(L, 1);
    GLenum texture;
    switch(n)
        {
#define C(i) case i: texture = GL_TEXTURE##i; break
        C(0); C(1); C(2); C(3); C(4); C(5); C(6); C(7); C(8); C(9); 
        C(10); C(11); C(12); C(13); C(14); C(15); C(16); C(17); C(18); C(19); C(20); 
        C(21); C(22); C(23); C(24); C(25); C(26); C(27); C(28); C(29); C(30); C(31); 
#undef C
        default: return luaL_argerror(L, 1, "out of range");
        }
    glActiveTexture(texture);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x11af0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq %rax, 0x8(%rsp)
subq $0x1f, %rax
ja 0x48966
movq 0x8(%rsp), %rax
leaq 0x155a5(%rip), %rcx     # 0x5dd80
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x84c0, 0x10(%rsp)     # imm = 0x84C0
jmp 0x48982
movl $0x84c1, 0x10(%rsp)     # imm = 0x84C1
jmp 0x48982
movl $0x84c2, 0x10(%rsp)     # imm = 0x84C2
jmp 0x48982
movl $0x84c3, 0x10(%rsp)     # imm = 0x84C3
jmp 0x48982
movl $0x84c4, 0x10(%rsp)     # imm = 0x84C4
jmp 0x48982
movl $0x84c5, 0x10(%rsp)     # imm = 0x84C5
jmp 0x48982
movl $0x84c6, 0x10(%rsp)     # imm = 0x84C6
jmp 0x48982
movl $0x84c7, 0x10(%rsp)     # imm = 0x84C7
jmp 0x48982
movl $0x84c8, 0x10(%rsp)     # imm = 0x84C8
jmp 0x48982
movl $0x84c9, 0x10(%rsp)     # imm = 0x84C9
jmp 0x48982
movl $0x84ca, 0x10(%rsp)     # imm = 0x84CA
jmp 0x48982
movl $0x84cb, 0x10(%rsp)     # imm = 0x84CB
jmp 0x48982
movl $0x84cc, 0x10(%rsp)     # imm = 0x84CC
jmp 0x48982
movl $0x84cd, 0x10(%rsp)     # imm = 0x84CD
jmp 0x48982
movl $0x84ce, 0x10(%rsp)     # imm = 0x84CE
jmp 0x48982
movl $0x84cf, 0x10(%rsp)     # imm = 0x84CF
jmp 0x48982
movl $0x84d0, 0x10(%rsp)     # imm = 0x84D0
jmp 0x48982
movl $0x84d1, 0x10(%rsp)     # imm = 0x84D1
jmp 0x48982
movl $0x84d2, 0x10(%rsp)     # imm = 0x84D2
jmp 0x48982
movl $0x84d3, 0x10(%rsp)     # imm = 0x84D3
jmp 0x48982
movl $0x84d4, 0x10(%rsp)     # imm = 0x84D4
jmp 0x48982
movl $0x84d5, 0x10(%rsp)     # imm = 0x84D5
jmp 0x48982
movl $0x84d6, 0x10(%rsp)     # imm = 0x84D6
jmp 0x48982
movl $0x84d7, 0x10(%rsp)     # imm = 0x84D7
jmp 0x48982
movl $0x84d8, 0x10(%rsp)     # imm = 0x84D8
jmp 0x48982
movl $0x84d9, 0x10(%rsp)     # imm = 0x84D9
jmp 0x48982
movl $0x84da, 0x10(%rsp)     # imm = 0x84DA
jmp 0x48982
movl $0x84db, 0x10(%rsp)     # imm = 0x84DB
jmp 0x48982
movl $0x84dc, 0x10(%rsp)     # imm = 0x84DC
jmp 0x48982
movl $0x84dd, 0x10(%rsp)     # imm = 0x84DD
jmp 0x48982
movl $0x84de, 0x10(%rsp)     # imm = 0x84DE
jmp 0x48982
movl $0x84df, 0x10(%rsp)     # imm = 0x84DF
jmp 0x48982
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x1410e(%rip), %rdx     # 0x5ca85
callq 0x11940
movl %eax, 0x24(%rsp)
jmp 0x489a4
movq 0x1e9af(%rip), %rax     # 0x67338
movq (%rax), %rax
movl 0x10(%rsp), %edi
callq *%rax
movq 0x18(%rsp), %rdi
callq 0x11880
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/texture.c
// Function: SetEnum
static int SetEnum(lua_State *L, GLuint texture, GLenum target, GLenum pname, int arg, uint32_t domain) 
    {
    GLint param = enums_check(L, domain, arg);
    if(texture==0)
        glTexParameteri(target, pname, param);
    else 
        glTextureParameteri(texture, pname, param);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x11160
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x4935f
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
movl 0x8(%rsp), %edx
callq 0x11b00
jmp 0x49377
movq 0x1ddb2(%rip), %rax     # 0x67118
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x14(%rsp), %esi
movl 0x8(%rsp), %edx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/texture.c
// Function: SetInt
static int SetInt(lua_State *L, GLuint texture, GLenum target, GLenum pname, int arg)
    {
    GLint param = luaL_checkinteger(L, arg);
    if(texture==0)
        glTexParameteri(target, pname, param);
    else 
        glTextureParameteri(texture, pname, param);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x11af0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x493d6
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
movl 0xc(%rsp), %edx
callq 0x11b00
jmp 0x493ee
movq 0x1dd3b(%rip), %rax     # 0x67118
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x14(%rsp), %esi
movl 0xc(%rsp), %edx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/texture.c
// Function: SetColor
static int SetColor(lua_State *L, GLuint texture, GLenum target, GLenum pname, int arg)
    {
    GLfloat param[4];
    checkcolor(L, arg, param);
    if(texture==0)
        glTexParameterfv(target, pname, param);
    else 
        glTextureParameterfv(texture, pname, param);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rsp, %rdx
callq 0x11400
cmpl $0x0, 0x1c(%rsp)
jne 0x49444
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
movq %rsp, %rdx
callq 0x11740
jmp 0x4945b
movq 0x1e365(%rip), %rax     # 0x677b0
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x14(%rsp), %esi
movq %rsp, %rdx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/texture.c
// Function: SetFloat
static int SetFloat(lua_State *L, GLuint texture, GLenum target, GLenum pname, int arg)
    {
    GLfloat param = luaL_checkinteger(L, arg);
    if(texture==0)
        glTexParameterf(target, pname, param);
    else 
        glTextureParameterf(texture, pname, param);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x11af0
cvtsi2ss %rax, %xmm0
movss %xmm0, 0xc(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x494bf
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
movss 0xc(%rsp), %xmm0
callq 0x111d0
jmp 0x494d9
movq 0x1e7da(%rip), %rax     # 0x67ca0
movq (%rax), %rax
movl 0x1c(%rsp), %edi
movl 0x14(%rsp), %esi
movss 0xc(%rsp), %xmm0
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/texture.c
// Function: SetEnum4
static int SetEnum4(lua_State *L, GLuint texture, GLenum target, GLenum pname, int arg, uint32_t domain) 
    {
    GLint param[4];
    param[0] = enums_check(L, domain, arg++);
    param[1] = enums_check(L, domain, arg++);
    param[2] = enums_check(L, domain, arg++);
    param[3] = enums_check(L, domain, arg++);
    if(texture==0)
        glTexParameteriv(target, pname, param);
    else 
        glTextureParameteriv(texture, pname, param);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movl %r8d, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x20(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
callq 0x11160
movl %eax, (%rsp)
movq 0x30(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x20(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
callq 0x11160
movl %eax, 0x4(%rsp)
movq 0x30(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x20(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
callq 0x11160
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x20(%rsp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
callq 0x11160
movl %eax, 0xc(%rsp)
cmpl $0x0, 0x2c(%rsp)
jne 0x495a3
movl 0x28(%rsp), %edi
movl 0x24(%rsp), %esi
movq %rsp, %rdx
callq 0x117d0
jmp 0x495ba
movq 0x1e8ae(%rip), %rax     # 0x67e58
movq (%rax), %rax
movl 0x2c(%rsp), %edi
movl 0x24(%rsp), %esi
movq %rsp, %rdx
callq *%rax
movq 0x30(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)