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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x400ed
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x40173
leaq 0x5bc99(%rip), %rsi     # 0x9bd79
movq %rbx, %rdi
callq 0x1a2c0
jmp 0x4016e
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
testl %eax, %eax
je 0x4013f
leaq 0x5bc6f(%rip), %r14     # 0x9bd79
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x18ff0
testl %eax, %eax
jne 0x40143
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x4010a
movl $0x1, %esi
jmp 0x40166
xorl %esi, %esi
jmp 0x40166
leaq 0x4e89c(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: ExternalMemoryHandleTypeFlags
static int ExternalMemoryHandleTypeFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushexternalmemoryhandletypeflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkexternalmemoryhandletypeflags(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 0x1a0f0
cmpl $0x3, %eax
jne 0x4025e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x401cb
leaq 0x5bbc2(%rip), %rsi     # 0x9bd80
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x401e2
leaq 0x5bbb2(%rip), %rsi     # 0x9bd8a
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x4, %r14b
je 0x401f9
leaq 0x5bba8(%rip), %rsi     # 0x9bd97
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x8, %r14b
je 0x40210
leaq 0x5bba2(%rip), %rsi     # 0x9bda8
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x10, %r14b
je 0x40227
leaq 0x5bb99(%rip), %rsi     # 0x9bdb6
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x20, %r14b
je 0x4023e
leaq 0x5bb94(%rip), %rsi     # 0x9bdc8
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x40, %r14b
je 0x4036b
leaq 0x5bb84(%rip), %rsi     # 0x9bdd3
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x4036b
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x4035b
leaq 0x5bafe(%rip), %r15     # 0x9bd80
leaq 0x5bb01(%rip), %r12     # 0x9bd8a
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x4031c
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x40323
movq %r13, %rdi
leaq 0x5bad7(%rip), %rsi     # 0x9bd97
callq 0x18ff0
testl %eax, %eax
je 0x4032a
movq %r13, %rdi
leaq 0x5bad5(%rip), %rsi     # 0x9bda8
callq 0x18ff0
testl %eax, %eax
je 0x40331
movq %r13, %rdi
leaq 0x5bad0(%rip), %rsi     # 0x9bdb6
callq 0x18ff0
testl %eax, %eax
je 0x40338
movq %r13, %rdi
leaq 0x5bacf(%rip), %rsi     # 0x9bdc8
callq 0x18ff0
testl %eax, %eax
je 0x4033f
movq %r13, %rdi
leaq 0x5bac7(%rip), %rsi     # 0x9bdd3
callq 0x18ff0
movl $0x40, %ecx
testl %eax, %eax
je 0x40344
jmp 0x4037c
movl $0x1, %ecx
jmp 0x40344
movl $0x2, %ecx
jmp 0x40344
movl $0x4, %ecx
jmp 0x40344
movl $0x8, %ecx
jmp 0x40344
movl $0x10, %ecx
jmp 0x40344
movl $0x20, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x40289
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4e663(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
jmp 0x4035b
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: ExternalMemoryFeatureFlags
static int ExternalMemoryFeatureFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushexternalmemoryfeatureflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkexternalmemoryfeatureflags(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 0x1a0f0
cmpl $0x3, %eax
jne 0x40422
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x403eb
leaq 0x5ba04(%rip), %rsi     # 0x9bde2
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x40402
leaq 0x5b9f9(%rip), %rsi     # 0x9bdf1
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x4, %r14b
je 0x404e9
leaq 0x5b9e9(%rip), %rsi     # 0x9bdfc
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x404e9
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x404d9
leaq 0x5b99c(%rip), %r15     # 0x9bde2
leaq 0x5b9a4(%rip), %r12     # 0x9bdf1
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x40494
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x4049b
movq %r13, %rdi
leaq 0x5b978(%rip), %rsi     # 0x9bdfc
callq 0x18ff0
movl $0x4, %ecx
testl %eax, %eax
je 0x404a0
jmp 0x404b5
movl $0x1, %ecx
jmp 0x404a0
movl $0x2, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x4044d
jmp 0x404d9
leaq 0x4e52a(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
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_O3/stetre[P]moonvulkan/src/flags.c
// Function: ExternalSemaphoreHandleTypeFlags
static int ExternalSemaphoreHandleTypeFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushexternalsemaphorehandletypeflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkexternalsemaphorehandletypeflags(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 0x1a0f0
cmpl $0x3, %eax
jne 0x405ac
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x40547
leaq 0x5b846(%rip), %rsi     # 0x9bd80
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x4055e
leaq 0x5b836(%rip), %rsi     # 0x9bd8a
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x4, %r14b
je 0x40575
leaq 0x5b82c(%rip), %rsi     # 0x9bd97
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x8, %r14b
je 0x4058c
leaq 0x5b885(%rip), %rsi     # 0x9be07
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x10, %r14b
je 0x40685
leaq 0x5b876(%rip), %rsi     # 0x9be13
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x40685
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x40675
leaq 0x5b7b0(%rip), %r15     # 0x9bd80
leaq 0x5b7b3(%rip), %r12     # 0x9bd8a
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x40644
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x4064b
movq %r13, %rdi
leaq 0x5b789(%rip), %rsi     # 0x9bd97
callq 0x18ff0
testl %eax, %eax
je 0x40652
movq %r13, %rdi
leaq 0x5b7e6(%rip), %rsi     # 0x9be07
callq 0x18ff0
testl %eax, %eax
je 0x40659
movq %r13, %rdi
leaq 0x5b7df(%rip), %rsi     # 0x9be13
callq 0x18ff0
movl $0x10, %ecx
testl %eax, %eax
je 0x4065e
jmp 0x40696
movl $0x1, %ecx
jmp 0x4065e
movl $0x2, %ecx
jmp 0x4065e
movl $0x4, %ecx
jmp 0x4065e
movl $0x8, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x405d7
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4e349(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
jmp 0x40675
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: ExternalSemaphoreFeatureFlags
static int ExternalSemaphoreFeatureFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushexternalsemaphorefeatureflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkexternalsemaphorefeatureflags(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 0x1a0f0
cmpl $0x3, %eax
jne 0x40725
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x40705
leaq 0x5b6f9(%rip), %rsi     # 0x9bdf1
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x407d2
leaq 0x5b6e6(%rip), %rsi     # 0x9bdfc
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x407d2
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x407c2
leaq 0x5b6a8(%rip), %r15     # 0x9bdf1
leaq 0x5b6ac(%rip), %r12     # 0x9bdfc
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x40784
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
movl $0x2, %ecx
testl %eax, %eax
je 0x40789
jmp 0x4079e
movl $0x1, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x40750
jmp 0x407c2
leaq 0x4e241(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
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_O3/stetre[P]moonvulkan/src/flags.c
// Function: SemaphoreImportFlags
static int SemaphoreImportFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushsemaphoreimportflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checksemaphoreimportflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x4082b
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x408b1
leaq 0x5b5fd(%rip), %rsi     # 0x9be1b
movq %rbx, %rdi
callq 0x1a2c0
jmp 0x408ac
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
testl %eax, %eax
je 0x4087d
leaq 0x5b5d3(%rip), %r14     # 0x9be1b
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x18ff0
testl %eax, %eax
jne 0x40881
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x40848
movl $0x1, %esi
jmp 0x408a4
xorl %esi, %esi
jmp 0x408a4
leaq 0x4e15e(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: ExternalFenceHandleTypeFlags
static int ExternalFenceHandleTypeFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushexternalfencehandletypeflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkexternalfencehandletypeflags(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 0x1a0f0
cmpl $0x3, %eax
jne 0x40953
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x40905
leaq 0x5b488(%rip), %rsi     # 0x9bd80
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x4091c
leaq 0x5b478(%rip), %rsi     # 0x9bd8a
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x4, %r14b
je 0x40933
leaq 0x5b46e(%rip), %rsi     # 0x9bd97
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x8, %r14b
je 0x40a0e
leaq 0x5b4cf(%rip), %rsi     # 0x9be13
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x40a0e
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x409fe
leaq 0x5b409(%rip), %r15     # 0x9bd80
leaq 0x5b40c(%rip), %r12     # 0x9bd8a
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x409d8
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x409df
movq %r13, %rdi
leaq 0x5b3e2(%rip), %rsi     # 0x9bd97
callq 0x18ff0
testl %eax, %eax
je 0x409e6
movq %r13, %rdi
leaq 0x5b44b(%rip), %rsi     # 0x9be13
callq 0x18ff0
movl $0x8, %ecx
testl %eax, %eax
je 0x409eb
jmp 0x40a1f
movl $0x1, %ecx
jmp 0x409eb
movl $0x2, %ecx
jmp 0x409eb
movl $0x4, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x4097e
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4dfc0(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
jmp 0x409fe
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: ExternalFenceFeatureFlags
static int ExternalFenceFeatureFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushexternalfencefeatureflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkexternalfencefeatureflags(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 0x1a0f0
cmpl $0x3, %eax
jne 0x40aae
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x40a8e
leaq 0x5b370(%rip), %rsi     # 0x9bdf1
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x40b5b
leaq 0x5b35d(%rip), %rsi     # 0x9bdfc
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x40b5b
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x40b4b
leaq 0x5b31f(%rip), %r15     # 0x9bdf1
leaq 0x5b323(%rip), %r12     # 0x9bdfc
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x40b0d
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
movl $0x2, %ecx
testl %eax, %eax
je 0x40b12
jmp 0x40b27
movl $0x1, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x40ad9
jmp 0x40b4b
leaq 0x4deb8(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
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_O3/stetre[P]moonvulkan/src/flags.c
// Function: FenceImportFlags
static int FenceImportFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushfenceimportflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkfenceimportflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x40bb4
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x40c3a
leaq 0x5b274(%rip), %rsi     # 0x9be1b
movq %rbx, %rdi
callq 0x1a2c0
jmp 0x40c35
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
testl %eax, %eax
je 0x40c06
leaq 0x5b24a(%rip), %r14     # 0x9be1b
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x18ff0
testl %eax, %eax
jne 0x40c0a
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x40bd1
movl $0x1, %esi
jmp 0x40c2d
xorl %esi, %esi
jmp 0x40c2d
leaq 0x4ddd5(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: DebugUtilsMessageSeverityFlags
static int DebugUtilsMessageSeverityFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushdebugutilsmessageseverityflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkdebugutilsmessageseverityflags(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 0x1a0f0
cmpl $0x3, %eax
jne 0x40cde
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x40c8e
leaq 0x5b1a4(%rip), %rsi     # 0x9be25
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x10, %r14b
je 0x40ca5
leaq 0x61dfb(%rip), %rsi     # 0xa2a96
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
btl $0x8, %r14d
jae 0x40cbd
leaq 0x5b0b8(%rip), %rsi     # 0x9bd6b
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
btl $0xc, %r14d
jae 0x40d99
leaq 0x5fda3(%rip), %rsi     # 0xa0a72
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x40d99
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x40d89
leaq 0x5b123(%rip), %r15     # 0x9be25
leaq 0x61d8d(%rip), %r12     # 0xa2a96
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x40d63
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x40d6a
movq %r13, %rdi
leaq 0x5b02b(%rip), %rsi     # 0x9bd6b
callq 0x18ff0
testl %eax, %eax
je 0x40d71
movq %r13, %rdi
leaq 0x5fd1f(%rip), %rsi     # 0xa0a72
callq 0x18ff0
movl $0x1000, %ecx           # imm = 0x1000
testl %eax, %eax
je 0x40d76
jmp 0x40daa
movl $0x1, %ecx
jmp 0x40d76
movl $0x10, %ecx
jmp 0x40d76
movl $0x100, %ecx            # imm = 0x100
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x40d09
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4dc35(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
jmp 0x40d89
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: DebugUtilsMessageTypeFlags
static int DebugUtilsMessageTypeFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushdebugutilsmessagetypeflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkdebugutilsmessagetypeflags(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 0x1a0f0
cmpl $0x3, %eax
jne 0x40e50
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x40e19
leaq 0x51171(%rip), %rsi     # 0x91f7d
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x40e30
leaq 0x549d3(%rip), %rsi     # 0x957f9
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x4, %r14b
je 0x40f17
leaq 0x5afec(%rip), %rsi     # 0x9be2d
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x40f17
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x40f07
leaq 0x51109(%rip), %r15     # 0x91f7d
leaq 0x5497e(%rip), %r12     # 0x957f9
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x40ec2
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x40ec9
movq %r13, %rdi
leaq 0x5af7b(%rip), %rsi     # 0x9be2d
callq 0x18ff0
movl $0x4, %ecx
testl %eax, %eax
je 0x40ece
jmp 0x40ee3
movl $0x1, %ecx
jmp 0x40ece
movl $0x2, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x40e7b
jmp 0x40f07
leaq 0x4dafc(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
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_O3/stetre[P]moonvulkan/src/flags.c
// Function: DeviceGroupPresentModeFlags
static int DeviceGroupPresentModeFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushdevicegrouppresentmodeflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkdevicegrouppresentmodeflags(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 0x1a0f0
cmpl $0x3, %eax
jne 0x40fbf
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x40f71
leaq 0x5a6ec(%rip), %rsi     # 0x9b650
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x40f88
leaq 0x5aebb(%rip), %rsi     # 0x9be39
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x4, %r14b
je 0x40f9f
leaq 0x5aeab(%rip), %rsi     # 0x9be40
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x8, %r14b
je 0x4107a
leaq 0x5ae94(%rip), %rsi     # 0x9be44
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x4107a
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x4106a
leaq 0x5a66d(%rip), %r15     # 0x9b650
leaq 0x5ae4f(%rip), %r12     # 0x9be39
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x41044
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x4104b
movq %r13, %rdi
leaq 0x5ae1f(%rip), %rsi     # 0x9be40
callq 0x18ff0
testl %eax, %eax
je 0x41052
movq %r13, %rdi
leaq 0x5ae10(%rip), %rsi     # 0x9be44
callq 0x18ff0
movl $0x8, %ecx
testl %eax, %eax
je 0x41057
jmp 0x4108b
movl $0x1, %ecx
jmp 0x41057
movl $0x2, %ecx
jmp 0x41057
movl $0x4, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x40fea
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4d954(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
jmp 0x4106a
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: SwapchainCreateFlags
static int SwapchainCreateFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushswapchaincreateflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkswapchaincreateflags(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 0x1a0f0
cmpl $0x3, %eax
jne 0x41131
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x410fa
leaq 0x5a61c(%rip), %rsi     # 0x9b709
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x41111
leaq 0x65b44(%rip), %rsi     # 0xa6c4b
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x4, %r14b
je 0x411f8
leaq 0x5a57b(%rip), %rsi     # 0x9b69d
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x411f8
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x411e8
leaq 0x5a5b4(%rip), %r15     # 0x9b709
leaq 0x65aef(%rip), %r12     # 0xa6c4b
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x411a3
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x411aa
movq %r13, %rdi
leaq 0x5a50a(%rip), %rsi     # 0x9b69d
callq 0x18ff0
movl $0x4, %ecx
testl %eax, %eax
je 0x411af
jmp 0x411c4
movl $0x1, %ecx
jmp 0x411af
movl $0x2, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x4115c
jmp 0x411e8
leaq 0x4d81b(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
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_O3/stetre[P]moonvulkan/src/flags.c
// Function: DescriptorBindingFlags
static int DescriptorBindingFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushdescriptorbindingflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkdescriptorbindingflags(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 0x1a0f0
cmpl $0x3, %eax
jne 0x412a0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x41252
leaq 0x59ccc(%rip), %rsi     # 0x9af11
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x41269
leaq 0x5abf8(%rip), %rsi     # 0x9be57
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x4, %r14b
je 0x41280
leaq 0x5abfd(%rip), %rsi     # 0x9be73
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x8, %r14b
je 0x4135b
leaq 0x5abf2(%rip), %rsi     # 0x9be83
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x4135b
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x4134b
leaq 0x59c4d(%rip), %r15     # 0x9af11
leaq 0x5ab8c(%rip), %r12     # 0x9be57
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x41325
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x4132c
movq %r13, %rdi
leaq 0x5ab71(%rip), %rsi     # 0x9be73
callq 0x18ff0
testl %eax, %eax
je 0x41333
movq %r13, %rdi
leaq 0x5ab6e(%rip), %rsi     # 0x9be83
callq 0x18ff0
movl $0x8, %ecx
testl %eax, %eax
je 0x41338
jmp 0x4136c
movl $0x1, %ecx
jmp 0x41338
movl $0x2, %ecx
jmp 0x41338
movl $0x4, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x412cb
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4d673(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
jmp 0x4134b
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: ConditionalRenderingFlags
static int ConditionalRenderingFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushconditionalrenderingflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkconditionalrenderingflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x413da
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x41460
leaq 0x516fb(%rip), %rsi     # 0x92ac8
movq %rbx, %rdi
callq 0x1a2c0
jmp 0x4145b
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
testl %eax, %eax
je 0x4142c
leaq 0x516d1(%rip), %r14     # 0x92ac8
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x18ff0
testl %eax, %eax
jne 0x41430
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x413f7
movl $0x1, %esi
jmp 0x41453
xorl %esi, %esi
jmp 0x41453
leaq 0x4d5af(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: AccelerationStructureCreateFlagsKHR
static int AccelerationStructureCreateFlagsKHR(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushaccelerationstructurecreateflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkaccelerationstructurecreateflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x414b3
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, %cl
je 0x41539
leaq 0x59dfe(%rip), %rsi     # 0x9b2a4
movq %rbx, %rdi
callq 0x1a2c0
jmp 0x41534
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
testl %eax, %eax
je 0x41505
leaq 0x59dd4(%rip), %r14     # 0x9b2a4
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x18ff0
testl %eax, %eax
jne 0x41509
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x414d0
movl $0x1, %esi
jmp 0x4152c
xorl %esi, %esi
jmp 0x4152c
leaq 0x4d4d6(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %esi
movq %rbx, %rdi
callq 0x18b50
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/flags.c
// Function: RenderingFlagsKHR
static int RenderingFlagsKHR(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushrenderingflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkrenderingflags(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 0x1a0f0
cmpl $0x3, %eax
jne 0x415c4
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x4158d
leaq 0x5a91d(%rip), %rsi     # 0x9be9d
movq %rbx, %rdi
callq 0x1a2c0
movl $0x1, %ebp
testb $0x2, %r14b
je 0x415a4
leaq 0x5a926(%rip), %rsi     # 0x9bec0
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
testb $0x4, %r14b
je 0x4168b
leaq 0x5a916(%rip), %rsi     # 0x9becb
movq %rbx, %rdi
callq 0x1a2c0
incl %ebp
jmp 0x4168b
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
xorl %r14d, %r14d
testl %eax, %eax
je 0x4167b
leaq 0x5a8b5(%rip), %r15     # 0x9be9d
leaq 0x5a8d1(%rip), %r12     # 0x9bec0
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18680
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x41636
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ff0
testl %eax, %eax
je 0x4163d
movq %r13, %rdi
leaq 0x5a8a5(%rip), %rsi     # 0x9becb
callq 0x18ff0
movl $0x4, %ecx
testl %eax, %eax
je 0x41642
jmp 0x41657
movl $0x1, %ecx
jmp 0x41642
movl $0x2, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a640
testl %eax, %eax
jne 0x415ef
jmp 0x4167b
leaq 0x4d388(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x18b50
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_O3/stetre[P]moonvulkan/src/flags.c
// Function: ReservedFlags
static int ReservedFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushreservedflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkreservedflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a0f0
cmpl $0x3, %eax
jne 0x416c2
movq %rbx, %rdi
movl $0x1, %esi
callq 0x190e0
xorl %ebp, %ebp
jmp 0x41719
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1a640
testl %eax, %eax
je 0x4170f
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x18680
leaq 0x4d2f8(%rip), %rsi     # 0x8e9e6
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x18ea0
movq %rbx, %rdi
movl $0x1, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %esi
jmp 0x41711
xorl %esi, %esi
movq %rbx, %rdi
callq 0x18b50
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/framebuffer.c
// Function: Create
static int Create(lua_State *L)
    {
    int err;
    ud_t *ud, *device_ud;
    VkResult ec;
    VkFramebuffer framebuffer;
    VkFramebufferCreateInfo* info;
    VkDevice device = checkdevice(L, 1, &device_ud);
    const VkAllocationCallbacks *allocator = optallocator(L, 3);
#define CLEANUP zfreeVkFramebufferCreateInfo(L, info, 1)
    info = zcheckVkFramebufferCreateInfo(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ec = device_ud->ddt->CreateFramebuffer(device, info, allocator, &framebuffer);
    CLEANUP;
#undef CLEANUP
    CheckError(L, ec);
    TRACE_CREATE(framebuffer, "framebuffer");
    ud = newuserdata_nondispatchable(L, framebuffer, FRAMEBUFFER_MT);
    ud->parent_ud = device_ud;
    ud->device = device;
    ud->instance = device_ud->instance;
    ud->allocator = allocator;
    ud->destructor = freeframebuffer;
    ud->ddt = device_ud->ddt;
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x4a790(%rip), %rcx     # 0x8c03b
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x1a4e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x191b0
movq %rax, %r15
leaq 0x14(%rsp), %r13
movq %rbx, %rdi
movl $0x2, %esi
movq %r13, %rdx
callq 0x18220
movq %rax, %r12
cmpl $0x0, (%r13)
je 0x41920
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19160
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x419cb
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rsp, %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x1f8(%rax)
movl %eax, %ebp
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19160
testl %ebp, %ebp
je 0x41967
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x18980
movq %rbx, %rdi
callq 0x199a0
jmp 0x419cb
movq 0x7e65a(%rip), %rax     # 0xbffc8
cmpl $0x0, (%rax)
je 0x41985
movq (%rsp), %rsi
leaq 0x5a57d(%rip), %rdi     # 0x9befb
xorl %eax, %eax
callq 0x18960
movq (%rsp), %rsi
leaq 0x4c65e(%rip), %rdx     # 0x8dfee
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x18320
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %r14, 0x20(%rax)
movq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq %r15, 0x40(%rax)
leaq 0x4f(%rip), %rdx        # 0x41a09
movq %rdx, 0x8(%rax)
movq 0x50(%rcx), %rcx
movq %rcx, 0x50(%rax)
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/framebuffer.c
// Function: freeframebuffer
static int freeframebuffer(lua_State *L, ud_t *ud)
    {
    VkFramebuffer framebuffer = (VkFramebuffer)ud->handle;
    const VkAllocationCallbacks *allocator = ud->allocator;
    VkDevice device = ud->device;
    if(!freeuserdata(L, ud))
        return 0; /* double call */
    TRACE_DELETE(framebuffer, "framebuffer");
    UD(device)->ddt->DestroyFramebuffer(device, framebuffer, allocator);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rsi), %rbx
movq 0x20(%rsi), %r15
movq 0x40(%rsi), %r14
callq 0x18d20
testl %eax, %eax
je 0x41a5a
movq 0x7e59f(%rip), %rax     # 0xbffc8
cmpl $0x0, (%rax)
je 0x41a3f
leaq 0x5a4e3(%rip), %rdi     # 0x9bf18
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18960
movq %r15, %rdi
callq 0x19e90
movq 0x50(%rax), %rax
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x200(%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/image.c
// Function: newimage
static int newimage(lua_State *L, VkImage image, ud_t *parent_ud, VkDevice device, const VkAllocationCallbacks *allocator, int borrowed)
    {
    ud_t *ud;
    TRACE_CREATE(image, "image");
    ud = newuserdata_nondispatchable(L, image, IMAGE_MT);
    ud->parent_ud = parent_ud;
    ud->device = device;
    ud->instance = UD(device)->instance;
    ud->allocator = allocator;
    ud->destructor = freeimage;
    ud->ddt = UD(device)->ddt;
    if(borrowed) MarkBorrowed(ud); 
    /* e.g. images got from a swapchain are borrowed, since they are owned by 
     * Vulkan and must not be destroyed by the application. */
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x7b282(%rip), %rax     # 0xbffc8
cmpl $0x0, (%rax)
je 0x44d5c
leaq 0x5a64d(%rip), %rdi     # 0x9f39f
movq %r13, %rsi
xorl %eax, %eax
callq 0x18960
leaq 0x47c37(%rip), %rdx     # 0x8c99a
movq %rbp, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
callq 0x18320
movq %rax, %r13
movq %r12, 0x10(%rax)
movq %r14, 0x20(%rax)
movq %r14, %rdi
callq 0x19e90
movq 0x18(%rax), %rax
movq %rax, 0x18(%r13)
movq %r15, 0x40(%r13)
leaq 0x5c(%rip), %rax        # 0x44df2
movq %rax, 0x8(%r13)
movq %r14, %rdi
callq 0x19e90
movq 0x50(%rax), %rax
movq %rax, 0x50(%r13)
testl %ebx, %ebx
je 0x44db3
orb $0x4, 0x28(%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/image.c
// Function: freeimage
static int freeimage(lua_State *L, ud_t *ud)
    {
    VkImage image = (VkImage)ud->handle;
    VkDevice device = ud->device;
    const VkAllocationCallbacks *allocator = ud->allocator;
    int borrowed = IsBorrowed(ud);

    /* delete all contained objects */
    freechildren(L, IMAGE_VIEW_MT, ud);

    if(!freeuserdata(L, ud))
        return 0; /* double call */
    TRACE_DELETE(image, "image");
    if(!borrowed)
        UD(device)->ddt->DestroyImage(device, image, allocator);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r13
movq (%rsi), %rbx
movq 0x20(%rsi), %r15
movq 0x40(%rsi), %r14
movl 0x28(%rsi), %ebp
leaq 0x48839(%rip), %rsi     # 0x8d651
movq %r12, %rdx
callq 0x18ef0
movq %r13, %rdi
movq %r12, %rsi
callq 0x18d20
testl %eax, %eax
je 0x44e6d
movq 0x7b192(%rip), %rax     # 0xbffc8
cmpl $0x0, (%rax)
je 0x44e4c
leaq 0x5a574(%rip), %rdi     # 0x9f3b6
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18960
testb $0x4, %bpl
jne 0x44e6d
movq %r15, %rdi
callq 0x19e90
movq 0x50(%rax), %rax
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x130(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/image.c
// Function: Create
static int Create(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkResult ec;
    VkImage image;
    VkImageCreateInfo* info;

    VkDevice device = checkdevice(L, 1, &ud);
    const VkAllocationCallbacks *allocator = optallocator(L, 3);
#define CLEANUP zfreeVkImageCreateInfo(L, info, 1)
    info = zcheckVkImageCreateInfo(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }

    ec = ud->ddt->CreateImage(device, info, allocator, &image);
    CLEANUP;
    CheckError(L, ec);
#undef CLEANUP
    return newimage(L, image, UD(device), device, allocator, 0);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x47066(%rip), %rcx     # 0x8c03b
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x1a4e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x191b0
movq %rax, %r15
leaq 0x14(%rsp), %r13
movq %rbx, %rdi
movl $0x2, %esi
movq %r13, %rdx
callq 0x18890
movq %rax, %r12
cmpl $0x0, (%r13)
je 0x45047
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19160
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x45094
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rsp, %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x128(%rax)
movl %eax, %r13d
movl $0x1, %ebp
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19160
testl %r13d, %r13d
je 0x450a7
movq %rbx, %rdi
xorl %esi, %esi
movl %r13d, %edx
callq 0x18980
movq %rbx, %rdi
callq 0x199a0
movl %eax, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %r12
movq %r14, %rdi
callq 0x19e90
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r14, %rcx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x44d22
jmp 0x45096
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/image.c
// Function: GetImageSubresourceLayout
static int GetImageSubresourceLayout(lua_State *L)
    {
    int err;
    VkImageSubresource* subresource;
    VkSubresourceLayout layout;
    ud_t *ud;
    VkImage image = checkimage(L, 1, &ud);
    VkDevice device = ud->device;
#define CLEANUP zfreeVkImageSubresource(L, subresource, 1)
    subresource = zcheckVkImageSubresource(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ud->ddt->GetImageSubresourceLayout(device, image, subresource, &layout);
    zpushVkSubresourceLayout(L, &layout);
    CLEANUP;
#undef CLEANUP
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x47887(%rip), %rcx     # 0x8c99a
movl $0x1, %ebp
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq %rax, %r15
movq (%r14), %rax
movq 0x20(%rax), %r12
leaq 0xc(%rsp), %r13
movq %rbx, %rdi
movl $0x2, %esi
movq %r13, %rdx
callq 0x187f0
movq %rax, %r14
cmpl $0x0, (%r13)
je 0x45186
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x19610
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %ebp
jmp 0x451c2
movq (%rsp), %rax
movq 0x50(%rax), %rax
leaq 0x10(%rsp), %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq *0x138(%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x18930
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x19610
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/image_view.c
// Function: Create
static int Create(lua_State *L)
    {
    int err;
    ud_t *ud, *image_ud;
    VkResult ec;
    VkImageView image_view;
    VkImageViewCreateInfo* info;
    const VkAllocationCallbacks *allocator = optallocator(L, 3);
    VkImage image = checkimage(L, 1, &image_ud);
    VkDevice device = image_ud->device;

#define CLEANUP zfreeVkImageViewCreateInfo(L, info, 1)
    info = zcheckVkImageViewCreateInfo(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    info->image = image;
    ec = UD(device)->ddt->CreateImageView(device, info, allocator, &image_view);
    CLEANUP;
#undef CLEANUP
    CheckError(L, ec);
    TRACE_CREATE(image_view, "image_view");
    ud = newuserdata_nondispatchable(L, image_view, IMAGE_VIEW_MT);
    ud->parent_ud = image_ud;
    ud->device = device;
    ud->instance = UD(device)->instance;
    ud->allocator = allocator;
    ud->destructor = freeimage_view;
    ud->ddt = UD(device)->ddt;
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x3, %esi
callq 0x191b0
movq %rax, %r14
leaq 0x47632(%rip), %rcx     # 0x8c99a
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a4e0
movq %rax, %r13
movq (%r15), %rax
movq 0x20(%rax), %r15
leaq 0x14(%rsp), %rbp
movq %rbx, %rdi
movl $0x2, %esi
movq %rbp, %rdx
callq 0x183c0
movq %rax, %r12
cmpl $0x0, (%rbp)
je 0x453d9
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19160
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x4549f
movq %r13, 0x18(%r12)
movq %r15, %rdi
callq 0x19e90
movq 0x50(%rax), %rax
movq %rsp, %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq *0x140(%rax)
movl %eax, %ebp
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19160
testl %ebp, %ebp
je 0x45428
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x18980
movq %rbx, %rdi
callq 0x199a0
jmp 0x4549f
movq 0x7ab99(%rip), %rax     # 0xbffc8
cmpl $0x0, (%rax)
je 0x45446
movq (%rsp), %rsi
leaq 0x59feb(%rip), %rdi     # 0x9f42a
xorl %eax, %eax
callq 0x18960
movq (%rsp), %rsi
leaq 0x48200(%rip), %rdx     # 0x8d651
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x18320
movq %rax, %rbx
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rbx)
movq %r15, 0x20(%rbx)
movq %r15, %rdi
callq 0x19e90
movq 0x18(%rax), %rax
movq %rax, 0x18(%rbx)
movq %r14, 0x40(%rbx)
leaq 0x57(%rip), %rax        # 0x454dd
movq %rax, 0x8(%rbx)
movq %r15, %rdi
callq 0x19e90
movq 0x50(%rax), %rax
movq %rax, 0x50(%rbx)
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/image_view.c
// Function: freeimage_view
static int freeimage_view(lua_State *L, ud_t *ud)
    {
    VkImageView image_view = (VkImageView)ud->handle;
    const VkAllocationCallbacks *allocator = ud->allocator;
    VkDevice device = ud->device;
    if(!freeuserdata(L, ud))
        return 0; /* double call */
    TRACE_DELETE(image_view, "image_view");
    UD(device)->ddt->DestroyImageView(device, image_view, allocator);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rsi), %rbx
movq 0x20(%rsi), %r15
movq 0x40(%rsi), %r14
callq 0x18d20
testl %eax, %eax
je 0x4552e
movq 0x7aacb(%rip), %rax     # 0xbffc8
cmpl $0x0, (%rax)
je 0x45513
leaq 0x59f3d(%rip), %rdi     # 0x9f446
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18960
movq %r15, %rdi
callq 0x19e90
movq 0x50(%rax), %rax
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x148(%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop