LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/fence.c
// Function: RegisterDisplayEvent
static int RegisterDisplayEvent(lua_State *L)
    {
    int err;
    ud_t *device_ud;
    VkResult ec;
    VkFence fence;
    VkDisplayEventInfoEXT* info;
    VkDevice device = checkdevice(L, 1, &device_ud);
    VkDisplayKHR display = checkdisplay(L, 2, NULL);
    const VkAllocationCallbacks *allocator = optallocator(L, 4);
    CheckDevicePfn(L, device_ud, RegisterDisplayEventEXT);
#define CLEANUP zfreeVkDisplayEventInfoEXT(L, info, 1)
    info = zcheckVkDisplayEventInfoEXT(L, 3, &err);
    if(err) { CLEANUP; return argerror(L, 3); }
    ec = device_ud->ddt->RegisterDisplayEventEXT(device, display, info, allocator, &fence);
    CLEANUP;
    CheckError(L, ec);
#undef CLEANUP
    return Created(L, fence, device, allocator);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x55e77(%rip), %rcx     # 0x8c03b
leaq 0x8(%rsp), %r13
movl $0x1, %esi
movq %r13, %rdx
callq 0x1a4e0
movq %rax, %r14
leaq 0x5846e(%rip), %rcx     # 0x8e64e
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
callq 0x191b0
movq %rax, %r15
movq (%r13), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x2a8(%rax)
je 0x36263
leaq 0x14(%rsp), %rbp
movq %rbx, %rdi
movl $0x3, %esi
movq %rbp, %rdx
callq 0x19fb0
movq %rax, %r13
cmpl $0x0, (%rbp)
je 0x36276
movq %rbx, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x19160
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x362c6
leaq 0x609b5(%rip), %rsi     # 0x96c1f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
jmp 0x362c6
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rsp, %r8
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq *0x2a8(%rax)
movl %eax, %r12d
movl $0x1, %ebp
movq %rbx, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x19160
testl %r12d, %r12d
je 0x362d9
movq %rbx, %rdi
xorl %esi, %esi
movl %r12d, %edx
callq 0x18980
movq %rbx, %rdi
callq 0x199a0
movl %eax, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x3675e
jmp 0x362c8
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/fence.c
// Function: ResetFences
static int ResetFences(lua_State *L)
    {
    ud_t **ud;
    int err;
    uint32_t count;
    VkResult ec;
    VkDevice device;
    VkFence *fences = checkfencelist(L, 1, &count, &err, &ud);
    if(err) return argerrorc(L, 1, err);
    device = ud[0]->device;
    ec = UD(device)->ddt->ResetFences(device, count, fences);
    Free(L, fences);
    Free(L, ud);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x57c7b(%rip), %r9      # 0x8dfab
leaq 0x4(%rsp), %rdx
leaq 0x14(%rsp), %r15
leaq 0x8(%rsp), %r8
movl $0x1, %esi
movq %r15, %rcx
callq 0x19140
movl (%r15), %edi
testl %edi, %edi
je 0x3636a
callq 0x19930
movq %rbx, %rdi
movl $0x1, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x363cb
movq %rax, %r14
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rax), %r15
movq %r15, %rdi
callq 0x19e90
movq 0x50(%rax), %rax
movl 0x4(%rsp), %esi
movq %r15, %rdi
movq %r14, %rdx
callq *0xa0(%rax)
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x182d0
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x182d0
testl %ebp, %ebp
je 0x363c9
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x18980
movq %rbx, %rdi
callq 0x199a0
jmp 0x363cb
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/fence.c
// Function: GetFenceStatus
static int GetFenceStatus(lua_State *L)
    {
    ud_t *ud;
    VkFence fence = checkfence(L, 1, &ud);
    VkDevice device = ud->device;
    VkResult ec = ud->ddt->GetFenceStatus(device, fence);
    switch(ec)
        {
        case VK_SUCCESS: lua_pushboolean(L, 1); return 1;
        case VK_NOT_READY: lua_pushboolean(L, 0); return 1;
        default:
            CheckError(L, ec);
        }
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x57bc3(%rip), %rcx     # 0x8dfab
movl $0x1, %ebp
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq (%r14), %rcx
movq 0x20(%rcx), %rdi
movq 0x50(%rcx), %rcx
movq %rax, %rsi
callq *0xa8(%rcx)
cmpl $0x1, %eax
je 0x3642b
testl %eax, %eax
jne 0x36437
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
jmp 0x36430
movq %rbx, %rdi
xorl %esi, %esi
callq 0x193a0
jmp 0x3644d
movq %rbx, %rdi
xorl %esi, %esi
movl %eax, %edx
callq 0x18980
movq %rbx, %rdi
callq 0x199a0
movl %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/fence.c
// Function: WaitForFences
static int WaitForFences(lua_State *L)
    {
    ud_t **ud;
    int err;
    uint32_t count;
    VkResult ec;
    VkBool32 waitall = checkboolean(L, 2);
    uint64_t timeout = checktimeout(L, 3);
    VkFence *fences = checkfencelist(L, 1, &count, &err, &ud);
    if(err) return argerrorc(L, 1, err);
    ec = ud[0]->ddt->WaitForFences(ud[0]->device, count, fences, waitall, timeout);
    Free(L, fences);
    Free(L, ud);
    switch(ec)
        {
        case VK_SUCCESS: lua_pushboolean(L, 1); return 1;
        case VK_TIMEOUT: lua_pushboolean(L, 0); return 1;
        default:
            CheckError(L, ec);
        }
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x2, %esi
callq 0x18790
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x19b60
movq %rax, %r14
leaq 0x57b21(%rip), %r9      # 0x8dfab
leaq 0xc(%rsp), %rdx
leaq 0x1c(%rsp), %r12
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movl $0x1, %esi
movq %r12, %rcx
callq 0x19140
movl (%r12), %edi
testl %edi, %edi
je 0x364d7
callq 0x19930
movq %rbx, %rdi
movl $0x1, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdi
movq 0x50(%rax), %rax
movl 0xc(%rsp), %esi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
callq *0xb0(%rax)
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x182d0
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x182d0
cmpl $0x2, %ebp
je 0x36533
testl %ebp, %ebp
jne 0x36544
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x193a0
jmp 0x364c8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x193a0
movl $0x1, %ebp
jmp 0x364c8
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x18980
movq %rbx, %rdi
callq 0x199a0
jmp 0x364c6
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/fence.c
// Function: ImportFenceFd
static int ImportFenceFd(lua_State *L)
    {
    int err;
    VkResult ec;
    ud_t *ud;
    VkImportFenceFdInfoKHR* info;
    VkFence fence = checkfence(L, 1, &ud);
    CheckDevicePfn(L, ud, ImportFenceFdKHR);
#define CLEANUP zfreeVkImportFenceFdInfoKHR(L, info, 1)
    info = zcheckVkImportFenceFdInfoKHR(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    info->fence = fence;
    ec = ud->ddt->ImportFenceFdKHR(ud->device, info);
    CLEANUP;
    CheckError(L, ec);
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x57a38(%rip), %rcx     # 0x8dfab
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq %rax, %r15
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x498(%rax)
je 0x365e7
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x19c80
movq %rax, %r14
cmpl $0x0, (%r12)
je 0x365fa
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x19160
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x36641
leaq 0x6065e(%rip), %rsi     # 0x96c4c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
jmp 0x36641
movq %r15, 0x10(%r14)
movq (%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x50(%rax), %rax
movq %r14, %rsi
callq *0x498(%rax)
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x19160
testl %ebp, %ebp
je 0x3663f
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x18980
movq %rbx, %rdi
callq 0x199a0
jmp 0x36641
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/fence.c
// Function: GetFenceFd
static int GetFenceFd(lua_State *L)
    {
    int err, fd;
    VkResult ec;
    ud_t *ud;
    VkFenceGetFdInfoKHR* info;
    VkFence fence = checkfence(L, 1, &ud);
    CheckDevicePfn(L, ud, GetFenceFdKHR);
#define CLEANUP zfreeVkFenceGetFdInfoKHR(L, info, 1)
    info = zcheckVkFenceGetFdInfoKHR(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    info->fence = fence;
    ec = ud->ddt->GetFenceFdKHR(ud->device, info, &fd);
    CLEANUP;
    CheckError(L, ec);
#undef CLEANUP
    lua_pushinteger(L, fd);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x57947(%rip), %rcx     # 0x8dfab
leaq 0x10(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq %rax, %r15
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x4a0(%rax)
je 0x366da
leaq 0x1c(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x18210
movq %rax, %r14
cmpl $0x0, (%r12)
je 0x366ed
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x19160
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x3673e
leaq 0x60591(%rip), %rsi     # 0x96c72
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
jmp 0x3673e
movq %r15, 0x10(%r14)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x50(%rax), %rax
leaq 0xc(%rsp), %rdx
movq %r14, %rsi
callq *0x4a0(%rax)
movl %eax, %r15d
movl $0x1, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x19160
testl %r15d, %r15d
je 0x3674f
movq %rbx, %rdi
xorl %esi, %esi
movl %r15d, %edx
callq 0x18980
movq %rbx, %rdi
callq 0x199a0
movl %eax, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movslq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x18b50
jmp 0x36740
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/fence.c
// Function: Created
static int Created(lua_State *L, VkFence fence, VkDevice device, const VkAllocationCallbacks *allocator)
    {
    ud_t *ud, *device_ud = UD(device);
    TRACE_CREATE(fence, "fence");
    ud = newuserdata_nondispatchable(L, fence, FENCE_MT);
    ud->parent_ud = device_ud;
    ud->device = device;
    ud->instance = device_ud->instance;
    ud->allocator = allocator;
    ud->destructor = freefence;
    ud->ddt = device_ud->ddt;
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
movq %rdx, %rdi
callq 0x19e90
movq %rax, %r15
movq 0x89843(%rip), %rax     # 0xbffc8
cmpl $0x0, (%rax)
je 0x3679b
leaq 0x60434(%rip), %rdi     # 0x96bc5
movq %r12, %rsi
xorl %eax, %eax
callq 0x18960
leaq 0x57809(%rip), %rdx     # 0x8dfab
movq %r13, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x18320
movq %r15, 0x10(%rax)
movq %r14, 0x20(%rax)
movq 0x18(%r15), %rcx
movq %rcx, 0x18(%rax)
movq %rbx, 0x40(%rax)
leaq 0x16(%rip), %rcx        # 0x367e0
movq %rcx, 0x8(%rax)
movq 0x50(%r15), %rcx
movq %rcx, 0x50(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/fence.c
// Function: freefence
static int freefence(lua_State *L, ud_t *ud)
    {
    VkFence fence = (VkFence)ud->handle;
    const VkAllocationCallbacks *allocator = ud->allocator;
    VkDevice device = ud->device;
    if(!freeuserdata(L, ud))
        return 0; /* double call */
    TRACE_DELETE(fence, "fence");
    UD(device)->ddt->DestroyFence(device, fence, allocator);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rsi), %rbx
movq 0x20(%rsi), %r15
movq 0x40(%rsi), %r14
callq 0x18d20
testl %eax, %eax
je 0x36831
movq 0x897c8(%rip), %rax     # 0xbffc8
cmpl $0x0, (%rax)
je 0x36816
leaq 0x603d0(%rip), %rdi     # 0x96bdc
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18960
movq %r15, %rdi
callq 0x19e90
movq 0x50(%rax), %rax
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x98(%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: StencilFaceFlags
static int StencilFaceFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushstencilfaceflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkstencilfaceflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x39891
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3985a
leaq 0x61393(%rip), %rsi     # 0x9abe0
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x39871
leaq 0x61389(%rip), %rsi     # 0x9abf0
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x3, %r14b
je 0x39954
leaq 0x61364(%rip), %rsi     # 0x9abe6
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x39954
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x39944
leaq 0x6132b(%rip), %r15     # 0x9abe0
leaq 0x61334(%rip), %r12     # 0x9abf0
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x39904
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x3990a
movq %r13, %rdi
leaq 0x612f3(%rip), %rsi     # 0x9abe6
callq 0x18ff0
movl $0x3, %r14d
testl %eax, %eax
je 0x3990e
jmp 0x39920
orl $0x1, %r14d
jmp 0x3990e
orl $0x2, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x398bc
jmp 0x39944
leaq 0x550bf(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: CommandBufferResetFlags
static int CommandBufferResetFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushcommandbufferresetflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkcommandbufferresetflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x399ad
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x39a33
leaq 0x61255(%rip), %rsi     # 0x9abf5
movq %rbx, %rdi
callq 0x1a2c0
jmp 0x39a2e
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
testl %eax, %eax
je 0x399ff
leaq 0x6122b(%rip), %r14     # 0x9abf5
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x18ff0
testl %eax, %eax
jne 0x39a03
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x399ca
movl $0x1, %esi
jmp 0x39a26
xorl %esi, %esi
jmp 0x39a26
leaq 0x54fdc(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: QueryControlFlags
static int QueryControlFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushquerycontrolflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkquerycontrolflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x39a86
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x39b0c
leaq 0x67b7f(%rip), %rsi     # 0xa15f8
movq %rbx, %rdi
callq 0x1a2c0
jmp 0x39b07
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
testl %eax, %eax
je 0x39ad8
leaq 0x67b55(%rip), %r14     # 0xa15f8
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x18ff0
testl %eax, %eax
jne 0x39adc
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x39aa3
movl $0x1, %esi
jmp 0x39aff
xorl %esi, %esi
jmp 0x39aff
leaq 0x54f03(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: CommandBufferUsageFlags
static int CommandBufferUsageFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushcommandbufferusageflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkcommandbufferusageflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x39b97
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x39b60
leaq 0x610b4(%rip), %rsi     # 0x9ac07
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x39b77
leaq 0x610aa(%rip), %rsi     # 0x9ac17
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x4, %r14b
je 0x39c5e
leaq 0x610a4(%rip), %rsi     # 0x9ac2c
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x39c5e
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x39c4e
leaq 0x6104c(%rip), %r15     # 0x9ac07
leaq 0x61055(%rip), %r12     # 0x9ac17
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x39c09
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x39c10
movq %r13, %rdi
leaq 0x61033(%rip), %rsi     # 0x9ac2c
callq 0x18ff0
movl $0x4, %ecx
testl %eax, %eax
je 0x39c15
jmp 0x39c2a
movl $0x1, %ecx
jmp 0x39c15
movl $0x2, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x39bc2
jmp 0x39c4e
leaq 0x54db5(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: CommandPoolResetFlags
static int CommandPoolResetFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushcommandpoolresetflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkcommandpoolresetflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x39cb7
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x39d3d
leaq 0x60f4b(%rip), %rsi     # 0x9abf5
movq %rbx, %rdi
callq 0x1a2c0
jmp 0x39d38
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
testl %eax, %eax
je 0x39d09
leaq 0x60f21(%rip), %r14     # 0x9abf5
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x18ff0
testl %eax, %eax
jne 0x39d0d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x39cd4
movl $0x1, %esi
jmp 0x39d30
xorl %esi, %esi
jmp 0x39d30
leaq 0x54cd2(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: CommandPoolCreateFlags
static int CommandPoolCreateFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushcommandpoolcreateflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkcommandpoolcreateflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x39dc8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x39d91
leaq 0x60eb9(%rip), %rsi     # 0x9ac3d
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x39da8
leaq 0x60ea9(%rip), %rsi     # 0x9ac47
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x4, %r14b
je 0x39e8f
leaq 0x6ce92(%rip), %rsi     # 0xa6c4b
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x39e8f
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x39e7f
leaq 0x60e51(%rip), %r15     # 0x9ac3d
leaq 0x60e54(%rip), %r12     # 0x9ac47
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x39e3a
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x39e41
movq %r13, %rdi
leaq 0x6ce21(%rip), %rsi     # 0xa6c4b
callq 0x18ff0
movl $0x4, %ecx
testl %eax, %eax
je 0x39e46
jmp 0x39e5b
movl $0x1, %ecx
jmp 0x39e46
movl $0x2, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x39df3
jmp 0x39e7f
leaq 0x54b84(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: DependencyFlags
static int DependencyFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushdependencyflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkdependencyflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x39f20
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x39ee9
leaq 0x60d80(%rip), %rsi     # 0x9ac5c
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x4, %r14b
je 0x39f00
leaq 0x60d70(%rip), %rsi     # 0x9ac66
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x2, %r14b
je 0x39fe7
leaq 0x60d62(%rip), %rsi     # 0x9ac73
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x39fe7
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x39fd7
leaq 0x60d18(%rip), %r15     # 0x9ac5c
leaq 0x60d1b(%rip), %r12     # 0x9ac66
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x39f92
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x39f99
movq %r13, %rdi
leaq 0x60cf1(%rip), %rsi     # 0x9ac73
callq 0x18ff0
movl $0x2, %ecx
testl %eax, %eax
je 0x39f9e
jmp 0x39fb3
movl $0x1, %ecx
jmp 0x39f9e
movl $0x4, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x39f4b
jmp 0x39fd7
leaq 0x54a2c(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: AttachmentDescriptionFlags
static int AttachmentDescriptionFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushattachmentdescriptionflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkattachmentdescriptionflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x3a77e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x3a804
leaq 0x60782(%rip), %rsi     # 0x9aef3
movq %rbx, %rdi
callq 0x1a2c0
jmp 0x3a7ff
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
testl %eax, %eax
je 0x3a7d0
leaq 0x60758(%rip), %r14     # 0x9aef3
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x18ff0
testl %eax, %eax
jne 0x3a7d4
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x3a79b
movl $0x1, %esi
jmp 0x3a7f7
xorl %esi, %esi
jmp 0x3a7f7
leaq 0x5420b(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: DescriptorPoolCreateFlags
static int DescriptorPoolCreateFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushdescriptorpoolcreateflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkdescriptorpoolcreateflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x3a85b
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x3a908
leaq 0x606af(%rip), %rsi     # 0x9aefd
movq %rbx, %rdi
callq 0x1a2c0
jmp 0x3a903
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x3a8f8
leaq 0x6067e(%rip), %r15     # 0x9aefd
leaq 0x6068b(%rip), %r12     # 0x9af11
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x3a8ba
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
movl $0x2, %ecx
testl %eax, %eax
je 0x3a8bf
jmp 0x3a8d4
movl $0x1, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x3a886
jmp 0x3a8f8
leaq 0x5410b(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: DescriptorSetLayoutCreateFlags
static int DescriptorSetLayoutCreateFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushdescriptorsetlayoutcreateflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkdescriptorsetlayoutcreateflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x3a963
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x3aa10
leaq 0x605cd(%rip), %rsi     # 0x9af23
movq %rbx, %rdi
callq 0x1a2c0
jmp 0x3aa0b
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x3aa00
leaq 0x6059c(%rip), %r15     # 0x9af23
leaq 0x605a5(%rip), %r12     # 0x9af33
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x3a9c2
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
movl $0x2, %ecx
testl %eax, %eax
je 0x3a9c7
jmp 0x3a9dc
movl $0x1, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x3a98e
jmp 0x3aa00
leaq 0x54003(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: ColorComponentFlags
static int ColorComponentFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushcolorcomponentflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkcolorcomponentflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x3aaaf
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3aa61
leaq 0x5801e(%rip), %rsi     # 0x92a72
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3aa78
leaq 0x52ec5(%rip), %rsi     # 0x8d933
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x4, %r14b
je 0x3aa8f
leaq 0x586d3(%rip), %rsi     # 0x93158
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x8, %r14b
je 0x3ab55
leaq 0x685ba(%rip), %rsi     # 0xa305a
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x3ab55
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x3ab45
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movzbl (%rax), %ecx
cmpl $0x66, %ecx
jg 0x3aaed
cmpl $0x61, %ecx
je 0x3aafe
cmpl $0x62, %ecx
jne 0x3ab21
movl $0x4, %ecx
jmp 0x3ab0a
cmpl $0x67, %ecx
je 0x3ab05
cmpl $0x72, %ecx
jne 0x3ab21
movl $0x1, %ecx
jmp 0x3ab0a
movl $0x8, %ecx
jmp 0x3ab0a
movl $0x2, %ecx
cmpb $0x0, 0x1(%rax)
jne 0x3ab21
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
jmp 0x3aac4
leaq 0x53ebe(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: CullModeFlags
static int CullModeFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushcullmodeflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkcullmodeflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x3abc5
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3aba5
leaq 0x60048(%rip), %rsi     # 0x9abe0
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3ac75
leaq 0x6003a(%rip), %rsi     # 0x9abf0
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x3ac75
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x3ac65
leaq 0x6ae45(%rip), %r15     # 0xa5a2e
leaq 0x5fff0(%rip), %r12     # 0x9abe0
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x3ac55
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x3ac4b
movq %r13, %rdi
leaq 0x5ffc9(%rip), %rsi     # 0x9abf0
callq 0x18ff0
testl %eax, %eax
je 0x3ac51
movq %r13, %rdi
leaq 0x5ffac(%rip), %rsi     # 0x9abe6
callq 0x18ff0
movl $0x3, %r14d
testl %eax, %eax
je 0x3ac55
jmp 0x3ac86
orl $0x1, %r14d
jmp 0x3ac55
orl $0x2, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x3abf0
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x53d59(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
jmp 0x3ac65
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: BufferCreateFlags
static int BufferCreateFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushbuffercreateflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkbuffercreateflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x3b990
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3b92b
leaq 0x5f957(%rip), %rsi     # 0x9b275
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3b942
leaq 0x5f94c(%rip), %rsi     # 0x9b284
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x4, %r14b
je 0x3b959
leaq 0x5f946(%rip), %rsi     # 0x9b295
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x8, %r14b
je 0x3b970
leaq 0x6b2e5(%rip), %rsi     # 0xa6c4b
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x10, %r14b
je 0x3ba69
leaq 0x5f923(%rip), %rsi     # 0x9b2a4
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x3ba69
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x3ba59
leaq 0x5f8c1(%rip), %r15     # 0x9b275
leaq 0x5f8c9(%rip), %r12     # 0x9b284
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x3ba28
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x3ba2f
movq %r13, %rdi
leaq 0x5f8a3(%rip), %rsi     # 0x9b295
callq 0x18ff0
testl %eax, %eax
je 0x3ba36
movq %r13, %rdi
leaq 0x6b246(%rip), %rsi     # 0xa6c4b
callq 0x18ff0
testl %eax, %eax
je 0x3ba3d
movq %r13, %rdi
leaq 0x5f88c(%rip), %rsi     # 0x9b2a4
callq 0x18ff0
movl $0x10, %ecx
testl %eax, %eax
je 0x3ba42
jmp 0x3ba7a
movl $0x1, %ecx
jmp 0x3ba42
movl $0x2, %ecx
jmp 0x3ba42
movl $0x4, %ecx
jmp 0x3ba42
movl $0x8, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x3b9bb
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x52f65(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
jmp 0x3ba59
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: QueryResultFlags
static int QueryResultFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushqueryresultflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkqueryresultflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x3bb37
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3bae9
leaq 0x5a2c9(%rip), %rsi     # 0x95da5
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3bb00
leaq 0x6869d(%rip), %rsi     # 0xa4193
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x4, %r14b
je 0x3bb17
leaq 0x5f7b5(%rip), %rsi     # 0x9b2c2
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x8, %r14b
je 0x3bc18
leaq 0x5f7ac(%rip), %rsi     # 0x9b2d4
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x3bc18
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x3bc08
leaq 0x68638(%rip), %r15     # 0xa4193
leaq 0x5f760(%rip), %r12     # 0x9b2c2
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
cmpb $0x36, (%rax)
jne 0x3bb84
cmpb $0x34, 0x1(%r13)
jne 0x3bb84
cmpb $0x0, 0x2(%r13)
je 0x3bbca
movq %r13, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x3bbbc
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x3bbc3
movq %r13, %rdi
leaq 0x5f728(%rip), %rsi     # 0x9b2d4
callq 0x18ff0
movl $0x8, %ecx
testl %eax, %eax
je 0x3bbcf
jmp 0x3bbe4
movl $0x2, %ecx
jmp 0x3bbcf
movl $0x4, %ecx
jmp 0x3bbcf
movl $0x1, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x3bb62
jmp 0x3bc08
leaq 0x52dfb(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: FenceCreateFlags
static int FenceCreateFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushfencecreateflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkfencecreateflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x3bf73
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x3bff9
leaq 0x5f4a8(%rip), %rsi     # 0x9b40e
movq %rbx, %rdi
callq 0x1a2c0
jmp 0x3bff4
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
testl %eax, %eax
je 0x3bfc5
leaq 0x5f47e(%rip), %r14     # 0x9b40e
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x18ff0
testl %eax, %eax
jne 0x3bfc9
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x3bf90
movl $0x1, %esi
jmp 0x3bfec
xorl %esi, %esi
jmp 0x3bfec
leaq 0x52a16(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: SparseMemoryBindFlags
static int SparseMemoryBindFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushsparsememorybindflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checksparsememorybindflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x3c04c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x3c0d2
leaq 0x6482a(%rip), %rsi     # 0xa0869
movq %rbx, %rdi
callq 0x1a2c0
jmp 0x3c0cd
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
testl %eax, %eax
je 0x3c09e
leaq 0x64800(%rip), %r14     # 0xa0869
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x18ff0
testl %eax, %eax
jne 0x3c0a2
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x3c069
movl $0x1, %esi
jmp 0x3c0c5
xorl %esi, %esi
jmp 0x3c0c5
leaq 0x5293d(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: SparseImageFormatFlags
static int SparseImageFormatFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushsparseimageformatflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checksparseimageformatflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x3c15d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3c126
leaq 0x5f2fe(%rip), %rsi     # 0x9b417
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3c13d
leaq 0x5f2f3(%rip), %rsi     # 0x9b426
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x4, %r14b
je 0x3c224
leaq 0x5f2e9(%rip), %rsi     # 0x9b437
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x3c224
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x3c214
leaq 0x5f296(%rip), %r15     # 0x9b417
leaq 0x5f29e(%rip), %r12     # 0x9b426
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x3c1cf
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x3c1d6
movq %r13, %rdi
leaq 0x5f278(%rip), %rsi     # 0x9b437
callq 0x18ff0
movl $0x4, %ecx
testl %eax, %eax
je 0x3c1db
jmp 0x3c1f0
movl $0x1, %ecx
jmp 0x3c1db
movl $0x2, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x3c188
jmp 0x3c214
leaq 0x527ef(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: MemoryHeapFlag
static int MemoryHeapFlag(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushmemoryheapflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkmemoryheapflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x3cd0e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3ccee
leaq 0x5e968(%rip), %rsi     # 0x9b649
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3cdbb
leaq 0x5e957(%rip), %rsi     # 0x9b656
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x3cdbb
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x3cdab
leaq 0x5e917(%rip), %r15     # 0x9b649
leaq 0x5e91d(%rip), %r12     # 0x9b656
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x3cd6d
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
movl $0x2, %ecx
testl %eax, %eax
je 0x3cd72
jmp 0x3cd87
movl $0x1, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x3cd39
jmp 0x3cdab
leaq 0x51c58(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: MemoryPropertyFlags
static int MemoryPropertyFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushmemorypropertyflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkmemorypropertyflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x3ce95
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3ce19
leaq 0x5e83d(%rip), %rsi     # 0x9b649
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3ce30
leaq 0x5e83f(%rip), %rsi     # 0x9b665
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x4, %r14b
je 0x3ce47
leaq 0x5e835(%rip), %rsi     # 0x9b672
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x8, %r14b
je 0x3ce5e
leaq 0x5e82c(%rip), %rsi     # 0x9b680
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x10, %r14b
je 0x3ce75
leaq 0x5e821(%rip), %rsi     # 0x9b68c
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x20, %r14b
je 0x3cf88
leaq 0x69dc5(%rip), %rsi     # 0xa6c4b
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x3cf88
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x3cf78
leaq 0x5e790(%rip), %r15     # 0x9b649
leaq 0x5e7a5(%rip), %r12     # 0x9b665
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x3cf40
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x3cf47
movq %r13, %rdi
leaq 0x5e77b(%rip), %rsi     # 0x9b672
callq 0x18ff0
testl %eax, %eax
je 0x3cf4e
movq %r13, %rdi
leaq 0x5e776(%rip), %rsi     # 0x9b680
callq 0x18ff0
testl %eax, %eax
je 0x3cf55
movq %r13, %rdi
leaq 0x5e76f(%rip), %rsi     # 0x9b68c
callq 0x18ff0
testl %eax, %eax
je 0x3cf5c
movq %r13, %rdi
leaq 0x69d1b(%rip), %rsi     # 0xa6c4b
callq 0x18ff0
movl $0x20, %ecx
testl %eax, %eax
je 0x3cf61
jmp 0x3cf99
movl $0x1, %ecx
jmp 0x3cf61
movl $0x2, %ecx
jmp 0x3cf61
movl $0x4, %ecx
jmp 0x3cf61
movl $0x8, %ecx
jmp 0x3cf61
movl $0x10, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x3cec0
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x51a46(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
jmp 0x3cf78