LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdPushDescriptorSetWithTemplate
static int CmdPushDescriptorSetWithTemplate(lua_State *L)
    {
    size_t len;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkDescriptorUpdateTemplate desc_template = checkdescriptor_update_template(L, 2, NULL);
    VkPipelineLayout layout = checkpipeline_layout(L, 3, NULL);
    uint32_t set = luaL_checkinteger(L, 4);
    const void* data = luaL_checklstring(L, 5, &len);
    CheckDevicePfn(L, ud, CmdPushDescriptorSetWithTemplateKHR);
    ud->ddt->CmdPushDescriptorSetWithTemplateKHR(cb, desc_template, layout, set, data);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x5f90d(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdx
callq 0x1a500
movq %rax, (%rsp)
leaq 0x5fabe(%rip), %rcx     # 0x7dad5
xorl %ebx, %ebx
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %r13
leaq 0x5f907(%rip), %rcx     # 0x7d937
pushq $0x3
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %rbp
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %r15
pushq $0x5
popq %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x18d50
movq (%r12), %rcx
movq 0x50(%rcx), %rcx
movq 0x470(%rcx), %r9
testq %r9, %r9
je 0x1e087
movq (%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movl %r15d, %ecx
movq %rax, %r8
callq *%r9
jmp 0x1e09a
leaq 0x5fa6d(%rip), %rsi     # 0x7dafb
movq %r14, %rdi
xorl %eax, %eax
callq 0x19bc0
movl %eax, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5f847(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq %rax, %r12
movq (%r15), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x4c0(%rax)
je 0x1e14c
pushq $0x3
popq %rsi
leaq 0xc(%rsp), %rdx
leaq 0x1c(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rcx
callq 0x1a470
movq %rax, %r15
cmpl $0x0, (%r13)
je 0x1e162
movl 0xc(%rsp), %ecx
pushq $0x10
popq %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r15, %rsi
xorl %r9d, %r9d
callq 0x18d30
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
jmp 0x1e15d
leaq 0x5f9e1(%rip), %rsi     # 0x7db34
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
movl %eax, %r14d
jmp 0x1e19a
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movl 0xc(%rsp), %edx
movq %r14, %rdi
movl %r12d, %esi
movq %r15, %rcx
callq *0x4c0(%rax)
movl 0xc(%rsp), %ecx
xorl %r14d, %r14d
pushq $0x10
popq %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r15, %rsi
xorl %r9d, %r9d
callq 0x18d30
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5f749(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
movq (%r15), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x4e0(%rax)
je 0x1e22c
pushq $0x2
popq %rsi
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x18550
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1e23f
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19150
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
jmp 0x1e264
leaq 0x5f930(%rip), %rsi     # 0x7db63
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
jmp 0x1e264
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x4e0(%rax)
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19150
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5f684(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
movq (%r15), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x170(%rax)
je 0x1e2f1
pushq $0x2
popq %rsi
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x18360
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1e304
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19150
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
jmp 0x1e329
leaq 0x5f899(%rip), %rsi     # 0x7db91
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
jmp 0x1e329
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x170(%rax)
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19150
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5f5c6(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
movq %rsp, %r14
movq %r14, %rdx
callq 0x1a500
movq (%r14), %rcx
movq 0x48(%rcx), %rcx
movq 0x178(%rcx), %rcx
testq %rcx, %rcx
je 0x1e36d
movq %rax, %rdi
callq *%rcx
xorl %eax, %eax
jmp 0x1e37e
leaq 0x5f84d(%rip), %rsi     # 0x7dbc1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5f56e(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
movq (%r15), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x180(%rax)
je 0x1e407
pushq $0x2
popq %rsi
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x18360
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1e41a
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19150
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
jmp 0x1e43f
leaq 0x5f7e1(%rip), %rsi     # 0x7dbef
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
jmp 0x1e43f
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x180(%rax)
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19150
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5f4a9(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x1a500
movq %rax, %r15
pushq $0x2
popq %rsi
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x19070
movq %rax, %r14
cmpl $0x0, (%r12)
je 0x1e4b8
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19150
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
jmp 0x1e4f8
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x518(%rax), %rax
testq %rax, %rax
je 0x1e4e7
movq %r15, %rdi
movq %r14, %rsi
callq *%rax
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19150
xorl %eax, %eax
jmp 0x1e4f8
leaq 0x5f732(%rip), %rsi     # 0x7dc20
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5f3f7(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
movq %rsp, %r14
movq %r14, %rdx
callq 0x1a500
movq (%r14), %rcx
movq 0x50(%rcx), %rcx
movq 0x520(%rcx), %rcx
testq %rcx, %rcx
je 0x1e53c
movq %rax, %rdi
callq *%rcx
xorl %eax, %eax
jmp 0x1e54d
leaq 0x5f712(%rip), %rsi     # 0x7dc55
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5f39c(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x20(%rsp), %rdx
callq 0x1a500
movq %rax, 0x18(%rsp)
leaq 0x5ea7a(%rip), %r15     # 0x7d000
xorl %ebx, %ebx
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
movq %r15, %rcx
callq 0x1a500
movq %rax, 0x10(%rsp)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %rbp
pushq $0x4
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
movq %r15, %rcx
callq 0x1a500
movq %rax, %r15
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %r13
pushq $0x6
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %r12
pushq $0x7
popq %rsi
movq %r14, %rdi
callq 0x190d0
leaq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq 0x50(%rcx), %rcx
movq 0x5a8(%rcx), %r10
testq %r10, %r10
je 0x1e61b
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 0x1e62e
leaq 0x5f666(%rip), %rsi     # 0x7dc88
movq %r14, %rdi
xorl %eax, %eax
callq 0x19bc0
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_O2/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 0x5f2b2(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x20(%rsp), %rdx
callq 0x1a500
movq %rax, 0x18(%rsp)
leaq 0x5e990(%rip), %r15     # 0x7d000
xorl %ebx, %ebx
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
movq %r15, %rcx
callq 0x1a500
movq %rax, 0x10(%rsp)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %rbp
pushq $0x4
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
movq %r15, %rcx
callq 0x1a500
movq %rax, %r15
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %r13
pushq $0x6
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %r12
pushq $0x7
popq %rsi
movq %r14, %rdi
callq 0x190d0
leaq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq 0x50(%rcx), %rcx
movq 0x5b0(%rcx), %r10
testq %r10, %r10
je 0x1e705
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 0x1e718
leaq 0x5f5a6(%rip), %rsi     # 0x7dcb2
movq %r14, %rdi
xorl %eax, %eax
callq 0x19bc0
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_O2/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 0x5f1cd(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x538(%rcx), %rcx
testq %rcx, %rcx
je 0x1e778
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1e789
leaq 0x5f564(%rip), %rsi     # 0x7dce3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5f15e(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x20(%rsp), %r13
movq %r13, %rdx
callq 0x1a500
movq %rax, 0x18(%rsp)
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, 0x10(%rsp)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %r12
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %rbp
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %rbx
pushq $0x6
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %r15
pushq $0x7
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq (%r13), %rcx
movq 0x50(%rcx), %rcx
movq 0x540(%rcx), %r10
testq %r10, %r10
je 0x1e846
movl %eax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl %r12d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
movl %r15d, %r9d
callq *%r10
xorl %eax, %eax
jmp 0x1e857
leaq 0x5f4bc(%rip), %rsi     # 0x7dd09
movq %r14, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, 0xc(%rsp)
leaq 0x5eecc(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r12
movq (%r15), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x578(%rax)
je 0x1eb08
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq %rax, %r14
leaq 0x5e586(%rip), %r8      # 0x7d000
pushq $0x3
popq %rbp
leaq 0x14(%rsp), %rdx
leaq 0xc(%rsp), %r13
movq %rbx, %rdi
movl %ebp, %esi
movq %r13, %rcx
callq 0x199d0
movq %rax, %r15
movl (%r13), %eax
testl %eax, %eax
je 0x1eaa9
cmpl $0x1, %eax
jne 0x1eb1b
andl $0x0, 0xc(%rsp)
movq %r14, 0x18(%rsp)
pushq $0x4
popq %rbp
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %r14
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rcx
callq 0x19e90
movq %rax, %r13
movl (%r14), %eax
testl %eax, %eax
je 0x1eadc
cmpl $0x1, %eax
jne 0x1eb28
andl $0x0, 0xc(%rsp)
movl 0x10(%rsp), %edx
cmpl 0x14(%rsp), %edx
jne 0x1eb20
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movq %r12, %rdi
movq 0x18(%rsp), %rsi
movq %r15, %rcx
movq %r13, %r8
callq *0x578(%rax)
pushq $0x1
popq %rbp
jmp 0x1eb28
leaq 0x5f257(%rip), %rsi     # 0x7dd66
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
jmp 0x1eb66
xorl %r13d, %r13d
jmp 0x1eb28
movl $0xfffffff9, 0xc(%rsp)  # imm = 0xFFFFFFF9
testq %r15, %r15
je 0x1eb38
movq %rbx, %rdi
movq %r15, %rsi
callq 0x182e0
testq %r13, %r13
je 0x1eb48
movq %rbx, %rdi
movq %r13, %rsi
callq 0x182e0
movl 0xc(%rsp), %edi
testl %edi, %edi
je 0x1eb64
callq 0x19950
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x1eb66
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_O2/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 0x5ec2a(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
movq %rsp, %r14
movq %r14, %rdx
callq 0x1a500
movq %rax, %r15
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x588(%rax)
je 0x1ed61
leaq 0x5ed07(%rip), %rcx     # 0x7da0f
xorl %r14d, %r14d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq %rax, %r13
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x18f50
movq %rax, %rbp
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x190d0
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 0x1ed75
leaq 0x5f060(%rip), %rsi     # 0x7ddc8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
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_O2/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 0x5eb6b(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0x1a500
movq %rax, %r15
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x590(%rax)
je 0x1ee12
leaq 0x5ec46(%rip), %rcx     # 0x7da0f
xorl %r14d, %r14d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq %rax, %r13
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %r8
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
movl %eax, %ecx
callq *0x590(%r8)
jmp 0x1ee26
leaq 0x5efdc(%rip), %rsi     # 0x7ddf5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
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_O2/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 0x5eaba(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x20(%rsp), %rdx
callq 0x1a500
movq %rax, 0x18(%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq %rax, 0x10(%rsp)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq %rax, %r13
leaq 0x5e17a(%rip), %rcx     # 0x7d000
xorl %r15d, %r15d
pushq $0x4
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %r14
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x19c70
movq %rax, %r12
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq %rax, %rbp
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x190d0
leaq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq 0x50(%rcx), %rcx
movq 0x598(%rcx), %r10
testq %r10, %r10
je 0x1eef6
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 0x1ef0a
leaq 0x5ef23(%rip), %rsi     # 0x7de20
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
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_O2/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 0x5e9db(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
movq %rsp, %r12
movq %r12, %rdx
callq 0x1a500
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq (%r12), %rcx
movq 0x50(%rcx), %rcx
movq 0x788(%rcx), %rcx
testq %rcx, %rcx
je 0x1ef7b
movzwl %ax, %edx
movq %r14, %rdi
movl %r15d, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1ef8c
leaq 0x5eecf(%rip), %rsi     # 0x7de51
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e95c(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
movq (%r15), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x840(%rax)
je 0x1f01b
pushq $0x2
popq %rsi
leaq 0x4(%rsp), %rdx
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rcx
callq 0x192d0
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1f02e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x182e0
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
jmp 0x1f054
leaq 0x5ee59(%rip), %rsi     # 0x7de7b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
jmp 0x1f054
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_O2/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 0x5e896(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x18f50
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x790(%rcx), %rcx
testq %rcx, %rcx
je 0x1f0af
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f0c0
leaq 0x5edf4(%rip), %rsi     # 0x7deaa
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e82c(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
pushq $0x10
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x19c00
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x798(%rcx), %rcx
testq %rcx, %rcx
je 0x1f11c
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f12d
leaq 0x5edae(%rip), %rsi     # 0x7ded1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e7bf(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
pushq $0xe
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x19c00
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x7a0(%rcx), %rcx
testq %rcx, %rcx
je 0x1f189
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f19a
leaq 0x5ed69(%rip), %rsi     # 0x7def9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e750(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0x1a500
movq %rax, %r15
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x7a8(%rax)
je 0x1f235
pushq $0x2
popq %rsi
leaq 0x4(%rsp), %rdx
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rcx
callq 0x19300
movq %rax, %r14
cmpl $0x0, (%r12)
je 0x1f24b
movl 0x4(%rsp), %ecx
pushq $0x18
popq %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %r9d, %r9d
callq 0x18d30
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
jmp 0x1f246
leaq 0x5eced(%rip), %rsi     # 0x7df29
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
movl %eax, %r15d
jmp 0x1f280
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
pushq $0x18
popq %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %r9d, %r9d
callq 0x18d30
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e665(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0x1a500
movq %rax, %r15
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x7b0(%rax)
je 0x1f320
pushq $0x2
popq %rsi
leaq 0x4(%rsp), %rdx
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rcx
callq 0x1a470
movq %rax, %r14
cmpl $0x0, (%r12)
je 0x1f336
movl 0x4(%rsp), %ecx
pushq $0x10
popq %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %r9d, %r9d
callq 0x18d30
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
jmp 0x1f331
leaq 0x5ec32(%rip), %rsi     # 0x7df59
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
movl %eax, %r15d
jmp 0x1f36b
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
pushq $0x10
popq %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %r9d, %r9d
callq 0x18d30
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e57c(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x18790
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x7c0(%rcx), %rcx
testq %rcx, %rcx
je 0x1f3c9
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f3da
leaq 0x5ebb8(%rip), %rsi     # 0x7df88
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e512(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x18790
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x7c8(%rcx), %rcx
testq %rcx, %rcx
je 0x1f433
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f444
leaq 0x5eb7c(%rip), %rsi     # 0x7dfb6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e4a8(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
pushq $0x11
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x19c00
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x7d0(%rcx), %rcx
testq %rcx, %rcx
je 0x1f4a0
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f4b1
leaq 0x5eb3e(%rip), %rsi     # 0x7dfe5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e43b(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x18790
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x7d8(%rcx), %rcx
testq %rcx, %rcx
je 0x1f50a
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f51b
leaq 0x5eb01(%rip), %rsi     # 0x7e012
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e3d1(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x18790
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x7e0(%rcx), %rcx
testq %rcx, %rcx
je 0x1f574
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f585
leaq 0x5eacb(%rip), %rsi     # 0x7e046
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e362(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdx
callq 0x1a500
movq %rax, 0x8(%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x18f50
movq %rax, %r15
pushq $0x12
popq %r14
pushq $0x3
popq %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x19c00
movl %eax, %ebp
pushq $0x4
popq %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x19c00
movl %eax, %r13d
pushq $0x5
popq %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x19c00
movl %eax, %r14d
pushq $0x11
popq %rsi
pushq $0x6
popq %rdx
movq %rbx, %rdi
callq 0x19c00
movq (%r12), %rcx
movq 0x50(%rcx), %rcx
movq 0x7e8(%rcx), %r10
testq %r10, %r10
je 0x1f63c
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 0x1f64d
leaq 0x5ea33(%rip), %rsi     # 0x7e076
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e29a(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x818(%rcx), %rcx
testq %rcx, %rcx
je 0x1f6ab
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f6bc
leaq 0x5e9ec(%rip), %rsi     # 0x7e09e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e230(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x18790
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x820(%rcx), %rcx
testq %rcx, %rcx
je 0x1f715
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f726
leaq 0x5e9b3(%rip), %rsi     # 0x7e0cf
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e1c6(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x18790
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x828(%rcx), %rcx
testq %rcx, %rcx
je 0x1f77f
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f790
leaq 0x5e97f(%rip), %rsi     # 0x7e105
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e15c(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
pushq $0x13
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x19c00
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x830(%rcx), %rcx
testq %rcx, %rcx
je 0x1f7ec
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f7fd
leaq 0x5e940(%rip), %rsi     # 0x7e133
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e0ef(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x18790
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x838(%rcx), %rcx
testq %rcx, %rcx
je 0x1f856
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f867
leaq 0x5e8fc(%rip), %rsi     # 0x7e159
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq