LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/flags.c
// Function: DebugUtilsMessageSeverityFlags
static int DebugUtilsMessageSeverityFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushdebugutilsmessageseverityflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkdebugutilsmessageseverityflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x1a110
cmpl $0x3, %eax
jne 0x3e26c
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x190d0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3e21c
leaq 0x4ec14(%rip), %rsi     # 0x8ce25
movq %rbx, %rdi
callq 0x1a2e0
movl %r15d, %ebp
testb $0x10, %r14b
je 0x3e233
leaq 0x5583d(%rip), %rsi     # 0x93a66
movq %rbx, %rdi
callq 0x1a2e0
incl %ebp
btl $0x8, %r14d
jae 0x3e24b
leaq 0x4eb2a(%rip), %rsi     # 0x8cd6b
movq %rbx, %rdi
callq 0x1a2e0
incl %ebp
btl $0xc, %r14d
jae 0x3e333
leaq 0x53815(%rip), %rsi     # 0x91a72
movq %rbx, %rdi
callq 0x1a2e0
incl %ebp
jmp 0x3e333
xorl %r14d, %r14d
leaq 0x4ebaf(%rip), %r12     # 0x8ce25
movl %ebp, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1a660
testl %eax, %eax
je 0x3e325
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x18fe0
movl %ebp, %ecx
testl %eax, %eax
je 0x3e2f5
movq %r13, %rdi
leaq 0x557af(%rip), %rsi     # 0x93a66
callq 0x18fe0
pushq $0x10
popq %rcx
testl %eax, %eax
je 0x3e2f5
movq %r13, %rdi
leaq 0x4ea9e(%rip), %rsi     # 0x8cd6b
callq 0x18fe0
testl %eax, %eax
je 0x3e2f0
movq %r13, %rdi
leaq 0x53792(%rip), %rsi     # 0x91a72
callq 0x18fe0
movl $0x1000, %ecx           # imm = 0x1000
testl %eax, %eax
je 0x3e2f5
jmp 0x3e300
movl $0x100, %ecx            # imm = 0x100
orl %ecx, %r14d
incl %r15d
jmp 0x3e279
leaq 0x416df(%rip), %rsi     # 0x7f9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18e90
movq %rbx, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
pushq $0x1
popq %rbp
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_O2/stetre[P]moonvulkan/src/flags.c
// Function: DebugUtilsMessageTypeFlags
static int DebugUtilsMessageTypeFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushdebugutilsmessagetypeflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkdebugutilsmessagetypeflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x1a110
cmpl $0x3, %eax
jne 0x3e3c4
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x190d0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3e38d
leaq 0x44bfb(%rip), %rsi     # 0x82f7d
movq %rbx, %rdi
callq 0x1a2e0
movl %r15d, %ebp
testb $0x2, %r14b
je 0x3e3a4
leaq 0x4845f(%rip), %rsi     # 0x867f9
movq %rbx, %rdi
callq 0x1a2e0
incl %ebp
testb $0x4, %r14b
je 0x3e468
leaq 0x4ea78(%rip), %rsi     # 0x8ce2d
movq %rbx, %rdi
callq 0x1a2e0
incl %ebp
jmp 0x3e468
xorl %r14d, %r14d
leaq 0x44baf(%rip), %r12     # 0x82f7d
movl %ebp, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1a660
testl %eax, %eax
je 0x3e45a
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x18fe0
movl %ebp, %ecx
testl %eax, %eax
je 0x3e42d
movq %r13, %rdi
leaq 0x483ee(%rip), %rsi     # 0x867f9
callq 0x18fe0
pushq $0x2
popq %rcx
testl %eax, %eax
je 0x3e42d
movq %r13, %rdi
leaq 0x4ea0c(%rip), %rsi     # 0x8ce2d
callq 0x18fe0
pushq $0x4
popq %rcx
testl %eax, %eax
jne 0x3e435
orl %ecx, %r14d
incl %r15d
jmp 0x3e3d1
leaq 0x415aa(%rip), %rsi     # 0x7f9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18e90
movq %rbx, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
pushq $0x1
popq %rbp
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_O2/stetre[P]moonvulkan/src/flags.c
// Function: DeviceGroupPresentModeFlags
static int DeviceGroupPresentModeFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushdevicegrouppresentmodeflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkdevicegrouppresentmodeflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x1a110
cmpl $0x3, %eax
jne 0x3e510
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x190d0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3e4c2
leaq 0x4e199(%rip), %rsi     # 0x8c650
movq %rbx, %rdi
callq 0x1a2e0
movl %r15d, %ebp
testb $0x2, %r14b
je 0x3e4d9
leaq 0x4e96a(%rip), %rsi     # 0x8ce39
movq %rbx, %rdi
callq 0x1a2e0
incl %ebp
testb $0x4, %r14b
je 0x3e4f0
leaq 0x4e95a(%rip), %rsi     # 0x8ce40
movq %rbx, %rdi
callq 0x1a2e0
incl %ebp
testb $0x8, %r14b
je 0x3e5ce
leaq 0x4e943(%rip), %rsi     # 0x8ce44
movq %rbx, %rdi
callq 0x1a2e0
incl %ebp
jmp 0x3e5ce
xorl %r14d, %r14d
leaq 0x4e136(%rip), %r12     # 0x8c650
movl %ebp, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1a660
testl %eax, %eax
je 0x3e5c0
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x18fe0
movl %ebp, %ecx
testl %eax, %eax
je 0x3e593
movq %r13, %rdi
leaq 0x4e8de(%rip), %rsi     # 0x8ce39
callq 0x18fe0
pushq $0x2
popq %rcx
testl %eax, %eax
je 0x3e593
movq %r13, %rdi
leaq 0x4e8cf(%rip), %rsi     # 0x8ce40
callq 0x18fe0
pushq $0x4
popq %rcx
testl %eax, %eax
je 0x3e593
movq %r13, %rdi
leaq 0x4e8bd(%rip), %rsi     # 0x8ce44
callq 0x18fe0
pushq $0x8
popq %rcx
testl %eax, %eax
jne 0x3e59b
orl %ecx, %r14d
incl %r15d
jmp 0x3e51d
leaq 0x41444(%rip), %rsi     # 0x7f9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18e90
movq %rbx, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
pushq $0x1
popq %rbp
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_O2/stetre[P]moonvulkan/src/flags.c
// Function: SwapchainCreateFlags
static int SwapchainCreateFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushswapchaincreateflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkswapchaincreateflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x1a110
cmpl $0x3, %eax
jne 0x3e65f
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x190d0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3e628
leaq 0x4e0ec(%rip), %rsi     # 0x8c709
movq %rbx, %rdi
callq 0x1a2e0
movl %r15d, %ebp
testb $0x2, %r14b
je 0x3e63f
leaq 0x595e6(%rip), %rsi     # 0x97c1b
movq %rbx, %rdi
callq 0x1a2e0
incl %ebp
testb $0x4, %r14b
je 0x3e703
leaq 0x4e04d(%rip), %rsi     # 0x8c69d
movq %rbx, %rdi
callq 0x1a2e0
incl %ebp
jmp 0x3e703
xorl %r14d, %r14d
leaq 0x4e0a0(%rip), %r12     # 0x8c709
movl %ebp, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1a660
testl %eax, %eax
je 0x3e6f5
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x18fe0
movl %ebp, %ecx
testl %eax, %eax
je 0x3e6c8
movq %r13, %rdi
leaq 0x59575(%rip), %rsi     # 0x97c1b
callq 0x18fe0
pushq $0x2
popq %rcx
testl %eax, %eax
je 0x3e6c8
movq %r13, %rdi
leaq 0x4dfe1(%rip), %rsi     # 0x8c69d
callq 0x18fe0
pushq $0x4
popq %rcx
testl %eax, %eax
jne 0x3e6d0
orl %ecx, %r14d
incl %r15d
jmp 0x3e66c
leaq 0x4130f(%rip), %rsi     # 0x7f9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18e90
movq %rbx, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
pushq $0x1
popq %rbp
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_O2/stetre[P]moonvulkan/src/flags.c
// Function: DescriptorBindingFlags
static int DescriptorBindingFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushdescriptorbindingflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkdescriptorbindingflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x1a110
cmpl $0x3, %eax
jne 0x3e7ab
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x190d0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3e75d
leaq 0x4d7bf(%rip), %rsi     # 0x8bf11
movq %rbx, %rdi
callq 0x1a2e0
movl %r15d, %ebp
testb $0x2, %r14b
je 0x3e774
leaq 0x4e6ed(%rip), %rsi     # 0x8ce57
movq %rbx, %rdi
callq 0x1a2e0
incl %ebp
testb $0x4, %r14b
je 0x3e78b
leaq 0x4e6f2(%rip), %rsi     # 0x8ce73
movq %rbx, %rdi
callq 0x1a2e0
incl %ebp
testb $0x8, %r14b
je 0x3e869
leaq 0x4e6e7(%rip), %rsi     # 0x8ce83
movq %rbx, %rdi
callq 0x1a2e0
incl %ebp
jmp 0x3e869
xorl %r14d, %r14d
leaq 0x4d75c(%rip), %r12     # 0x8bf11
movl %ebp, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1a660
testl %eax, %eax
je 0x3e85b
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x18fe0
movl %ebp, %ecx
testl %eax, %eax
je 0x3e82e
movq %r13, %rdi
leaq 0x4e661(%rip), %rsi     # 0x8ce57
callq 0x18fe0
pushq $0x2
popq %rcx
testl %eax, %eax
je 0x3e82e
movq %r13, %rdi
leaq 0x4e667(%rip), %rsi     # 0x8ce73
callq 0x18fe0
pushq $0x4
popq %rcx
testl %eax, %eax
je 0x3e82e
movq %r13, %rdi
leaq 0x4e661(%rip), %rsi     # 0x8ce83
callq 0x18fe0
pushq $0x8
popq %rcx
testl %eax, %eax
jne 0x3e836
orl %ecx, %r14d
incl %r15d
jmp 0x3e7b8
leaq 0x411a9(%rip), %rsi     # 0x7f9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18e90
movq %rbx, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
pushq $0x1
popq %rbp
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_O2/stetre[P]moonvulkan/src/flags.c
// Function: ConditionalRenderingFlags
static int ConditionalRenderingFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushconditionalrenderingflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkconditionalrenderingflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %r14
movl %r14d, %esi
callq 0x1a110
cmpl $0x3, %eax
jne 0x3e8c4
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x190d0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x3e936
leaq 0x45210(%rip), %rsi     # 0x83ac8
movq %rbx, %rdi
callq 0x1a2e0
movl %ebp, %eax
jmp 0x3e936
xorl %r12d, %r12d
leaq 0x451fa(%rip), %r15     # 0x83ac8
movl %r14d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a660
testl %eax, %eax
je 0x3e928
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x18fe0
testl %eax, %eax
jne 0x3e904
incl %ebp
movl %r14d, %r12d
jmp 0x3e8d1
leaq 0x410db(%rip), %rsi     # 0x7f9e6
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x18e90
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r12d
movl %r12d, %esi
movq %rbx, %rdi
callq 0x18b50
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/flags.c
// Function: AccelerationStructureCreateFlagsKHR
static int AccelerationStructureCreateFlagsKHR(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushaccelerationstructurecreateflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkaccelerationstructurecreateflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %r14
movl %r14d, %esi
callq 0x1a110
cmpl $0x3, %eax
jne 0x3e989
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x190d0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x3e9fb
leaq 0x4d927(%rip), %rsi     # 0x8c2a4
movq %rbx, %rdi
callq 0x1a2e0
movl %ebp, %eax
jmp 0x3e9fb
xorl %r12d, %r12d
leaq 0x4d911(%rip), %r15     # 0x8c2a4
movl %r14d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a660
testl %eax, %eax
je 0x3e9ed
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x18fe0
testl %eax, %eax
jne 0x3e9c9
incl %ebp
movl %r14d, %r12d
jmp 0x3e996
leaq 0x41016(%rip), %rsi     # 0x7f9e6
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x18e90
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r12d
movl %r12d, %esi
movq %rbx, %rdi
callq 0x18b50
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/flags.c
// Function: RenderingFlagsKHR
static int RenderingFlagsKHR(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushrenderingflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkrenderingflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x1a110
cmpl $0x3, %eax
jne 0x3ea84
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x190d0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3ea4d
leaq 0x4e45b(%rip), %rsi     # 0x8ce9d
movq %rbx, %rdi
callq 0x1a2e0
movl %r15d, %ebp
testb $0x2, %r14b
je 0x3ea64
leaq 0x4e466(%rip), %rsi     # 0x8cec0
movq %rbx, %rdi
callq 0x1a2e0
incl %ebp
testb $0x4, %r14b
je 0x3eb28
leaq 0x4e456(%rip), %rsi     # 0x8cecb
movq %rbx, %rdi
callq 0x1a2e0
incl %ebp
jmp 0x3eb28
xorl %r14d, %r14d
leaq 0x4e40f(%rip), %r12     # 0x8ce9d
movl %ebp, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1a660
testl %eax, %eax
je 0x3eb1a
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x18fe0
movl %ebp, %ecx
testl %eax, %eax
je 0x3eaed
movq %r13, %rdi
leaq 0x4e3f5(%rip), %rsi     # 0x8cec0
callq 0x18fe0
pushq $0x2
popq %rcx
testl %eax, %eax
je 0x3eaed
movq %r13, %rdi
leaq 0x4e3ea(%rip), %rsi     # 0x8cecb
callq 0x18fe0
pushq $0x4
popq %rcx
testl %eax, %eax
jne 0x3eaf5
orl %ecx, %r14d
incl %r15d
jmp 0x3ea91
leaq 0x40eea(%rip), %rsi     # 0x7f9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18e90
movq %rbx, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
pushq $0x1
popq %rbp
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_O2/stetre[P]moonvulkan/src/flags.c
// Function: ReservedFlags
static int ReservedFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushreservedflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkreservedflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x1a110
cmpl $0x3, %eax
jne 0x3eb5c
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x190d0
xorl %ebp, %ebp
jmp 0x3ebae
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a660
testl %eax, %eax
je 0x3eba4
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x18680
leaq 0x40e61(%rip), %rsi     # 0x7f9e6
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x18e90
movq %rbx, %rdi
movl %r14d, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %esi
jmp 0x3eba6
xorl %esi, %esi
movq %rbx, %rdi
callq 0x18b50
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/framebuffer.c
// Function: Create
static int Create(lua_State *L)
    {
    int err;
    ud_t *ud, *device_ud;
    VkResult ec;
    VkFramebuffer framebuffer;
    VkFramebufferCreateInfo* info;
    VkDevice device = checkdevice(L, 1, &device_ud);
    const VkAllocationCallbacks *allocator = optallocator(L, 3);
#define CLEANUP zfreeVkFramebufferCreateInfo(L, info, 1)
    info = zcheckVkFramebufferCreateInfo(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ec = device_ud->ddt->CreateFramebuffer(device, info, allocator, &framebuffer);
    CLEANUP;
#undef CLEANUP
    CheckError(L, ec);
    TRACE_CREATE(framebuffer, "framebuffer");
    ud = newuserdata_nondispatchable(L, framebuffer, FRAMEBUFFER_MT);
    ud->parent_ud = device_ud;
    ud->device = device;
    ud->instance = device_ud->instance;
    ud->allocator = allocator;
    ud->destructor = freeframebuffer;
    ud->ddt = device_ud->ddt;
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x3e2fc(%rip), %rcx     # 0x7d03b
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x1a500
movq %rax, %r14
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x191a0
movq %rax, %r15
pushq $0x2
popq %rsi
leaq 0x14(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rdx
callq 0x18230
movq %rax, %r12
cmpl $0x0, (%r13)
je 0x3eda5
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x19150
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
jmp 0x3eded
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rsp, %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x1f8(%rax)
movl %eax, %r13d
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x19150
testl %r13d, %r13d
je 0x3ee00
movq %rbx, %rdi
xorl %esi, %esi
movl %r13d, %edx
callq 0x18980
movq %rbx, %rdi
callq 0x199c0
movl %eax, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x7c191(%rip), %rax     # 0xbaf98
cmpl $0x0, (%rax)
je 0x3ee1e
movq (%rsp), %rsi
leaq 0x4e0e4(%rip), %rdi     # 0x8cefb
xorl %eax, %eax
callq 0x18960
movq (%rsp), %rsi
leaq 0x401c5(%rip), %rdx     # 0x7efee
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x18330
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %r14, 0x20(%rax)
movq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq %r15, 0x40(%rax)
leaq 0x3b(%rip), %rdx        # 0x3ee8e
movq %rdx, 0x8(%rax)
movq 0x50(%rcx), %rcx
movq %rcx, 0x50(%rax)
jmp 0x3edef
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/framebuffer.c
// Function: freeframebuffer
static int freeframebuffer(lua_State *L, ud_t *ud)
    {
    VkFramebuffer framebuffer = (VkFramebuffer)ud->handle;
    const VkAllocationCallbacks *allocator = ud->allocator;
    VkDevice device = ud->device;
    if(!freeuserdata(L, ud))
        return 0; /* double call */
    TRACE_DELETE(framebuffer, "framebuffer");
    UD(device)->ddt->DestroyFramebuffer(device, framebuffer, 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 0x3eedf
movq 0x7c0ea(%rip), %rax     # 0xbaf98
cmpl $0x0, (%rax)
je 0x3eec4
leaq 0x4e05e(%rip), %rdi     # 0x8cf18
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18960
movq %r15, %rdi
callq 0x19eb0
movq 0x50(%rax), %rax
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x200(%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/image.c
// Function: newimage
static int newimage(lua_State *L, VkImage image, ud_t *parent_ud, VkDevice device, const VkAllocationCallbacks *allocator, int borrowed)
    {
    ud_t *ud;
    TRACE_CREATE(image, "image");
    ud = newuserdata_nondispatchable(L, image, IMAGE_MT);
    ud->parent_ud = parent_ud;
    ud->device = device;
    ud->instance = UD(device)->instance;
    ud->allocator = allocator;
    ud->destructor = freeimage;
    ud->ddt = UD(device)->ddt;
    if(borrowed) MarkBorrowed(ud); 
    /* e.g. images got from a swapchain are borrowed, since they are owned by 
     * Vulkan and must not be destroyed by the application. */
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x78dd1(%rip), %rax     # 0xbaf98
cmpl $0x0, (%rax)
je 0x421dd
leaq 0x4e1cc(%rip), %rdi     # 0x9039f
movq %r13, %rsi
xorl %eax, %eax
callq 0x18960
leaq 0x3b7b6(%rip), %rdx     # 0x7d99a
movq %rbp, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
callq 0x18330
movq %rax, %r13
movq %r12, 0x10(%rax)
movq %r14, 0x20(%rax)
movq %r14, %rdi
callq 0x19eb0
movq 0x18(%rax), %rax
movq %rax, 0x18(%r13)
movq %r15, 0x40(%r13)
leaq 0x5c(%rip), %rax        # 0x42273
movq %rax, 0x8(%r13)
movq %r14, %rdi
callq 0x19eb0
movq 0x50(%rax), %rax
movq %rax, 0x50(%r13)
testl %ebx, %ebx
je 0x42234
orb $0x4, 0x28(%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/image.c
// Function: freeimage
static int freeimage(lua_State *L, ud_t *ud)
    {
    VkImage image = (VkImage)ud->handle;
    VkDevice device = ud->device;
    const VkAllocationCallbacks *allocator = ud->allocator;
    int borrowed = IsBorrowed(ud);

    /* delete all contained objects */
    freechildren(L, IMAGE_VIEW_MT, ud);

    if(!freeuserdata(L, ud))
        return 0; /* double call */
    TRACE_DELETE(image, "image");
    if(!borrowed)
        UD(device)->ddt->DestroyImage(device, image, allocator);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r13
movq (%rsi), %rbx
movq 0x20(%rsi), %r15
movq 0x40(%rsi), %r14
movl 0x28(%rsi), %ebp
leaq 0x3c3b8(%rip), %rsi     # 0x7e651
movq %r12, %rdx
callq 0x18ee0
movq %r13, %rdi
movq %r12, %rsi
callq 0x18d20
testl %eax, %eax
je 0x422ee
movq 0x78ce1(%rip), %rax     # 0xbaf98
cmpl $0x0, (%rax)
je 0x422cd
leaq 0x4e0f3(%rip), %rdi     # 0x903b6
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18960
testb $0x4, %bpl
jne 0x422ee
movq %r15, %rdi
callq 0x19eb0
movq 0x50(%rax), %rax
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x130(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/image.c
// Function: Create
static int Create(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkResult ec;
    VkImage image;
    VkImageCreateInfo* info;

    VkDevice device = checkdevice(L, 1, &ud);
    const VkAllocationCallbacks *allocator = optallocator(L, 3);
#define CLEANUP zfreeVkImageCreateInfo(L, info, 1)
    info = zcheckVkImageCreateInfo(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }

    ec = ud->ddt->CreateImage(device, info, allocator, &image);
    CLEANUP;
    CheckError(L, ec);
#undef CLEANUP
    return newimage(L, image, UD(device), device, allocator, 0);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x3abe5(%rip), %rcx     # 0x7d03b
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x1a500
movq %rax, %r14
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x191a0
movq %rax, %r15
pushq $0x2
popq %rsi
leaq 0x14(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rdx
callq 0x18890
movq %rax, %r12
cmpl $0x0, (%r13)
je 0x424bc
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x19150
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
jmp 0x42504
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rsp, %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x128(%rax)
movl %eax, %r13d
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x19150
testl %r13d, %r13d
je 0x42517
movq %rbx, %rdi
xorl %esi, %esi
movl %r13d, %edx
callq 0x18980
movq %rbx, %rdi
callq 0x199c0
movl %eax, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %r12
movq %r14, %rdi
callq 0x19eb0
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r14, %rcx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x421a3
jmp 0x42506
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/image.c
// Function: GetImageSubresourceLayout
static int GetImageSubresourceLayout(lua_State *L)
    {
    int err;
    VkImageSubresource* subresource;
    VkSubresourceLayout layout;
    ud_t *ud;
    VkImage image = checkimage(L, 1, &ud);
    VkDevice device = ud->device;
#define CLEANUP zfreeVkImageSubresource(L, subresource, 1)
    subresource = zcheckVkImageSubresource(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ud->ddt->GetImageSubresourceLayout(device, image, subresource, &layout);
    zpushVkSubresourceLayout(L, &layout);
    CLEANUP;
#undef CLEANUP
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x3b419(%rip), %rcx     # 0x7d99a
pushq $0x1
popq %rbp
movq %rsp, %r14
movl %ebp, %esi
movq %r14, %rdx
callq 0x1a500
movq %rax, %r15
movq (%r14), %rax
movq 0x20(%rax), %r12
pushq $0x2
popq %rsi
leaq 0xc(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rdx
callq 0x187f0
movq %rax, %r14
cmpl $0x0, (%r13)
je 0x425e7
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x19620
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
movl %eax, %ebp
jmp 0x42620
movq (%rsp), %rax
movq 0x50(%rax), %rax
leaq 0x10(%rsp), %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq *0x138(%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x18930
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x19620
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/image_view.c
// Function: Create
static int Create(lua_State *L)
    {
    int err;
    ud_t *ud, *image_ud;
    VkResult ec;
    VkImageView image_view;
    VkImageViewCreateInfo* info;
    const VkAllocationCallbacks *allocator = optallocator(L, 3);
    VkImage image = checkimage(L, 1, &image_ud);
    VkDevice device = image_ud->device;

#define CLEANUP zfreeVkImageViewCreateInfo(L, info, 1)
    info = zcheckVkImageViewCreateInfo(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    info->image = image;
    ec = UD(device)->ddt->CreateImageView(device, info, allocator, &image_view);
    CLEANUP;
#undef CLEANUP
    CheckError(L, ec);
    TRACE_CREATE(image_view, "image_view");
    ud = newuserdata_nondispatchable(L, image_view, IMAGE_VIEW_MT);
    ud->parent_ud = image_ud;
    ud->device = device;
    ud->instance = UD(device)->instance;
    ud->allocator = allocator;
    ud->destructor = freeimage_view;
    ud->ddt = UD(device)->ddt;
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x3
popq %rsi
callq 0x191a0
movq %rax, %r14
leaq 0x3b1d4(%rip), %rcx     # 0x7d99a
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1a500
movq %rax, %r13
movq (%r15), %rax
movq 0x20(%rax), %r15
pushq $0x2
popq %rsi
leaq 0x14(%rsp), %rbp
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x183d0
movq %rax, %r12
cmpl $0x0, (%rbp)
je 0x4282a
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x19150
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
jmp 0x4287a
movq %r13, 0x18(%r12)
movq %r15, %rdi
callq 0x19eb0
movq 0x50(%rax), %rax
movq %rsp, %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq *0x140(%rax)
movl %eax, %r13d
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x19150
testl %r13d, %r13d
je 0x4288d
movq %rbx, %rdi
xorl %esi, %esi
movl %r13d, %edx
callq 0x18980
movq %rbx, %rdi
callq 0x199c0
movl %eax, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x78704(%rip), %rax     # 0xbaf98
cmpl $0x0, (%rax)
je 0x428ab
movq (%rsp), %rsi
leaq 0x4db86(%rip), %rdi     # 0x9042a
xorl %eax, %eax
callq 0x18960
movq (%rsp), %rsi
leaq 0x3bd9b(%rip), %rdx     # 0x7e651
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x18330
movq %rax, %rbx
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rbx)
movq %r15, 0x20(%rbx)
movq %r15, %rdi
callq 0x19eb0
movq 0x18(%rax), %rax
movq %rax, 0x18(%rbx)
movq %r14, 0x40(%rbx)
leaq 0x46(%rip), %rax        # 0x42931
movq %rax, 0x8(%rbx)
movq %r15, %rdi
callq 0x19eb0
movq 0x50(%rax), %rax
movq %rax, 0x50(%rbx)
jmp 0x4287c
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/image_view.c
// Function: freeimage_view
static int freeimage_view(lua_State *L, ud_t *ud)
    {
    VkImageView image_view = (VkImageView)ud->handle;
    const VkAllocationCallbacks *allocator = ud->allocator;
    VkDevice device = ud->device;
    if(!freeuserdata(L, ud))
        return 0; /* double call */
    TRACE_DELETE(image_view, "image_view");
    UD(device)->ddt->DestroyImageView(device, image_view, 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 0x42982
movq 0x78647(%rip), %rax     # 0xbaf98
cmpl $0x0, (%rax)
je 0x42967
leaq 0x4dae9(%rip), %rdi     # 0x90446
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18960
movq %r15, %rdi
callq 0x19eb0
movq 0x50(%rax), %rax
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x148(%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/instance.c
// Function: Create
static int Create(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkResult ec;
    VkInstance instance;
    VkInstanceCreateInfo* info;
    const VkAllocationCallbacks *allocator = optallocator(L, 2);
#define CLEANUP zfreeVkInstanceCreateInfo(L, info, 1)
    info = zcheckVkInstanceCreateInfo(L, 1, &err);
    if(err) { CLEANUP; return argerror(L, 1); }
    ec = vk.CreateInstance(info, allocator, &instance);
    if(ec)
        { CLEANUP; CheckError(L, ec); return 0; }
    TRACE_CREATE(instance, "instance");
    ud = newuserdata_dispatchable(L, instance, INSTANCE_MT);
    ud->instance = instance;
/*  ud->parent_ud = NULL; */
    ud->destructor = freeinstance;  
    ud->allocator = allocator; /* see you later allocator */
    ud->idt = getproc_instance(L, instance, info);
    CLEANUP;
#undef CLEANUP
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x2
popq %rsi
callq 0x191a0
movq %rax, %r15
pushq $0x1
popq %rbp
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x187e0
movq %rax, %r14
cmpl $0x0, (%r12)
je 0x42b60
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x19150
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x42b9d
movq 0x78459(%rip), %rax     # 0xbafc0
movq %rsp, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq *0x10(%rax)
testl %eax, %eax
je 0x42bae
movl %eax, %r12d
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19150
movq %rbx, %rdi
xorl %esi, %esi
movl %r12d, %edx
callq 0x18980
movq %rbx, %rdi
callq 0x199c0
movl %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x783e3(%rip), %rax     # 0xbaf98
cmpl $0x0, (%rax)
je 0x42bcc
movq (%rsp), %rsi
leaq 0x4d8fa(%rip), %rdi     # 0x904bf
xorl %eax, %eax
callq 0x18960
movq (%rsp), %rsi
leaq 0x3bb3a(%rip), %rdx     # 0x7e711
movq %rbx, %rdi
movl %ebp, %ecx
callq 0x18330
movq %rax, %r12
movq (%rsp), %rsi
movq %rsi, 0x18(%rax)
leaq 0x33d(%rip), %rax       # 0x42f30
movq %rax, 0x8(%r12)
movq %r15, 0x40(%r12)
movq %rbx, %rdi
movq %r14, %rdx
callq 0x191e0
movq %rax, 0x48(%r12)
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x19150
jmp 0x42b9f
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/instance.c
// Function: EnumeratePhysicalDevices
static int EnumeratePhysicalDevices(lua_State *L)
    {
    uint32_t count, remaining, tot, i;
    VkResult ec;
    VkPhysicalDevice physical_device[N];
    ud_t *ud;
    VkInstance instance = checkinstance(L, 1, &ud);

    lua_newtable(L);
    ec = ud->idt->EnumeratePhysicalDevices(instance, &remaining, NULL);
    CheckError(L, ec);
    if(remaining == 0)
        return 1;

    tot = 0;
    do {
        if(remaining > N)
            { count = N; remaining -= N; }
        else
            { count = remaining; remaining = 0; }
        ec = ud->idt->EnumeratePhysicalDevices(instance, &count, physical_device);
        if(ec != VK_INCOMPLETE)
            CheckError(L, ec);

        for(i=0; i<count; i++)
            {
            pushphysical_device(L, physical_device[i], instance);
            lua_rawseti(L, -2, ++tot);
            }
    } while(remaining > 0);

    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
leaq 0x3baad(%rip), %rcx     # 0x7e711
pushq $0x1
popq %rbp
leaq 0x8(%rsp), %r15
movl %ebp, %esi
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x187d0
movq (%r15), %rax
movq 0x48(%rax), %rax
movq %rsp, %rsi
movq %r14, %rdi
xorl %edx, %edx
callq *0x8(%rax)
testl %eax, %eax
je 0x42cc5
movq %rbx, %rdi
xorl %esi, %esi
movl %eax, %edx
callq 0x18980
movq %rbx, %rdi
callq 0x199c0
movl %eax, %ebp
movl %ebp, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl (%rsp), %eax
testl %eax, %eax
je 0x42cb1
pushq $-0x2
popq %r13
xorl %ebp, %ebp
movl %eax, %ecx
subl $0x20, %ecx
pushq $0x20
popq %rdx
cmovael %edx, %eax
movl $0x0, %edx
cmovbl %edx, %ecx
movl %eax, 0x4(%rsp)
movl %ecx, (%rsp)
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq %r14, %rdi
leaq 0x4(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq *0x8(%rax)
cmpl $0x5, %eax
je 0x42d0e
testl %eax, %eax
jne 0x42c9b
movl %ebp, %r15d
xorl %r12d, %r12d
movl 0x4(%rsp), %eax
cmpq %rax, %r12
jae 0x42d43
movq 0x10(%rsp,%r12,8), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x19ec0
leal (%r15,%r12), %edx
incl %edx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x19120
incq %r12
jmp 0x42d14
movl (%rsp), %eax
addl %r12d, %ebp
testl %eax, %eax
jne 0x42cd2
pushq $0x1
popq %rbp
jmp 0x42cb1
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/instance.c
// Function: freeinstance
static int freeinstance(lua_State *L, ud_t *ud)
    {
    VkInstance instance = (VkInstance)(uintptr_t)ud->handle;
    const VkAllocationCallbacks *allocator = ud->allocator;
    PFN_vkDestroyInstance DestroyInstance = NULL;
    if(ud->idt) DestroyInstance = ud->idt->DestroyInstance;
    freechildren(L, DEBUG_UTILS_MESSENGER_MT, ud);
    freechildren(L, DEBUG_REPORT_CALLBACK_MT, ud);
    freechildren(L, DEVICE_MT, ud);
    freechildren(L, PHYSICAL_DEVICE_MT, ud);
    freechildren(L, SURFACE_MT, ud);
    if(ud->idt) Free(L, ud->idt);
    if(!freeuserdata(L, ud))
        return 0; /* double call */
    TRACE_DELETE(instance, "instance");
    if(DestroyInstance) DestroyInstance(instance, allocator);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x48(%rsi), %rax
testq %rax, %rax
je 0x42f4d
movq (%rax), %r13
jmp 0x42f50
xorl %r13d, %r13d
movq (%r15), %rbx
movq 0x40(%r15), %r14
leaq 0x3b8eb(%rip), %rsi     # 0x7e849
movq %r12, %rdi
movq %r15, %rdx
callq 0x18ee0
leaq 0x3b6f7(%rip), %rsi     # 0x7e667
movq %r12, %rdi
movq %r15, %rdx
callq 0x18ee0
leaq 0x3a0b9(%rip), %rsi     # 0x7d03b
movq %r12, %rdi
movq %r15, %rdx
callq 0x18ee0
leaq 0x3bf60(%rip), %rsi     # 0x7eef4
movq %r12, %rdi
movq %r15, %rdx
callq 0x18ee0
leaq 0x4d533(%rip), %rsi     # 0x904d9
movq %r12, %rdi
movq %r15, %rdx
callq 0x18ee0
movq 0x48(%r15), %rsi
testq %rsi, %rsi
je 0x42fc2
movq %r12, %rdi
callq 0x182e0
movq %r12, %rdi
movq %r15, %rsi
callq 0x18d20
testl %eax, %eax
je 0x42ffc
movq 0x77fc0(%rip), %rax     # 0xbaf98
cmpl $0x0, (%rax)
je 0x42fee
leaq 0x4d508(%rip), %rdi     # 0x904ec
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18960
testq %r13, %r13
je 0x42ffc
movq %rbx, %rdi
movq %r14, %rsi
callq *%r13
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/main.c
// Function: AtExit
static void AtExit(void)
    {
    if(moonvulkan_L)
        {
        enums_free_all(moonvulkan_L);
        moonvulkan_atexit_getproc();
        moonvulkan_L = NULL;
        }
    }

// Assembly:
pushq %rbx
movq 0x774b3(%rip), %rbx     # 0xbafa0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x43b03
callq 0x18350
callq 0x181b0
andq $0x0, (%rbx)
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/objects.c
// Function: moonvulkan_newuserdata
ud_t *newuserdata(lua_State *L, uint64_t handle, const char *mt, int dispatchable)
    {
    ud_t *ud;
    /* For dispatchable objects we use handle as search key.
     * For non-dispatchable objects we cannot use handle as search key, because it
     * is not guaranteed to be unique, so we use ud instead.
     */
    if(dispatchable)
        ud = (ud_t*)udata_new(L, sizeof(ud_t), (uint64_t)handle, mt);
    else 
        ud = (ud_t*)udata_new(L, sizeof(ud_t), 0, mt);
    memset(ud, 0, sizeof(ud_t));
    ud->handle = handle;
    MarkValid(ud);
    ud->ref1 = ud->ref2 = ud->ref3 = ud->ref4 = LUA_NOREF;
    if(dispatchable) MarkDispatchable(ud);
    return ud;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %rcx
movq %rsi, %r14
xorl %edx, %edx
testl %ebx, %ebx
cmovneq %rsi, %rdx
pushq $0x60
popq %rsi
callq 0x18c70
andq $0x0, 0x58(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x48(%rax)
movq %r14, (%rax)
movl $0xfffffffe, 0x38(%rax) # imm = 0xFFFFFFFE
movaps 0x4cab3(%rip), %xmm0    # 0x90600
movups %xmm0, 0x28(%rax)
testl %ebx, %ebx
je 0x43b5c
movl $0x3, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/objects.c
// Function: moonvulkan_freeuserdata
int freeuserdata(lua_State *L, ud_t *ud)
    {
    /* The 'Valid' mark prevents double calls when an object is explicitly destroyed, 
     * and subsequently deleted also by the GC (the ud sticks around until the GC
     * collects it, so we mark it as invalid when the object is explicitly destroyed
     * by the script, or implicitly destroyed because child of a destroyed object). */
    if(!IsValid(ud)) return 0;
    CancelValid(ud);
    Unreference(L, ud->ref1);
    Unreference(L, ud->ref2);
    Unreference(L, ud->ref3);
    Unreference(L, ud->ref4);
    if(ud->info) 
        Free(L, ud->info);
    if(IsDispatchable(ud))
        udata_free(L, ud->handle);
    else
        udata_free(L, (uint64_t)(uintptr_t)ud);
    return 1;
    }

// Assembly:
movl 0x28(%rsi), %ecx
xorl %eax, %eax
testb $0x1, %cl
je 0x43c21
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
andl $-0x2, %ecx
movl %ecx, 0x28(%rsi)
movl 0x2c(%rsi), %edx
cmpl $-0x2, %edx
je 0x43b9e
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x1a2c0
movl $0xfffffffe, 0x2c(%rbx) # imm = 0xFFFFFFFE
movl 0x30(%rbx), %edx
cmpl $-0x2, %edx
je 0x43bba
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x1a2c0
movl $0xfffffffe, 0x30(%rbx) # imm = 0xFFFFFFFE
movl 0x34(%rbx), %edx
cmpl $-0x2, %edx
je 0x43bd6
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x1a2c0
movl $0xfffffffe, 0x34(%rbx) # imm = 0xFFFFFFFE
movl 0x38(%rbx), %edx
cmpl $-0x2, %edx
je 0x43bf2
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x1a2c0
movl $0xfffffffe, 0x38(%rbx) # imm = 0xFFFFFFFE
movq 0x58(%rbx), %rsi
testq %rsi, %rsi
je 0x43c03
movq %r14, %rdi
callq 0x182e0
testb $0x2, 0x28(%rbx)
je 0x43c0c
movq (%rbx), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19050
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/objects.c
// Function: moonvulkan_testxxx
uint64_t testxxx(lua_State *L, int arg, ud_t **udp, const char *mt)
    {
    ud_t *ud = (ud_t*)udata_test(L, arg, mt);
    if(ud && IsValid(ud)) { if(udp) *udp=ud; return ud->handle; }
    if(udp) *udp = NULL;
    return 0;
    }

// Assembly:
pushq %rbx
movq %rdx, %rbx
movq %rcx, %rdx
callq 0x1a1c0
testq %rax, %rax
je 0x43cfc
testb $0x1, 0x28(%rax)
jne 0x43d09
testq %rbx, %rbx
je 0x43d05
andq $0x0, (%rbx)
xorl %eax, %eax
jmp 0x43d14
testq %rbx, %rbx
je 0x43d11
movq %rax, (%rbx)
movq (%rax), %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/objects.c
// Function: moonvulkan_checkxxx
uint64_t checkxxx(lua_State *L, int arg, ud_t **udp, const char *mt)
    {
    ud_t *ud = (ud_t*)udata_test(L, arg, mt);
    if(ud && IsValid(ud)) 
        { if(udp) *udp = ud; return ud->handle; }
    lua_pushfstring(L, "not a %s", mt);
    return argerror(L, arg);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
movq %rcx, %rdx
callq 0x1a1c0
testq %rax, %rax
je 0x43d3c
testb $0x1, 0x28(%rax)
jne 0x43d6e
leaq 0x4c8d7(%rip), %rsi     # 0x9061a
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18e90
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x18680
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
callq 0x18420
cltq
jmp 0x43d7a
testq %r12, %r12
je 0x43d77
movq %rax, (%r12)
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/objects.c
// Function: moonvulkan_checkxxxlist_dispatchable
void** checkxxxlist_dispatchable(lua_State *L, int arg, uint32_t *count, int *err, const char *mt)
    {
    void** list;
    uint32_t i;

    *count = 0;
    *err = 0;
    if(lua_isnoneornil(L, arg))
        { *err = ERR_NOTPRESENT; return NULL; }
    if(lua_type(L, arg) != LUA_TTABLE)
        { *err = ERR_TABLE; return NULL; }
    *count = luaL_len(L, arg);
    if(*count == 0)
        { *err = ERR_EMPTY; return NULL; }
    list = (void**)MallocNoErr(L, sizeof(void*) * (*count));

    if(!list)
        { *count = 0; *err = ERR_MEMORY; return NULL; }

    for(i=0; i<*count; i++)
        {
        lua_rawgeti(L, arg, i+1);
        list[i] = (void*)(uintptr_t)testxxx(L, -1, NULL, mt);
        if(!list[i])
            { Free(L, list); *count = 0; *err = ERR_TYPE; return NULL; }
        lua_pop(L, 1);
        }
    return list;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, %r14
movl %esi, %ebp
movq %rdx, (%rsp)
andl $0x0, (%rdx)
movq %rdi, %r12
andl $0x0, (%rcx)
callq 0x1a110
testl %eax, %eax
jle 0x43e4d
movq %r12, %rdi
movl %ebp, %esi
callq 0x1a110
cmpl $0x5, %eax
jne 0x43e51
movq %r12, %rdi
movl %ebp, %esi
callq 0x1a140
movq (%rsp), %rcx
movl %eax, (%rcx)
testl %eax, %eax
je 0x43e55
movl %eax, %esi
shlq $0x3, %rsi
movq %r12, %rdi
callq 0x18050
testq %rax, %rax
je 0x43e70
movq %rax, %rbx
movq %r14, 0x8(%rsp)
xorl %r14d, %r14d
pushq $-0x2
popq %r13
movq (%rsp), %rax
movl (%rax), %eax
cmpq %rax, %r14
jae 0x43e5e
leaq 0x1(%r14), %r15
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x18970
movq %r12, %rdi
pushq $-0x1
popq %rsi
xorl %edx, %edx
movq 0x10(%rsp), %rcx
callq 0x1a4b0
movq %rax, (%rbx,%r14,8)
testq %rax, %rax
je 0x43e76
movq %r12, %rdi
movl %r13d, %esi
callq 0x18150
movq %r15, %r14
jmp 0x43e06
pushq $0x1
jmp 0x43e57
pushq $-0x4
jmp 0x43e57
pushq $-0x5
popq %r13
movl %r13d, (%r14)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x6
popq %r13
jmp 0x43e86
movq %r12, %rdi
movq %rbx, %rsi
callq 0x182e0
movq 0x8(%rsp), %r14
movq (%rsp), %rax
andl $0x0, (%rax)
jmp 0x43e59
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/physical_device.c
// Function: moonvulkan_pushphysical_device
int pushphysical_device(lua_State *L, VkPhysicalDevice physical_device, VkInstance instance)
    { 
    ud_t *ud = UD(physical_device);
    if(!ud)
        {
        /* create the userdata associated with this object */
        ud = newuserdata_dispatchable(L, physical_device, PHYSICAL_DEVICE_MT);
        ud->instance = instance;
        ud->parent_ud = UD(instance);
        ud->destructor = freephysical_device;
        ud->idt = UD(instance)->idt;
        TRACE_CREATE(physical_device, "physical_device");
        return 1;
        }
    return pushuserdata(L, ud);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x19eb0
testq %rax, %rax
je 0x44087
movq %r15, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x195c0
leaq 0x3ae66(%rip), %rdx     # 0x7eef4
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x18330
movq %rax, %r15
movq %r14, 0x18(%rax)
movq %r14, %rdi
callq 0x19eb0
movq %rax, 0x10(%r15)
leaq 0x3a(%rip), %rax        # 0x440f0
movq %rax, 0x8(%r15)
movq %r14, %rdi
callq 0x19eb0
movq 0x48(%rax), %rax
movq %rax, 0x48(%r15)
movq 0x76ec7(%rip), %rax     # 0xbaf98
cmpl $0x0, (%rax)
je 0x440e7
leaq 0x4c546(%rip), %rdi     # 0x90623
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18960
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/physical_device.c
// Function: freephysical_device
static int freephysical_device(lua_State *L, ud_t *ud)
    {
    VkPhysicalDevice physical_device = (VkPhysicalDevice)(uintptr_t)ud->handle;
    freechildren(L, DISPLAY_MT, ud);
    if(!freeuserdata(L, ud))
        return 0; /* double call */
    TRACE_DELETE(physical_device, "physical_device");
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rbx
leaq 0x3b549(%rip), %rsi     # 0x7f64e
movq %r14, %rdx
callq 0x18ee0
movq %r15, %rdi
movq %r14, %rsi
callq 0x18d20
testl %eax, %eax
je 0x44139
movq 0x76e75(%rip), %rax     # 0xbaf98
cmpl $0x0, (%rax)
je 0x44139
leaq 0x4c515(%rip), %rdi     # 0x90644
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18960
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/physical_device.c
// Function: GetPhysicalDeviceProperties
static int GetPhysicalDeviceProperties(lua_State *L)
    {
    ud_t *ud;
    VkPhysicalDeviceProperties props;
    VkPhysicalDevice physical_device = checkphysical_device(L, 1, &ud);
    if(ud->idt->GetPhysicalDeviceProperties2)
        return GetPhysicalDeviceProperties2(L, physical_device, ud);
    ud->idt->GetPhysicalDeviceProperties(physical_device, &props);
    zpushVkPhysicalDeviceProperties(L, &props);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x348, %rsp            # imm = 0x348
movq %rdi, %rbx
leaq 0x3ac29(%rip), %rcx     # 0x7eef4
pushq $0x1
popq %rbp
leaq 0x8(%rsp), %r15
movl %ebp, %esi
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
movq (%r15), %r13
movq 0x48(%r13), %rax
cmpq $0x0, 0xf0(%rax)
je 0x44325
leaq 0x10(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x19aa0
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x44340
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19150
movq %rbx, %rdi
callq 0x199c0
movl %eax, %ebp
jmp 0x4436b
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq *0x38(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19350
jmp 0x4436b
movq 0x48(%r13), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xf0(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x18990
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x19150
movl %ebp, %eax
addq $0x348, %rsp            # imm = 0x348
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq