LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: stetre[P]moonvulkan/src/flags.c
// Function: pushmemorypropertyflags
static int pushmemorypropertyflags(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_PROPERTY_DEVICE_LOCAL_BIT, "device local");
        CASE(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, "host visible");
        CASE(VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, "host coherent");
        CASE(VK_MEMORY_PROPERTY_HOST_CACHED_BIT, "host cached");
        CASE(VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT, "lazily allocated");
        CASE(VK_MEMORY_PROPERTY_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 0x4badd
movq 0x10(%rsp), %rdi
leaq 0x92b43(%rip), %rsi     # 0xde610
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4badf
jmp 0x4bae1
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4bb09
movq 0x10(%rsp), %rdi
leaq 0x92b33(%rip), %rsi     # 0xde62c
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4bb0b
jmp 0x4bb0d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4bb35
movq 0x10(%rsp), %rdi
leaq 0x92b14(%rip), %rsi     # 0xde639
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4bb37
jmp 0x4bb39
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4bb61
movq 0x10(%rsp), %rdi
leaq 0x92af6(%rip), %rsi     # 0xde647
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4bb63
jmp 0x4bb65
movl 0xc(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x4bb8d
movq 0x10(%rsp), %rdi
leaq 0x92ad6(%rip), %rsi     # 0xde653
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4bb8f
jmp 0x4bb91
movl 0xc(%rsp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x4bbb9
movq 0x10(%rsp), %rdi
leaq 0x9df2a(%rip), %rsi     # 0xe9ad3
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4bbbb
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkmemorypropertyflags
static VkFlags checkmemorypropertyflags(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_PROPERTY_DEVICE_LOCAL_BIT, "device local");
        CASE(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, "host visible");
        CASE(VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, "host coherent");
        CASE(VK_MEMORY_PROPERTY_HOST_CACHED_BIT, "host cached");
        CASE(VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT, "lazily allocated");
        CASE(VK_MEMORY_PROPERTY_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 0x4bd53
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 0x929e8(%rip), %rsi     # 0xde610
callq 0x190a0
cmpl $0x0, %eax
jne 0x4bc44
jmp 0x4bc34
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4bd4e
movq 0x18(%rsp), %rdi
leaq 0x929dc(%rip), %rsi     # 0xde62c
callq 0x190a0
cmpl $0x0, %eax
jne 0x4bc6c
jmp 0x4bc5c
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x4bd4e
movq 0x18(%rsp), %rdi
leaq 0x929c1(%rip), %rsi     # 0xde639
callq 0x190a0
cmpl $0x0, %eax
jne 0x4bc94
jmp 0x4bc84
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x4bd4e
movq 0x18(%rsp), %rdi
leaq 0x929a7(%rip), %rsi     # 0xde647
callq 0x190a0
cmpl $0x0, %eax
jne 0x4bcbc
jmp 0x4bcac
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x4bd4e
movq 0x18(%rsp), %rdi
leaq 0x9298b(%rip), %rsi     # 0xde653
callq 0x190a0
cmpl $0x0, %eax
jne 0x4bce1
jmp 0x4bcd4
movl 0x14(%rsp), %eax
orl $0x10, %eax
movl %eax, 0x14(%rsp)
jmp 0x4bd4e
movq 0x18(%rsp), %rdi
leaq 0x9dde6(%rip), %rsi     # 0xe9ad3
callq 0x190a0
cmpl $0x0, %eax
jne 0x4bd06
jmp 0x4bcf9
movl 0x14(%rsp), %eax
orl $0x20, %eax
movl %eax, 0x14(%rsp)
jmp 0x4bd4e
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 0x85ca0(%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 0x4bd5b
jmp 0x4bbe5
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: pushqueueflags
static int pushqueueflags(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_QUEUE_GRAPHICS_BIT, "graphics");
        CASE(VK_QUEUE_COMPUTE_BIT, "compute");
        CASE(VK_QUEUE_TRANSFER_BIT, "transfer");
        CASE(VK_QUEUE_SPARSE_BINDING_BIT, "sparse binding");
        CASE(VK_QUEUE_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 0x4bdad
movq 0x10(%rsp), %rdi
leaq 0x921cc(%rip), %rsi     # 0xddf69
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4bdaf
jmp 0x4bdb1
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4bdd9
movq 0x10(%rsp), %rdi
leaq 0x8b28a(%rip), %rsi     # 0xd7053
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4bddb
jmp 0x4bddd
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4be05
movq 0x10(%rsp), %rdi
leaq 0x92737(%rip), %rsi     # 0xde52c
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4be07
jmp 0x4be09
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4be31
movq 0x10(%rsp), %rdi
leaq 0x9241b(%rip), %rsi     # 0xde23c
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4be33
jmp 0x4be35
movl 0xc(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x4be5d
movq 0x10(%rsp), %rdi
leaq 0x9dc86(%rip), %rsi     # 0xe9ad3
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4be5f
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkqueueflags
static VkFlags checkqueueflags(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_QUEUE_GRAPHICS_BIT, "graphics");
        CASE(VK_QUEUE_COMPUTE_BIT, "compute");
        CASE(VK_QUEUE_TRANSFER_BIT, "transfer");
        CASE(VK_QUEUE_SPARSE_BINDING_BIT, "sparse binding");
        CASE(VK_QUEUE_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 0x4bfcb
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 0x920a1(%rip), %rsi     # 0xddf69
callq 0x190a0
cmpl $0x0, %eax
jne 0x4bee4
jmp 0x4bed4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4bfc6
movq 0x18(%rsp), %rdi
leaq 0x8b163(%rip), %rsi     # 0xd7053
callq 0x190a0
cmpl $0x0, %eax
jne 0x4bf0c
jmp 0x4befc
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x4bfc6
movq 0x18(%rsp), %rdi
leaq 0x92614(%rip), %rsi     # 0xde52c
callq 0x190a0
cmpl $0x0, %eax
jne 0x4bf34
jmp 0x4bf24
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x4bfc6
movq 0x18(%rsp), %rdi
leaq 0x922fc(%rip), %rsi     # 0xde23c
callq 0x190a0
cmpl $0x0, %eax
jne 0x4bf59
jmp 0x4bf4c
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x4bfc6
movq 0x18(%rsp), %rdi
leaq 0x9db6e(%rip), %rsi     # 0xe9ad3
callq 0x190a0
cmpl $0x0, %eax
jne 0x4bf7e
jmp 0x4bf71
movl 0x14(%rsp), %eax
orl $0x10, %eax
movl %eax, 0x14(%rsp)
jmp 0x4bfc6
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 0x85a28(%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 0x4bfd3
jmp 0x4be85
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: pushsamplecountflags
static int pushsamplecountflags(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_SAMPLE_COUNT_1_BIT, "1");
        CASE(VK_SAMPLE_COUNT_2_BIT, "2");
        CASE(VK_SAMPLE_COUNT_4_BIT, "4");
        CASE(VK_SAMPLE_COUNT_8_BIT, "8");
        CASE(VK_SAMPLE_COUNT_16_BIT, "16");
        CASE(VK_SAMPLE_COUNT_32_BIT, "32");
        CASE(VK_SAMPLE_COUNT_64_BIT, "64");
#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 0x4c01d
movq 0x10(%rsp), %rdi
leaq 0x9242c(%rip), %rsi     # 0xde439
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4c01f
jmp 0x4c021
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4c049
movq 0x10(%rsp), %rdi
leaq 0x9240f(%rip), %rsi     # 0xde448
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4c04b
jmp 0x4c04d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4c075
movq 0x10(%rsp), %rdi
leaq 0x8cd2b(%rip), %rsi     # 0xd8d90
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4c077
jmp 0x4c079
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4c0a1
movq 0x10(%rsp), %rdi
leaq 0x86056(%rip), %rsi     # 0xd20e7
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4c0a3
jmp 0x4c0a5
movl 0xc(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x4c0cd
movq 0x10(%rsp), %rdi
leaq 0x88297(%rip), %rsi     # 0xd4354
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4c0cf
jmp 0x4c0d1
movl 0xc(%rsp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x4c0f9
movq 0x10(%rsp), %rdi
leaq 0x867db(%rip), %rsi     # 0xd28c4
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4c0fb
jmp 0x4c0fd
movl 0xc(%rsp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x4c125
movq 0x10(%rsp), %rdi
leaq 0x8cc7a(%rip), %rsi     # 0xd8d8f
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4c127
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
// File: stetre[P]moonvulkan/src/flags.c
// Function: checksamplecountflags
static VkFlags checksamplecountflags(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_SAMPLE_COUNT_1_BIT, "1");
        CASE(VK_SAMPLE_COUNT_2_BIT, "2");
        CASE(VK_SAMPLE_COUNT_4_BIT, "4");
        CASE(VK_SAMPLE_COUNT_8_BIT, "8");
        CASE(VK_SAMPLE_COUNT_16_BIT, "16");
        CASE(VK_SAMPLE_COUNT_32_BIT, "32");
        CASE(VK_SAMPLE_COUNT_64_BIT, "64");
#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 0x4c2db
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 0x922b1(%rip), %rsi     # 0xde439
callq 0x190a0
cmpl $0x0, %eax
jne 0x4c1a4
jmp 0x4c194
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4c2d6
movq 0x18(%rsp), %rdi
leaq 0x92298(%rip), %rsi     # 0xde448
callq 0x190a0
cmpl $0x0, %eax
jne 0x4c1cc
jmp 0x4c1bc
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x4c2d6
movq 0x18(%rsp), %rdi
leaq 0x8cbb8(%rip), %rsi     # 0xd8d90
callq 0x190a0
cmpl $0x0, %eax
jne 0x4c1f4
jmp 0x4c1e4
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x4c2d6
movq 0x18(%rsp), %rdi
leaq 0x85ee7(%rip), %rsi     # 0xd20e7
callq 0x190a0
cmpl $0x0, %eax
jne 0x4c21c
jmp 0x4c20c
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x4c2d6
movq 0x18(%rsp), %rdi
leaq 0x8812c(%rip), %rsi     # 0xd4354
callq 0x190a0
cmpl $0x0, %eax
jne 0x4c244
jmp 0x4c234
movl 0x14(%rsp), %eax
orl $0x10, %eax
movl %eax, 0x14(%rsp)
jmp 0x4c2d6
movq 0x18(%rsp), %rdi
leaq 0x86674(%rip), %rsi     # 0xd28c4
callq 0x190a0
cmpl $0x0, %eax
jne 0x4c269
jmp 0x4c25c
movl 0x14(%rsp), %eax
orl $0x20, %eax
movl %eax, 0x14(%rsp)
jmp 0x4c2d6
movq 0x18(%rsp), %rdi
leaq 0x8cb1a(%rip), %rsi     # 0xd8d8f
callq 0x190a0
cmpl $0x0, %eax
jne 0x4c28e
jmp 0x4c281
movl 0x14(%rsp), %eax
orl $0x40, %eax
movl %eax, 0x14(%rsp)
jmp 0x4c2d6
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 0x85718(%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 0x4c2e3
jmp 0x4c145
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: pushimageusageflags
static int pushimageusageflags(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_IMAGE_USAGE_TRANSFER_SRC_BIT, "transfer src");
        CASE(VK_IMAGE_USAGE_TRANSFER_DST_BIT, "transfer dst");
        CASE(VK_IMAGE_USAGE_SAMPLED_BIT, "sampled");
        CASE(VK_IMAGE_USAGE_STORAGE_BIT, "storage");
        CASE(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, "color attachment");
        CASE(VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, "depth stencil attachment");
        CASE(VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, "transient attachment");
        CASE(VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, "input attachment");
        CASE(VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT, "fragment density map");
#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 0x4c8bd
movq 0x10(%rsp), %rdi
leaq 0x9188f(%rip), %rsi     # 0xde13c
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4c8bf
jmp 0x4c8c1
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4c8e9
movq 0x10(%rsp), %rdi
leaq 0x91870(%rip), %rsi     # 0xde149
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4c8eb
jmp 0x4c8ed
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4c915
movq 0x10(%rsp), %rdi
leaq 0x91dfe(%rip), %rsi     # 0xde703
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4c917
jmp 0x4c919
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4c941
movq 0x10(%rsp), %rdi
leaq 0x918ee(%rip), %rsi     # 0xde21f
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4c943
jmp 0x4c945
movl 0xc(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x4c96d
movq 0x10(%rsp), %rdi
leaq 0x91dae(%rip), %rsi     # 0xde70b
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4c96f
jmp 0x4c971
movl 0xc(%rsp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x4c999
movq 0x10(%rsp), %rdi
leaq 0x91d93(%rip), %rsi     # 0xde71c
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4c99b
jmp 0x4c99d
movl 0xc(%rsp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x4c9c5
movq 0x10(%rsp), %rdi
leaq 0x91d80(%rip), %rsi     # 0xde735
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4c9c7
jmp 0x4c9c9
movl 0xc(%rsp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x4c9f3
movq 0x10(%rsp), %rdi
leaq 0x8a4dd(%rip), %rsi     # 0xd6ec0
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4c9f5
jmp 0x4c9f7
movl 0xc(%rsp), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x4ca21
movq 0x10(%rsp), %rdi
leaq 0x91d39(%rip), %rsi     # 0xde74a
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4ca23
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkdevicequeuecreateflags
static VkFlags checkdevicequeuecreateflags(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_QUEUE_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 0x4d91e
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 0x9c21b(%rip), %rsi     # 0xe9ad3
callq 0x190a0
cmpl $0x0, %eax
jne 0x4d8d1
jmp 0x4d8c4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4d919
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 0x840d5(%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 0x4d926
jmp 0x4d875
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: pushsubgroupfeatureflags
static int pushsubgroupfeatureflags(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_SUBGROUP_FEATURE_BASIC_BIT, "basic");
        CASE(VK_SUBGROUP_FEATURE_VOTE_BIT, "vote");
        CASE(VK_SUBGROUP_FEATURE_ARITHMETIC_BIT, "arithmetic");
        CASE(VK_SUBGROUP_FEATURE_BALLOT_BIT, "ballot");
        CASE(VK_SUBGROUP_FEATURE_SHUFFLE_BIT, "shuffle");
        CASE(VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT, "shuffle relative");
        CASE(VK_SUBGROUP_FEATURE_CLUSTERED_BIT, "clustered");
        CASE(VK_SUBGROUP_FEATURE_QUAD_BIT, "quad");
#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 0x4d96d
movq 0x10(%rsp), %rdi
leaq 0x9104c(%rip), %rsi     # 0xde9a9
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4d96f
jmp 0x4d971
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4d999
movq 0x10(%rsp), %rdi
leaq 0x91026(%rip), %rsi     # 0xde9af
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4d99b
jmp 0x4d99d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4d9c5
movq 0x10(%rsp), %rdi
leaq 0x90fff(%rip), %rsi     # 0xde9b4
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4d9c7
jmp 0x4d9c9
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4d9f1
movq 0x10(%rsp), %rdi
leaq 0x90fde(%rip), %rsi     # 0xde9bf
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4d9f3
jmp 0x4d9f5
movl 0xc(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x4da1d
movq 0x10(%rsp), %rdi
leaq 0x90fb9(%rip), %rsi     # 0xde9c6
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4da1f
jmp 0x4da21
movl 0xc(%rsp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x4da49
movq 0x10(%rsp), %rdi
leaq 0x90f95(%rip), %rsi     # 0xde9ce
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4da4b
jmp 0x4da4d
movl 0xc(%rsp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x4da75
movq 0x10(%rsp), %rdi
leaq 0x90f7a(%rip), %rsi     # 0xde9df
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4da77
jmp 0x4da79
movl 0xc(%rsp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x4daa3
movq 0x10(%rsp), %rdi
leaq 0x90f56(%rip), %rsi     # 0xde9e9
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4daa5
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/flags.c
// Function: pushpeermemoryfeatureflags
static int pushpeermemoryfeatureflags(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_PEER_MEMORY_FEATURE_COPY_SRC_BIT, "copy src");
        CASE(VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, "copy dst");
        CASE(VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, "generic src");
        CASE(VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT, "generic dst");
#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 0x4dcdd
movq 0x10(%rsp), %rdi
leaq 0x90d21(%rip), %rsi     # 0xde9ee
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4dcdf
jmp 0x4dce1
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4dd09
movq 0x10(%rsp), %rdi
leaq 0x90cfe(%rip), %rsi     # 0xde9f7
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4dd0b
jmp 0x4dd0d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4dd35
movq 0x10(%rsp), %rdi
leaq 0x90cdb(%rip), %rsi     # 0xdea00
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4dd37
jmp 0x4dd39
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4dd61
movq 0x10(%rsp), %rdi
leaq 0x90cbb(%rip), %rsi     # 0xdea0c
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4dd63
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkpeermemoryfeatureflags
static VkFlags checkpeermemoryfeatureflags(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_PEER_MEMORY_FEATURE_COPY_SRC_BIT, "copy src");
        CASE(VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, "copy dst");
        CASE(VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, "generic src");
        CASE(VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT, "generic dst");
#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 0x4dea3
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 0x90c26(%rip), %rsi     # 0xde9ee
callq 0x190a0
cmpl $0x0, %eax
jne 0x4dde4
jmp 0x4ddd4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4de9e
movq 0x18(%rsp), %rdi
leaq 0x90c07(%rip), %rsi     # 0xde9f7
callq 0x190a0
cmpl $0x0, %eax
jne 0x4de0c
jmp 0x4ddfc
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x4de9e
movq 0x18(%rsp), %rdi
leaq 0x90be8(%rip), %rsi     # 0xdea00
callq 0x190a0
cmpl $0x0, %eax
jne 0x4de31
jmp 0x4de24
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x4de9e
movq 0x18(%rsp), %rdi
leaq 0x90bcf(%rip), %rsi     # 0xdea0c
callq 0x190a0
cmpl $0x0, %eax
jne 0x4de56
jmp 0x4de49
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x4de9e
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 0x83b50(%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 0x4deab
jmp 0x4dd85
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: pushmemoryallocateflags
static int pushmemoryallocateflags(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_ALLOCATE_DEVICE_MASK_BIT, "device mask");
        CASE(VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT, "device address");
        CASE(VK_MEMORY_ALLOCATE_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 0x4defd
movq 0x10(%rsp), %rdi
leaq 0x90b2b(%rip), %rsi     # 0xdea18
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4deff
jmp 0x4df01
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4df29
movq 0x10(%rsp), %rdi
leaq 0x902b3(%rip), %rsi     # 0xde1cc
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4df2b
jmp 0x4df2d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4df55
movq 0x10(%rsp), %rdi
leaq 0x90326(%rip), %rsi     # 0xde26b
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4df57
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkmemoryallocateflags
static VkFlags checkmemoryallocateflags(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_ALLOCATE_DEVICE_MASK_BIT, "device mask");
        CASE(VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT, "device address");
        CASE(VK_MEMORY_ALLOCATE_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 0x4e06b
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 0x90a60(%rip), %rsi     # 0xdea18
callq 0x190a0
cmpl $0x0, %eax
jne 0x4dfd4
jmp 0x4dfc4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4e066
movq 0x18(%rsp), %rdi
leaq 0x901ec(%rip), %rsi     # 0xde1cc
callq 0x190a0
cmpl $0x0, %eax
jne 0x4dff9
jmp 0x4dfec
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x4e066
movq 0x18(%rsp), %rdi
leaq 0x90266(%rip), %rsi     # 0xde26b
callq 0x190a0
cmpl $0x0, %eax
jne 0x4e01e
jmp 0x4e011
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x4e066
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 0x83988(%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 0x4e073
jmp 0x4df75
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: pushimageviewcreateflags
static int pushimageviewcreateflags(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_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT, "fragment density map dynamic");
    CASE(VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT, "fragment density map deferred");
#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 0x4e0bd
movq 0x10(%rsp), %rdi
leaq 0x90977(%rip), %rsi     # 0xdea24
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4e0bf
jmp 0x4e0c1
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4e0e9
movq 0x10(%rsp), %rdi
leaq 0x90968(%rip), %rsi     # 0xdea41
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4e0eb
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkimageviewcreateflags
static VkFlags checkimageviewcreateflags(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_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT, "fragment density map dynamic");
    CASE(VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT, "fragment density map deferred");
#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 0x4e1e3
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 0x908cc(%rip), %rsi     # 0xdea24
callq 0x190a0
cmpl $0x0, %eax
jne 0x4e171
jmp 0x4e164
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4e1de
movq 0x18(%rsp), %rdi
leaq 0x908c4(%rip), %rsi     # 0xdea41
callq 0x190a0
cmpl $0x0, %eax
jne 0x4e196
jmp 0x4e189
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x4e1de
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 0x83810(%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 0x4e1eb
jmp 0x4e115
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: pushsamplercreateflags
static int pushsamplercreateflags(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_SAMPLER_CREATE_SUBSAMPLED_BIT, "subsampled");
    CASE(VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT, "subsampled coarse reconstruction");
#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 0x4e23d
movq 0x10(%rsp), %rdi
leaq 0x904d3(%rip), %rsi     # 0xde700
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4e23f
jmp 0x4e241
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4e269
movq 0x10(%rsp), %rdi
leaq 0x90806(%rip), %rsi     # 0xdea5f
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4e26b
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checksamplercreateflags
static VkFlags checksamplercreateflags(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_SAMPLER_CREATE_SUBSAMPLED_BIT, "subsampled");
    CASE(VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT, "subsampled coarse reconstruction");
#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 0x4e363
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 0x90428(%rip), %rsi     # 0xde700
callq 0x190a0
cmpl $0x0, %eax
jne 0x4e2f1
jmp 0x4e2e4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4e35e
movq 0x18(%rsp), %rdi
leaq 0x90762(%rip), %rsi     # 0xdea5f
callq 0x190a0
cmpl $0x0, %eax
jne 0x4e316
jmp 0x4e309
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x4e35e
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 0x83690(%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 0x4e36b
jmp 0x4e295
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: pushresolvemodeflags
static int pushresolvemodeflags(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_RESOLVE_MODE_NONE, "none");
    CASE(VK_RESOLVE_MODE_SAMPLE_ZERO_BIT, "sample zero");
    CASE(VK_RESOLVE_MODE_AVERAGE_BIT, "average");
    CASE(VK_RESOLVE_MODE_MIN_BIT, "min");
    CASE(VK_RESOLVE_MODE_MAX_BIT, "max");
#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 $0x0, %eax
cmpl $0x0, %eax
je 0x4e4dd
movq 0x10(%rsp), %rdi
leaq 0x9a3e9(%rip), %rsi     # 0xe88b6
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4e4df
jmp 0x4e4e1
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4e509
movq 0x10(%rsp), %rdi
leaq 0x90591(%rip), %rsi     # 0xdea8a
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4e50b
jmp 0x4e50d
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4e535
movq 0x10(%rsp), %rdi
leaq 0x8987b(%rip), %rsi     # 0xd7da0
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4e537
jmp 0x4e539
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4e561
movq 0x10(%rsp), %rdi
leaq 0x87997(%rip), %rsi     # 0xd5ee8
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4e563
jmp 0x4e565
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4e58d
movq 0x10(%rsp), %rdi
leaq 0x99156(%rip), %rsi     # 0xe76d3
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4e58f
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkresolvemodeflags
static VkFlags checkresolvemodeflags(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_RESOLVE_MODE_NONE, "none");
    CASE(VK_RESOLVE_MODE_SAMPLE_ZERO_BIT, "sample zero");
    CASE(VK_RESOLVE_MODE_AVERAGE_BIT, "average");
    CASE(VK_RESOLVE_MODE_MIN_BIT, "min");
    CASE(VK_RESOLVE_MODE_MAX_BIT, "max");
#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 0x4e6fb
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 0x9a2be(%rip), %rsi     # 0xe88b6
callq 0x190a0
cmpl $0x0, %eax
jne 0x4e614
jmp 0x4e604
movl 0x14(%rsp), %eax
orl $0x0, %eax
movl %eax, 0x14(%rsp)
jmp 0x4e6f6
movq 0x18(%rsp), %rdi
leaq 0x9046a(%rip), %rsi     # 0xdea8a
callq 0x190a0
cmpl $0x0, %eax
jne 0x4e63c
jmp 0x4e62c
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4e6f6
movq 0x18(%rsp), %rdi
leaq 0x89758(%rip), %rsi     # 0xd7da0
callq 0x190a0
cmpl $0x0, %eax
jne 0x4e664
jmp 0x4e654
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x4e6f6
movq 0x18(%rsp), %rdi
leaq 0x87878(%rip), %rsi     # 0xd5ee8
callq 0x190a0
cmpl $0x0, %eax
jne 0x4e689
jmp 0x4e67c
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x4e6f6
movq 0x18(%rsp), %rdi
leaq 0x9903e(%rip), %rsi     # 0xe76d3
callq 0x190a0
cmpl $0x0, %eax
jne 0x4e6ae
jmp 0x4e6a1
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x4e6f6
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 0x832f8(%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 0x4e703
jmp 0x4e5b5
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: pushpipelinecreationfeedbackflags
static int pushpipelinecreationfeedbackflags(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_PIPELINE_CREATION_FEEDBACK_VALID_BIT, "valid");
    CASE(VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT, "application pipeline cache hit");
    CASE(VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT, "base pipeline acceleration");
#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 0x4e74d
movq 0x10(%rsp), %rdi
leaq 0x994bf(%rip), %rsi     # 0xe7bfc
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4e74f
jmp 0x4e751
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4e779
movq 0x10(%rsp), %rdi
leaq 0x9032d(%rip), %rsi     # 0xdea96
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4e77b
jmp 0x4e77d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4e7a5
movq 0x10(%rsp), %rdi
leaq 0x90320(%rip), %rsi     # 0xdeab5
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4e7a7
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkpipelinecreationfeedbackflags
static VkFlags checkpipelinecreationfeedbackflags(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_PIPELINE_CREATION_FEEDBACK_VALID_BIT, "valid");
    CASE(VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT, "application pipeline cache hit");
    CASE(VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT, "base pipeline acceleration");
#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 0x4e8bb
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 0x993f4(%rip), %rsi     # 0xe7bfc
callq 0x190a0
cmpl $0x0, %eax
jne 0x4e824
jmp 0x4e814
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4e8b6
movq 0x18(%rsp), %rdi
leaq 0x90266(%rip), %rsi     # 0xdea96
callq 0x190a0
cmpl $0x0, %eax
jne 0x4e849
jmp 0x4e83c
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x4e8b6
movq 0x18(%rsp), %rdi
leaq 0x90260(%rip), %rsi     # 0xdeab5
callq 0x190a0
cmpl $0x0, %eax
jne 0x4e86e
jmp 0x4e861
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x4e8b6
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 0x83138(%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 0x4e8c3
jmp 0x4e7c5
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: checkeventcreateflags
static VkFlags checkeventcreateflags(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_EVENT_CREATE_DEVICE_ONLY_BIT, "device only");
#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 0x4e9de
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 0x90158(%rip), %rsi     # 0xdead0
callq 0x190a0
cmpl $0x0, %eax
jne 0x4e991
jmp 0x4e984
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4e9d9
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 0x83015(%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 0x4e9e6
jmp 0x4e935
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: checkpipelinecachecreateflags
static VkFlags checkpipelinecachecreateflags(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_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, "externally synchronized");
#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 0x4eafe
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 0x90044(%rip), %rsi     # 0xdeadc
callq 0x190a0
cmpl $0x0, %eax
jne 0x4eab1
jmp 0x4eaa4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4eaf9
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 0x82ef5(%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 0x4eb06
jmp 0x4ea55
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: pushpipelineshaderstagecreateflags
static int pushpipelineshaderstagecreateflags(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_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT, "allow varying subgroup size");
        CASE(VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT, "require full subgroups");
#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 0x4eb4d
movq 0x10(%rsp), %rdi
leaq 0x8ffb7(%rip), %rsi     # 0xdeaf4
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4eb4f
jmp 0x4eb51
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4eb79
movq 0x10(%rsp), %rdi
leaq 0x8ffa7(%rip), %rsi     # 0xdeb10
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4eb7b
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkpipelineshaderstagecreateflags
static VkFlags checkpipelineshaderstagecreateflags(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_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT, "allow varying subgroup size");
        CASE(VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT, "require full subgroups");
#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 0x4ec73
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 0x8ff0c(%rip), %rsi     # 0xdeaf4
callq 0x190a0
cmpl $0x0, %eax
jne 0x4ec01
jmp 0x4ebf4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4ec6e
movq 0x18(%rsp), %rdi
leaq 0x8ff03(%rip), %rsi     # 0xdeb10
callq 0x190a0
cmpl $0x0, %eax
jne 0x4ec26
jmp 0x4ec19
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x4ec6e
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 0x82d80(%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 0x4ec7b
jmp 0x4eba5
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)