LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x40eae
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x40e5e
leaq 0x5dfb1(%rip), %rsi     # 0x9ee02
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x10, %r14b
je 0x40e75
leaq 0x64c0b(%rip), %rsi     # 0xa5a76
movq %rbx, %rdi
callq 0x1a300
incl %ebp
btl $0x8, %r14d
jae 0x40e8d
leaq 0x5dec5(%rip), %rsi     # 0x9ed48
movq %rbx, %rdi
callq 0x1a300
incl %ebp
btl $0xc, %r14d
jae 0x40f69
leaq 0x62bb3(%rip), %rsi     # 0xa3a52
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x40f69
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x40f59
leaq 0x5df30(%rip), %r15     # 0x9ee02
leaq 0x64b9d(%rip), %r12     # 0xa5a76
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x40f33
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x40f3a
movq %r13, %rdi
leaq 0x5de38(%rip), %rsi     # 0x9ed48
callq 0x19000
testl %eax, %eax
je 0x40f41
movq %r13, %rdi
leaq 0x62b2f(%rip), %rsi     # 0xa3a52
callq 0x19000
movl $0x1000, %ecx           # imm = 0x1000
testl %eax, %eax
je 0x40f46
jmp 0x40f7a
movl $0x1, %ecx
jmp 0x40f46
movl $0x10, %ecx
jmp 0x40f46
movl $0x100, %ecx            # imm = 0x100
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x40ed9
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x50a65(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
jmp 0x40f59
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x41020
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x40fe9
leaq 0x53fa1(%rip), %rsi     # 0x94f7d
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x41000
leaq 0x57803(%rip), %rsi     # 0x987f9
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x4, %r14b
je 0x410e7
leaq 0x5ddf9(%rip), %rsi     # 0x9ee0a
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x410e7
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x410d7
leaq 0x53f39(%rip), %r15     # 0x94f7d
leaq 0x577ae(%rip), %r12     # 0x987f9
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x41092
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x41099
movq %r13, %rdi
leaq 0x5dd88(%rip), %rsi     # 0x9ee0a
callq 0x19000
movl $0x4, %ecx
testl %eax, %eax
je 0x4109e
jmp 0x410b3
movl $0x1, %ecx
jmp 0x4109e
movl $0x2, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x4104b
jmp 0x410d7
leaq 0x5092c(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
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_O1/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
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x4118f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x41141
leaq 0x5d4f9(%rip), %rsi     # 0x9e62d
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x41158
leaq 0x5dcc8(%rip), %rsi     # 0x9ee16
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x4, %r14b
je 0x4116f
leaq 0x5dcb8(%rip), %rsi     # 0x9ee1d
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x8, %r14b
je 0x4124a
leaq 0x5dca1(%rip), %rsi     # 0x9ee21
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x4124a
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x4123a
leaq 0x5d47a(%rip), %r15     # 0x9e62d
leaq 0x5dc5c(%rip), %r12     # 0x9ee16
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x41214
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x4121b
movq %r13, %rdi
leaq 0x5dc2c(%rip), %rsi     # 0x9ee1d
callq 0x19000
testl %eax, %eax
je 0x41222
movq %r13, %rdi
leaq 0x5dc1d(%rip), %rsi     # 0x9ee21
callq 0x19000
movl $0x8, %ecx
testl %eax, %eax
je 0x41227
jmp 0x4125b
movl $0x1, %ecx
jmp 0x41227
movl $0x2, %ecx
jmp 0x41227
movl $0x4, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x411ba
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x50784(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
jmp 0x4123a
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x41301
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x412ca
leaq 0x5d429(%rip), %rsi     # 0x9e6e6
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x412e1
leaq 0x68954(%rip), %rsi     # 0xa9c2b
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x4, %r14b
je 0x413c8
leaq 0x5d388(%rip), %rsi     # 0x9e67a
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x413c8
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x413b8
leaq 0x5d3c1(%rip), %r15     # 0x9e6e6
leaq 0x688ff(%rip), %r12     # 0xa9c2b
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x41373
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x4137a
movq %r13, %rdi
leaq 0x5d317(%rip), %rsi     # 0x9e67a
callq 0x19000
movl $0x4, %ecx
testl %eax, %eax
je 0x4137f
jmp 0x41394
movl $0x1, %ecx
jmp 0x4137f
movl $0x2, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x4132c
jmp 0x413b8
leaq 0x5064b(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
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_O1/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
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x41470
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x41422
leaq 0x5cad9(%rip), %rsi     # 0x9deee
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x41439
leaq 0x5da05(%rip), %rsi     # 0x9ee34
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x4, %r14b
je 0x41450
leaq 0x5da0a(%rip), %rsi     # 0x9ee50
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x8, %r14b
je 0x4152b
leaq 0x5d9ff(%rip), %rsi     # 0x9ee60
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x4152b
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x4151b
leaq 0x5ca5a(%rip), %r15     # 0x9deee
leaq 0x5d999(%rip), %r12     # 0x9ee34
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x414f5
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x414fc
movq %r13, %rdi
leaq 0x5d97e(%rip), %rsi     # 0x9ee50
callq 0x19000
testl %eax, %eax
je 0x41503
movq %r13, %rdi
leaq 0x5d97b(%rip), %rsi     # 0x9ee60
callq 0x19000
movl $0x8, %ecx
testl %eax, %eax
je 0x41508
jmp 0x4153c
movl $0x1, %ecx
jmp 0x41508
movl $0x2, %ecx
jmp 0x41508
movl $0x4, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x4149b
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x504a3(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
jmp 0x4151b
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x415aa
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x41630
leaq 0x5452b(%rip), %rsi     # 0x95ac8
movq %rbx, %rdi
callq 0x1a300
jmp 0x4162b
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
testl %eax, %eax
je 0x415fc
leaq 0x54501(%rip), %r14     # 0x95ac8
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x19000
testl %eax, %eax
jne 0x41600
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x415c7
movl $0x1, %esi
jmp 0x41623
xorl %esi, %esi
jmp 0x41623
leaq 0x503df(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x41683
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x41709
leaq 0x5cc0b(%rip), %rsi     # 0x9e281
movq %rbx, %rdi
callq 0x1a300
jmp 0x41704
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
testl %eax, %eax
je 0x416d5
leaq 0x5cbe1(%rip), %r14     # 0x9e281
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x19000
testl %eax, %eax
jne 0x416d9
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x416a0
movl $0x1, %esi
jmp 0x416fc
xorl %esi, %esi
jmp 0x416fc
leaq 0x50306(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x41794
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x4175d
leaq 0x5d72a(%rip), %rsi     # 0x9ee7a
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x41774
leaq 0x5d733(%rip), %rsi     # 0x9ee9d
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x4, %r14b
je 0x4185b
leaq 0x5d723(%rip), %rsi     # 0x9eea8
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x4185b
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x4184b
leaq 0x5d6c2(%rip), %r15     # 0x9ee7a
leaq 0x5d6de(%rip), %r12     # 0x9ee9d
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x41806
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x4180d
movq %r13, %rdi
leaq 0x5d6b2(%rip), %rsi     # 0x9eea8
callq 0x19000
movl $0x4, %ecx
testl %eax, %eax
je 0x41812
jmp 0x41827
movl $0x1, %ecx
jmp 0x41812
movl $0x2, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x417bf
jmp 0x4184b
leaq 0x501b8(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
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_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x41892
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
xorl %ebp, %ebp
jmp 0x418e9
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
testl %eax, %eax
je 0x418df
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x18690
leaq 0x50128(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl $0x1, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %esi
jmp 0x418e1
xorl %esi, %esi
movq %rbx, %rdi
callq 0x18b60
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4d5c0(%rip), %rcx     # 0x8f03b
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x191c0
movq %rax, %r15
leaq 0x14(%rsp), %r13
movq %rbx, %rdi
movl $0x2, %esi
movq %r13, %rdx
callq 0x18230
movq %rax, %r12
cmpl $0x0, (%r13)
je 0x41af0
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19170
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x41b9b
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, %ebp
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19170
testl %ebp, %ebp
je 0x41b37
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x18990
movq %rbx, %rdi
callq 0x199e0
jmp 0x41b9b
movq 0x8148a(%rip), %rax     # 0xc2fc8
cmpl $0x0, (%rax)
je 0x41b55
movq (%rsp), %rsi
leaq 0x5d38a(%rip), %rdi     # 0x9eed8
xorl %eax, %eax
callq 0x18970
movq (%rsp), %rsi
leaq 0x4f48e(%rip), %rdx     # 0x90fee
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 0x4f(%rip), %rdx        # 0x41bd9
movq %rdx, 0x8(%rax)
movq 0x50(%rcx), %rcx
movq %rcx, 0x50(%rax)
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18d30
testl %eax, %eax
je 0x41c2a
movq 0x813cf(%rip), %rax     # 0xc2fc8
cmpl $0x0, (%rax)
je 0x41c0f
leaq 0x5d2f0(%rip), %rdi     # 0x9eef5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18970
movq %r15, %rdi
callq 0x19ed0
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_O1/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 0x7dfee(%rip), %rax     # 0xc2fc8
cmpl $0x0, (%rax)
je 0x44ff0
leaq 0x5d396(%rip), %rdi     # 0xa237c
movq %r13, %rsi
xorl %eax, %eax
callq 0x18970
leaq 0x4a9a3(%rip), %rdx     # 0x8f99a
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 0x19ed0
movq 0x18(%rax), %rax
movq %rax, 0x18(%r13)
movq %r15, 0x40(%r13)
leaq 0x5c(%rip), %rax        # 0x45086
movq %rax, 0x8(%r13)
movq %r14, %rdi
callq 0x19ed0
movq 0x50(%rax), %rax
movq %rax, 0x50(%r13)
testl %ebx, %ebx
je 0x45047
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_O1/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 0x4b5a5(%rip), %rsi     # 0x90651
movq %r12, %rdx
callq 0x18f00
movq %r13, %rdi
movq %r12, %rsi
callq 0x18d30
testl %eax, %eax
je 0x45101
movq 0x7defe(%rip), %rax     # 0xc2fc8
cmpl $0x0, (%rax)
je 0x450e0
leaq 0x5d2bd(%rip), %rdi     # 0xa2393
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18970
testb $0x4, %bpl
jne 0x45101
movq %r15, %rdi
callq 0x19ed0
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_O1/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 0x49dd2(%rip), %rcx     # 0x8f03b
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x191c0
movq %rax, %r15
leaq 0x14(%rsp), %r13
movq %rbx, %rdi
movl $0x2, %esi
movq %r13, %rdx
callq 0x188a0
movq %rax, %r12
cmpl $0x0, (%r13)
je 0x452db
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19170
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x45328
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
movl $0x1, %ebp
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19170
testl %r13d, %r13d
je 0x4533b
movq %rbx, %rdi
xorl %esi, %esi
movl %r13d, %edx
callq 0x18990
movq %rbx, %rdi
callq 0x199e0
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 0x19ed0
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r14, %rcx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x44fb6
jmp 0x4532a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4a5f3(%rip), %rcx     # 0x8f99a
movl $0x1, %ebp
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq %rax, %r15
movq (%r14), %rax
movq 0x20(%rax), %r12
leaq 0xc(%rsp), %r13
movq %rbx, %rdi
movl $0x2, %esi
movq %r13, %rdx
callq 0x18800
movq %rax, %r14
cmpl $0x0, (%r13)
je 0x4541a
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x19640
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %ebp
jmp 0x45456
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 0x18940
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x19640
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x3, %esi
callq 0x191c0
movq %rax, %r14
leaq 0x4a39e(%rip), %rcx     # 0x8f99a
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r13
movq (%r15), %rax
movq 0x20(%rax), %r15
leaq 0x14(%rsp), %rbp
movq %rbx, %rdi
movl $0x2, %esi
movq %rbp, %rdx
callq 0x183d0
movq %rax, %r12
cmpl $0x0, (%rbp)
je 0x4566d
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19170
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x45733
movq %r13, 0x18(%r12)
movq %r15, %rdi
callq 0x19ed0
movq 0x50(%rax), %rax
movq %rsp, %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq *0x140(%rax)
movl %eax, %ebp
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19170
testl %ebp, %ebp
je 0x456bc
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x18990
movq %rbx, %rdi
callq 0x199e0
jmp 0x45733
movq 0x7d905(%rip), %rax     # 0xc2fc8
cmpl $0x0, (%rax)
je 0x456da
movq (%rsp), %rsi
leaq 0x5cd34(%rip), %rdi     # 0xa2407
xorl %eax, %eax
callq 0x18970
movq (%rsp), %rsi
leaq 0x4af6c(%rip), %rdx     # 0x90651
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 0x19ed0
movq 0x18(%rax), %rax
movq %rax, 0x18(%rbx)
movq %r14, 0x40(%rbx)
leaq 0x57(%rip), %rax        # 0x45771
movq %rax, 0x8(%rbx)
movq %r15, %rdi
callq 0x19ed0
movq 0x50(%rax), %rax
movq %rax, 0x50(%rbx)
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18d30
testl %eax, %eax
je 0x457c2
movq 0x7d837(%rip), %rax     # 0xc2fc8
cmpl $0x0, (%rax)
je 0x457a7
leaq 0x5cc86(%rip), %rdi     # 0xa2423
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18970
movq %r15, %rdi
callq 0x19ed0
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_O1/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
movl $0x2, %esi
callq 0x191c0
movq %rax, %r15
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movl $0x1, %esi
movq %r12, %rdx
callq 0x187f0
movq %rax, %r14
cmpl $0x0, (%r12)
je 0x459a7
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x19170
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x1, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x459e4
movq 0x7d632(%rip), %rax     # 0xc2fe0
movq %rsp, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq *0x10(%rax)
testl %eax, %eax
je 0x459f5
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x19170
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x18990
movq %rbx, %rdi
callq 0x199e0
movl %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x7d5cc(%rip), %rax     # 0xc2fc8
cmpl $0x0, (%rax)
je 0x45a13
movq (%rsp), %rsi
leaq 0x5ca90(%rip), %rdi     # 0xa249c
xorl %eax, %eax
callq 0x18970
movq (%rsp), %rsi
leaq 0x4acf3(%rip), %rdx     # 0x90711
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x18330
movq %rax, %r12
movq (%rsp), %rsi
movq %rsi, 0x18(%rax)
leaq 0x356(%rip), %rax       # 0x45d98
movq %rax, 0x8(%r12)
movq %r15, 0x40(%r12)
movq %rbx, %rdi
movq %r14, %rdx
callq 0x19200
movq %rax, 0x48(%r12)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x19170
jmp 0x459e6
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4ac56(%rip), %rcx     # 0x90711
movl $0x1, %ebp
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x187e0
movq (%r15), %rax
movq 0x48(%rax), %rax
movq %rsp, %rsi
movq %r14, %rdi
xorl %edx, %edx
callq *0x8(%rax)
testl %eax, %eax
je 0x45b21
movq %rbx, %rdi
xorl %esi, %esi
movl %eax, %edx
callq 0x18990
movq %rbx, %rdi
callq 0x199e0
movl %eax, %ebp
movl %ebp, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, (%rsp)
je 0x45b0d
xorl %r13d, %r13d
leaq 0x10(%rsp), %r12
movl (%rsp), %eax
cmpl $0x21, %eax
jb 0x45b44
movl $0x20, 0x4(%rsp)
addl $-0x20, %eax
jmp 0x45b4a
movl %eax, 0x4(%rsp)
xorl %eax, %eax
movl %eax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq %r14, %rdi
leaq 0x4(%rsp), %rsi
movq %r12, %rdx
callq *0x8(%rax)
cmpl $0x5, %eax
je 0x45b6d
testl %eax, %eax
jne 0x45af7
cmpl $0x0, 0x4(%rsp)
je 0x45bac
movl %r13d, %ebp
xorl %r15d, %r15d
movq 0x10(%rsp,%r15,8), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x19ee0
leal (%r15,%rbp), %edx
incl %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x19140
incq %r15
movl 0x4(%rsp), %eax
cmpq %rax, %r15
jb 0x45b7a
addl %r15d, %r13d
cmpl $0x0, (%rsp)
jne 0x45b2f
movl $0x1, %ebp
jmp 0x45b0d
// File: /workspace/github_cpp_makefile_star2_O1/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 0x45db5
movq (%rax), %r13
jmp 0x45db8
xorl %r13d, %r13d
movq (%r15), %rbx
movq 0x40(%r15), %r14
leaq 0x4aa83(%rip), %rsi     # 0x90849
movq %r12, %rdi
movq %r15, %rdx
callq 0x18f00
leaq 0x4a88f(%rip), %rsi     # 0x90667
movq %r12, %rdi
movq %r15, %rdx
callq 0x18f00
leaq 0x49251(%rip), %rsi     # 0x8f03b
movq %r12, %rdi
movq %r15, %rdx
callq 0x18f00
leaq 0x4b0f8(%rip), %rsi     # 0x90ef4
movq %r12, %rdi
movq %r15, %rdx
callq 0x18f00
leaq 0x5c6a8(%rip), %rsi     # 0xa24b6
movq %r12, %rdi
movq %r15, %rdx
callq 0x18f00
movq 0x48(%r15), %rsi
testq %rsi, %rsi
je 0x45e2a
movq %r12, %rdi
callq 0x182e0
movq %r12, %rdi
movq %r15, %rsi
callq 0x18d30
testl %eax, %eax
je 0x45e64
movq 0x7d188(%rip), %rax     # 0xc2fc8
cmpl $0x0, (%rax)
je 0x45e56
leaq 0x5c67d(%rip), %rdi     # 0xa24c9
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18970
testq %r13, %r13
je 0x45e64
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_O1/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 0x7c63d(%rip), %rbx     # 0xc2fd0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x469ac
callq 0x18350
callq 0x181b0
movq $0x0, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x60, %esi
callq 0x18c80
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movl 0x28(%rax), %ecx
movl %ecx, %edx
orl $0x1, %edx
movups %xmm0, (%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
movq %r14, (%rax)
movl %edx, 0x28(%rax)
movaps 0x5bbe3(%rip), %xmm0    # 0xa25e0
movups %xmm0, 0x2c(%rax)
testl %ebx, %ebx
je 0x46a0b
orl $0x3, %ecx
movl %ecx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x46ad2
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 0x46a4d
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x1a2e0
movl $0xfffffffe, 0x2c(%rbx) # imm = 0xFFFFFFFE
movl 0x30(%rbx), %edx
cmpl $-0x2, %edx
je 0x46a69
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x1a2e0
movl $0xfffffffe, 0x30(%rbx) # imm = 0xFFFFFFFE
movl 0x34(%rbx), %edx
cmpl $-0x2, %edx
je 0x46a85
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x1a2e0
movl $0xfffffffe, 0x34(%rbx) # imm = 0xFFFFFFFE
movl 0x38(%rbx), %edx
cmpl $-0x2, %edx
je 0x46aa1
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x1a2e0
movl $0xfffffffe, 0x38(%rbx) # imm = 0xFFFFFFFE
movq 0x58(%rbx), %rsi
testq %rsi, %rsi
je 0x46ab2
movq %r14, %rdi
callq 0x182e0
testb $0x2, 0x28(%rbx)
je 0x46abb
movq (%rbx), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19070
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a1e0
testq %rax, %rax
je 0x46bb1
testb $0x1, 0x28(%rax)
jne 0x46bc1
testq %rbx, %rbx
je 0x46bbd
movq $0x0, (%rbx)
xorl %eax, %eax
jmp 0x46bcc
testq %rbx, %rbx
je 0x46bc9
movq %rax, (%rbx)
movq (%rax), %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a1e0
testq %rax, %rax
je 0x46bf4
testb $0x1, 0x28(%rax)
jne 0x46c28
leaq 0x5b9ff(%rip), %rsi     # 0xa25fa
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
callq 0x18420
cltq
jmp 0x46c34
testq %r12, %r12
je 0x46c31
movq %rax, (%r12)
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
xorl %eax, %eax
movl %eax, (%rdx)
movl %eax, (%rcx)
callq 0x1a130
testl %eax, %eax
jle 0x46d24
movq %r12, %rdi
movl %ebp, %esi
callq 0x1a130
movl $0xfffffffc, %ecx       # imm = 0xFFFFFFFC
cmpl $0x5, %eax
jne 0x46d55
movq %r12, %rdi
movl %ebp, %esi
callq 0x1a160
movl %eax, (%r14)
testl %eax, %eax
je 0x46d2b
movl %eax, %esi
shlq $0x3, %rsi
movq %r12, %rdi
callq 0x18050
testq %rax, %rax
je 0x46d32
movq %rax, %r13
cmpl $0x0, (%r14)
je 0x46d5a
movq %rbx, 0x8(%rsp)
xorl %r15d, %r15d
leaq 0x1(%r15), %rbx
movq %r12, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x18980
movq %r12, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rdx
callq 0x1a1e0
testq %rax, %rax
je 0x46cf9
testb $0x1, 0x28(%rax)
jne 0x46cfd
xorl %eax, %eax
jmp 0x46d00
movq (%rax), %rax
movq %rax, (%r13,%r15,8)
testq %rax, %rax
je 0x46d39
movq %r12, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x18150
movl (%r14), %eax
movq %rbx, %r15
cmpq %rax, %rbx
jb 0x46ccb
jmp 0x46d5a
movl $0x1, %ecx
jmp 0x46d55
movl $0xfffffffb, %ecx       # imm = 0xFFFFFFFB
jmp 0x46d55
movl $0xfffffffa, %ecx       # imm = 0xFFFFFFFA
jmp 0x46d4e
movq %r12, %rdi
movq %r13, %rsi
callq 0x182e0
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
movq 0x8(%rsp), %rbx
movl $0x0, (%r14)
movl %ecx, (%rbx)
xorl %r13d, %r13d
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19ed0
testq %rax, %rax
je 0x46fa7
movq %r15, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x195e0
leaq 0x49f46(%rip), %rdx     # 0x90ef4
movq %r15, %rdi
movq %rbx, %rsi
movl $0x1, %ecx
callq 0x18330
movq %rax, %r15
movq %r14, 0x18(%rax)
movq %r14, %rdi
callq 0x19ed0
movq %rax, 0x10(%r15)
leaq 0x3c(%rip), %rax        # 0x47014
movq %rax, 0x8(%r15)
movq %r14, %rdi
callq 0x19ed0
movq 0x48(%rax), %rax
movq %rax, 0x48(%r15)
movq 0x7bfd5(%rip), %rax     # 0xc2fc8
cmpl $0x0, (%rax)
je 0x47009
leaq 0x5b604(%rip), %rdi     # 0xa2603
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18970
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4a625(%rip), %rsi     # 0x9164e
movq %r14, %rdx
callq 0x18f00
movq %r15, %rdi
movq %r14, %rsi
callq 0x18d30
testl %eax, %eax
je 0x4705d
movq 0x7bf81(%rip), %rax     # 0xc2fc8
cmpl $0x0, (%rax)
je 0x4705d
leaq 0x5b5d1(%rip), %rdi     # 0xa2624
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18970
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq