LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x1a240
cmpl $0x3, %eax
jne 0x46ad8
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x19190
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x52180
movl %eax, 0x24(%rsp)
jmp 0x46b07
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x52190
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x18be0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: stetre[P]moonvulkan/src/flags.c
// Function: pushstencilfaceflags
static int pushstencilfaceflags(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_STENCIL_FACE_FRONT_BIT, "front");
    CASE(VK_STENCIL_FACE_BACK_BIT, "back");
    CASE(VK_STENCIL_FACE_FRONT_AND_BACK, "front and back");
#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 0x46b4d
movq 0x10(%rsp), %rdi
leaq 0x9706a(%rip), %rsi     # 0xddba7
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x46b4f
jmp 0x46b51
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x46b79
movq 0x10(%rsp), %rdi
leaq 0x9704e(%rip), %rsi     # 0xddbb7
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x46b7b
jmp 0x46b7d
movl 0xc(%rsp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x46ba5
movq 0x10(%rsp), %rdi
leaq 0x97018(%rip), %rsi     # 0xddbad
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x46ba7
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkstencilfaceflags
static VkFlags checkstencilfaceflags(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_STENCIL_FACE_FRONT_BIT, "front");
    CASE(VK_STENCIL_FACE_BACK_BIT, "back");
    CASE(VK_STENCIL_FACE_FRONT_AND_BACK, "front and back");
#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 0x46cbb
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 0x96f9f(%rip), %rsi     # 0xddba7
callq 0x190a0
cmpl $0x0, %eax
jne 0x46c24
jmp 0x46c14
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x46cb6
movq 0x18(%rsp), %rdi
leaq 0x96f87(%rip), %rsi     # 0xddbb7
callq 0x190a0
cmpl $0x0, %eax
jne 0x46c49
jmp 0x46c3c
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x46cb6
movq 0x18(%rsp), %rdi
leaq 0x96f58(%rip), %rsi     # 0xddbad
callq 0x190a0
cmpl $0x0, %eax
jne 0x46c6e
jmp 0x46c61
movl 0x14(%rsp), %eax
orl $0x3, %eax
movl %eax, 0x14(%rsp)
jmp 0x46cb6
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 0x8ad38(%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 0x46cc3
jmp 0x46bc5
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: checkcommandbufferresetflags
static VkFlags checkcommandbufferresetflags(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_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT, "release resources");
#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 0x46dde
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 0x96e44(%rip), %rsi     # 0xddbbc
callq 0x190a0
cmpl $0x0, %eax
jne 0x46d91
jmp 0x46d84
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x46dd9
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 0x8ac15(%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 0x46de6
jmp 0x46d35
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: checkquerycontrolflags
static VkFlags checkquerycontrolflags(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_QUERY_CONTROL_PRECISE_BIT, "precise");
#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 0x46efe
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 0x9d5e8(%rip), %rsi     # 0xe4480
callq 0x190a0
cmpl $0x0, %eax
jne 0x46eb1
jmp 0x46ea4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x46ef9
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 0x8aaf5(%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 0x46f06
jmp 0x46e55
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: pushcommandbufferusageflags
static int pushcommandbufferusageflags(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_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, "one time submit");
    CASE(VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, "render pass continue");
    CASE(VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, "simultaneous use");
#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 0x46f4d
movq 0x10(%rsp), %rdi
leaq 0x96c91(%rip), %rsi     # 0xddbce
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x46f4f
jmp 0x46f51
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x46f79
movq 0x10(%rsp), %rdi
leaq 0x96c75(%rip), %rsi     # 0xddbde
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x46f7b
jmp 0x46f7d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x46fa5
movq 0x10(%rsp), %rdi
leaq 0x96c5e(%rip), %rsi     # 0xddbf3
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x46fa7
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkcommandbufferusageflags
static VkFlags checkcommandbufferusageflags(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_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, "one time submit");
    CASE(VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, "render pass continue");
    CASE(VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, "simultaneous use");
#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 0x470bb
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 0x96bc6(%rip), %rsi     # 0xddbce
callq 0x190a0
cmpl $0x0, %eax
jne 0x47024
jmp 0x47014
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x470b6
movq 0x18(%rsp), %rdi
leaq 0x96bae(%rip), %rsi     # 0xddbde
callq 0x190a0
cmpl $0x0, %eax
jne 0x47049
jmp 0x4703c
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x470b6
movq 0x18(%rsp), %rdi
leaq 0x96b9e(%rip), %rsi     # 0xddbf3
callq 0x190a0
cmpl $0x0, %eax
jne 0x4706e
jmp 0x47061
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x470b6
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 0x8a938(%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 0x470c3
jmp 0x46fc5
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: checkcommandpoolresetflags
static VkFlags checkcommandpoolresetflags(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_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT, "release resources");
#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 0x471de
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 0x96a44(%rip), %rsi     # 0xddbbc
callq 0x190a0
cmpl $0x0, %eax
jne 0x47191
jmp 0x47184
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x471d9
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 0x8a815(%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 0x471e6
jmp 0x47135
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: pushcommandpoolcreateflags
static int pushcommandpoolcreateflags(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_COMMAND_POOL_CREATE_TRANSIENT_BIT, "transient");
    CASE(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, "reset command buffer");
    CASE(VK_COMMAND_POOL_CREATE_PROTECTED_BIT, "protected");
#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 0x4722d
movq 0x10(%rsp), %rdi
leaq 0x969e7(%rip), %rsi     # 0xddc04
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4722f
jmp 0x47231
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x47259
movq 0x10(%rsp), %rdi
leaq 0x969c5(%rip), %rsi     # 0xddc0e
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4725b
jmp 0x4725d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x47285
movq 0x10(%rsp), %rdi
leaq 0xa285e(%rip), %rsi     # 0xe9ad3
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x47287
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkcommandpoolcreateflags
static VkFlags checkcommandpoolcreateflags(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_COMMAND_POOL_CREATE_TRANSIENT_BIT, "transient");
    CASE(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, "reset command buffer");
    CASE(VK_COMMAND_POOL_CREATE_PROTECTED_BIT, "protected");
#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 0x4739b
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 0x9691c(%rip), %rsi     # 0xddc04
callq 0x190a0
cmpl $0x0, %eax
jne 0x47304
jmp 0x472f4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x47396
movq 0x18(%rsp), %rdi
leaq 0x968fe(%rip), %rsi     # 0xddc0e
callq 0x190a0
cmpl $0x0, %eax
jne 0x47329
jmp 0x4731c
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x47396
movq 0x18(%rsp), %rdi
leaq 0xa279e(%rip), %rsi     # 0xe9ad3
callq 0x190a0
cmpl $0x0, %eax
jne 0x4734e
jmp 0x47341
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x47396
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 0x8a658(%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 0x473a3
jmp 0x472a5
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: pushdependencyflags
static int pushdependencyflags(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_DEPENDENCY_BY_REGION_BIT, "by region");
    CASE(VK_DEPENDENCY_DEVICE_GROUP_BIT, "device group");
    CASE(VK_DEPENDENCY_VIEW_LOCAL_BIT, "view local");
#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 0x473ed
movq 0x10(%rsp), %rdi
leaq 0x96846(%rip), %rsi     # 0xddc23
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x473ef
jmp 0x473f1
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x47419
movq 0x10(%rsp), %rdi
leaq 0x96824(%rip), %rsi     # 0xddc2d
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4741b
jmp 0x4741d
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x47445
movq 0x10(%rsp), %rdi
leaq 0x96805(%rip), %rsi     # 0xddc3a
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x47447
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkdependencyflags
static VkFlags checkdependencyflags(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_DEPENDENCY_BY_REGION_BIT, "by region");
    CASE(VK_DEPENDENCY_DEVICE_GROUP_BIT, "device group");
    CASE(VK_DEPENDENCY_VIEW_LOCAL_BIT, "view local");
#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 0x4755b
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 0x9677b(%rip), %rsi     # 0xddc23
callq 0x190a0
cmpl $0x0, %eax
jne 0x474c4
jmp 0x474b4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x47556
movq 0x18(%rsp), %rdi
leaq 0x9675d(%rip), %rsi     # 0xddc2d
callq 0x190a0
cmpl $0x0, %eax
jne 0x474e9
jmp 0x474dc
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x47556
movq 0x18(%rsp), %rdi
leaq 0x96745(%rip), %rsi     # 0xddc3a
callq 0x190a0
cmpl $0x0, %eax
jne 0x4750e
jmp 0x47501
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x47556
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 0x8a498(%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 0x47563
jmp 0x47465
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: checkattachmentdescriptionflags
static VkFlags checkattachmentdescriptionflags(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_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT, "may alias");
#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 0x4824e
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 0x95cd2(%rip), %rsi     # 0xddeba
callq 0x190a0
cmpl $0x0, %eax
jne 0x48201
jmp 0x481f4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x48249
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 0x897a5(%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 0x48256
jmp 0x481a5
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: checkdescriptorpoolcreateflags
static VkFlags checkdescriptorpoolcreateflags(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_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, "free descriptor set");
    CASE(VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT, "update after bind");
#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 0x48393
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 0x95bbc(%rip), %rsi     # 0xddec4
callq 0x190a0
cmpl $0x0, %eax
jne 0x48321
jmp 0x48314
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4838e
movq 0x18(%rsp), %rdi
leaq 0x95bab(%rip), %rsi     # 0xdded8
callq 0x190a0
cmpl $0x0, %eax
jne 0x48346
jmp 0x48339
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x4838e
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 0x89660(%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 0x4839b
jmp 0x482c5
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: checkdescriptorsetlayoutcreateflags
static VkFlags checkdescriptorsetlayoutcreateflags(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_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT, "push descriptor");
        CASE(VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, "update after bind pool");
#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 0x484e3
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 0x95a92(%rip), %rsi     # 0xddeea
callq 0x190a0
cmpl $0x0, %eax
jne 0x48471
jmp 0x48464
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x484de
movq 0x18(%rsp), %rdi
leaq 0x95a7d(%rip), %rsi     # 0xddefa
callq 0x190a0
cmpl $0x0, %eax
jne 0x48496
jmp 0x48489
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x484de
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 0x89510(%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 0x484eb
jmp 0x48415
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: pushcolorcomponentflags
static int pushcolorcomponentflags(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_COLOR_COMPONENT_R_BIT, "r");
    CASE(VK_COLOR_COMPONENT_G_BIT, "g");
    CASE(VK_COLOR_COMPONENT_B_BIT, "b");
    CASE(VK_COLOR_COMPONENT_A_BIT, "a");
#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 0x4853d
movq 0x10(%rsp), %rdi
leaq 0x8d52f(%rip), %rsi     # 0xd5a5c
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4853f
jmp 0x48541
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x48569
movq 0x10(%rsp), %rdi
leaq 0x88392(%rip), %rsi     # 0xd08eb
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4856b
jmp 0x4856d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x48595
movq 0x10(%rsp), %rdi
leaq 0x8dbbd(%rip), %rsi     # 0xd6142
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x48597
jmp 0x48599
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x485c1
movq 0x10(%rsp), %rdi
leaq 0x9d931(%rip), %rsi     # 0xe5ee2
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x485c3
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkcolorcomponentflags
static VkFlags checkcolorcomponentflags(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_COLOR_COMPONENT_R_BIT, "r");
    CASE(VK_COLOR_COMPONENT_G_BIT, "g");
    CASE(VK_COLOR_COMPONENT_B_BIT, "b");
    CASE(VK_COLOR_COMPONENT_A_BIT, "a");
#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 0x48703
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 0x8d434(%rip), %rsi     # 0xd5a5c
callq 0x190a0
cmpl $0x0, %eax
jne 0x48644
jmp 0x48634
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x486fe
movq 0x18(%rsp), %rdi
leaq 0x8829b(%rip), %rsi     # 0xd08eb
callq 0x190a0
cmpl $0x0, %eax
jne 0x4866c
jmp 0x4865c
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x486fe
movq 0x18(%rsp), %rdi
leaq 0x8daca(%rip), %rsi     # 0xd6142
callq 0x190a0
cmpl $0x0, %eax
jne 0x48691
jmp 0x48684
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x486fe
movq 0x18(%rsp), %rdi
leaq 0x9d845(%rip), %rsi     # 0xe5ee2
callq 0x190a0
cmpl $0x0, %eax
jne 0x486b6
jmp 0x486a9
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x486fe
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 0x892f0(%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 0x4870b
jmp 0x485e5
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: pushcullmodeflags
static int pushcullmodeflags(lua_State *L, VkFlags flags)
    {
    int n = 0;

//    if(flags==0) { lua_pushstring(L, "none"); return 1; }

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
//  CASE(VK_CULL_MODE_NONE, "none");
    CASE(VK_CULL_MODE_FRONT_BIT, "front");
    CASE(VK_CULL_MODE_BACK_BIT, "back");
//  CASE(VK_CULL_MODE_FRONT_AND_BACK, "front and back");
#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 0x4875d
movq 0x10(%rsp), %rdi
leaq 0x9545a(%rip), %rsi     # 0xddba7
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4875f
jmp 0x48761
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x48789
movq 0x10(%rsp), %rdi
leaq 0x9543e(%rip), %rsi     # 0xddbb7
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4878b
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkcullmodeflags
static VkFlags checkcullmodeflags(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_CULL_MODE_NONE, "none");
    CASE(VK_CULL_MODE_FRONT_BIT, "front");
    CASE(VK_CULL_MODE_BACK_BIT, "back");
    CASE(VK_CULL_MODE_FRONT_AND_BACK, "front and back");
#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 0x488d3
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 0xa00be(%rip), %rsi     # 0xe88b6
callq 0x190a0
cmpl $0x0, %eax
jne 0x48814
jmp 0x48804
movl 0x14(%rsp), %eax
orl $0x0, %eax
movl %eax, 0x14(%rsp)
jmp 0x488ce
movq 0x18(%rsp), %rdi
leaq 0x95387(%rip), %rsi     # 0xddba7
callq 0x190a0
cmpl $0x0, %eax
jne 0x4883c
jmp 0x4882c
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x488ce
movq 0x18(%rsp), %rdi
leaq 0x9536f(%rip), %rsi     # 0xddbb7
callq 0x190a0
cmpl $0x0, %eax
jne 0x48861
jmp 0x48854
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x488ce
movq 0x18(%rsp), %rdi
leaq 0x95340(%rip), %rsi     # 0xddbad
callq 0x190a0
cmpl $0x0, %eax
jne 0x48886
jmp 0x48879
movl 0x14(%rsp), %eax
orl $0x3, %eax
movl %eax, 0x14(%rsp)
jmp 0x488ce
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 0x89120(%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 0x488db
jmp 0x487b5
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: pushbuffercreateflags
static int pushbuffercreateflags(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_BUFFER_CREATE_SPARSE_BINDING_BIT, "sparse binding");
    CASE(VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, "sparse residency");
    CASE(VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, "sparse aliased");
    CASE(VK_BUFFER_CREATE_PROTECTED_BIT, "protected");
    CASE(VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, "device address capture replay");
#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 0x49b7d
movq 0x10(%rsp), %rdi
leaq 0x946cf(%rip), %rsi     # 0xde23c
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x49b7f
jmp 0x49b81
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x49ba9
movq 0x10(%rsp), %rdi
leaq 0x946b2(%rip), %rsi     # 0xde24b
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x49bab
jmp 0x49bad
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x49bd5
movq 0x10(%rsp), %rdi
leaq 0x94697(%rip), %rsi     # 0xde25c
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x49bd7
jmp 0x49bd9
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x49c01
movq 0x10(%rsp), %rdi
leaq 0x9fee2(%rip), %rsi     # 0xe9ad3
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x49c03
jmp 0x49c05
movl 0xc(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x49c2d
movq 0x10(%rsp), %rdi
leaq 0x9464e(%rip), %rsi     # 0xde26b
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x49c2f
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkbuffercreateflags
static VkFlags checkbuffercreateflags(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_BUFFER_CREATE_SPARSE_BINDING_BIT, "sparse binding");
    CASE(VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, "sparse residency");
    CASE(VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, "sparse aliased");
    CASE(VK_BUFFER_CREATE_PROTECTED_BIT, "protected");
    CASE(VK_BUFFER_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 0x49d9b
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 0x945a4(%rip), %rsi     # 0xde23c
callq 0x190a0
cmpl $0x0, %eax
jne 0x49cb4
jmp 0x49ca4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x49d96
movq 0x18(%rsp), %rdi
leaq 0x9458b(%rip), %rsi     # 0xde24b
callq 0x190a0
cmpl $0x0, %eax
jne 0x49cdc
jmp 0x49ccc
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x49d96
movq 0x18(%rsp), %rdi
leaq 0x94574(%rip), %rsi     # 0xde25c
callq 0x190a0
cmpl $0x0, %eax
jne 0x49d04
jmp 0x49cf4
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x49d96
movq 0x18(%rsp), %rdi
leaq 0x9fdc3(%rip), %rsi     # 0xe9ad3
callq 0x190a0
cmpl $0x0, %eax
jne 0x49d29
jmp 0x49d1c
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x49d96
movq 0x18(%rsp), %rdi
leaq 0x94536(%rip), %rsi     # 0xde26b
callq 0x190a0
cmpl $0x0, %eax
jne 0x49d4e
jmp 0x49d41
movl 0x14(%rsp), %eax
orl $0x10, %eax
movl %eax, 0x14(%rsp)
jmp 0x49d96
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 0x87c58(%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 0x49da3
jmp 0x49c55
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: pushqueryresultflags
static int pushqueryresultflags(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_QUERY_RESULT_64_BIT, "64");
    CASE(VK_QUERY_RESULT_WAIT_BIT, "wait");
    CASE(VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, "with availability");
    CASE(VK_QUERY_RESULT_PARTIAL_BIT, "partial");
#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 0x49ded
movq 0x10(%rsp), %rdi
leaq 0x8efb2(%rip), %rsi     # 0xd8d8f
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x49def
jmp 0x49df1
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x49e19
movq 0x10(%rsp), %rdi
leaq 0x9d212(%rip), %rsi     # 0xe701b
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x49e1b
jmp 0x49e1d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x49e45
movq 0x10(%rsp), %rdi
leaq 0x94454(%rip), %rsi     # 0xde289
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x49e47
jmp 0x49e49
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x49e71
movq 0x10(%rsp), %rdi
leaq 0x9443a(%rip), %rsi     # 0xde29b
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x49e73
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkqueryresultflags
static VkFlags checkqueryresultflags(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_QUERY_RESULT_64_BIT, "64");
    CASE(VK_QUERY_RESULT_WAIT_BIT, "wait");
    CASE(VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, "with availability");
    CASE(VK_QUERY_RESULT_PARTIAL_BIT, "partial");
#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 0x49fb3
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 0x8eeb7(%rip), %rsi     # 0xd8d8f
callq 0x190a0
cmpl $0x0, %eax
jne 0x49ef4
jmp 0x49ee4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x49fae
movq 0x18(%rsp), %rdi
leaq 0x9d11b(%rip), %rsi     # 0xe701b
callq 0x190a0
cmpl $0x0, %eax
jne 0x49f1c
jmp 0x49f0c
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x49fae
movq 0x18(%rsp), %rdi
leaq 0x94361(%rip), %rsi     # 0xde289
callq 0x190a0
cmpl $0x0, %eax
jne 0x49f41
jmp 0x49f34
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x49fae
movq 0x18(%rsp), %rdi
leaq 0x9434e(%rip), %rsi     # 0xde29b
callq 0x190a0
cmpl $0x0, %eax
jne 0x49f66
jmp 0x49f59
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x49fae
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 0x87a40(%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 0x49fbb
jmp 0x49e95
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: checkfencecreateflags
static VkFlags checkfencecreateflags(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_CREATE_SIGNALED_BIT, "signaled");
#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 0x4a55e
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 0x93edd(%rip), %rsi     # 0xde3d5
callq 0x190a0
cmpl $0x0, %eax
jne 0x4a511
jmp 0x4a504
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4a559
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 0x87495(%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 0x4a566
jmp 0x4a4b5
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: checksparsememorybindflags
static VkFlags checksparsememorybindflags(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_SPARSE_MEMORY_BIND_METADATA_BIT, "metadata");
#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 0x4a67e
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 0x99203(%rip), %rsi     # 0xe381b
callq 0x190a0
cmpl $0x0, %eax
jne 0x4a631
jmp 0x4a624
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4a679
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 0x87375(%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 0x4a686
jmp 0x4a5d5
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: pushsparseimageformatflags
static int pushsparseimageformatflags(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_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT, "single miptail");
    CASE(VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT, "aligned mip size");
    CASE(VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT, "nonstandard block size");
#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 0x4a6cd
movq 0x10(%rsp), %rdi
leaq 0x93d21(%rip), %rsi     # 0xde3de
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4a6cf
jmp 0x4a6d1
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4a6f9
movq 0x10(%rsp), %rdi
leaq 0x93d04(%rip), %rsi     # 0xde3ed
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4a6fb
jmp 0x4a6fd
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4a725
movq 0x10(%rsp), %rdi
leaq 0x93ce9(%rip), %rsi     # 0xde3fe
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4a727
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
// File: stetre[P]moonvulkan/src/flags.c
// Function: checksparseimageformatflags
static VkFlags checksparseimageformatflags(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_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT, "single miptail");
    CASE(VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT, "aligned mip size");
    CASE(VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT, "nonstandard block size");
#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 0x4a83b
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 0x93c56(%rip), %rsi     # 0xde3de
callq 0x190a0
cmpl $0x0, %eax
jne 0x4a7a4
jmp 0x4a794
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4a836
movq 0x18(%rsp), %rdi
leaq 0x93c3d(%rip), %rsi     # 0xde3ed
callq 0x190a0
cmpl $0x0, %eax
jne 0x4a7c9
jmp 0x4a7bc
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x4a836
movq 0x18(%rsp), %rdi
leaq 0x93c29(%rip), %rsi     # 0xde3fe
callq 0x190a0
cmpl $0x0, %eax
jne 0x4a7ee
jmp 0x4a7e1
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x4a836
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 0x871b8(%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 0x4a843
jmp 0x4a745
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: pushmemoryheapflags
static int pushmemoryheapflags(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_MEMORY_HEAP_DEVICE_LOCAL_BIT, "device local");
        CASE(VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, "multi instance");
#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 0x4b95d
movq 0x10(%rsp), %rdi
leaq 0x92cc3(%rip), %rsi     # 0xde610
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4b95f
jmp 0x4b961
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4b989
movq 0x10(%rsp), %rdi
leaq 0x92ca4(%rip), %rsi     # 0xde61d
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4b98b
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkmemoryheapflags
static VkFlags checkmemoryheapflags(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_MEMORY_HEAP_DEVICE_LOCAL_BIT, "device local");
        CASE(VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, "multi instance");
#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 0x4ba83
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 0x92c18(%rip), %rsi     # 0xde610
callq 0x190a0
cmpl $0x0, %eax
jne 0x4ba11
jmp 0x4ba04
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4ba7e
movq 0x18(%rsp), %rdi
leaq 0x92c00(%rip), %rsi     # 0xde61d
callq 0x190a0
cmpl $0x0, %eax
jne 0x4ba36
jmp 0x4ba29
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x4ba7e
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 0x85f70(%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 0x4ba8b
jmp 0x4b9b5
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)