LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: QueryControlFlags
static int QueryControlFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushquerycontrolflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkquerycontrolflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x39bb2
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x39c38
leaq 0x6aa33(%rip), %rsi     # 0xa45d8
movq %rbx, %rdi
callq 0x1a300
jmp 0x39c33
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
testl %eax, %eax
je 0x39c04
leaq 0x6aa09(%rip), %r14     # 0xa45d8
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x19000
testl %eax, %eax
jne 0x39c08
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x39bcf
movl $0x1, %esi
jmp 0x39c2b
xorl %esi, %esi
jmp 0x39c2b
leaq 0x57dd7(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: CommandBufferUsageFlags
static int CommandBufferUsageFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushcommandbufferusageflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkcommandbufferusageflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x39cc3
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x39c8c
leaq 0x63f65(%rip), %rsi     # 0x9dbe4
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x39ca3
leaq 0x63f5b(%rip), %rsi     # 0x9dbf4
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x4, %r14b
je 0x39d8a
leaq 0x63f55(%rip), %rsi     # 0x9dc09
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x39d8a
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x39d7a
leaq 0x63efd(%rip), %r15     # 0x9dbe4
leaq 0x63f06(%rip), %r12     # 0x9dbf4
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x39d35
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x39d3c
movq %r13, %rdi
leaq 0x63ee4(%rip), %rsi     # 0x9dc09
callq 0x19000
movl $0x4, %ecx
testl %eax, %eax
je 0x39d41
jmp 0x39d56
movl $0x1, %ecx
jmp 0x39d41
movl $0x2, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x39cee
jmp 0x39d7a
leaq 0x57c89(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: CommandPoolResetFlags
static int CommandPoolResetFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushcommandpoolresetflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkcommandpoolresetflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x39de3
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x39e69
leaq 0x63dfc(%rip), %rsi     # 0x9dbd2
movq %rbx, %rdi
callq 0x1a300
jmp 0x39e64
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
testl %eax, %eax
je 0x39e35
leaq 0x63dd2(%rip), %r14     # 0x9dbd2
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x19000
testl %eax, %eax
jne 0x39e39
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x39e00
movl $0x1, %esi
jmp 0x39e5c
xorl %esi, %esi
jmp 0x39e5c
leaq 0x57ba6(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: CommandPoolCreateFlags
static int CommandPoolCreateFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushcommandpoolcreateflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkcommandpoolcreateflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x39ef4
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x39ebd
leaq 0x63d6a(%rip), %rsi     # 0x9dc1a
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x39ed4
leaq 0x63d5a(%rip), %rsi     # 0x9dc24
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x4, %r14b
je 0x39fbb
leaq 0x6fd46(%rip), %rsi     # 0xa9c2b
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x39fbb
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x39fab
leaq 0x63d02(%rip), %r15     # 0x9dc1a
leaq 0x63d05(%rip), %r12     # 0x9dc24
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x39f66
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x39f6d
movq %r13, %rdi
leaq 0x6fcd5(%rip), %rsi     # 0xa9c2b
callq 0x19000
movl $0x4, %ecx
testl %eax, %eax
je 0x39f72
jmp 0x39f87
movl $0x1, %ecx
jmp 0x39f72
movl $0x2, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x39f1f
jmp 0x39fab
leaq 0x57a58(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: DependencyFlags
static int DependencyFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushdependencyflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkdependencyflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3a04c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3a015
leaq 0x63c31(%rip), %rsi     # 0x9dc39
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x4, %r14b
je 0x3a02c
leaq 0x63c21(%rip), %rsi     # 0x9dc43
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x2, %r14b
je 0x3a113
leaq 0x63c13(%rip), %rsi     # 0x9dc50
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x3a113
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x3a103
leaq 0x63bc9(%rip), %r15     # 0x9dc39
leaq 0x63bcc(%rip), %r12     # 0x9dc43
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x3a0be
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x3a0c5
movq %r13, %rdi
leaq 0x63ba2(%rip), %rsi     # 0x9dc50
callq 0x19000
movl $0x2, %ecx
testl %eax, %eax
je 0x3a0ca
jmp 0x3a0df
movl $0x1, %ecx
jmp 0x3a0ca
movl $0x4, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3a077
jmp 0x3a103
leaq 0x57900(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: AttachmentDescriptionFlags
static int AttachmentDescriptionFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushattachmentdescriptionflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkattachmentdescriptionflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3a8aa
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x3a930
leaq 0x63633(%rip), %rsi     # 0x9ded0
movq %rbx, %rdi
callq 0x1a300
jmp 0x3a92b
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
testl %eax, %eax
je 0x3a8fc
leaq 0x63609(%rip), %r14     # 0x9ded0
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x19000
testl %eax, %eax
jne 0x3a900
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3a8c7
movl $0x1, %esi
jmp 0x3a923
xorl %esi, %esi
jmp 0x3a923
leaq 0x570df(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: DescriptorPoolCreateFlags
static int DescriptorPoolCreateFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushdescriptorpoolcreateflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkdescriptorpoolcreateflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3a987
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x3aa34
leaq 0x63560(%rip), %rsi     # 0x9deda
movq %rbx, %rdi
callq 0x1a300
jmp 0x3aa2f
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x3aa24
leaq 0x6352f(%rip), %r15     # 0x9deda
leaq 0x6353c(%rip), %r12     # 0x9deee
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x3a9e6
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
movl $0x2, %ecx
testl %eax, %eax
je 0x3a9eb
jmp 0x3aa00
movl $0x1, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3a9b2
jmp 0x3aa24
leaq 0x56fdf(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: DescriptorSetLayoutCreateFlags
static int DescriptorSetLayoutCreateFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushdescriptorsetlayoutcreateflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkdescriptorsetlayoutcreateflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3aa8f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x3ab3c
leaq 0x6347e(%rip), %rsi     # 0x9df00
movq %rbx, %rdi
callq 0x1a300
jmp 0x3ab37
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x3ab2c
leaq 0x6344d(%rip), %r15     # 0x9df00
leaq 0x63456(%rip), %r12     # 0x9df10
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x3aaee
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
movl $0x2, %ecx
testl %eax, %eax
je 0x3aaf3
jmp 0x3ab08
movl $0x1, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3aaba
jmp 0x3ab2c
leaq 0x56ed7(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: ColorComponentFlags
static int ColorComponentFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushcolorcomponentflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkcolorcomponentflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3abe2
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3ab94
leaq 0x5aeeb(%rip), %rsi     # 0x95a72
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3abab
leaq 0x55d92(%rip), %rsi     # 0x90933
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x4, %r14b
je 0x3abc2
leaq 0x5b5a0(%rip), %rsi     # 0x96158
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x8, %r14b
je 0x3ac9d
leaq 0x6b467(%rip), %rsi     # 0xa603a
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x3ac9d
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x3ac8d
leaq 0x5ae6c(%rip), %r15     # 0x95a72
leaq 0x55d26(%rip), %r12     # 0x90933
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x3ac67
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x3ac6e
movq %r13, %rdi
leaq 0x5b514(%rip), %rsi     # 0x96158
callq 0x19000
testl %eax, %eax
je 0x3ac75
movq %r13, %rdi
leaq 0x6b3e3(%rip), %rsi     # 0xa603a
callq 0x19000
movl $0x8, %ecx
testl %eax, %eax
je 0x3ac7a
jmp 0x3acae
movl $0x1, %ecx
jmp 0x3ac7a
movl $0x2, %ecx
jmp 0x3ac7a
movl $0x4, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3ac0d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x56d31(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
jmp 0x3ac8d
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: CullModeFlags
static int CullModeFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushcullmodeflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkcullmodeflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3ad3d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3ad1d
leaq 0x62ead(%rip), %rsi     # 0x9dbbd
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3aded
leaq 0x62e9f(%rip), %rsi     # 0x9dbcd
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x3aded
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x3addd
leaq 0x6dcad(%rip), %r15     # 0xa8a0e
leaq 0x62e55(%rip), %r12     # 0x9dbbd
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x3adcd
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x3adc3
movq %r13, %rdi
leaq 0x62e2e(%rip), %rsi     # 0x9dbcd
callq 0x19000
testl %eax, %eax
je 0x3adc9
movq %r13, %rdi
leaq 0x62e11(%rip), %rsi     # 0x9dbc3
callq 0x19000
movl $0x3, %r14d
testl %eax, %eax
je 0x3adcd
jmp 0x3adfe
orl $0x1, %r14d
jmp 0x3adcd
orl $0x2, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3ad68
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x56be1(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
jmp 0x3addd
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: BufferCreateFlags
static int BufferCreateFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushbuffercreateflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkbuffercreateflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3bb08
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3baa3
leaq 0x627bc(%rip), %rsi     # 0x9e252
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3baba
leaq 0x627b1(%rip), %rsi     # 0x9e261
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x4, %r14b
je 0x3bad1
leaq 0x627ab(%rip), %rsi     # 0x9e272
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x8, %r14b
je 0x3bae8
leaq 0x6e14d(%rip), %rsi     # 0xa9c2b
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x10, %r14b
je 0x3bbe1
leaq 0x62788(%rip), %rsi     # 0x9e281
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x3bbe1
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x3bbd1
leaq 0x62726(%rip), %r15     # 0x9e252
leaq 0x6272e(%rip), %r12     # 0x9e261
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x3bba0
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x3bba7
movq %r13, %rdi
leaq 0x62708(%rip), %rsi     # 0x9e272
callq 0x19000
testl %eax, %eax
je 0x3bbae
movq %r13, %rdi
leaq 0x6e0ae(%rip), %rsi     # 0xa9c2b
callq 0x19000
testl %eax, %eax
je 0x3bbb5
movq %r13, %rdi
leaq 0x626f1(%rip), %rsi     # 0x9e281
callq 0x19000
movl $0x10, %ecx
testl %eax, %eax
je 0x3bbba
jmp 0x3bbf2
movl $0x1, %ecx
jmp 0x3bbba
movl $0x2, %ecx
jmp 0x3bbba
movl $0x4, %ecx
jmp 0x3bbba
movl $0x8, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3bb33
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x55ded(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
jmp 0x3bbd1
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: QueryResultFlags
static int QueryResultFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushqueryresultflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkqueryresultflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3bcaf
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3bc61
leaq 0x5d151(%rip), %rsi     # 0x98da5
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3bc78
leaq 0x6b505(%rip), %rsi     # 0xa7173
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x4, %r14b
je 0x3bc8f
leaq 0x6261a(%rip), %rsi     # 0x9e29f
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x8, %r14b
je 0x3bd6a
leaq 0x62611(%rip), %rsi     # 0x9e2b1
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x3bd6a
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x3bd5a
leaq 0x5d0d2(%rip), %r15     # 0x98da5
leaq 0x6b499(%rip), %r12     # 0xa7173
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x3bd34
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x3bd3b
movq %r13, %rdi
leaq 0x6258e(%rip), %rsi     # 0x9e29f
callq 0x19000
testl %eax, %eax
je 0x3bd42
movq %r13, %rdi
leaq 0x6258d(%rip), %rsi     # 0x9e2b1
callq 0x19000
movl $0x8, %ecx
testl %eax, %eax
je 0x3bd47
jmp 0x3bd7b
movl $0x1, %ecx
jmp 0x3bd47
movl $0x2, %ecx
jmp 0x3bd47
movl $0x4, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3bcda
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x55c64(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
jmp 0x3bd5a
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: FenceCreateFlags
static int FenceCreateFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushfencecreateflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkfencecreateflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3c0eb
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x3c171
leaq 0x6230d(%rip), %rsi     # 0x9e3eb
movq %rbx, %rdi
callq 0x1a300
jmp 0x3c16c
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
testl %eax, %eax
je 0x3c13d
leaq 0x622e3(%rip), %r14     # 0x9e3eb
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x19000
testl %eax, %eax
jne 0x3c141
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3c108
movl $0x1, %esi
jmp 0x3c164
xorl %esi, %esi
jmp 0x3c164
leaq 0x5589e(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: SparseMemoryBindFlags
static int SparseMemoryBindFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushsparsememorybindflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checksparsememorybindflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3c1c4
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x3c24a
leaq 0x67692(%rip), %rsi     # 0xa3849
movq %rbx, %rdi
callq 0x1a300
jmp 0x3c245
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
testl %eax, %eax
je 0x3c216
leaq 0x67668(%rip), %r14     # 0xa3849
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x19000
testl %eax, %eax
jne 0x3c21a
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3c1e1
movl $0x1, %esi
jmp 0x3c23d
xorl %esi, %esi
jmp 0x3c23d
leaq 0x557c5(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: SparseImageFormatFlags
static int SparseImageFormatFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushsparseimageformatflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checksparseimageformatflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3c2d5
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3c29e
leaq 0x62163(%rip), %rsi     # 0x9e3f4
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3c2b5
leaq 0x62158(%rip), %rsi     # 0x9e403
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x4, %r14b
je 0x3c39c
leaq 0x6214e(%rip), %rsi     # 0x9e414
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x3c39c
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x3c38c
leaq 0x620fb(%rip), %r15     # 0x9e3f4
leaq 0x62103(%rip), %r12     # 0x9e403
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x3c347
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x3c34e
movq %r13, %rdi
leaq 0x620dd(%rip), %rsi     # 0x9e414
callq 0x19000
movl $0x4, %ecx
testl %eax, %eax
je 0x3c353
jmp 0x3c368
movl $0x1, %ecx
jmp 0x3c353
movl $0x2, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3c300
jmp 0x3c38c
leaq 0x55677(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: MemoryHeapFlag
static int MemoryHeapFlag(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushmemoryheapflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkmemoryheapflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3ce86
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3ce66
leaq 0x617cd(%rip), %rsi     # 0x9e626
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3cf33
leaq 0x617bc(%rip), %rsi     # 0x9e633
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x3cf33
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x3cf23
leaq 0x6177c(%rip), %r15     # 0x9e626
leaq 0x61782(%rip), %r12     # 0x9e633
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x3cee5
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
movl $0x2, %ecx
testl %eax, %eax
je 0x3ceea
jmp 0x3ceff
movl $0x1, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3ceb1
jmp 0x3cf23
leaq 0x54ae0(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: MemoryPropertyFlags
static int MemoryPropertyFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushmemorypropertyflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkmemorypropertyflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3d00d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3cf91
leaq 0x616a2(%rip), %rsi     # 0x9e626
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3cfa8
leaq 0x616a4(%rip), %rsi     # 0x9e642
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x4, %r14b
je 0x3cfbf
leaq 0x6169a(%rip), %rsi     # 0x9e64f
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x8, %r14b
je 0x3cfd6
leaq 0x61691(%rip), %rsi     # 0x9e65d
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x10, %r14b
je 0x3cfed
leaq 0x61686(%rip), %rsi     # 0x9e669
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x20, %r14b
je 0x3d100
leaq 0x6cc2d(%rip), %rsi     # 0xa9c2b
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x3d100
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x3d0f0
leaq 0x615f5(%rip), %r15     # 0x9e626
leaq 0x6160a(%rip), %r12     # 0x9e642
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x3d0b8
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x3d0bf
movq %r13, %rdi
leaq 0x615e0(%rip), %rsi     # 0x9e64f
callq 0x19000
testl %eax, %eax
je 0x3d0c6
movq %r13, %rdi
leaq 0x615db(%rip), %rsi     # 0x9e65d
callq 0x19000
testl %eax, %eax
je 0x3d0cd
movq %r13, %rdi
leaq 0x615d4(%rip), %rsi     # 0x9e669
callq 0x19000
testl %eax, %eax
je 0x3d0d4
movq %r13, %rdi
leaq 0x6cb83(%rip), %rsi     # 0xa9c2b
callq 0x19000
movl $0x20, %ecx
testl %eax, %eax
je 0x3d0d9
jmp 0x3d111
movl $0x1, %ecx
jmp 0x3d0d9
movl $0x2, %ecx
jmp 0x3d0d9
movl $0x4, %ecx
jmp 0x3d0d9
movl $0x8, %ecx
jmp 0x3d0d9
movl $0x10, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3d038
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x548ce(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
jmp 0x3d0f0
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: QueueFlags
static int QueueFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushqueueflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkqueueflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3d1e9
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3d184
leaq 0x60e08(%rip), %rsi     # 0x9df7f
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3d19b
leaq 0x59ed8(%rip), %rsi     # 0x97069
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x4, %r14b
je 0x3d1b2
leaq 0x6139a(%rip), %rsi     # 0x9e542
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x8, %r14b
je 0x3d1c9
leaq 0x61093(%rip), %rsi     # 0x9e252
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x10, %r14b
je 0x3d2c2
leaq 0x6ca51(%rip), %rsi     # 0xa9c2b
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x3d2c2
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x3d2b2
leaq 0x60d72(%rip), %r15     # 0x9df7f
leaq 0x59e55(%rip), %r12     # 0x97069
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x3d281
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x3d288
movq %r13, %rdi
leaq 0x612f7(%rip), %rsi     # 0x9e542
callq 0x19000
testl %eax, %eax
je 0x3d28f
movq %r13, %rdi
leaq 0x60ff4(%rip), %rsi     # 0x9e252
callq 0x19000
testl %eax, %eax
je 0x3d296
movq %r13, %rdi
leaq 0x6c9ba(%rip), %rsi     # 0xa9c2b
callq 0x19000
movl $0x10, %ecx
testl %eax, %eax
je 0x3d29b
jmp 0x3d2d3
movl $0x1, %ecx
jmp 0x3d29b
movl $0x2, %ecx
jmp 0x3d29b
movl $0x4, %ecx
jmp 0x3d29b
movl $0x8, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3d214
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5470c(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
jmp 0x3d2b2
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: SampleCountFlags
static int SampleCountFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushsamplecountflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checksamplecountflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3d3d9
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3d346
leaq 0x61116(%rip), %rsi     # 0x9e44f
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3d35d
leaq 0x6110b(%rip), %rsi     # 0x9e45e
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x4, %r14b
je 0x3d374
leaq 0x5ba3c(%rip), %rsi     # 0x98da6
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x8, %r14b
je 0x3d38b
leaq 0x54d7c(%rip), %rsi     # 0x920fd
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x10, %r14b
je 0x3d3a2
leaq 0x56fd2(%rip), %rsi     # 0x9436a
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x20, %r14b
je 0x3d3b9
leaq 0x5552b(%rip), %rsi     # 0x928da
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x40, %r14b
je 0x3d4e6
leaq 0x5b9db(%rip), %rsi     # 0x98da5
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x3d4e6
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x3d4d6
leaq 0x61052(%rip), %r15     # 0x9e44f
leaq 0x6105a(%rip), %r12     # 0x9e45e
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x3d497
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x3d49e
movq %r13, %rdi
leaq 0x5b96b(%rip), %rsi     # 0x98da6
callq 0x19000
testl %eax, %eax
je 0x3d4a5
movq %r13, %rdi
leaq 0x54caf(%rip), %rsi     # 0x920fd
callq 0x19000
testl %eax, %eax
je 0x3d4ac
movq %r13, %rdi
leaq 0x56f09(%rip), %rsi     # 0x9436a
callq 0x19000
testl %eax, %eax
je 0x3d4b3
movq %r13, %rdi
leaq 0x55466(%rip), %rsi     # 0x928da
callq 0x19000
testl %eax, %eax
je 0x3d4ba
movq %r13, %rdi
leaq 0x5b91e(%rip), %rsi     # 0x98da5
callq 0x19000
movl $0x40, %ecx
testl %eax, %eax
je 0x3d4bf
jmp 0x3d4f7
movl $0x1, %ecx
jmp 0x3d4bf
movl $0x2, %ecx
jmp 0x3d4bf
movl $0x4, %ecx
jmp 0x3d4bf
movl $0x8, %ecx
jmp 0x3d4bf
movl $0x10, %ecx
jmp 0x3d4bf
movl $0x20, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3d404
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x544e8(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
jmp 0x3d4d6
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: DeviceQueueCreateFlags
static int DeviceQueueCreateFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushdevicequeuecreateflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkdevicequeuecreateflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3e2e1
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x3e367
leaq 0x6b957(%rip), %rsi     # 0xa9c2b
movq %rbx, %rdi
callq 0x1a300
jmp 0x3e362
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
testl %eax, %eax
je 0x3e333
leaq 0x6b92d(%rip), %r14     # 0xa9c2b
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x19000
testl %eax, %eax
jne 0x3e337
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3e2fe
movl $0x1, %esi
jmp 0x3e35a
xorl %esi, %esi
jmp 0x3e35a
leaq 0x536a8(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: SubgroupFeatureFlags
static int SubgroupFeatureFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushsubgroupfeatureflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checksubgroupfeatureflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3e468
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3e3bf
leaq 0x6060d(%rip), %rsi     # 0x9e9bf
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3e3d6
leaq 0x605f9(%rip), %rsi     # 0x9e9c5
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x4, %r14b
je 0x3e3ed
leaq 0x605e7(%rip), %rsi     # 0x9e9ca
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x8, %r14b
je 0x3e404
leaq 0x605db(%rip), %rsi     # 0x9e9d5
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x10, %r14b
je 0x3e41b
leaq 0x605cb(%rip), %rsi     # 0x9e9dc
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x20, %r14b
je 0x3e432
leaq 0x605bc(%rip), %rsi     # 0x9e9e4
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x40, %r14b
je 0x3e449
leaq 0x605b6(%rip), %rsi     # 0x9e9f5
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb %r14b, %r14b
jns 0x3e597
leaq 0x605a6(%rip), %rsi     # 0x9e9ff
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x3e597
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x3e587
leaq 0x60533(%rip), %r15     # 0x9e9bf
leaq 0x60532(%rip), %r12     # 0x9e9c5
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x3e541
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x3e548
movq %r13, %rdi
leaq 0x604f8(%rip), %rsi     # 0x9e9ca
callq 0x19000
testl %eax, %eax
je 0x3e54f
movq %r13, %rdi
leaq 0x604f0(%rip), %rsi     # 0x9e9d5
callq 0x19000
testl %eax, %eax
je 0x3e556
movq %r13, %rdi
leaq 0x604e4(%rip), %rsi     # 0x9e9dc
callq 0x19000
testl %eax, %eax
je 0x3e55d
movq %r13, %rdi
leaq 0x604d9(%rip), %rsi     # 0x9e9e4
callq 0x19000
testl %eax, %eax
je 0x3e564
movq %r13, %rdi
leaq 0x604d7(%rip), %rsi     # 0x9e9f5
callq 0x19000
testl %eax, %eax
je 0x3e56b
movq %r13, %rdi
leaq 0x604ce(%rip), %rsi     # 0x9e9ff
callq 0x19000
movl $0x80, %ecx
testl %eax, %eax
je 0x3e570
jmp 0x3e5a8
movl $0x1, %ecx
jmp 0x3e570
movl $0x2, %ecx
jmp 0x3e570
movl $0x4, %ecx
jmp 0x3e570
movl $0x8, %ecx
jmp 0x3e570
movl $0x10, %ecx
jmp 0x3e570
movl $0x20, %ecx
jmp 0x3e570
movl $0x40, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3e493
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x53437(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
jmp 0x3e587
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: PeerMemoryFeatureFlags
static int PeerMemoryFeatureFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushpeermemoryfeatureflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkpeermemoryfeatureflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3e665
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3e617
leaq 0x603fa(%rip), %rsi     # 0x9ea04
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3e62e
leaq 0x603e9(%rip), %rsi     # 0x9ea0d
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x4, %r14b
je 0x3e645
leaq 0x603db(%rip), %rsi     # 0x9ea16
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x8, %r14b
je 0x3e720
leaq 0x603cc(%rip), %rsi     # 0x9ea22
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x3e720
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x3e710
leaq 0x6037b(%rip), %r15     # 0x9ea04
leaq 0x6037d(%rip), %r12     # 0x9ea0d
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x3e6ea
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x3e6f1
movq %r13, %rdi
leaq 0x6034f(%rip), %rsi     # 0x9ea16
callq 0x19000
testl %eax, %eax
je 0x3e6f8
movq %r13, %rdi
leaq 0x60348(%rip), %rsi     # 0x9ea22
callq 0x19000
movl $0x8, %ecx
testl %eax, %eax
je 0x3e6fd
jmp 0x3e731
movl $0x1, %ecx
jmp 0x3e6fd
movl $0x2, %ecx
jmp 0x3e6fd
movl $0x4, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3e690
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x532ae(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
jmp 0x3e710
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: MemoryAllocateFlags
static int MemoryAllocateFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushmemoryallocateflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkmemoryallocateflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3e7d7
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3e7a0
leaq 0x6029b(%rip), %rsi     # 0x9ea2e
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3e7b7
leaq 0x5fa35(%rip), %rsi     # 0x9e1e2
movq %rbx, %rdi
callq 0x1a300
incl %ebp
testb $0x4, %r14b
je 0x3e89e
leaq 0x5fab9(%rip), %rsi     # 0x9e281
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x3e89e
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x3e88e
leaq 0x60233(%rip), %r15     # 0x9ea2e
leaq 0x5f9e0(%rip), %r12     # 0x9e1e2
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x3e849
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
testl %eax, %eax
je 0x3e850
movq %r13, %rdi
leaq 0x5fa48(%rip), %rsi     # 0x9e281
callq 0x19000
movl $0x4, %ecx
testl %eax, %eax
je 0x3e855
jmp 0x3e86a
movl $0x1, %ecx
jmp 0x3e855
movl $0x2, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3e802
jmp 0x3e88e
leaq 0x53175(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: ImageViewCreateFlags
static int ImageViewCreateFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushimageviewcreateflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkimageviewcreateflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3e918
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3e8f8
leaq 0x6014f(%rip), %rsi     # 0x9ea3a
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3e9c5
leaq 0x6014e(%rip), %rsi     # 0x9ea57
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x3e9c5
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x3e9b5
leaq 0x600fe(%rip), %r15     # 0x9ea3a
leaq 0x60114(%rip), %r12     # 0x9ea57
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x3e977
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
movl $0x2, %ecx
testl %eax, %eax
je 0x3e97c
jmp 0x3e991
movl $0x1, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3e943
jmp 0x3e9b5
leaq 0x5304e(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/flags.c
// Function: SamplerCreateFlags
static int SamplerCreateFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushsamplercreateflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checksamplercreateflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a130
cmpl $0x3, %eax
jne 0x3ea3f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190f0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x3ea1f
leaq 0x5fd04(%rip), %rsi     # 0x9e716
movq %rbx, %rdi
callq 0x1a300
movl $0x1, %ebp
testb $0x2, %r14b
je 0x3eaec
leaq 0x60045(%rip), %rsi     # 0x9ea75
movq %rbx, %rdi
callq 0x1a300
incl %ebp
jmp 0x3eaec
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a680
xorl %r14d, %r14d
testl %eax, %eax
je 0x3eadc
leaq 0x5fcb3(%rip), %r15     # 0x9e716
leaq 0x6000b(%rip), %r12     # 0x9ea75
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x19000
testl %eax, %eax
je 0x3ea9e
movq %r13, %rdi
movq %r12, %rsi
callq 0x19000
movl $0x2, %ecx
testl %eax, %eax
je 0x3eaa3
jmp 0x3eab8
movl $0x1, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a680
testl %eax, %eax
jne 0x3ea6a
jmp 0x3eadc
leaq 0x52f27(%rip), %rsi     # 0x919e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18eb0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq