LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: stetre[P]moonvulkan/src/flags.c
// Function: pushexternalsemaphorehandletypeflags
static int pushexternalsemaphorehandletypeflags(lua_State *L, VkFlags flags)
    {
    int n = 0;

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
    CASE(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, "opaque fd");
    CASE(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, "opaque win32");
    CASE(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, "opaque win32 kmt");
    CASE(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, "d3d12 fence");
    CASE(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, "sync fd");
#undef CASE

    return n;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x50a0d
movq 0x10(%rsp), %rdi
leaq 0x8e34a(%rip), %rsi     # 0xded47
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x50a0f
jmp 0x50a11
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x50a39
movq 0x10(%rsp), %rdi
leaq 0x8e328(%rip), %rsi     # 0xded51
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x50a3b
jmp 0x50a3d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x50a65
movq 0x10(%rsp), %rdi
leaq 0x8e309(%rip), %rsi     # 0xded5e
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x50a67
jmp 0x50a69
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x50a91
movq 0x10(%rsp), %rdi
leaq 0x8e34d(%rip), %rsi     # 0xdedce
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x50a93
jmp 0x50a95
movl 0xc(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x50abd
movq 0x10(%rsp), %rdi
leaq 0x8e32d(%rip), %rsi     # 0xdedda
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x50abf
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkexternalsemaphorehandletypeflags
static VkFlags checkexternalsemaphorehandletypeflags(lua_State *L, int arg)
    {
    const char *s;
    VkFlags flags = 0;

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
    CASE(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, "opaque fd");
    CASE(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, "opaque win32");
    CASE(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, "opaque win32 kmt");
    CASE(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, "d3d12 fence");
    CASE(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, "sync fd");
#undef CASE
        return (VkFlags)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }

    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1a7a0
cmpl $0x0, %eax
je 0x50c2b
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8e21f(%rip), %rsi     # 0xded47
callq 0x190a0
cmpl $0x0, %eax
jne 0x50b44
jmp 0x50b34
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x50c26
movq 0x18(%rsp), %rdi
leaq 0x8e201(%rip), %rsi     # 0xded51
callq 0x190a0
cmpl $0x0, %eax
jne 0x50b6c
jmp 0x50b5c
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x50c26
movq 0x18(%rsp), %rdi
leaq 0x8e1e6(%rip), %rsi     # 0xded5e
callq 0x190a0
cmpl $0x0, %eax
jne 0x50b94
jmp 0x50b84
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x50c26
movq 0x18(%rsp), %rdi
leaq 0x8e22e(%rip), %rsi     # 0xdedce
callq 0x190a0
cmpl $0x0, %eax
jne 0x50bb9
jmp 0x50bac
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x50c26
movq 0x18(%rsp), %rdi
leaq 0x8e215(%rip), %rsi     # 0xdedda
callq 0x190a0
cmpl $0x0, %eax
jne 0x50bde
jmp 0x50bd1
movl 0x14(%rsp), %eax
orl $0x10, %eax
movl %eax, 0x14(%rsp)
jmp 0x50c26
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x80dc8(%rip), %rsi     # 0xd19d0
movb $0x0, %al
callq 0x18f50
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rax, %rdx
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x50c33
jmp 0x50ae5
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: pushexternalsemaphorefeatureflags
static int pushexternalsemaphorefeatureflags(lua_State *L, VkFlags flags)
    {
    int n = 0;

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
    CASE(VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, "exportable");
    CASE(VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT, "importable");
#undef CASE

    return n;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x50c7d
movq 0x10(%rsp), %rdi
leaq 0x8e14b(%rip), %rsi     # 0xdedb8
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x50c7f
jmp 0x50c81
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x50ca9
movq 0x10(%rsp), %rdi
leaq 0x8e12a(%rip), %rsi     # 0xdedc3
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x50cab
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkexternalsemaphorefeatureflags
static VkFlags checkexternalsemaphorefeatureflags(lua_State *L, int arg)
    {
    const char *s;
    VkFlags flags = 0;

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
    CASE(VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, "exportable");
    CASE(VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT, "importable");
#undef CASE
        return (VkFlags)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }

    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1a7a0
cmpl $0x0, %eax
je 0x50da3
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8e0a0(%rip), %rsi     # 0xdedb8
callq 0x190a0
cmpl $0x0, %eax
jne 0x50d31
jmp 0x50d24
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x50d9e
movq 0x18(%rsp), %rdi
leaq 0x8e086(%rip), %rsi     # 0xdedc3
callq 0x190a0
cmpl $0x0, %eax
jne 0x50d56
jmp 0x50d49
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x50d9e
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x80c50(%rip), %rsi     # 0xd19d0
movb $0x0, %al
callq 0x18f50
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rax, %rdx
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x50dab
jmp 0x50cd5
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checksemaphoreimportflags
static VkFlags checksemaphoreimportflags(lua_State *L, int arg)
    {
    const char *s;
    VkFlags flags = 0;

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
    CASE(VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, "temporary");
#undef CASE
        return (VkFlags)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }

    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1a7a0
cmpl $0x0, %eax
je 0x50ece
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8df7a(%rip), %rsi     # 0xdede2
callq 0x190a0
cmpl $0x0, %eax
jne 0x50e81
jmp 0x50e74
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x50ec9
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x80b25(%rip), %rsi     # 0xd19d0
movb $0x0, %al
callq 0x18f50
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rax, %rdx
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x50ed6
jmp 0x50e25
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/flags.c
// Function: pushexternalfencehandletypeflags
static int pushexternalfencehandletypeflags(lua_State *L, VkFlags flags)
    {
    int n = 0;

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
    CASE(VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, "opaque fd");
    CASE(VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, "opaque win32");
    CASE(VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, "opaque win32 kmt");
    CASE(VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, "sync fd");
#undef CASE

    return n;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x50f1d
movq 0x10(%rsp), %rdi
leaq 0x8de3a(%rip), %rsi     # 0xded47
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x50f1f
jmp 0x50f21
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x50f49
movq 0x10(%rsp), %rdi
leaq 0x8de18(%rip), %rsi     # 0xded51
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x50f4b
jmp 0x50f4d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x50f75
movq 0x10(%rsp), %rdi
leaq 0x8ddf9(%rip), %rsi     # 0xded5e
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x50f77
jmp 0x50f79
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x50fa1
movq 0x10(%rsp), %rdi
leaq 0x8de49(%rip), %rsi     # 0xdedda
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x50fa3
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkexternalfencehandletypeflags
static VkFlags checkexternalfencehandletypeflags(lua_State *L, int arg)
    {
    const char *s;
    VkFlags flags = 0;

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
    CASE(VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, "opaque fd");
    CASE(VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, "opaque win32");
    CASE(VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, "opaque win32 kmt");
    CASE(VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, "sync fd");
#undef CASE
        return (VkFlags)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }

    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1a7a0
cmpl $0x0, %eax
je 0x510e3
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8dd3f(%rip), %rsi     # 0xded47
callq 0x190a0
cmpl $0x0, %eax
jne 0x51024
jmp 0x51014
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x510de
movq 0x18(%rsp), %rdi
leaq 0x8dd21(%rip), %rsi     # 0xded51
callq 0x190a0
cmpl $0x0, %eax
jne 0x5104c
jmp 0x5103c
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x510de
movq 0x18(%rsp), %rdi
leaq 0x8dd06(%rip), %rsi     # 0xded5e
callq 0x190a0
cmpl $0x0, %eax
jne 0x51071
jmp 0x51064
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x510de
movq 0x18(%rsp), %rdi
leaq 0x8dd5d(%rip), %rsi     # 0xdedda
callq 0x190a0
cmpl $0x0, %eax
jne 0x51096
jmp 0x51089
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x510de
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x80910(%rip), %rsi     # 0xd19d0
movb $0x0, %al
callq 0x18f50
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rax, %rdx
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x510eb
jmp 0x50fc5
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: pushexternalfencefeatureflags
static int pushexternalfencefeatureflags(lua_State *L, VkFlags flags)
    {
    int n = 0;

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
    CASE(VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, "exportable");
    CASE(VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT, "importable");
#undef CASE

    return n;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5113d
movq 0x10(%rsp), %rdi
leaq 0x8dc8b(%rip), %rsi     # 0xdedb8
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x5113f
jmp 0x51141
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x51169
movq 0x10(%rsp), %rdi
leaq 0x8dc6a(%rip), %rsi     # 0xdedc3
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x5116b
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkexternalfencefeatureflags
static VkFlags checkexternalfencefeatureflags(lua_State *L, int arg)
    {
    const char *s;
    VkFlags flags = 0;

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
    CASE(VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, "exportable");
    CASE(VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT, "importable");
#undef CASE
        return (VkFlags)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }

    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1a7a0
cmpl $0x0, %eax
je 0x51263
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8dbe0(%rip), %rsi     # 0xdedb8
callq 0x190a0
cmpl $0x0, %eax
jne 0x511f1
jmp 0x511e4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x5125e
movq 0x18(%rsp), %rdi
leaq 0x8dbc6(%rip), %rsi     # 0xdedc3
callq 0x190a0
cmpl $0x0, %eax
jne 0x51216
jmp 0x51209
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x5125e
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x80790(%rip), %rsi     # 0xd19d0
movb $0x0, %al
callq 0x18f50
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rax, %rdx
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x5126b
jmp 0x51195
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkfenceimportflags
static VkFlags checkfenceimportflags(lua_State *L, int arg)
    {
    const char *s;
    VkFlags flags = 0;

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
    CASE(VK_FENCE_IMPORT_TEMPORARY_BIT, "temporary");
#undef CASE
        return (VkFlags)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }

    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1a7a0
cmpl $0x0, %eax
je 0x5138e
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8daba(%rip), %rsi     # 0xdede2
callq 0x190a0
cmpl $0x0, %eax
jne 0x51341
jmp 0x51334
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x51389
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x80665(%rip), %rsi     # 0xd19d0
movb $0x0, %al
callq 0x18f50
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rax, %rdx
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x51396
jmp 0x512e5
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/flags.c
// Function: pushdebugutilsmessageseverityflags
static int pushdebugutilsmessageseverityflags(lua_State *L, VkFlags flags)
    {
    int n = 0;

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
        CASE(VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT, "verbose");
        CASE(VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT, "info");
        CASE(VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT, "warning");
        CASE(VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT, "error");
#undef CASE

    return n;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x513dd
movq 0x10(%rsp), %rdi
leaq 0x8da1f(%rip), %rsi     # 0xdedec
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x513df
jmp 0x513e1
movl 0xc(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x51409
movq 0x10(%rsp), %rdi
leaq 0x94525(%rip), %rsi     # 0xe591e
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x5140b
jmp 0x5140d
movl 0xc(%rsp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x51437
movq 0x10(%rsp), %rdi
leaq 0x8d90b(%rip), %rsi     # 0xded32
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x51439
jmp 0x5143b
movl 0xc(%rsp), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0x51465
movq 0x10(%rsp), %rdi
leaq 0x925cf(%rip), %rsi     # 0xe3a24
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x51467
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkdebugutilsmessageseverityflags
static VkFlags checkdebugutilsmessageseverityflags(lua_State *L, int arg)
    {
    const char *s;
    VkFlags flags = 0;

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
        CASE(VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT, "verbose");
        CASE(VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT, "info");
        CASE(VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT, "warning");
        CASE(VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT, "error");
#undef CASE
        return (VkFlags)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }

    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1a7a0
cmpl $0x0, %eax
je 0x515a7
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8d924(%rip), %rsi     # 0xdedec
callq 0x190a0
cmpl $0x0, %eax
jne 0x514e4
jmp 0x514d4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x515a2
movq 0x18(%rsp), %rdi
leaq 0x9442e(%rip), %rsi     # 0xe591e
callq 0x190a0
cmpl $0x0, %eax
jne 0x5150c
jmp 0x514fc
movl 0x14(%rsp), %eax
orl $0x10, %eax
movl %eax, 0x14(%rsp)
jmp 0x515a2
movq 0x18(%rsp), %rdi
leaq 0x8d81a(%rip), %rsi     # 0xded32
callq 0x190a0
cmpl $0x0, %eax
jne 0x51533
jmp 0x51524
movl 0x14(%rsp), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, 0x14(%rsp)
jmp 0x515a2
movq 0x18(%rsp), %rdi
leaq 0x924e5(%rip), %rsi     # 0xe3a24
callq 0x190a0
cmpl $0x0, %eax
jne 0x5155a
jmp 0x5154b
movl 0x14(%rsp), %eax
orl $0x1000, %eax           # imm = 0x1000
movl %eax, 0x14(%rsp)
jmp 0x515a2
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x8044c(%rip), %rsi     # 0xd19d0
movb $0x0, %al
callq 0x18f50
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rax, %rdx
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x515af
jmp 0x51485
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: pushdebugutilsmessagetypeflags
static int pushdebugutilsmessagetypeflags(lua_State *L, VkFlags flags)
    {
    int n = 0;

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
        CASE(VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT, "general");
        CASE(VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT, "validation");
        CASE(VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT, "performance");
#undef CASE

    return n;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x515fd
movq 0x10(%rsp), %rdi
leaq 0x8397a(%rip), %rsi     # 0xd4f67
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x515ff
jmp 0x51601
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x51629
movq 0x10(%rsp), %rdi
leaq 0x871ca(%rip), %rsi     # 0xd87e3
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x5162b
jmp 0x5162d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x51655
movq 0x10(%rsp), %rdi
leaq 0x8d7af(%rip), %rsi     # 0xdedf4
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x51657
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkdebugutilsmessagetypeflags
static VkFlags checkdebugutilsmessagetypeflags(lua_State *L, int arg)
    {
    const char *s;
    VkFlags flags = 0;

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
        CASE(VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT, "general");
        CASE(VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT, "validation");
        CASE(VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT, "performance");
#undef CASE
        return (VkFlags)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }

    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1a7a0
cmpl $0x0, %eax
je 0x5176b
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x838af(%rip), %rsi     # 0xd4f67
callq 0x190a0
cmpl $0x0, %eax
jne 0x516d4
jmp 0x516c4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x51766
movq 0x18(%rsp), %rdi
leaq 0x87103(%rip), %rsi     # 0xd87e3
callq 0x190a0
cmpl $0x0, %eax
jne 0x516f9
jmp 0x516ec
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x51766
movq 0x18(%rsp), %rdi
leaq 0x8d6ef(%rip), %rsi     # 0xdedf4
callq 0x190a0
cmpl $0x0, %eax
jne 0x5171e
jmp 0x51711
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x51766
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x80288(%rip), %rsi     # 0xd19d0
movb $0x0, %al
callq 0x18f50
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rax, %rdx
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x51773
jmp 0x51675
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: pushdevicegrouppresentmodeflags
static int pushdevicegrouppresentmodeflags(lua_State *L, VkFlags flags)
    {
    int n = 0;

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
        CASE(VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT, "local");
        CASE(VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT, "remote");
        CASE(VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT, "sum");
        CASE(VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT, "local multi device");
#undef CASE

    return n;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x517bd
movq 0x10(%rsp), %rdi
leaq 0x8ce6a(%rip), %rsi     # 0xde617
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x517bf
jmp 0x517c1
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x517e9
movq 0x10(%rsp), %rdi
leaq 0x8d627(%rip), %rsi     # 0xdee00
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x517eb
jmp 0x517ed
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x51815
movq 0x10(%rsp), %rdi
leaq 0x8d602(%rip), %rsi     # 0xdee07
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x51817
jmp 0x51819
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x51841
movq 0x10(%rsp), %rdi
leaq 0x8d5da(%rip), %rsi     # 0xdee0b
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x51843
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkdevicegrouppresentmodeflags
static VkFlags checkdevicegrouppresentmodeflags(lua_State *L, int arg)
    {
    const char *s;
    VkFlags flags = 0;

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
        CASE(VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT, "local");
        CASE(VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT, "remote");
        CASE(VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT, "sum");
        CASE(VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT, "local multi device");
#undef CASE
        return (VkFlags)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }

    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1a7a0
cmpl $0x0, %eax
je 0x51983
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8cd6f(%rip), %rsi     # 0xde617
callq 0x190a0
cmpl $0x0, %eax
jne 0x518c4
jmp 0x518b4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x5197e
movq 0x18(%rsp), %rdi
leaq 0x8d530(%rip), %rsi     # 0xdee00
callq 0x190a0
cmpl $0x0, %eax
jne 0x518ec
jmp 0x518dc
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x5197e
movq 0x18(%rsp), %rdi
leaq 0x8d50f(%rip), %rsi     # 0xdee07
callq 0x190a0
cmpl $0x0, %eax
jne 0x51911
jmp 0x51904
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x5197e
movq 0x18(%rsp), %rdi
leaq 0x8d4ee(%rip), %rsi     # 0xdee0b
callq 0x190a0
cmpl $0x0, %eax
jne 0x51936
jmp 0x51929
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x5197e
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x80070(%rip), %rsi     # 0xd19d0
movb $0x0, %al
callq 0x18f50
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rax, %rdx
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x5198b
jmp 0x51865
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: pushswapchaincreateflags
static int pushswapchaincreateflags(lua_State *L, VkFlags flags)
    {
    int n = 0;

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
        CASE(VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, "split instance bind regions");
        CASE(VK_SWAPCHAIN_CREATE_PROTECTED_BIT, "protected");
        CASE(VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT, "mutable format");
#undef CASE

    return n;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x519dd
movq 0x10(%rsp), %rdi
leaq 0x8cd03(%rip), %rsi     # 0xde6d0
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x519df
jmp 0x519e1
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x51a09
movq 0x10(%rsp), %rdi
leaq 0x980da(%rip), %rsi     # 0xe9ad3
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x51a0b
jmp 0x51a0d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x51a35
movq 0x10(%rsp), %rdi
leaq 0x8cc3f(%rip), %rsi     # 0xde664
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x51a37
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkswapchaincreateflags
static VkFlags checkswapchaincreateflags(lua_State *L, int arg)
    {
    const char *s;
    VkFlags flags = 0;

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
        CASE(VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, "split instance bind regions");
        CASE(VK_SWAPCHAIN_CREATE_PROTECTED_BIT, "protected");
        CASE(VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT, "mutable format");
#undef CASE
        return (VkFlags)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }

    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1a7a0
cmpl $0x0, %eax
je 0x51b4b
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8cc38(%rip), %rsi     # 0xde6d0
callq 0x190a0
cmpl $0x0, %eax
jne 0x51ab4
jmp 0x51aa4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x51b46
movq 0x18(%rsp), %rdi
leaq 0x98013(%rip), %rsi     # 0xe9ad3
callq 0x190a0
cmpl $0x0, %eax
jne 0x51ad9
jmp 0x51acc
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x51b46
movq 0x18(%rsp), %rdi
leaq 0x8cb7f(%rip), %rsi     # 0xde664
callq 0x190a0
cmpl $0x0, %eax
jne 0x51afe
jmp 0x51af1
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x51b46
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x7fea8(%rip), %rsi     # 0xd19d0
movb $0x0, %al
callq 0x18f50
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rax, %rdx
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x51b53
jmp 0x51a55
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: pushdescriptorbindingflags
static int pushdescriptorbindingflags(lua_State *L, VkFlags flags)
    {
    int n = 0;

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
        CASE(VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT, "update after bind");
        CASE(VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT, "update unused while pending");
        CASE(VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT, "partially bound");
        CASE(VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, "variable descriptor count");
#undef CASE

    return n;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x51b9d
movq 0x10(%rsp), %rdi
leaq 0x8c34b(%rip), %rsi     # 0xdded8
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x51b9f
jmp 0x51ba1
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x51bc9
movq 0x10(%rsp), %rdi
leaq 0x8d265(%rip), %rsi     # 0xdee1e
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x51bcb
jmp 0x51bcd
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x51bf5
movq 0x10(%rsp), %rdi
leaq 0x8d255(%rip), %rsi     # 0xdee3a
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x51bf7
jmp 0x51bf9
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x51c21
movq 0x10(%rsp), %rdi
leaq 0x8d239(%rip), %rsi     # 0xdee4a
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x51c23
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkdescriptorbindingflags
static VkFlags checkdescriptorbindingflags(lua_State *L, int arg)
    {
    const char *s;
    VkFlags flags = 0;

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
        CASE(VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT, "update after bind");
        CASE(VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT, "update unused while pending");
        CASE(VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT, "partially bound");
        CASE(VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, "variable descriptor count");
#undef CASE
        return (VkFlags)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }

    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1a7a0
cmpl $0x0, %eax
je 0x51d63
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8c250(%rip), %rsi     # 0xdded8
callq 0x190a0
cmpl $0x0, %eax
jne 0x51ca4
jmp 0x51c94
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x51d5e
movq 0x18(%rsp), %rdi
leaq 0x8d16e(%rip), %rsi     # 0xdee1e
callq 0x190a0
cmpl $0x0, %eax
jne 0x51ccc
jmp 0x51cbc
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x51d5e
movq 0x18(%rsp), %rdi
leaq 0x8d162(%rip), %rsi     # 0xdee3a
callq 0x190a0
cmpl $0x0, %eax
jne 0x51cf1
jmp 0x51ce4
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x51d5e
movq 0x18(%rsp), %rdi
leaq 0x8d14d(%rip), %rsi     # 0xdee4a
callq 0x190a0
cmpl $0x0, %eax
jne 0x51d16
jmp 0x51d09
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x51d5e
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x7fc90(%rip), %rsi     # 0xd19d0
movb $0x0, %al
callq 0x18f50
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rax, %rdx
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x51d6b
jmp 0x51c45
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkconditionalrenderingflags
static VkFlags checkconditionalrenderingflags(lua_State *L, int arg)
    {
    const char *s;
    VkFlags flags = 0;

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
        CASE(VK_CONDITIONAL_RENDERING_INVERTED_BIT, "inverted");
#undef CASE
        return (VkFlags)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }

    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1a7a0
cmpl $0x0, %eax
je 0x51e8e
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x83c8a(%rip), %rsi     # 0xd5ab2
callq 0x190a0
cmpl $0x0, %eax
jne 0x51e41
jmp 0x51e34
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x51e89
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x7fb65(%rip), %rsi     # 0xd19d0
movb $0x0, %al
callq 0x18f50
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rax, %rdx
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x51e96
jmp 0x51de5
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkaccelerationstructurecreateflags
static VkFlags checkaccelerationstructurecreateflags(lua_State *L, int arg)
    {
    const char *s;
    VkFlags flags = 0;

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
        CASE(VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, "device address capture replay");
#undef CASE
        return (VkFlags)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }

    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1a7a0
cmpl $0x0, %eax
je 0x51fae
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8c323(%rip), %rsi     # 0xde26b
callq 0x190a0
cmpl $0x0, %eax
jne 0x51f61
jmp 0x51f54
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x51fa9
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x7fa45(%rip), %rsi     # 0xd19d0
movb $0x0, %al
callq 0x18f50
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rax, %rdx
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x51fb6
jmp 0x51f05
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/flags.c
// Function: pushrenderingflags
static int pushrenderingflags(lua_State *L, VkFlags flags)
    {
    int n = 0;

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
    CASE(VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT, "contents secondary command buffers");
    CASE(VK_RENDERING_SUSPENDING_BIT, "suspending");
    CASE(VK_RENDERING_RESUMING_BIT, "resuming");
#undef CASE

    return n;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x51ffd
movq 0x10(%rsp), %rdi
leaq 0x8ce77(%rip), %rsi     # 0xdee64
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x51fff
jmp 0x52001
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x52029
movq 0x10(%rsp), %rdi
leaq 0x8ce6e(%rip), %rsi     # 0xdee87
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x5202b
jmp 0x5202d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x52055
movq 0x10(%rsp), %rdi
leaq 0x8ce4d(%rip), %rsi     # 0xdee92
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x52057
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkrenderingflags
static VkFlags checkrenderingflags(lua_State *L, int arg)
    {
    const char *s;
    VkFlags flags = 0;

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
    CASE(VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT, "contents secondary command buffers");
    CASE(VK_RENDERING_SUSPENDING_BIT, "suspending");
    CASE(VK_RENDERING_RESUMING_BIT, "resuming");
#undef CASE
        return (VkFlags)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }

    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1a7a0
cmpl $0x0, %eax
je 0x5216b
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8cdac(%rip), %rsi     # 0xdee64
callq 0x190a0
cmpl $0x0, %eax
jne 0x520d4
jmp 0x520c4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x52166
movq 0x18(%rsp), %rdi
leaq 0x8cda7(%rip), %rsi     # 0xdee87
callq 0x190a0
cmpl $0x0, %eax
jne 0x520f9
jmp 0x520ec
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x52166
movq 0x18(%rsp), %rdi
leaq 0x8cd8d(%rip), %rsi     # 0xdee92
callq 0x190a0
cmpl $0x0, %eax
jne 0x5211e
jmp 0x52111
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x52166
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x7f888(%rip), %rsi     # 0xd19d0
movb $0x0, %al
callq 0x18f50
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rax, %rdx
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x52173
jmp 0x52075
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkreservedflags
static VkFlags checkreservedflags(lua_State *L, int arg)
    {
    const char *s;

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
        return (VkFlags)luaL_argerror(L, --arg, badvalue(L,s));
        }

    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1a7a0
cmpl $0x0, %eax
je 0x52218
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x7f7d6(%rip), %rsi     # 0xd19d0
movb $0x0, %al
callq 0x18f50
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq %rax, %rdx
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x52220
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
leaq 0x30(%rsp), %rdx
leaq 0x7cbbc(%rip), %rcx     # 0xcf03b
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movl $0x3, %esi
callq 0x19260
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movl $0x2, %esi
leaq 0x44(%rsp), %rdx
callq 0x18250
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x44(%rsp)
je 0x52507
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x18460
movl %eax, 0x54(%rsp)
jmp 0x52617
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x1f8(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq *%rax
movl %eax, 0x2c(%rsp)
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
cmpl $0x0, 0x2c(%rsp)
je 0x5256f
movq 0x48(%rsp), %rdi
movl 0x2c(%rsp), %edx
xorl %esi, %esi
callq 0x18a00
movq 0x48(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x54(%rsp)
jmp 0x52617
jmp 0x52571
jmp 0x52573
movq 0xaaa1e(%rip), %rax     # 0xfcf98
cmpl $0x0, (%rax)
je 0x52592
movq 0x20(%rsp), %rsi
leaq 0x8c937(%rip), %rdi     # 0xdeec2
movb $0x0, %al
callq 0x189d0
jmp 0x52594
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x7ea01(%rip), %rdx     # 0xd0fa6
xorl %ecx, %ecx
callq 0x18350
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x38(%rsp), %rax
leaq 0x67(%rip), %rcx        # 0x52660
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x50(%rax)
movl $0x1, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x18dc0
cmpl $0x0, %eax
jne 0x526b5
movl $0x0, 0x34(%rsp)
jmp 0x52706
jmp 0x526b7
movq 0xaa8da(%rip), %rax     # 0xfcf98
cmpl $0x0, (%rax)
je 0x526d6
movq 0x18(%rsp), %rsi
leaq 0x8c810(%rip), %rdi     # 0xdeedf
movb $0x0, %al
callq 0x189d0
jmp 0x526d8
movq 0x8(%rsp), %rdi
callq 0x19fd0
movq 0x50(%rax), %rax
movq 0x200(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq *%rax
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop