LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetDiscardRectangle
static int CmdSetDiscardRectangle(lua_State *L)
    {
    int err;
    uint32_t count;
    ud_t *ud;
    VkRect2D* rects;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t first = luaL_checkinteger(L, 2);
    CheckDevicePfn(L, ud, CmdSetDiscardRectangleEXT);
#define CLEANUP zfreearrayVkRect2D(L, rects, count, 1)
    rects = zcheckarrayVkRect2D(L, 3, &count, &err);
    if(err) { CLEANUP; return argerror(L, 3); }
    ud->ddt->CmdSetDiscardRectangleEXT(cb, first, count, rects);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x713b5(%rip), %rcx     # 0x8f909
leaq 0x10(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x190f0
movq %rax, %r12
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x4c0(%rax)
je 0x1e5ec
leaq 0xc(%rsp), %rdx
leaq 0x1c(%rsp), %r13
movq %rbx, %rdi
movl $0x3, %esi
movq %r13, %rcx
callq 0x1a490
movq %rax, %r14
cmpl $0x0, (%r13)
je 0x1e602
movl 0xc(%rsp), %ecx
movl $0x10, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x1e5fd
leaq 0x71541(%rip), %rsi     # 0x8fb34
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
movl %eax, %r15d
jmp 0x1e63e
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movl 0xc(%rsp), %edx
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rcx
callq *0x4c0(%rax)
movl 0xc(%rsp), %ecx
xorl %r15d, %r15d
movl $0x10, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movl %r15d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetSampleLocations
static int CmdSetSampleLocations(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkSampleLocationsInfoEXT* info;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdSetSampleLocationsEXT);
#define CLEANUP zfreeVkSampleLocationsInfoEXT(L, info, 1)
    info = zcheckVkSampleLocationsInfoEXT(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ud->ddt->CmdSetSampleLocationsEXT(cb, info);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x712a5(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq (%r15), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x4e0(%rax)
je 0x1e6da
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x18550
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1e6ed
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19170
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x1e714
leaq 0x71482(%rip), %rsi     # 0x8fb63
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
jmp 0x1e714
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x4e0(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19170
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdBeginDebugUtilsLabel
static int CmdBeginDebugUtilsLabel(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkDebugUtilsLabelEXT* label;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckInstancePfn(L, ud, CmdBeginDebugUtilsLabelEXT);
#define CLEANUP zfreeVkDebugUtilsLabelEXT(L, label, 1)
    label = zcheckVkDebugUtilsLabelEXT(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ud->idt->CmdBeginDebugUtilsLabelEXT(cb, label);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x711d4(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq (%r15), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x170(%rax)
je 0x1e7ab
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x18360
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1e7be
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19170
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x1e7e5
leaq 0x713df(%rip), %rsi     # 0x8fb91
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
jmp 0x1e7e5
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x170(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19170
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdEndDebugUtilsLabel
static int CmdEndDebugUtilsLabel(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckInstancePfn(L, ud, CmdEndDebugUtilsLabelEXT);
    ud->idt->CmdEndDebugUtilsLabelEXT(cb);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7110a(%rip), %rcx     # 0x8f909
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq (%r14), %rcx
movq 0x48(%rcx), %rcx
movq 0x178(%rcx), %rcx
testq %rcx, %rcx
je 0x1e82b
movq %rax, %rdi
callq *%rcx
xorl %eax, %eax
jmp 0x1e83c
leaq 0x7138f(%rip), %rsi     # 0x8fbc1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdInsertDebugUtilsLabel
static int CmdInsertDebugUtilsLabel(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkDebugUtilsLabelEXT* label;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckInstancePfn(L, ud, CmdInsertDebugUtilsLabelEXT);
#define CLEANUP zfreeVkDebugUtilsLabelEXT(L, label, 1)
    label = zcheckVkDebugUtilsLabelEXT(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ud->idt->CmdInsertDebugUtilsLabelEXT(cb, label);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x710b0(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq (%r15), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x180(%rax)
je 0x1e8cf
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x18360
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1e8e2
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19170
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x1e909
leaq 0x71319(%rip), %rsi     # 0x8fbef
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
jmp 0x1e909
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x180(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19170
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdBeginConditionalRendering
static int CmdBeginConditionalRendering(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkConditionalRenderingBeginInfoEXT* info;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
#define CLEANUP zfreeVkConditionalRenderingBeginInfoEXT(L, info, 1)
    info = zcheckVkConditionalRenderingBeginInfoEXT(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    CheckDevicePfn(L, ud, CmdBeginConditionalRenderingEXT);
    ud->ddt->CmdBeginConditionalRenderingEXT(cb, info);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x70fdf(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x1a520
movq %rax, %r15
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x19090
movq %rax, %r14
cmpl $0x0, (%r12)
je 0x1e98c
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x19170
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x1e9ce
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x518(%rax), %rax
testq %rax, %rax
je 0x1e9bd
movq %r15, %rdi
movq %r14, %rsi
callq *%rax
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x19170
xorl %eax, %eax
jmp 0x1e9ce
leaq 0x7125c(%rip), %rsi     # 0x8fc20
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdEndConditionalRendering
static int CmdEndConditionalRendering(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdEndConditionalRenderingEXT);
    ud->ddt->CmdEndConditionalRenderingEXT(cb);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x70f21(%rip), %rcx     # 0x8f909
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq (%r14), %rcx
movq 0x50(%rcx), %rcx
movq 0x520(%rcx), %rcx
testq %rcx, %rcx
je 0x1ea14
movq %rax, %rdi
callq *%rcx
xorl %eax, %eax
jmp 0x1ea25
leaq 0x7123a(%rip), %rsi     # 0x8fc55
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdDrawIndirectCount
static int CmdDrawIndirectCount(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBuffer buffer = checkbuffer(L, 2, NULL);
    VkDeviceSize offset = luaL_checkinteger(L, 3);
    VkBuffer countBuffer = checkbuffer(L, 4, NULL);
    VkDeviceSize countBufferOffset = luaL_checkinteger(L, 5);
    uint32_t maxDrawCount = luaL_checkinteger(L, 6);
    uint32_t stride = luaL_checkinteger(L, 7);
    CheckDevicePfn(L, ud, CmdDrawIndirectCount);
    ud->ddt->CmdDrawIndirectCount(cb, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x70ec4(%rip), %rcx     # 0x8f909
leaq 0x20(%rsp), %rdx
movl $0x1, %esi
callq 0x1a520
movq %rax, 0x18(%rsp)
leaq 0x705a0(%rip), %r15     # 0x8f000
xorl %ebx, %ebx
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x1a520
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movl $0x3, %esi
callq 0x190f0
movq %rax, %rbp
movq %r14, %rdi
movl $0x4, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x1a520
movq %rax, %r15
movq %r14, %rdi
movl $0x5, %esi
callq 0x190f0
movq %rax, %r13
movq %r14, %rdi
movl $0x6, %esi
callq 0x190f0
movq %rax, %r12
movq %r14, %rdi
movl $0x7, %esi
callq 0x190f0
leaq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq 0x50(%rcx), %rcx
movq 0x5a8(%rcx), %r10
testq %r10, %r10
je 0x1eb01
movl %eax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rbp, %rdx
movq %r15, %rcx
movq %r13, %r8
movl %r12d, %r9d
callq *%r10
jmp 0x1eb14
leaq 0x71180(%rip), %rsi     # 0x8fc88
movq %r14, %rdi
xorl %eax, %eax
callq 0x19be0
movl %eax, %ebx
movl %ebx, %eax
addq $0x28, %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/cmd.c
// Function: CmdDrawIndexedIndirectCount
static int CmdDrawIndexedIndirectCount(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBuffer buffer = checkbuffer(L, 2, NULL);
    VkDeviceSize offset = luaL_checkinteger(L, 3);
    VkBuffer countBuffer = checkbuffer(L, 4, NULL);
    VkDeviceSize countBufferOffset = luaL_checkinteger(L, 5);
    uint32_t maxDrawCount = luaL_checkinteger(L, 6);
    uint32_t stride = luaL_checkinteger(L, 7);
    CheckDevicePfn(L, ud, CmdDrawIndexedIndirectCount);
    ud->ddt->CmdDrawIndexedIndirectCount(cb, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x70dcc(%rip), %rcx     # 0x8f909
leaq 0x20(%rsp), %rdx
movl $0x1, %esi
callq 0x1a520
movq %rax, 0x18(%rsp)
leaq 0x704a8(%rip), %r15     # 0x8f000
xorl %ebx, %ebx
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x1a520
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movl $0x3, %esi
callq 0x190f0
movq %rax, %rbp
movq %r14, %rdi
movl $0x4, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x1a520
movq %rax, %r15
movq %r14, %rdi
movl $0x5, %esi
callq 0x190f0
movq %rax, %r13
movq %r14, %rdi
movl $0x6, %esi
callq 0x190f0
movq %rax, %r12
movq %r14, %rdi
movl $0x7, %esi
callq 0x190f0
leaq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq 0x50(%rcx), %rcx
movq 0x5b0(%rcx), %r10
testq %r10, %r10
je 0x1ebf9
movl %eax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rbp, %rdx
movq %r15, %rcx
movq %r13, %r8
movl %r12d, %r9d
callq *%r10
jmp 0x1ec0c
leaq 0x710b2(%rip), %rsi     # 0x8fcb2
movq %r14, %rdi
xorl %eax, %eax
callq 0x19be0
movl %eax, %ebx
movl %ebx, %eax
addq $0x28, %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/cmd.c
// Function: CmdSetDeviceMask
static int CmdSetDeviceMask(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t deviceMask = luaL_checkinteger(L, 2);
    CheckDevicePfn(L, ud, CmdSetDeviceMask);
    ud->ddt->CmdSetDeviceMask(cb, deviceMask);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x70cd9(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x190f0
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x538(%rcx), %rcx
testq %rcx, %rcx
je 0x1ec70
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1ec81
leaq 0x7106c(%rip), %rsi     # 0x8fce3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdDispatchBase
static int CmdDispatchBase(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t baseGroupX = luaL_checkinteger(L, 2);
    uint32_t baseGroupY = luaL_checkinteger(L, 3);
    uint32_t baseGroupZ = luaL_checkinteger(L, 4);
    uint32_t groupCountX = luaL_checkinteger(L, 5);
    uint32_t groupCountY = luaL_checkinteger(L, 6);
    uint32_t groupCountZ = luaL_checkinteger(L, 7);
    CheckDevicePfn(L, ud, CmdDispatchBase);
    ud->ddt->CmdDispatchBase(cb, baseGroupX, baseGroupY, baseGroupZ,
            groupCountX, groupCountY, groupCountZ);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x70c66(%rip), %rcx     # 0x8f909
leaq 0x20(%rsp), %rbp
movl $0x1, %esi
movq %rbp, %rdx
callq 0x1a520
movq %rax, 0x18(%rsp)
movq %r14, %rdi
movl $0x2, %esi
callq 0x190f0
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movl $0x3, %esi
callq 0x190f0
movq %rax, %r12
movq %r14, %rdi
movl $0x4, %esi
callq 0x190f0
movq %rax, %r13
movq %r14, %rdi
movl $0x5, %esi
callq 0x190f0
movq %rax, %rbx
movq %r14, %rdi
movl $0x6, %esi
callq 0x190f0
movq %rax, %r15
movq %r14, %rdi
movl $0x7, %esi
callq 0x190f0
movq (%rbp), %rcx
movq 0x50(%rcx), %rcx
movq 0x540(%rcx), %r10
testq %r10, %r10
je 0x1ed4d
movl %eax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl %r12d, %edx
movl %r13d, %ecx
movl %ebx, %r8d
movl %r15d, %r9d
callq *%r10
xorl %eax, %eax
jmp 0x1ed5e
leaq 0x70fb5(%rip), %rsi     # 0x8fd09
movq %r14, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x28, %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/cmd.c
// Function: CmdBeginTransformFeedback
static int CmdBeginTransformFeedback(lua_State *L)
    {
    ud_t *ud;
    int err = 0, errargc=1;
    uint32_t first, count, count1;
    VkBuffer* buffers = NULL;
    VkDeviceSize *offsets = NULL;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdBeginTransformFeedbackEXT);

    first = luaL_checkinteger(L, 2);

    buffers = checkbufferlist(L, 3, &count, &err);
    if(err == ERR_NOTPRESENT) err = 0;
    else if(err) { errargc=3; goto failure; }

    offsets = checkdevicesizelist(L, 4, &count1, &err);
    if(err == ERR_NOTPRESENT) err = 0;
    else if(err) { errargc=4; goto failure; }
    if(count1 != count) { err=ERR_LENGTH; errargc=4; goto failure; }

    ud->ddt->CmdBeginTransformFeedbackEXT(cb, first, count, buffers, offsets);
failure:
    if(buffers) Free(L, buffers);
    if(offsets) Free(L, offsets);
    return err ? argerrorc(L, errargc, err) : 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x0, 0xc(%rsp)
leaq 0x7099a(%rip), %rcx     # 0x8f909
leaq 0x20(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq %rax, %r15
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x578(%rax)
je 0x1f055
movq %rbx, %rdi
movl $0x2, %esi
callq 0x190f0
movq %rax, %r13
leaq 0x70050(%rip), %r8      # 0x8f000
movl $0x3, %ebp
leaq 0x14(%rsp), %rdx
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movl $0x3, %esi
movq %r12, %rcx
callq 0x199f0
movq %rax, %r14
movl (%r12), %eax
testl %eax, %eax
je 0x1efeb
cmpl $0x1, %eax
jne 0x1f068
movl $0x0, 0xc(%rsp)
movq %r13, 0x18(%rsp)
movl $0x4, %ebp
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %r13
movq %rbx, %rdi
movl $0x4, %esi
movq %r13, %rcx
callq 0x19eb0
movq %rax, %r12
movl (%r13), %eax
testl %eax, %eax
je 0x1f027
cmpl $0x1, %eax
jne 0x1f075
movl $0x0, 0xc(%rsp)
movl 0x14(%rsp), %edx
cmpl %edx, 0x10(%rsp)
jne 0x1f06d
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movq %r15, %rdi
movq 0x18(%rsp), %rsi
movq %r14, %rcx
movq %r12, %r8
callq *0x578(%rax)
movl $0x1, %ebp
jmp 0x1f075
leaq 0x70d0a(%rip), %rsi     # 0x8fd66
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
jmp 0x1f0b3
xorl %r12d, %r12d
jmp 0x1f075
movl $0xfffffff9, 0xc(%rsp)  # imm = 0xFFFFFFF9
testq %r14, %r14
je 0x1f085
movq %rbx, %rdi
movq %r14, %rsi
callq 0x182e0
testq %r12, %r12
je 0x1f095
movq %rbx, %rdi
movq %r12, %rsi
callq 0x182e0
movl 0xc(%rsp), %edi
testl %edi, %edi
je 0x1f0b1
callq 0x19970
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x1f0b3
xorl %eax, %eax
addq $0x28, %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/cmd.c
// Function: CmdBeginQueryIndexed
static int CmdBeginQueryIndexed(lua_State *L)
    {
    ud_t *ud;
    VkQueryPool query_pool;
    VkQueryControlFlags flags;
    uint32_t query, index;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdBeginQueryIndexedEXT);
    query_pool = checkquery_pool(L, 2, NULL);
    query = luaL_checkinteger(L, 3);
    flags = checkflags(L, 4);
    index = luaL_checkinteger(L, 5);
    ud->ddt->CmdBeginQueryIndexedEXT(cb, query_pool, query, flags, index);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x706bf(%rip), %rcx     # 0x8f909
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq %rax, %r15
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x588(%rax)
je 0x1f2d6
leaq 0x7079a(%rip), %rcx     # 0x8fa0f
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x190f0
movq %rax, %r13
movq %rbx, %rdi
movl $0x4, %esi
callq 0x18f70
movq %rax, %rbp
movq %rbx, %rdi
movl $0x5, %esi
callq 0x190f0
movq (%rsp), %rcx
movq 0x50(%rcx), %r9
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
movl %ebp, %ecx
movl %eax, %r8d
callq *0x588(%r9)
jmp 0x1f2ea
leaq 0x70aeb(%rip), %rsi     # 0x8fdc8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
movl %eax, %r14d
movl %r14d, %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/cmd.c
// Function: CmdEndQueryIndexed
static int CmdEndQueryIndexed(lua_State *L)
    {
    ud_t *ud;
    VkQueryPool query_pool;
    uint32_t query, index;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdEndQueryIndexedEXT);
    query_pool = checkquery_pool(L, 2, NULL);
    query = luaL_checkinteger(L, 3);
    index = luaL_checkinteger(L, 4);
    ud->ddt->CmdEndQueryIndexedEXT(cb, query_pool, query, index);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x705f6(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq %rax, %r15
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x590(%rax)
je 0x1f38f
leaq 0x706cf(%rip), %rcx     # 0x8fa0f
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x190f0
movq %rax, %r13
movq %rbx, %rdi
movl $0x4, %esi
callq 0x190f0
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %r8
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
movl %eax, %ecx
callq *0x590(%r8)
jmp 0x1f3a3
leaq 0x70a5f(%rip), %rsi     # 0x8fdf5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
movl %eax, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdDrawIndirectByteCount
static int CmdDrawIndirectByteCount(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t instanceCount = luaL_checkinteger(L, 2);
    uint32_t firstInstance = luaL_checkinteger(L, 3);
    VkBuffer counterBuffer = checkbuffer(L, 4, NULL);
    VkDeviceSize counterBufferOffset = checkdevicesize(L, 5);
    uint32_t counterOffset = luaL_checkinteger(L, 6);
    uint32_t vertexStride = luaL_checkinteger(L, 7);
    CheckDevicePfn(L, ud, CmdDrawIndirectByteCountEXT);
    ud->ddt->CmdDrawIndirectByteCountEXT(cb, instanceCount, firstInstance,
            counterBuffer, counterBufferOffset, counterOffset, vertexStride);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x7053d(%rip), %rcx     # 0x8f909
leaq 0x20(%rsp), %rdx
movl $0x1, %esi
callq 0x1a520
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x190f0
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x190f0
movq %rax, %r13
leaq 0x6fbf7(%rip), %rcx     # 0x8f000
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x5, %esi
callq 0x19c90
movq %rax, %r12
movq %rbx, %rdi
movl $0x6, %esi
callq 0x190f0
movq %rax, %rbp
movq %rbx, %rdi
movl $0x7, %esi
callq 0x190f0
leaq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq 0x50(%rcx), %rcx
movq 0x598(%rcx), %r10
testq %r10, %r10
je 0x1f481
movl %eax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl %r13d, %edx
movq %r14, %rcx
movq %r12, %r8
movl %ebp, %r9d
callq *%r10
jmp 0x1f495
leaq 0x70998(%rip), %rsi     # 0x8fe20
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
movl %eax, %r15d
movl %r15d, %eax
addq $0x28, %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/cmd.c
// Function: CmdSetLineStipple
static int CmdSetLineStipple(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t lineStippleFactor = luaL_checkinteger(L, 2);
    uint16_t lineStipplePattern = luaL_checkinteger(L, 3);
    CheckDevicePfn(L, ud, CmdSetLineStippleEXT);
    ud->ddt->CmdSetLineStippleEXT(cb, lineStippleFactor, lineStipplePattern);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x70450(%rip), %rcx     # 0x8f909
movq %rsp, %r12
movl $0x1, %esi
movq %r12, %rdx
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x190f0
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x190f0
movq (%r12), %rcx
movq 0x50(%rcx), %rcx
movq 0x788(%rcx), %rcx
testq %rcx, %rcx
je 0x1f50c
movzwl %ax, %edx
movq %r14, %rdi
movl %r15d, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f51d
leaq 0x7093e(%rip), %rsi     # 0x8fe51
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetColorWriteEnable
static int CmdSetColorWriteEnable(lua_State *L)
    {
    int err;
    ud_t *ud;
    uint32_t count;
    VkBool32 *enables;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdSetColorWriteEnableEXT);
#define CLEANUP Free(L, enables)
    enables = checkbooleanlist(L, 2, &count, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ud->ddt->CmdSetColorWriteEnableEXT(cb, count, enables);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x703cb(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq (%r15), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x840(%rax)
je 0x1f5b4
leaq 0x4(%rsp), %rdx
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rcx
callq 0x192f0
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1f5c7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x182e0
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x1f5ed
leaq 0x708c0(%rip), %rsi     # 0x8fe7b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
jmp 0x1f5ed
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x4(%rsp), %esi
movq %r14, %rdi
movq %r15, %rdx
callq *0x840(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x182e0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetCullMode
static int CmdSetCullMode(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkCullModeFlags cullMode = checkflags(L, 2);
    CheckDevicePfn(L, ud, CmdSetCullModeEXT);
    ud->ddt->CmdSetCullModeEXT(cb, cullMode);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x702fd(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x18f70
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x790(%rcx), %rcx
testq %rcx, %rcx
je 0x1f64c
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f65d
leaq 0x70857(%rip), %rsi     # 0x8feaa
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetFrontFace
static int CmdSetFrontFace(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkFrontFace frontFace = checkfrontface(L, 2);
    CheckDevicePfn(L, ud, CmdSetFrontFaceEXT);
    ud->ddt->CmdSetFrontFaceEXT(cb, frontFace);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x7028f(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x10, %esi
movl $0x2, %edx
callq 0x19c20
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x798(%rcx), %rcx
testq %rcx, %rcx
je 0x1f6bf
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f6d0
leaq 0x7080b(%rip), %rsi     # 0x8fed1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetPrimitiveTopology
static int CmdSetPrimitiveTopology(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkPrimitiveTopology primitiveTopology = checkprimitivetopology(L, 2);
    CheckDevicePfn(L, ud, CmdSetPrimitiveTopologyEXT);
    ud->ddt->CmdSetPrimitiveTopologyEXT(cb, primitiveTopology);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x7021c(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0xe, %esi
movl $0x2, %edx
callq 0x19c20
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x7a0(%rcx), %rcx
testq %rcx, %rcx
je 0x1f732
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f743
leaq 0x707c0(%rip), %rsi     # 0x8fef9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetViewportWithCount
static int CmdSetViewportWithCount(lua_State *L)
    {
    int err;
    ud_t *ud;
    uint32_t count;
    VkViewport *viewports;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdSetViewportWithCountEXT);
#define CLEANUP zfreearrayVkViewport (L, viewports, count, 1)
    viewports = zcheckarrayVkViewport(L, 2, &count, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ud->ddt->CmdSetViewportWithCountEXT(cb, count, viewports);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x701a7(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq %rax, %r15
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x7a8(%rax)
je 0x1f7ea
leaq 0x4(%rsp), %rdx
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rcx
callq 0x19320
movq %rax, %r14
cmpl $0x0, (%r12)
je 0x1f800
movl 0x4(%rsp), %ecx
movl $0x18, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x1f7fb
leaq 0x70738(%rip), %rsi     # 0x8ff29
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
movl %eax, %r15d
jmp 0x1f839
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x4(%rsp), %esi
movq %r15, %rdi
movq %r14, %rdx
callq *0x7a8(%rax)
movl 0x4(%rsp), %ecx
xorl %r15d, %r15d
movl $0x18, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetScissorWithCount
static int CmdSetScissorWithCount(lua_State *L)
    {
    int err;
    ud_t *ud;
    uint32_t count;
    VkRect2D* scissors;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdSetScissorWithCountEXT);
#define CLEANUP zfreearrayVkRect2D(L, scissors, count, 1)
    scissors = zcheckarrayVkRect2D(L, 2, &count, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ud->ddt->CmdSetScissorWithCountEXT(cb, count, scissors);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x700ac(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq %rax, %r15
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x7b0(%rax)
je 0x1f8e5
leaq 0x4(%rsp), %rdx
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rcx
callq 0x1a490
movq %rax, %r14
cmpl $0x0, (%r12)
je 0x1f8fb
movl 0x4(%rsp), %ecx
movl $0x10, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x1f8f6
leaq 0x7066d(%rip), %rsi     # 0x8ff59
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
movl %eax, %r15d
jmp 0x1f934
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x4(%rsp), %esi
movq %r15, %rdi
movq %r14, %rdx
callq *0x7b0(%rax)
movl 0x4(%rsp), %ecx
xorl %r15d, %r15d
movl $0x10, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetDepthTestEnable
static int CmdSetDepthTestEnable(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBool32 depthTestEnable = checkboolean(L, 2);
    CheckDevicePfn(L, ud, CmdSetDepthTestEnableEXT);
    ud->ddt->CmdSetDepthTestEnableEXT(cb, depthTestEnable);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x6ffb3(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x187a0
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x7c0(%rcx), %rcx
testq %rcx, %rcx
je 0x1f996
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f9a7
leaq 0x705eb(%rip), %rsi     # 0x8ff88
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetDepthWriteEnable
static int CmdSetDepthWriteEnable(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBool32 depthWriteEnable = checkboolean(L, 2);
    CheckDevicePfn(L, ud, CmdSetDepthWriteEnableEXT);
    ud->ddt->CmdSetDepthWriteEnableEXT(cb, depthWriteEnable);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x6ff45(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x187a0
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x7c8(%rcx), %rcx
testq %rcx, %rcx
je 0x1fa04
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1fa15
leaq 0x705ab(%rip), %rsi     # 0x8ffb6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetDepthCompareOp
static int CmdSetDepthCompareOp(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkCompareOp depthCompareOp = checkcompareop(L, 2);
    CheckDevicePfn(L, ud, CmdSetDepthCompareOpEXT);
    ud->ddt->CmdSetDepthCompareOpEXT(cb, depthCompareOp);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x6fed7(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x11, %esi
movl $0x2, %edx
callq 0x19c20
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x7d0(%rcx), %rcx
testq %rcx, %rcx
je 0x1fa77
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1fa88
leaq 0x70567(%rip), %rsi     # 0x8ffe5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetDepthBoundsTestEnable
static int CmdSetDepthBoundsTestEnable(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBool32 depthBoundsTestEnable = checkboolean(L, 2);
    CheckDevicePfn(L, ud, CmdSetDepthBoundsTestEnableEXT);
    ud->ddt->CmdSetDepthBoundsTestEnableEXT(cb, depthBoundsTestEnable);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x6fe64(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x187a0
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x7d8(%rcx), %rcx
testq %rcx, %rcx
je 0x1fae5
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1faf6
leaq 0x70526(%rip), %rsi     # 0x90012
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetStencilTestEnable
static int CmdSetStencilTestEnable(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBool32 stencilTestEnable = checkboolean(L, 2);
    CheckDevicePfn(L, ud, CmdSetStencilTestEnableEXT);
    ud->ddt->CmdSetStencilTestEnableEXT(cb, stencilTestEnable);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x6fdf6(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x187a0
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x7e0(%rcx), %rcx
testq %rcx, %rcx
je 0x1fb53
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1fb64
leaq 0x704ec(%rip), %rsi     # 0x90046
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetStencilOp
static int CmdSetStencilOp(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkStencilFaceFlags faceMask = checkflags(L, 2);
    VkStencilOp failOp = checkstencilop(L, 3);
    VkStencilOp passOp = checkstencilop(L, 4);
    VkStencilOp depthFailOp = checkstencilop(L, 5);
    VkCompareOp compareOp = checkcompareop(L, 6);
    CheckDevicePfn(L, ud, CmdSetStencilOpEXT);
    ud->ddt->CmdSetStencilOpEXT(cb, faceMask, failOp, passOp, depthFailOp, compareOp);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x6fd83(%rip), %rcx     # 0x8f909
leaq 0x10(%rsp), %r12
movl $0x1, %esi
movq %r12, %rdx
callq 0x1a520
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x18f70
movq %rax, %r15
movq %rbx, %rdi
movl $0x12, %esi
movl $0x3, %edx
callq 0x19c20
movl %eax, %ebp
movq %rbx, %rdi
movl $0x12, %esi
movl $0x4, %edx
callq 0x19c20
movl %eax, %r13d
movq %rbx, %rdi
movl $0x12, %esi
movl $0x5, %edx
callq 0x19c20
movl %eax, %r14d
movq %rbx, %rdi
movl $0x11, %esi
movl $0x6, %edx
callq 0x19c20
movq (%r12), %rcx
movq 0x50(%rcx), %rcx
movq 0x7e8(%rcx), %r10
testq %r10, %r10
je 0x1fc2b
movq 0x8(%rsp), %rdi
movl %r15d, %esi
movl %ebp, %edx
movl %r13d, %ecx
movl %r14d, %r8d
movl %eax, %r9d
callq *%r10
xorl %eax, %eax
jmp 0x1fc3c
leaq 0x70444(%rip), %rsi     # 0x90076
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x18, %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/cmd.c
// Function: CmdSetPatchControlPoints
static int CmdSetPatchControlPoints(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t patchControlPoints = luaL_checkinteger(L, 2);
    CheckDevicePfn(L, ud, CmdSetPatchControlPointsEXT);
    ud->ddt->CmdSetPatchControlPointsEXT(cb, patchControlPoints);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x6fcab(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x190f0
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x818(%rcx), %rcx
testq %rcx, %rcx
je 0x1fc9e
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1fcaf
leaq 0x703f9(%rip), %rsi     # 0x9009e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetRasterizerDiscardEnable
static int CmdSetRasterizerDiscardEnable(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBool32 rasterizerDiscardEnable = checkboolean(L, 2);
    CheckDevicePfn(L, ud, CmdSetRasterizerDiscardEnableEXT);
    ud->ddt->CmdSetRasterizerDiscardEnableEXT(cb, rasterizerDiscardEnable);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x6fc3d(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x187a0
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x820(%rcx), %rcx
testq %rcx, %rcx
je 0x1fd0c
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1fd1d
leaq 0x703bc(%rip), %rsi     # 0x900cf
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetDepthBiasEnable
static int CmdSetDepthBiasEnable(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBool32 depthBiasEnable = checkboolean(L, 2);
    CheckDevicePfn(L, ud, CmdSetDepthBiasEnableEXT);
    ud->ddt->CmdSetDepthBiasEnableEXT(cb, depthBiasEnable);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x6fbcf(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x187a0
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x828(%rcx), %rcx
testq %rcx, %rcx
je 0x1fd7a
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1fd8b
leaq 0x70384(%rip), %rsi     # 0x90105
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetLogicOp
static int CmdSetLogicOp(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkLogicOp logicOp = checklogicop(L, 2);
    CheckDevicePfn(L, ud, CmdSetLogicOpEXT);
    ud->ddt->CmdSetLogicOpEXT(cb, logicOp);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x6fb61(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x13, %esi
movl $0x2, %edx
callq 0x19c20
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x830(%rcx), %rcx
testq %rcx, %rcx
je 0x1fded
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1fdfe
leaq 0x7033f(%rip), %rsi     # 0x90133
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetPrimitiveRestartEnable
static int CmdSetPrimitiveRestartEnable(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBool32 primitiveRestartEnable = checkboolean(L, 2);
    CheckDevicePfn(L, ud, CmdSetPrimitiveRestartEnableEXT);
    ud->ddt->CmdSetPrimitiveRestartEnableEXT(cb, primitiveRestartEnable);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x6faee(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x187a0
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x838(%rcx), %rcx
testq %rcx, %rcx
je 0x1fe5b
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1fe6c
leaq 0x702f7(%rip), %rsi     # 0x90159
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdDrawMulti
static int CmdDrawMulti(lua_State *L)
    {
    int err;
    uint32_t count;
    ud_t *ud;
    VkMultiDrawInfoEXT *info = NULL;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t instanceCount = luaL_checkinteger(L, 3);
    uint32_t firstInstance = luaL_checkinteger(L, 4);
    uint32_t stride = luaL_checkinteger(L, 5);
    CheckDevicePfn(L, ud, CmdDrawMultiEXT);
#define CLEANUP do {                                            \
    if(info) zfreearrayVkMultiDrawInfoEXT(L, info, count, 1);   \
} while(0)
    info = zcheckarrayVkMultiDrawInfoEXT(L, 2, &count, &err);
    if(err < 0 && err != ERR_EMPTY) { CLEANUP; return argerror(L, 2); }
    ud->ddt->CmdDrawMultiEXT(cb, count, info, instanceCount, firstInstance, stride);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x6f8bb(%rip), %rcx     # 0x8f909
leaq 0x18(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x190f0
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
callq 0x190f0
movq %rax, %r13
movq %rbx, %rdi
movl $0x5, %esi
callq 0x190f0
movq %rax, %rbp
movq (%r15), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x848(%rax)
je 0x2011b
movq %r14, 0x10(%rsp)
leaq 0xc(%rsp), %rdx
leaq 0x24(%rsp), %r14
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rcx
callq 0x18ec0
movq %rax, %r15
movl (%r14), %eax
testl %eax, %eax
setns %cl
cmpl $-0x5, %eax
sete %al
orb %cl, %al
jne 0x20131
testq %r15, %r15
je 0x200fa
movl 0xc(%rsp), %ecx
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x2012c
leaq 0x70096(%rip), %rsi     # 0x901b8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
movl %eax, %r14d
jmp 0x2017f
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdi
movq %r15, %rdx
movl %r12d, %ecx
movl %r13d, %r8d
movl %ebp, %r9d
callq *0x848(%rax)
testq %r15, %r15
je 0x2017c
movl 0xc(%rsp), %ecx
xorl %r14d, %r14d
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
jmp 0x2017f
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq