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

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
        CASE(VK_SEMAPHORE_WAIT_ANY_BIT, "any");
#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 0x4ed9e
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 0x8fdef(%rip), %rsi     # 0xdeb27
callq 0x190a0
cmpl $0x0, %eax
jne 0x4ed51
jmp 0x4ed44
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4ed99
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 0x82c55(%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 0x4eda6
jmp 0x4ecf5
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: pushperformancecounterdescriptionflags
static int pushperformancecounterdescriptionflags(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_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT, "performance impacting");
        CASE(VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT, "concurrently impacted");
#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 0x4eded
movq 0x10(%rsp), %rdi
leaq 0x8fd4e(%rip), %rsi     # 0xdeb2b
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4edef
jmp 0x4edf1
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4ee19
movq 0x10(%rsp), %rdi
leaq 0x8fd38(%rip), %rsi     # 0xdeb41
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4ee1b
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkperformancecounterdescriptionflags
static VkFlags checkperformancecounterdescriptionflags(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_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT, "performance impacting");
        CASE(VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT, "concurrently impacted");
#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 0x4ef13
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 0x8fca3(%rip), %rsi     # 0xdeb2b
callq 0x190a0
cmpl $0x0, %eax
jne 0x4eea1
jmp 0x4ee94
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4ef0e
movq 0x18(%rsp), %rdi
leaq 0x8fc94(%rip), %rsi     # 0xdeb41
callq 0x190a0
cmpl $0x0, %eax
jne 0x4eec6
jmp 0x4eeb9
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x4ef0e
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 0x82ae0(%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 0x4ef1b
jmp 0x4ee45
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: checksubmitflags
static VkFlags checksubmitflags(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_SUBMIT_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 0x4f03e
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 0x9aafb(%rip), %rsi     # 0xe9ad3
callq 0x190a0
cmpl $0x0, %eax
jne 0x4eff1
jmp 0x4efe4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f039
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 0x829b5(%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 0x4f046
jmp 0x4ef95
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: pushgeometryflags
static int pushgeometryflags(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_GEOMETRY_OPAQUE_BIT, "opaque");
        CASE(VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT, "no duplicate any hit invocation");
#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 0x4f08d
movq 0x10(%rsp), %rdi
leaq 0x8fb32(%rip), %rsi     # 0xdebaf
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f08f
jmp 0x4f091
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4f0b9
movq 0x10(%rsp), %rdi
leaq 0x8faae(%rip), %rsi     # 0xdeb57
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f0bb
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkgeometryflags
static VkFlags checkgeometryflags(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_GEOMETRY_OPAQUE_BIT, "opaque");
        CASE(VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT, "no duplicate any hit invocation");
#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 0x4f1b3
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 0x8fa87(%rip), %rsi     # 0xdebaf
callq 0x190a0
cmpl $0x0, %eax
jne 0x4f141
jmp 0x4f134
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f1ae
movq 0x18(%rsp), %rdi
leaq 0x8fa0a(%rip), %rsi     # 0xdeb57
callq 0x190a0
cmpl $0x0, %eax
jne 0x4f166
jmp 0x4f159
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f1ae
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 0x82840(%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 0x4f1bb
jmp 0x4f0e5
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: pushgeometryinstanceflags
static int pushgeometryinstanceflags(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_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT, "triangle facing cull disable");
        CASE(VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT, "triangle flip facing");
        CASE(VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT, "force opaque");
        CASE(VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT, "force no opaque");
#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 0x4f20d
movq 0x10(%rsp), %rdi
leaq 0x8f97a(%rip), %rsi     # 0xdeb77
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f20f
jmp 0x4f211
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4f239
movq 0x10(%rsp), %rdi
leaq 0x8f96b(%rip), %rsi     # 0xdeb94
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f23b
jmp 0x4f23d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4f265
movq 0x10(%rsp), %rdi
leaq 0x8f954(%rip), %rsi     # 0xdeba9
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f267
jmp 0x4f269
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4f291
movq 0x10(%rsp), %rdi
leaq 0x8f935(%rip), %rsi     # 0xdebb6
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f293
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkgeometryinstanceflags
static VkFlags checkgeometryinstanceflags(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_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT, "triangle facing cull disable");
        CASE(VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT, "triangle flip facing");
        CASE(VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT, "force opaque");
        CASE(VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT, "force no opaque");
#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 0x4f3d3
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 0x8f87f(%rip), %rsi     # 0xdeb77
callq 0x190a0
cmpl $0x0, %eax
jne 0x4f314
jmp 0x4f304
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f3ce
movq 0x18(%rsp), %rdi
leaq 0x8f874(%rip), %rsi     # 0xdeb94
callq 0x190a0
cmpl $0x0, %eax
jne 0x4f33c
jmp 0x4f32c
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f3ce
movq 0x18(%rsp), %rdi
leaq 0x8f861(%rip), %rsi     # 0xdeba9
callq 0x190a0
cmpl $0x0, %eax
jne 0x4f361
jmp 0x4f354
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f3ce
movq 0x18(%rsp), %rdi
leaq 0x8f849(%rip), %rsi     # 0xdebb6
callq 0x190a0
cmpl $0x0, %eax
jne 0x4f386
jmp 0x4f379
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f3ce
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 0x82620(%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 0x4f3db
jmp 0x4f2b5
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: pushbuildaccelerationstructureflags
static int pushbuildaccelerationstructureflags(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_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT, "allow update");
        CASE(VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT, "allow compaction");
        CASE(VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT, "prefer fast trace");
        CASE(VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT, "prefer fast build");
        CASE(VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT, "low memory");
#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 0x4f42d
movq 0x10(%rsp), %rdi
leaq 0x8f7a9(%rip), %rsi     # 0xdebc6
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f42f
jmp 0x4f431
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4f459
movq 0x10(%rsp), %rdi
leaq 0x8f78a(%rip), %rsi     # 0xdebd3
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f45b
jmp 0x4f45d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4f485
movq 0x10(%rsp), %rdi
leaq 0x8f76f(%rip), %rsi     # 0xdebe4
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f487
jmp 0x4f489
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4f4b1
movq 0x10(%rsp), %rdi
leaq 0x8f755(%rip), %rsi     # 0xdebf6
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f4b3
jmp 0x4f4b5
movl 0xc(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x4f4dd
movq 0x10(%rsp), %rdi
leaq 0x8f73b(%rip), %rsi     # 0xdec08
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f4df
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkbuildaccelerationstructureflags
static VkFlags checkbuildaccelerationstructureflags(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_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT, "allow update");
        CASE(VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT, "allow compaction");
        CASE(VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT, "prefer fast trace");
        CASE(VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT, "prefer fast build");
        CASE(VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT, "low memory");
#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 0x4f64b
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 0x8f67e(%rip), %rsi     # 0xdebc6
callq 0x190a0
cmpl $0x0, %eax
jne 0x4f564
jmp 0x4f554
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f646
movq 0x18(%rsp), %rdi
leaq 0x8f663(%rip), %rsi     # 0xdebd3
callq 0x190a0
cmpl $0x0, %eax
jne 0x4f58c
jmp 0x4f57c
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f646
movq 0x18(%rsp), %rdi
leaq 0x8f64c(%rip), %rsi     # 0xdebe4
callq 0x190a0
cmpl $0x0, %eax
jne 0x4f5b4
jmp 0x4f5a4
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f646
movq 0x18(%rsp), %rdi
leaq 0x8f636(%rip), %rsi     # 0xdebf6
callq 0x190a0
cmpl $0x0, %eax
jne 0x4f5d9
jmp 0x4f5cc
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f646
movq 0x18(%rsp), %rdi
leaq 0x8f623(%rip), %rsi     # 0xdec08
callq 0x190a0
cmpl $0x0, %eax
jne 0x4f5fe
jmp 0x4f5f1
movl 0x14(%rsp), %eax
orl $0x10, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f646
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 0x823a8(%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 0x4f653
jmp 0x4f505
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: pushtoolpurposeflags
static int pushtoolpurposeflags(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_TOOL_PURPOSE_VALIDATION_BIT, "validation");
        CASE(VK_TOOL_PURPOSE_PROFILING_BIT, "profiling");
        CASE(VK_TOOL_PURPOSE_TRACING_BIT, "tracing");
        CASE(VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT, "additional features");
        CASE(VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT, "modifying features");
        CASE(VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT, "debug reporting");
        CASE(VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT, "debug markers");
#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 0x4f69d
movq 0x10(%rsp), %rdi
leaq 0x89156(%rip), %rsi     # 0xd87e3
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f69f
jmp 0x4f6a1
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4f6c9
movq 0x10(%rsp), %rdi
leaq 0x8f55a(%rip), %rsi     # 0xdec13
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f6cb
jmp 0x4f6cd
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4f6f5
movq 0x10(%rsp), %rdi
leaq 0x87996(%rip), %rsi     # 0xd707b
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f6f7
jmp 0x4f6f9
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4f721
movq 0x10(%rsp), %rdi
leaq 0x8f50c(%rip), %rsi     # 0xdec1d
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f723
jmp 0x4f725
movl 0xc(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x4f74d
movq 0x10(%rsp), %rdi
leaq 0x8f4f4(%rip), %rsi     # 0xdec31
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f74f
jmp 0x4f751
movl 0xc(%rsp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x4f779
movq 0x10(%rsp), %rdi
leaq 0x8f4db(%rip), %rsi     # 0xdec44
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f77b
jmp 0x4f77d
movl 0xc(%rsp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x4f7a5
movq 0x10(%rsp), %rdi
leaq 0x8f4bf(%rip), %rsi     # 0xdec54
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f7a7
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
// File: stetre[P]moonvulkan/src/flags.c
// Function: checktoolpurposeflags
static VkFlags checktoolpurposeflags(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_TOOL_PURPOSE_VALIDATION_BIT, "validation");
        CASE(VK_TOOL_PURPOSE_PROFILING_BIT, "profiling");
        CASE(VK_TOOL_PURPOSE_TRACING_BIT, "tracing");
        CASE(VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT, "additional features");
        CASE(VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT, "modifying features");
        CASE(VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT, "debug reporting");
        CASE(VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT, "debug markers");
#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 0x4f95b
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 0x88fdb(%rip), %rsi     # 0xd87e3
callq 0x190a0
cmpl $0x0, %eax
jne 0x4f824
jmp 0x4f814
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f956
movq 0x18(%rsp), %rdi
leaq 0x8f3e3(%rip), %rsi     # 0xdec13
callq 0x190a0
cmpl $0x0, %eax
jne 0x4f84c
jmp 0x4f83c
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f956
movq 0x18(%rsp), %rdi
leaq 0x87823(%rip), %rsi     # 0xd707b
callq 0x190a0
cmpl $0x0, %eax
jne 0x4f874
jmp 0x4f864
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f956
movq 0x18(%rsp), %rdi
leaq 0x8f39d(%rip), %rsi     # 0xdec1d
callq 0x190a0
cmpl $0x0, %eax
jne 0x4f89c
jmp 0x4f88c
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f956
movq 0x18(%rsp), %rdi
leaq 0x8f389(%rip), %rsi     # 0xdec31
callq 0x190a0
cmpl $0x0, %eax
jne 0x4f8c4
jmp 0x4f8b4
movl 0x14(%rsp), %eax
orl $0x10, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f956
movq 0x18(%rsp), %rdi
leaq 0x8f374(%rip), %rsi     # 0xdec44
callq 0x190a0
cmpl $0x0, %eax
jne 0x4f8e9
jmp 0x4f8dc
movl 0x14(%rsp), %eax
orl $0x20, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f956
movq 0x18(%rsp), %rdi
leaq 0x8f35f(%rip), %rsi     # 0xdec54
callq 0x190a0
cmpl $0x0, %eax
jne 0x4f90e
jmp 0x4f901
movl 0x14(%rsp), %eax
orl $0x40, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f956
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 0x82098(%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 0x4f963
jmp 0x4f7c5
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: pushsurfacetransformflags
static int pushsurfacetransformflags(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_SURFACE_TRANSFORM_IDENTITY_BIT, "identity");
    CASE(VK_SURFACE_TRANSFORM_ROTATE_90_BIT, "rotate 90");
    CASE(VK_SURFACE_TRANSFORM_ROTATE_180_BIT, "rotate 180");
    CASE(VK_SURFACE_TRANSFORM_ROTATE_270_BIT, "rotate 270");
    CASE(VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT, "horizontal mirror");
    CASE(VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT, "horizontal mirror rotate 90");
    CASE(VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT, "horizontal mirror rotate 180");
    CASE(VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT, "horizontal mirror rotate 270");
    CASE(VK_SURFACE_TRANSFORM_INHERIT_BIT, "inherit");
#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 0x4f9ad
movq 0x10(%rsp), %rdi
leaq 0x88597(%rip), %rsi     # 0xd7f34
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f9af
jmp 0x4f9b1
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4f9d9
movq 0x10(%rsp), %rdi
leaq 0x8f2bd(%rip), %rsi     # 0xdec86
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f9db
jmp 0x4f9dd
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4fa05
movq 0x10(%rsp), %rdi
leaq 0x8f2ad(%rip), %rsi     # 0xdeca2
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4fa07
jmp 0x4fa09
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4fa31
movq 0x10(%rsp), %rdi
leaq 0x8f29e(%rip), %rsi     # 0xdecbf
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4fa33
jmp 0x4fa35
movl 0xc(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x4fa5d
movq 0x10(%rsp), %rdi
leaq 0x8f215(%rip), %rsi     # 0xdec62
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4fa5f
jmp 0x4fa61
movl 0xc(%rsp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x4fa89
movq 0x10(%rsp), %rdi
leaq 0x8f1fb(%rip), %rsi     # 0xdec74
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4fa8b
jmp 0x4fa8d
movl 0xc(%rsp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x4fab5
movq 0x10(%rsp), %rdi
leaq 0x8f1eb(%rip), %rsi     # 0xdec90
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4fab7
jmp 0x4fab9
movl 0xc(%rsp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x4fae3
movq 0x10(%rsp), %rdi
leaq 0x8f1da(%rip), %rsi     # 0xdecad
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4fae5
jmp 0x4fae7
movl 0xc(%rsp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x4fb11
movq 0x10(%rsp), %rdi
leaq 0x8f1c9(%rip), %rsi     # 0xdecca
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4fb13
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: pushcompositealphaflags
static int pushcompositealphaflags(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_COMPOSITE_ALPHA_OPAQUE_BIT, "opaque");
    CASE(VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT, "pre multiplied");
    CASE(VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT, "post multiplied");
    CASE(VK_COMPOSITE_ALPHA_INHERIT_BIT, "inherit");
#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 0x4fd6d
movq 0x10(%rsp), %rdi
leaq 0x8ee52(%rip), %rsi     # 0xdebaf
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4fd6f
jmp 0x4fd71
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4fd99
movq 0x10(%rsp), %rdi
leaq 0x8ef49(%rip), %rsi     # 0xdecd2
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4fd9b
jmp 0x4fd9d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4fdc5
movq 0x10(%rsp), %rdi
leaq 0x8ef2c(%rip), %rsi     # 0xdece1
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4fdc7
jmp 0x4fdc9
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4fdf1
movq 0x10(%rsp), %rdi
leaq 0x8eee9(%rip), %rsi     # 0xdecca
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4fdf3
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkcompositealphaflags
static VkFlags checkcompositealphaflags(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_COMPOSITE_ALPHA_OPAQUE_BIT, "opaque");
    CASE(VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT, "pre multiplied");
    CASE(VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT, "post multiplied");
    CASE(VK_COMPOSITE_ALPHA_INHERIT_BIT, "inherit");
#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 0x4ff33
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 0x8ed57(%rip), %rsi     # 0xdebaf
callq 0x190a0
cmpl $0x0, %eax
jne 0x4fe74
jmp 0x4fe64
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4ff2e
movq 0x18(%rsp), %rdi
leaq 0x8ee52(%rip), %rsi     # 0xdecd2
callq 0x190a0
cmpl $0x0, %eax
jne 0x4fe9c
jmp 0x4fe8c
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x4ff2e
movq 0x18(%rsp), %rdi
leaq 0x8ee39(%rip), %rsi     # 0xdece1
callq 0x190a0
cmpl $0x0, %eax
jne 0x4fec1
jmp 0x4feb4
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x4ff2e
movq 0x18(%rsp), %rdi
leaq 0x8edfd(%rip), %rsi     # 0xdecca
callq 0x190a0
cmpl $0x0, %eax
jne 0x4fee6
jmp 0x4fed9
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x4ff2e
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 0x81ac0(%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 0x4ff3b
jmp 0x4fe15
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: pushdisplayplanealphaflags
static int pushdisplayplanealphaflags(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_DISPLAY_PLANE_ALPHA_OPAQUE_BIT, "opaque");
    CASE(VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT, "global");
    CASE(VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT, "per pixel");
    CASE(VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT, "per pixel premultiplied");
#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 0x4ff8d
movq 0x10(%rsp), %rdi
leaq 0x8ec32(%rip), %rsi     # 0xdebaf
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4ff8f
jmp 0x4ff91
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4ffb9
movq 0x10(%rsp), %rdi
leaq 0x8ed48(%rip), %rsi     # 0xdecf1
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4ffbb
jmp 0x4ffbd
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4ffe5
movq 0x10(%rsp), %rdi
leaq 0x8ed23(%rip), %rsi     # 0xdecf8
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4ffe7
jmp 0x4ffe9
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x50011
movq 0x10(%rsp), %rdi
leaq 0x8ed01(%rip), %rsi     # 0xded02
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x50013
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkdisplayplanealphaflags
static VkFlags checkdisplayplanealphaflags(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_DISPLAY_PLANE_ALPHA_OPAQUE_BIT, "opaque");
    CASE(VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT, "global");
    CASE(VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT, "per pixel");
    CASE(VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT, "per pixel premultiplied");
#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 0x50153
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 0x8eb37(%rip), %rsi     # 0xdebaf
callq 0x190a0
cmpl $0x0, %eax
jne 0x50094
jmp 0x50084
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x5014e
movq 0x18(%rsp), %rdi
leaq 0x8ec51(%rip), %rsi     # 0xdecf1
callq 0x190a0
cmpl $0x0, %eax
jne 0x500bc
jmp 0x500ac
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x5014e
movq 0x18(%rsp), %rdi
leaq 0x8ec30(%rip), %rsi     # 0xdecf8
callq 0x190a0
cmpl $0x0, %eax
jne 0x500e1
jmp 0x500d4
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x5014e
movq 0x18(%rsp), %rdi
leaq 0x8ec15(%rip), %rsi     # 0xded02
callq 0x190a0
cmpl $0x0, %eax
jne 0x50106
jmp 0x500f9
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x5014e
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 0x818a0(%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 0x5015b
jmp 0x50035
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: pushdebugreportflags
static int pushdebugreportflags(lua_State *L, VkFlags flags)
    {
    int n = 0;

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
    CASE(VK_DEBUG_REPORT_INFORMATION_BIT, "information");
    CASE(VK_DEBUG_REPORT_WARNING_BIT, "warning");
    CASE(VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT, "performance warning");
    CASE(VK_DEBUG_REPORT_ERROR_BIT, "error");
    CASE(VK_DEBUG_REPORT_DEBUG_BIT, "debug");
#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 0x501ad
movq 0x10(%rsp), %rdi
leaq 0x8eb7d(%rip), %rsi     # 0xded1a
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x501af
jmp 0x501b1
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x501d9
movq 0x10(%rsp), %rdi
leaq 0x8eb69(%rip), %rsi     # 0xded32
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x501db
jmp 0x501dd
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x50205
movq 0x10(%rsp), %rdi
leaq 0x8eb31(%rip), %rsi     # 0xded26
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x50207
jmp 0x50209
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x50231
movq 0x10(%rsp), %rdi
leaq 0x93803(%rip), %rsi     # 0xe3a24
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x50233
jmp 0x50235
movl 0xc(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x5025d
movq 0x10(%rsp), %rdi
leaq 0x8eaed(%rip), %rsi     # 0xded3a
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x5025f
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkdebugreportflags
static VkFlags checkdebugreportflags(lua_State *L, int arg)
    {
    const char *s;
    VkFlags flags = 0;

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
    CASE(VK_DEBUG_REPORT_INFORMATION_BIT, "information");
    CASE(VK_DEBUG_REPORT_WARNING_BIT, "warning");
    CASE(VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT, "performance warning");
    CASE(VK_DEBUG_REPORT_ERROR_BIT, "error");
    CASE(VK_DEBUG_REPORT_DEBUG_BIT, "debug");
#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 0x503cb
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 0x8ea52(%rip), %rsi     # 0xded1a
callq 0x190a0
cmpl $0x0, %eax
jne 0x502e4
jmp 0x502d4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x503c6
movq 0x18(%rsp), %rdi
leaq 0x8ea42(%rip), %rsi     # 0xded32
callq 0x190a0
cmpl $0x0, %eax
jne 0x5030c
jmp 0x502fc
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x503c6
movq 0x18(%rsp), %rdi
leaq 0x8ea0e(%rip), %rsi     # 0xded26
callq 0x190a0
cmpl $0x0, %eax
jne 0x50334
jmp 0x50324
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x503c6
movq 0x18(%rsp), %rdi
leaq 0x936e4(%rip), %rsi     # 0xe3a24
callq 0x190a0
cmpl $0x0, %eax
jne 0x50359
jmp 0x5034c
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x503c6
movq 0x18(%rsp), %rdi
leaq 0x8e9d5(%rip), %rsi     # 0xded3a
callq 0x190a0
cmpl $0x0, %eax
jne 0x5037e
jmp 0x50371
movl 0x14(%rsp), %eax
orl $0x10, %eax
movl %eax, 0x14(%rsp)
jmp 0x503c6
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 0x81628(%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 0x503d3
jmp 0x50285
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: checksurfacecounterflags
static VkFlags checksurfacecounterflags(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_SURFACE_COUNTER_VBLANK_BIT, "vblank");
#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 0x504ee
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 0x8e8b8(%rip), %rsi     # 0xded40
callq 0x190a0
cmpl $0x0, %eax
jne 0x504a1
jmp 0x50494
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x504e9
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 0x81505(%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 0x504f6
jmp 0x50445
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: pushexternalmemoryhandletypeflags
static int pushexternalmemoryhandletypeflags(lua_State *L, VkFlags flags)
    {
    int n = 0;

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
    CASE(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, "opaque fd");
    CASE(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, "opaque win32");
    CASE(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, "opaque win32 kmt");
    CASE(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, "d3d11 texture");
    CASE(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, "d3d11 texture kmt");
    CASE(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, "d3d12 heap");
    CASE(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, "d3d12 resource");
#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 0x5053d
movq 0x10(%rsp), %rdi
leaq 0x8e81a(%rip), %rsi     # 0xded47
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x5053f
jmp 0x50541
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x50569
movq 0x10(%rsp), %rdi
leaq 0x8e7f8(%rip), %rsi     # 0xded51
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x5056b
jmp 0x5056d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x50595
movq 0x10(%rsp), %rdi
leaq 0x8e7d9(%rip), %rsi     # 0xded5e
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x50597
jmp 0x50599
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x505c1
movq 0x10(%rsp), %rdi
leaq 0x8e7be(%rip), %rsi     # 0xded6f
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x505c3
jmp 0x505c5
movl 0xc(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x505ed
movq 0x10(%rsp), %rdi
leaq 0x8e7a0(%rip), %rsi     # 0xded7d
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x505ef
jmp 0x505f1
movl 0xc(%rsp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x50619
movq 0x10(%rsp), %rdi
leaq 0x8e786(%rip), %rsi     # 0xded8f
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x5061b
jmp 0x5061d
movl 0xc(%rsp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x50645
movq 0x10(%rsp), %rdi
leaq 0x8e765(%rip), %rsi     # 0xded9a
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x50647
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkexternalmemoryhandletypeflags
static VkFlags checkexternalmemoryhandletypeflags(lua_State *L, int arg)
    {
    const char *s;
    VkFlags flags = 0;

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
    CASE(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, "opaque fd");
    CASE(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, "opaque win32");
    CASE(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, "opaque win32 kmt");
    CASE(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, "d3d11 texture");
    CASE(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, "d3d11 texture kmt");
    CASE(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, "d3d12 heap");
    CASE(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, "d3d12 resource");
#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 0x507fb
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 0x8e69f(%rip), %rsi     # 0xded47
callq 0x190a0
cmpl $0x0, %eax
jne 0x506c4
jmp 0x506b4
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x507f6
movq 0x18(%rsp), %rdi
leaq 0x8e681(%rip), %rsi     # 0xded51
callq 0x190a0
cmpl $0x0, %eax
jne 0x506ec
jmp 0x506dc
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x507f6
movq 0x18(%rsp), %rdi
leaq 0x8e666(%rip), %rsi     # 0xded5e
callq 0x190a0
cmpl $0x0, %eax
jne 0x50714
jmp 0x50704
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x507f6
movq 0x18(%rsp), %rdi
leaq 0x8e64f(%rip), %rsi     # 0xded6f
callq 0x190a0
cmpl $0x0, %eax
jne 0x5073c
jmp 0x5072c
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x507f6
movq 0x18(%rsp), %rdi
leaq 0x8e635(%rip), %rsi     # 0xded7d
callq 0x190a0
cmpl $0x0, %eax
jne 0x50764
jmp 0x50754
movl 0x14(%rsp), %eax
orl $0x10, %eax
movl %eax, 0x14(%rsp)
jmp 0x507f6
movq 0x18(%rsp), %rdi
leaq 0x8e61f(%rip), %rsi     # 0xded8f
callq 0x190a0
cmpl $0x0, %eax
jne 0x50789
jmp 0x5077c
movl 0x14(%rsp), %eax
orl $0x20, %eax
movl %eax, 0x14(%rsp)
jmp 0x507f6
movq 0x18(%rsp), %rdi
leaq 0x8e605(%rip), %rsi     # 0xded9a
callq 0x190a0
cmpl $0x0, %eax
jne 0x507ae
jmp 0x507a1
movl 0x14(%rsp), %eax
orl $0x40, %eax
movl %eax, 0x14(%rsp)
jmp 0x507f6
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 0x811f8(%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 0x50803
jmp 0x50665
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: pushexternalmemoryfeatureflags
static int pushexternalmemoryfeatureflags(lua_State *L, VkFlags flags)
    {
    int n = 0;

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
    CASE(VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, "dedicated only");
    CASE(VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, "exportable");
    CASE(VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, "importable");
#undef CASE

    return n;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5084d
movq 0x10(%rsp), %rdi
leaq 0x8e56c(%rip), %rsi     # 0xdeda9
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x5084f
jmp 0x50851
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x50879
movq 0x10(%rsp), %rdi
leaq 0x8e54f(%rip), %rsi     # 0xdedb8
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x5087b
jmp 0x5087d
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x508a5
movq 0x10(%rsp), %rdi
leaq 0x8e52e(%rip), %rsi     # 0xdedc3
callq 0x1a420
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x508a7
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
// File: stetre[P]moonvulkan/src/flags.c
// Function: checkexternalmemoryfeatureflags
static VkFlags checkexternalmemoryfeatureflags(lua_State *L, int arg)
    {
    const char *s;
    VkFlags flags = 0;

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

    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1a7a0
cmpl $0x0, %eax
je 0x509bb
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 0x8e4a1(%rip), %rsi     # 0xdeda9
callq 0x190a0
cmpl $0x0, %eax
jne 0x50924
jmp 0x50914
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x509b6
movq 0x18(%rsp), %rdi
leaq 0x8e488(%rip), %rsi     # 0xdedb8
callq 0x190a0
cmpl $0x0, %eax
jne 0x50949
jmp 0x5093c
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x509b6
movq 0x18(%rsp), %rdi
leaq 0x8e46e(%rip), %rsi     # 0xdedc3
callq 0x190a0
cmpl $0x0, %eax
jne 0x5096e
jmp 0x50961
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x509b6
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 0x81038(%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 0x509c3
jmp 0x508c5
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)