LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdNextSubpass
static int CmdNextSubpass(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    if(ud->ddt->CmdNextSubpass2 && lua_type(L, 2) == LUA_TTABLE)
        {
#define CLEANUP do {                                    \
            zfreeVkSubpassBeginInfo(L, binfo, 1);    \
            zfreeVkSubpassEndInfo(L, einfo, 1);      \
} while(0)
        VkSubpassBeginInfo* binfo = NULL;
        VkSubpassEndInfo* einfo = NULL;
        binfo = zcheckVkSubpassBeginInfo(L, 2, &err);
        if(err) { CLEANUP; return argerror(L, 2); }
        einfo = zcheckVkSubpassEndInfo(L, 3, &err);
        if(err) { CLEANUP; return argerror(L, 3); }
        ud->ddt->CmdNextSubpass2(cb, binfo, einfo);
        CLEANUP;
#undef CLEANUP
        }
    else
        {
        VkSubpassContents contents = checksubpasscontents(L, 2);
        ud->ddt->CmdNextSubpass(cb, contents);
        }
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x6eaa1(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a4e0
movq %rax, %r14
movq (%r15), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x5c8(%rax)
je 0x1defa
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1a0f0
cmpl $0x5, %eax
jne 0x1defa
leaq 0x4(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x18240
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1df24
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19160
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x19160
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x1df7a
movq %rbx, %rdi
movl $0x21, %esi
movl $0x2, %edx
callq 0x19be0
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %rcx
movq %r14, %rdi
movl %eax, %esi
callq *0x418(%rcx)
xorl %eax, %eax
jmp 0x1df82
leaq 0x4(%rsp), %r13
movq %rbx, %rdi
movl $0x3, %esi
movq %r13, %rdx
callq 0x1a0d0
movq %rax, %r12
cmpl $0x0, (%r13)
je 0x1df90
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19160
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19160
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x18410
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x5c8(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19160
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19160
jmp 0x1df20
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdEndRenderPass
static int CmdEndRenderPass(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    if(ud->ddt->CmdEndRenderPass2 && lua_type(L, 2) == LUA_TTABLE)
        {
#define CLEANUP zfreeVkSubpassEndInfo(L, einfo, 1)
        VkSubpassEndInfo* einfo;
        einfo = zcheckVkSubpassEndInfo(L, 2, &err);
        if(err) { CLEANUP; return argerror(L, 2); }
        ud->ddt->CmdEndRenderPass2(cb, einfo);
        CLEANUP;
#undef CLEANUP
        }
    else
        {
        ud->ddt->CmdEndRenderPass(cb);
        }
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x6e927(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a4e0
movq %rax, %r14
movq (%r15), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x5d0(%rax)
je 0x1e073
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1a0f0
cmpl $0x5, %eax
jne 0x1e06a
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x1a0d0
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1e08a
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19160
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x1e07e
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %r14, %rdi
callq *0x420(%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x5d0(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19160
jmp 0x1e07c
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdExecuteCommands
static int CmdExecuteCommands(lua_State *L)
    {
    int err;
    uint32_t count;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkCommandBuffer *buffers = checkcommand_bufferlist(L, 2, &count, &err, NULL);
    if(err) return argerrorc(L, 2, err);

    ud->ddt->CmdExecuteCommands(cb, count, buffers);
    Free(L, buffers);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x6e843(%rip), %r15     # 0x8c909
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
movq %r15, %rcx
callq 0x1a4e0
movq %rax, %r14
leaq 0x4(%rsp), %rdx
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rcx
movq %r15, %r8
callq 0x199b0
movl (%r12), %edi
testl %edi, %edi
je 0x1e117
callq 0x19930
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x1e140
movq %rax, %r15
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x4(%rsp), %esi
movq %r14, %rdi
movq %r15, %rdx
callq *0x428(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x182d0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdDebugMarkerBegin
static int CmdDebugMarkerBegin(lua_State *L) 

    {
    ud_t *ud;
    VkDebugMarkerMarkerInfoEXT info;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    checkdebugmarkermarkerinfo(L, 2, &info);
    CheckDevicePfn(L, ud, CmdDebugMarkerBeginEXT);
    ud->ddt->CmdDebugMarkerBeginEXT(cb, &info);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x6e7aa(%rip), %rcx     # 0x8c909
movq %rsp, %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a4e0
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x204ce
movq (%r15), %rax
movq 0x50(%rax), %rax
movq 0x430(%rax), %rax
testq %rax, %rax
je 0x1e1a0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq *%rax
xorl %eax, %eax
jmp 0x1e1b1
leaq 0x6e87e(%rip), %rsi     # 0x8ca25
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdDebugMarkerEnd
static int CmdDebugMarkerEnd(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdDebugMarkerEndEXT);
    ud->ddt->CmdDebugMarkerEndEXT(cb);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6e740(%rip), %rcx     # 0x8c909
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq (%r14), %rcx
movq 0x50(%rcx), %rcx
movq 0x438(%rcx), %rcx
testq %rcx, %rcx
je 0x1e1f5
movq %rax, %rdi
callq *%rcx
xorl %eax, %eax
jmp 0x1e206
leaq 0x6e855(%rip), %rsi     # 0x8ca51
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdDebugMarkerInsert
static int CmdDebugMarkerInsert(lua_State *L)
    {
    ud_t *ud;
    VkDebugMarkerMarkerInfoEXT info;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdDebugMarkerInsertEXT);
    checkdebugmarkermarkerinfo(L, 2, &info);
    ud->ddt->CmdDebugMarkerInsertEXT(cb, &info);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x6e6e8(%rip), %rcx     # 0x8c909
movq %rsp, %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a4e0
movq %rax, %r14
movq (%r15), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x440(%rax)
je 0x1e26d
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x204ce
movq (%rsp), %rax
movq 0x50(%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x440(%rax)
xorl %eax, %eax
jmp 0x1e27e
leaq 0x6e807(%rip), %rsi     # 0x8ca7b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdPushDescriptorSet
static int CmdPushDescriptorSet(lua_State *L)
    {
    int err;
    ud_t *ud;
    uint32_t count;
    VkWriteDescriptorSet* writes;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkPipelineBindPoint pipelineBindPoint = checkpipelinebindpoint(L, 2);
    VkPipelineLayout layout = checkpipeline_layout(L, 3, NULL);
    uint32_t set = luaL_checkinteger(L, 4);
    CheckDevicePfn(L, ud, CmdPushDescriptorSetKHR);
#define CLEANUP zfreearrayVkWriteDescriptorSet(L, writes, count, 1)
    writes = zcheckarrayVkWriteDescriptorSet(L, 5, &count, &err);
    if(err) { CLEANUP; return argerror(L, 5); }
    ud->ddt->CmdPushDescriptorSetKHR(cb, pipelineBindPoint, layout, set, count, writes);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x6e669(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r12
movl $0x1, %esi
movq %r12, %rdx
callq 0x1a4e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x1e, %esi
movl $0x2, %edx
callq 0x19be0
movl %eax, %ebp
leaq 0x6e667(%rip), %rcx     # 0x8c937
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x190e0
movq %rax, %r13
movq (%r12), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x448(%rax)
je 0x1e366
movl %ebp, 0x4(%rsp)
movq %r14, %rbp
movq %rsp, %rdx
leaq 0x14(%rsp), %r14
movq %rbx, %rdi
movl $0x5, %esi
movq %r14, %rcx
callq 0x1a380
movq %rax, %r12
cmpl $0x0, (%r14)
je 0x1e379
movl (%rsp), %ecx
movl $0x40, %edx
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %r8d
callq 0x197d0
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x5, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x1e3b7
leaq 0x6e73b(%rip), %rsi     # 0x8caa8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
jmp 0x1e3b7
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl (%rsp), %r8d
movq %rbp, %rdi
movl 0x4(%rsp), %esi
movq %r15, %rdx
movl %r13d, %ecx
movq %r12, %r9
callq *0x448(%rax)
movl (%rsp), %ecx
movl $0x40, %edx
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %r8d
callq 0x197d0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/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 0x6e52b(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r12
movl $0x1, %esi
movq %r12, %rdx
callq 0x1a4e0
movq %rax, (%rsp)
leaq 0x6e6da(%rip), %rcx     # 0x8cad5
xorl %ebx, %ebx
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r13
leaq 0x6e521(%rip), %rcx     # 0x8c937
movq %r14, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %rbp
movq %r14, %rdi
movl $0x4, %esi
callq 0x190e0
movq %rax, %r15
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movl $0x5, %esi
callq 0x18d50
movq (%r12), %rcx
movq 0x50(%rcx), %rcx
movq 0x470(%rcx), %r9
testq %r9, %r9
je 0x1e473
movq (%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movl %r15d, %ecx
movq %rax, %r8
callq *%r9
jmp 0x1e486
leaq 0x6e681(%rip), %rsi     # 0x8cafb
movq %r14, %rdi
xorl %eax, %eax
callq 0x19ba0
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_O3/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 0x6e45b(%rip), %rcx     # 0x8c909
leaq 0x10(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x190e0
movq %rax, %r12
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x4c0(%rax)
je 0x1e546
leaq 0xc(%rsp), %rdx
leaq 0x1c(%rsp), %r13
movq %rbx, %rdi
movl $0x3, %esi
movq %r13, %rcx
callq 0x1a450
movq %rax, %r14
cmpl $0x0, (%r13)
je 0x1e55c
movl 0xc(%rsp), %ecx
movl $0x10, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d30
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x1e557
leaq 0x6e5e7(%rip), %rsi     # 0x8cb34
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
movl %eax, %r15d
jmp 0x1e598
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 0x18d30
movl %r15d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6e34b(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a4e0
movq %rax, %r14
movq (%r15), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x4e0(%rax)
je 0x1e634
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x18540
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1e647
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19160
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x1e66e
leaq 0x6e528(%rip), %rsi     # 0x8cb63
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
jmp 0x1e66e
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 0x19160
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6e27a(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a4e0
movq %rax, %r14
movq (%r15), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x170(%rax)
je 0x1e705
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x18350
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1e718
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19160
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x1e73f
leaq 0x6e485(%rip), %rsi     # 0x8cb91
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
jmp 0x1e73f
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 0x19160
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6e1b0(%rip), %rcx     # 0x8c909
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq (%r14), %rcx
movq 0x48(%rcx), %rcx
movq 0x178(%rcx), %rcx
testq %rcx, %rcx
je 0x1e785
movq %rax, %rdi
callq *%rcx
xorl %eax, %eax
jmp 0x1e796
leaq 0x6e435(%rip), %rsi     # 0x8cbc1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6e156(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a4e0
movq %rax, %r14
movq (%r15), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x180(%rax)
je 0x1e829
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x18350
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1e83c
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19160
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x1e863
leaq 0x6e3bf(%rip), %rsi     # 0x8cbef
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
jmp 0x1e863
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 0x19160
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6e085(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x1a4e0
movq %rax, %r15
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x19080
movq %rax, %r14
cmpl $0x0, (%r12)
je 0x1e8e6
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x19160
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x1e928
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x518(%rax), %rax
testq %rax, %rax
je 0x1e917
movq %r15, %rdi
movq %r14, %rsi
callq *%rax
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x19160
xorl %eax, %eax
jmp 0x1e928
leaq 0x6e302(%rip), %rsi     # 0x8cc20
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6dfc7(%rip), %rcx     # 0x8c909
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq (%r14), %rcx
movq 0x50(%rcx), %rcx
movq 0x520(%rcx), %rcx
testq %rcx, %rcx
je 0x1e96e
movq %rax, %rdi
callq *%rcx
xorl %eax, %eax
jmp 0x1e97f
leaq 0x6e2e0(%rip), %rsi     # 0x8cc55
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6df6a(%rip), %rcx     # 0x8c909
leaq 0x20(%rsp), %rdx
movl $0x1, %esi
callq 0x1a4e0
movq %rax, 0x18(%rsp)
leaq 0x6d646(%rip), %r15     # 0x8c000
xorl %ebx, %ebx
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x1a4e0
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movl $0x3, %esi
callq 0x190e0
movq %rax, %rbp
movq %r14, %rdi
movl $0x4, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x1a4e0
movq %rax, %r15
movq %r14, %rdi
movl $0x5, %esi
callq 0x190e0
movq %rax, %r13
movq %r14, %rdi
movl $0x6, %esi
callq 0x190e0
movq %rax, %r12
movq %r14, %rdi
movl $0x7, %esi
callq 0x190e0
leaq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq 0x50(%rcx), %rcx
movq 0x5a8(%rcx), %r10
testq %r10, %r10
je 0x1ea5b
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 0x1ea6e
leaq 0x6e226(%rip), %rsi     # 0x8cc88
movq %r14, %rdi
xorl %eax, %eax
callq 0x19ba0
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_O3/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 0x6de72(%rip), %rcx     # 0x8c909
leaq 0x20(%rsp), %rdx
movl $0x1, %esi
callq 0x1a4e0
movq %rax, 0x18(%rsp)
leaq 0x6d54e(%rip), %r15     # 0x8c000
xorl %ebx, %ebx
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x1a4e0
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movl $0x3, %esi
callq 0x190e0
movq %rax, %rbp
movq %r14, %rdi
movl $0x4, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x1a4e0
movq %rax, %r15
movq %r14, %rdi
movl $0x5, %esi
callq 0x190e0
movq %rax, %r13
movq %r14, %rdi
movl $0x6, %esi
callq 0x190e0
movq %rax, %r12
movq %r14, %rdi
movl $0x7, %esi
callq 0x190e0
leaq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq 0x50(%rcx), %rcx
movq 0x5b0(%rcx), %r10
testq %r10, %r10
je 0x1eb53
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 0x1eb66
leaq 0x6e158(%rip), %rsi     # 0x8ccb2
movq %r14, %rdi
xorl %eax, %eax
callq 0x19ba0
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_O3/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 0x6dd7f(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a4e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x190e0
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x538(%rcx), %rcx
testq %rcx, %rcx
je 0x1ebca
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1ebdb
leaq 0x6e112(%rip), %rsi     # 0x8cce3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6dd0c(%rip), %rcx     # 0x8c909
leaq 0x20(%rsp), %rbp
movl $0x1, %esi
movq %rbp, %rdx
callq 0x1a4e0
movq %rax, 0x18(%rsp)
movq %r14, %rdi
movl $0x2, %esi
callq 0x190e0
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movl $0x3, %esi
callq 0x190e0
movq %rax, %r12
movq %r14, %rdi
movl $0x4, %esi
callq 0x190e0
movq %rax, %r13
movq %r14, %rdi
movl $0x5, %esi
callq 0x190e0
movq %rax, %rbx
movq %r14, %rdi
movl $0x6, %esi
callq 0x190e0
movq %rax, %r15
movq %r14, %rdi
movl $0x7, %esi
callq 0x190e0
movq (%rbp), %rcx
movq 0x50(%rcx), %rcx
movq 0x540(%rcx), %r10
testq %r10, %r10
je 0x1eca7
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 0x1ecb8
leaq 0x6e05b(%rip), %rsi     # 0x8cd09
movq %r14, %rdi
xorl %eax, %eax
callq 0x19ba0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/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 0x6da40(%rip), %rcx     # 0x8c909
leaq 0x20(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq %rax, %r15
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x578(%rax)
je 0x1efaf
movq %rbx, %rdi
movl $0x2, %esi
callq 0x190e0
movq %rax, %r13
leaq 0x6d0f6(%rip), %r8      # 0x8c000
movl $0x3, %ebp
leaq 0x14(%rsp), %rdx
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movl $0x3, %esi
movq %r12, %rcx
callq 0x199b0
movq %rax, %r14
movl (%r12), %eax
testl %eax, %eax
je 0x1ef45
cmpl $0x1, %eax
jne 0x1efc2
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 0x19e70
movq %rax, %r12
movl (%r13), %eax
testl %eax, %eax
je 0x1ef81
cmpl $0x1, %eax
jne 0x1efcf
movl $0x0, 0xc(%rsp)
movl 0x10(%rsp), %edx
cmpl 0x14(%rsp), %edx
jne 0x1efc7
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 0x1efcf
leaq 0x6ddb0(%rip), %rsi     # 0x8cd66
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
jmp 0x1f00d
xorl %r12d, %r12d
jmp 0x1efcf
movl $0xfffffff9, 0xc(%rsp)  # imm = 0xFFFFFFF9
testq %r14, %r14
je 0x1efdf
movq %rbx, %rdi
movq %r14, %rsi
callq 0x182d0
testq %r12, %r12
je 0x1efef
movq %rbx, %rdi
movq %r12, %rsi
callq 0x182d0
movl 0xc(%rsp), %edi
testl %edi, %edi
je 0x1f00b
callq 0x19930
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x1f00d
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_O3/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 0x6d765(%rip), %rcx     # 0x8c909
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq %rax, %r15
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x588(%rax)
je 0x1f230
leaq 0x6d840(%rip), %rcx     # 0x8ca0f
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x190e0
movq %rax, %r13
movq %rbx, %rdi
movl $0x4, %esi
callq 0x18f60
movq %rax, %rbp
movq %rbx, %rdi
movl $0x5, %esi
callq 0x190e0
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 0x1f244
leaq 0x6db91(%rip), %rsi     # 0x8cdc8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
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_O3/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 0x6d69c(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq %rax, %r15
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x590(%rax)
je 0x1f2e9
leaq 0x6d775(%rip), %rcx     # 0x8ca0f
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x190e0
movq %rax, %r13
movq %rbx, %rdi
movl $0x4, %esi
callq 0x190e0
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %r8
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
movl %eax, %ecx
callq *0x590(%r8)
jmp 0x1f2fd
leaq 0x6db05(%rip), %rsi     # 0x8cdf5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
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_O3/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 0x6d5e3(%rip), %rcx     # 0x8c909
leaq 0x20(%rsp), %rdx
movl $0x1, %esi
callq 0x1a4e0
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x190e0
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x190e0
movq %rax, %r13
leaq 0x6cc9d(%rip), %rcx     # 0x8c000
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x5, %esi
callq 0x19c50
movq %rax, %r12
movq %rbx, %rdi
movl $0x6, %esi
callq 0x190e0
movq %rax, %rbp
movq %rbx, %rdi
movl $0x7, %esi
callq 0x190e0
leaq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq 0x50(%rcx), %rcx
movq 0x598(%rcx), %r10
testq %r10, %r10
je 0x1f3db
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 0x1f3ef
leaq 0x6da3e(%rip), %rsi     # 0x8ce20
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
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_O3/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 0x6d4f6(%rip), %rcx     # 0x8c909
movq %rsp, %r12
movl $0x1, %esi
movq %r12, %rdx
callq 0x1a4e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x190e0
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x190e0
movq (%r12), %rcx
movq 0x50(%rcx), %rcx
movq 0x788(%rcx), %rcx
testq %rcx, %rcx
je 0x1f466
movzwl %ax, %edx
movq %r14, %rdi
movl %r15d, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f477
leaq 0x6d9e4(%rip), %rsi     # 0x8ce51
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6d471(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a4e0
movq %rax, %r14
movq (%r15), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x840(%rax)
je 0x1f50e
leaq 0x4(%rsp), %rdx
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rcx
callq 0x192d0
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1f521
movq %rbx, %rdi
movq %r15, %rsi
callq 0x182d0
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x1f547
leaq 0x6d966(%rip), %rsi     # 0x8ce7b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
jmp 0x1f547
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 0x182d0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6d3a3(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a4e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x18f60
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x790(%rcx), %rcx
testq %rcx, %rcx
je 0x1f5a6
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f5b7
leaq 0x6d8fd(%rip), %rsi     # 0x8ceaa
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6d335(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a4e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x10, %esi
movl $0x2, %edx
callq 0x19be0
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x798(%rcx), %rcx
testq %rcx, %rcx
je 0x1f619
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f62a
leaq 0x6d8b1(%rip), %rsi     # 0x8ced1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6d2c2(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a4e0
movq %rax, %r14
movq %rbx, %rdi
movl $0xe, %esi
movl $0x2, %edx
callq 0x19be0
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x7a0(%rcx), %rcx
testq %rcx, %rcx
je 0x1f68c
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f69d
leaq 0x6d866(%rip), %rsi     # 0x8cef9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6d24d(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq %rax, %r15
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x7a8(%rax)
je 0x1f744
leaq 0x4(%rsp), %rdx
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rcx
callq 0x19300
movq %rax, %r14
cmpl $0x0, (%r12)
je 0x1f75a
movl 0x4(%rsp), %ecx
movl $0x18, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d30
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x1f755
leaq 0x6d7de(%rip), %rsi     # 0x8cf29
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
movl %eax, %r15d
jmp 0x1f793
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 0x18d30
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6d152(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq %rax, %r15
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x7b0(%rax)
je 0x1f83f
leaq 0x4(%rsp), %rdx
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rcx
callq 0x1a450
movq %rax, %r14
cmpl $0x0, (%r12)
je 0x1f855
movl 0x4(%rsp), %ecx
movl $0x10, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d30
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x1f850
leaq 0x6d713(%rip), %rsi     # 0x8cf59
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
movl %eax, %r15d
jmp 0x1f88e
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 0x18d30
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6d059(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a4e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x18790
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x7c0(%rcx), %rcx
testq %rcx, %rcx
je 0x1f8f0
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f901
leaq 0x6d691(%rip), %rsi     # 0x8cf88
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6cfeb(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a4e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x18790
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x7c8(%rcx), %rcx
testq %rcx, %rcx
je 0x1f95e
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f96f
leaq 0x6d651(%rip), %rsi     # 0x8cfb6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6cf7d(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a4e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x11, %esi
movl $0x2, %edx
callq 0x19be0
movq (%r15), %rcx
movq 0x50(%rcx), %rcx
movq 0x7d0(%rcx), %rcx
testq %rcx, %rcx
je 0x1f9d1
movq %r14, %rdi
movl %eax, %esi
callq *%rcx
xorl %eax, %eax
jmp 0x1f9e2
leaq 0x6d60d(%rip), %rsi     # 0x8cfe5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19ba0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq