LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/buffer_view.c
// Function: freebuffer_view
static int freebuffer_view(lua_State *L, ud_t *ud)
    {
    VkBufferView buffer_view = (VkBufferView)ud->handle;
    const VkAllocationCallbacks *allocator = ud->allocator;
    VkDevice device = ud->device;
    PFN_vkDestroyBufferView DestroyBufferView = ud->ddt->DestroyBufferView;
    if(!freeuserdata(L, ud))
        return 0; /* double call */
    TRACE_DELETE(buffer_view, "buffer_view");
    DestroyBufferView(device, buffer_view, allocator);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %rbx
movq 0x20(%rsi), %r15
movq 0x40(%rsi), %r14
movq 0x50(%rsi), %rax
movq 0x120(%rax), %r12
callq 0x18d20
testl %eax, %eax
je 0x1ade2
movq 0xa5208(%rip), %rax     # 0xbffc8
cmpl $0x0, (%rax)
je 0x1add6
leaq 0x7130c(%rip), %rdi     # 0x8c0d8
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18960
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *%r12
xorl %eax, %eax
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: CmdBindPipeline
static int CmdBindPipeline(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkPipelineBindPoint pipelineBindPoint = checkpipelinebindpoint(L, 2);
    VkPipeline pipeline = checkpipeline(L, 3, NULL);
    ud->ddt->CmdBindPipeline(cb, pipelineBindPoint, pipeline);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x71afa(%rip), %rcx     # 0x8c909
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq %rax, %r15
movq %rbx, %rdi
movl $0x1e, %esi
movl $0x2, %edx
callq 0x19be0
movl %eax, %ebp
leaq 0x71ae6(%rip), %rcx     # 0x8c923
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x1a4e0
movq (%r14), %rcx
movq 0x50(%rcx), %rcx
movq %r15, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq *0x2d0(%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetViewport
static int CmdSetViewport(lua_State *L)
    {
    int err;
    uint32_t count;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t firstViewport = luaL_checkinteger(L, 2);
#define CLEANUP zfreearrayVkViewport (L, viewports, count, 1)
    VkViewport *viewports = zcheckarrayVkViewport(L, 3, &count, &err);
    if(err) { CLEANUP; return argerror(L, 3); }
    ud->ddt->CmdSetViewport(cb, firstViewport, count, viewports);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x71a84(%rip), %rcx     # 0x8c909
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
callq 0x1a4e0
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x190e0
movq %rax, %r12
leaq 0xc(%rsp), %rdx
leaq 0x1c(%rsp), %r13
movq %rbx, %rdi
movl $0x3, %esi
movq %r13, %rcx
callq 0x19300
movq %rax, %r14
cmpl $0x0, (%r13)
je 0x1af0c
movl 0xc(%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 $0x3, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r15d
jmp 0x1af48
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movl 0xc(%rsp), %edx
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rcx
callq *0x2d8(%rax)
movl 0xc(%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 $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: CmdSetScissor
static int CmdSetScissor(lua_State *L)
    {
    int err;
    uint32_t count;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t first = luaL_checkinteger(L, 2);
#define CLEANUP zfreearrayVkRect2D(L, scissors, count, 1)
    VkRect2D* scissors = zcheckarrayVkRect2D(L, 3, &count, &err);
    if(err) { CLEANUP; return argerror(L, 3); }
    ud->ddt->CmdSetScissor(cb, first, count, scissors);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x71999(%rip), %rcx     # 0x8c909
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
callq 0x1a4e0
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x190e0
movq %rax, %r12
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 0x1aff7
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
movl %eax, %r15d
jmp 0x1b033
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movl 0xc(%rsp), %edx
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rcx
callq *0x2e0(%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: CmdSetLineWidth
static int CmdSetLineWidth(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    float line_width = luaL_optnumber(L, 2, 1.0);
    ud->ddt->CmdSetLineWidth(cb, line_width);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x718b2(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq %rax, %r15
movsd 0x71084(%rip), %xmm0    # 0x8c0f8
movq %rbx, %rdi
movl $0x2, %esi
callq 0x18920
cvtsd2ss %xmm0, %xmm0
movq (%r14), %rax
movq 0x50(%rax), %rax
movq %r15, %rdi
callq *0x2e8(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetDepthBias
static int CmdSetDepthBias(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    float depthBiasConstantFactor = luaL_checknumber(L, 2);
    float depthBiasClamp = luaL_checknumber(L, 3); 
    float depthBiasSlopeFactor = luaL_checknumber(L, 4);
    ud->ddt->CmdSetDepthBias(cb, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x71855(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x18840
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x18840
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x18840
cvtsd2ss %xmm0, %xmm2
movq (%r14), %rax
movq 0x50(%rax), %rax
movq %r15, %rdi
movss 0x4(%rsp), %xmm0
movss (%rsp), %xmm1
callq *0x2f0(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetBlendConstants
static int CmdSetBlendConstants(lua_State *L)
    {
    float blendConstants[4];
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    blendConstants[0] = luaL_checknumber(L, 2);
    blendConstants[1] = luaL_checknumber(L, 3);
    blendConstants[2] = luaL_checknumber(L, 4);
    blendConstants[3] = luaL_checknumber(L, 5);
    ud->ddt->CmdSetBlendConstants(cb, blendConstants);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x717c6(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %rbx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x1a4e0
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
callq 0x18840
cvtsd2ss %xmm0, %xmm0
leaq 0x10(%rsp), %r12
movss %xmm0, (%r12)
movq %r14, %rdi
movl $0x3, %esi
callq 0x18840
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%r12)
movq %r14, %rdi
movl $0x4, %esi
callq 0x18840
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%r12)
movq %r14, %rdi
movl $0x5, %esi
callq 0x18840
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%r12)
movq (%rbx), %rax
movq 0x50(%rax), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x2f8(%rax)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetDepthBounds
static int CmdSetDepthBounds(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    float minDepthBounds = luaL_checknumber(L, 2);
    float maxDepthBounds = luaL_checknumber(L, 3);
    ud->ddt->CmdSetDepthBounds(cb, minDepthBounds, maxDepthBounds);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x71719(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x18840
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x18840
cvtsd2ss %xmm0, %xmm1
movq (%r14), %rax
movq 0x50(%rax), %rax
movq %r15, %rdi
movss 0x4(%rsp), %xmm0
callq *0x300(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetStencilCompareMask
static int CmdSetStencilCompareMask(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkStencilFaceFlags faceMask = checkflags(L, 2);
    uint32_t compareMask = luaL_checkinteger(L, 3);
    ud->ddt->CmdSetStencilCompareMask(cb, faceMask, compareMask);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x716a8(%rip), %rcx     # 0x8c909
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x18f60
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x190e0
movq (%r14), %rcx
movq 0x50(%rcx), %rcx
movq %r15, %rdi
movl %r12d, %esi
movl %eax, %edx
callq *0x308(%rcx)
xorl %eax, %eax
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: CmdSetStencilWriteMask
static int CmdSetStencilWriteMask(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkStencilFaceFlags faceMask = checkflags(L, 2);
    uint32_t writeMask = luaL_checkinteger(L, 3);
    ud->ddt->CmdSetStencilWriteMask(cb, faceMask, writeMask);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x71643(%rip), %rcx     # 0x8c909
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x18f60
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x190e0
movq (%r14), %rcx
movq 0x50(%rcx), %rcx
movq %r15, %rdi
movl %r12d, %esi
movl %eax, %edx
callq *0x310(%rcx)
xorl %eax, %eax
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: CmdBindDescriptorSets
static int CmdBindDescriptorSets(lua_State *L)
    {
    int err; 
    uint32_t sets_count, offsets_count = 0;
    VkDescriptorSet* sets; 
    uint32_t* offsets;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkPipelineBindPoint bindpoint = checkpipelinebindpoint(L, 2);
    VkPipelineLayout layout = checkpipeline_layout(L, 3, NULL);
    uint32_t firstSet = luaL_checkinteger(L, 4);

    sets = checkdescriptor_setlist(L, 5, &sets_count, &err, NULL);
    if(err) return argerrorc(L, 5, err);
    
    offsets = checkuint32list(L, 6, &offsets_count, &err);
    if(err < 0) { Free(L, sets); return argerrorc(L, 6, err); }

    ud->ddt->CmdBindDescriptorSets(cb, bindpoint, layout, firstSet, sets_count, sets, offsets_count, offsets);
    Free(L, sets); 
    if(offsets) Free(L, offsets);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl $0x0, 0xc(%rsp)
leaq 0x7156b(%rip), %rcx     # 0x8c909
leaq 0x30(%rsp), %rdx
movl $0x1, %esi
callq 0x1a4e0
movq %rax, 0x28(%rsp)
movq %rbx, %rdi
movl $0x1e, %esi
movl $0x2, %edx
callq 0x19be0
movl %eax, %r15d
leaq 0x71569(%rip), %rcx     # 0x8c937
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r13
movq %rbx, %rdi
movl $0x4, %esi
callq 0x190e0
movq %rax, %rbp
leaq 0x7155b(%rip), %r9      # 0x8c952
leaq 0x14(%rsp), %rdx
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movl $0x5, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x19140
movl (%r14), %edi
testl %edi, %edi
je 0x1b443
callq 0x19930
movq %rbx, %rdi
movl $0x5, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %rbp, 0x18(%rsp)
movq %r13, 0x20(%rsp)
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rbp
movq %rbx, %rdi
movl $0x6, %esi
movq %rbp, %rcx
callq 0x1a370
cmpl $0x0, (%rbp)
js 0x1b4cf
movq %rax, %r14
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x14(%rsp), %r8d
movl 0xc(%rsp), %r10d
movq 0x28(%rsp), %rdi
movl %r15d, %esi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %r12, %r9
pushq %r14
pushq %r10
callq *0x320(%rax)
addq $0x10, %rsp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x182d0
xorl %ebp, %ebp
testq %r14, %r14
je 0x1b432
movq %rbx, %rdi
movq %r14, %rsi
callq 0x182d0
jmp 0x1b432
movq %rbx, %rdi
movq %r12, %rsi
callq 0x182d0
movl 0x10(%rsp), %edi
callq 0x19930
movq %rbx, %rdi
movl $0x6, %esi
jmp 0x1b428
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdBindIndexBuffer
static int CmdBindIndexBuffer(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);
    VkIndexType indexType = checkindextype(L, 4);
    ud->ddt->CmdBindIndexBuffer(cb, buffer, offset, indexType);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x71402(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %rbx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x1a4e0
movq %rax, %r15
leaq 0x70add(%rip), %rcx     # 0x8c000
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x190e0
movq %rax, %r13
movq %r14, %rdi
movl $0x20, %esi
movl $0x4, %edx
callq 0x19be0
movq (%rbx), %rcx
movq 0x50(%rcx), %r8
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %eax, %ecx
callq *0x328(%r8)
xorl %eax, %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: CmdDraw
static int CmdDraw(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t vertexCount = luaL_checkinteger(L, 2);
    uint32_t instanceCount = luaL_checkinteger(L, 3);
    uint32_t firstVertex = luaL_checkinteger(L, 4);
    uint32_t firstInstance = luaL_checkinteger(L, 5);
    ud->ddt->CmdDraw(cb, vertexCount, instanceCount, firstVertex, firstInstance);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x70f5c(%rip), %rcx     # 0x8c909
movq %rsp, %rbx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x1a4e0
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
callq 0x190e0
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x190e0
movq %rax, %r13
movq %r14, %rdi
movl $0x4, %esi
callq 0x190e0
movq %rax, %rbp
movq %r14, %rdi
movl $0x5, %esi
callq 0x190e0
movq (%rbx), %rcx
movq 0x50(%rcx), %r9
movq %r15, %rdi
movl %r12d, %esi
movl %r13d, %edx
movl %ebp, %ecx
movl %eax, %r8d
callq *0x338(%r9)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdDrawIndexed
static int CmdDrawIndexed(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t indexCount = luaL_checkinteger(L, 2);
    uint32_t instanceCount = luaL_checkinteger(L, 3);
    uint32_t firstIndex = luaL_checkinteger(L, 4);
    int32_t vertexOffset = luaL_checkinteger(L, 5);
    uint32_t firstInstance = luaL_checkinteger(L, 6);
    ud->ddt->CmdDrawIndexed(cb, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x70eca(%rip), %rcx     # 0x8c909
movq %rsp, %rdx
movl $0x1, %esi
callq 0x1a4e0
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
callq 0x190e0
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x190e0
movq %rax, %r13
movq %r14, %rdi
movl $0x4, %esi
callq 0x190e0
movq %rax, %rbp
movq %r14, %rdi
movl $0x5, %esi
callq 0x190e0
movq %rax, %rbx
movq %r14, %rdi
movl $0x6, %esi
callq 0x190e0
movq %rsp, %rcx
movq (%rcx), %rcx
movq 0x50(%rcx), %r10
movq %r15, %rdi
movl %r12d, %esi
movl %r13d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
movl %eax, %r9d
callq *0x340(%r10)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdDrawIndirect
static int CmdDrawIndirect(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);
    uint32_t drawCount = luaL_checkinteger(L, 4);
    uint32_t stride = luaL_checkinteger(L, 5);
    ud->ddt->CmdDrawIndirect(cb, buffer, offset, drawCount, stride);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x70e25(%rip), %rcx     # 0x8c909
movq %rsp, %rbx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x1a4e0
movq %rax, %r15
leaq 0x70502(%rip), %rcx     # 0x8c000
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x190e0
movq %rax, %r13
movq %r14, %rdi
movl $0x4, %esi
callq 0x190e0
movq %rax, %rbp
movq %r14, %rdi
movl $0x5, %esi
callq 0x190e0
movq (%rbx), %rcx
movq 0x50(%rcx), %r9
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %ebp, %ecx
movl %eax, %r8d
callq *0x348(%r9)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdDrawIndexedIndirect
static int CmdDrawIndexedIndirect(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);
    uint32_t drawCount = luaL_checkinteger(L, 4);
    uint32_t stride = luaL_checkinteger(L, 5);
    ud->ddt->CmdDrawIndexedIndirect(cb, buffer, offset, drawCount, stride);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x70d8a(%rip), %rcx     # 0x8c909
movq %rsp, %rbx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x1a4e0
movq %rax, %r15
leaq 0x70467(%rip), %rcx     # 0x8c000
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x190e0
movq %rax, %r13
movq %r14, %rdi
movl $0x4, %esi
callq 0x190e0
movq %rax, %rbp
movq %r14, %rdi
movl $0x5, %esi
callq 0x190e0
movq (%rbx), %rcx
movq 0x50(%rcx), %r9
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %ebp, %ecx
movl %eax, %r8d
callq *0x350(%r9)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdDispatch
static int CmdDispatch(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t x = luaL_checkinteger(L, 2);
    uint32_t y = luaL_checkinteger(L, 3);
    uint32_t z = luaL_checkinteger(L, 4);
    ud->ddt->CmdDispatch(cb, x, y, z);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x70ced(%rip), %rcx     # 0x8c909
leaq 0x8(%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 %rbx, %rdi
movl $0x3, %esi
callq 0x190e0
movq %rax, %r13
movq %rbx, %rdi
movl $0x4, %esi
callq 0x190e0
movq (%r14), %rcx
movq 0x50(%rcx), %r8
movq %r15, %rdi
movl %r12d, %esi
movl %r13d, %edx
movl %eax, %ecx
callq *0x358(%r8)
xorl %eax, %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: CmdDispatchIndirect
static int CmdDispatchIndirect(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);
    ud->ddt->CmdDispatchIndirect(cb, buffer, offset);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x70c70(%rip), %rcx     # 0x8c909
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq %rax, %r15
leaq 0x7034d(%rip), %rcx     # 0x8c000
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x190e0
movq (%r14), %rcx
movq 0x50(%rcx), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq *0x360(%rcx)
xorl %eax, %eax
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: CmdCopyBuffer
static int CmdCopyBuffer(lua_State *L)
    {
    int err;
    uint32_t count;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    if(ud->ddt->CmdCopyBuffer2KHR && lua_type(L, 2)==LUA_TTABLE)
        {
        VkCopyBufferInfo2KHR *info = zcheckVkCopyBufferInfo2KHR(L, 2, &err);
#define CLEANUP zfreeVkCopyBufferInfo2KHR(L, info, 1)
        if(err) { CLEANUP; return argerror(L, 2); }
        ud->ddt->CmdCopyBuffer2KHR(cb, info);
        CLEANUP;
#undef CLEANUP
        }
    else
        {
        VkBuffer srcBuffer = checkbuffer(L, 2, NULL);
        VkBuffer dstBuffer = checkbuffer(L, 3, NULL);
#define CLEANUP zfreearrayVkBufferCopy(L, regions, count, 1)
        VkBufferCopy* regions = zcheckarrayVkBufferCopy(L, 4, &count, &err);
        if(err) { CLEANUP; return argerror(L, 4); }
        ud->ddt->CmdCopyBuffer(cb, srcBuffer, dstBuffer, count, regions);
        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 0x70bfb(%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, 0x6a0(%rax)
je 0x1bd95
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1a0f0
cmpl $0x5, %eax
jne 0x1bd95
leaq 0x4(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x1a020
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1be6d
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
jmp 0x1be22
movq %r14, 0x10(%rsp)
leaq 0x7025f(%rip), %r12     # 0x8c000
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x1a4e0
movq %rax, %r13
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x1a4e0
movq %rax, %rbp
movq %rsp, %rdx
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movl $0x4, %esi
movq %r14, %rcx
callq 0x1a1d0
movq %rax, %r12
cmpl $0x0, (%r14)
je 0x1be2f
movl (%rsp), %ecx
movl $0x18, %edx
movq %rbx, %rdi
movq %r12, %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 $0x4, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r15d
jmp 0x1be95
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl (%rsp), %ecx
movq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r12, %r8
callq *0x368(%rax)
movl (%rsp), %ecx
movl $0x18, %edx
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d30
jmp 0x1be95
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x6a0(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19160
xorl %r15d, %r15d
movl %r15d, %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: CmdUpdateBuffer
static int CmdUpdateBuffer(lua_State *L)
    {
    size_t size;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBuffer dstBuffer = checkbuffer(L, 2, NULL);
    VkDeviceSize dstOffset = luaL_checkinteger(L, 3);
    const char *data = luaL_checklstring(L, 4, &size);
    if((size==0) || (size % 4)!=0)
        return argerrorc(L, 4, ERR_LENGTH);
    ud->ddt->CmdUpdateBuffer(cb, dstBuffer, dstOffset, (VkDeviceSize)size, data);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x702af(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x1a4e0
movq %rax, %r15
leaq 0x6f98d(%rip), %rcx     # 0x8c000
xorl %ebx, %ebx
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x190e0
movq %rax, %r13
leaq 0x10(%rsp), %rbp
movq %r14, %rdi
movl $0x4, %esi
movq %rbp, %rdx
callq 0x18d50
movq (%rbp), %rcx
testq %rcx, %rcx
setne %dl
testb $0x3, %cl
sete %sil
testb %sil, %dl
je 0x1c6e0
movq 0x8(%rsp), %rdx
movq 0x50(%rdx), %r9
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %r8
callq *0x390(%r9)
jmp 0x1c6fc
movl $0xfffffff9, %edi       # imm = 0xFFFFFFF9
callq 0x19930
movq %r14, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x18410
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: CmdFillBuffer
static int CmdFillBuffer(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBuffer dstBuffer = checkbuffer(L, 2, NULL);
    VkDeviceSize dstOffset = luaL_checkinteger(L, 3);
    VkDeviceSize size = checksizeorwholesize(L, 4);
    uint32_t data = luaL_checkinteger(L, 5);
    ud->ddt->CmdFillBuffer(cb, dstBuffer, dstOffset, size, data);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x701e7(%rip), %rcx     # 0x8c909
movq %rsp, %rbx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x1a4e0
movq %rax, %r15
leaq 0x6f8c4(%rip), %rcx     # 0x8c000
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x190e0
movq %rax, %r13
movq %r14, %rdi
movl $0x4, %esi
callq 0x1a610
movq %rax, %rbp
movq %r14, %rdi
movl $0x5, %esi
callq 0x190e0
movq (%rbx), %rcx
movq 0x50(%rcx), %r9
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
movl %eax, %r8d
callq *0x398(%r9)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdClearColorImage
static int CmdClearColorImage(lua_State *L)
    {
    int err;
    ud_t *ud;
    uint32_t count=0;
    VkImageSubresourceRange* ranges=NULL;
    VkClearColorValue* color=NULL;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkImage image = checkimage(L, 2, NULL);
    VkImageLayout imageLayout = checkimagelayout(L, 3);
#define CLEANUP do {                                            \
    zfreeVkClearColorValue(L, color, 1);                        \
    zfreearrayVkImageSubresourceRange(L, ranges, count, 1);     \
} while(0)
    color = zcheckVkClearColorValue(L, 4, &err);
    if(err) { CLEANUP; return argerror(L, 4); }
    ranges = zcheckarrayVkImageSubresourceRange(L, 5, &count, &err);
    if(err) { CLEANUP; return argerror(L, 5); }
    ud->ddt->CmdClearColorImage(cb, image, imageLayout, color, count, ranges);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x0, 0x8(%rsp)
leaq 0x70140(%rip), %rcx     # 0x8c909
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
callq 0x1a4e0
movq %rax, %r15
leaq 0x701b8(%rip), %rcx     # 0x8c99a
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r13
movq %rbx, %rdi
movl $0xa, %esi
movl $0x3, %edx
callq 0x19be0
movl %eax, %ebp
leaq 0xc(%rsp), %r14
movq %rbx, %rdi
movl $0x4, %esi
movq %r14, %rdx
callq 0x185a0
movq %rax, %r12
cmpl $0x0, (%r14)
je 0x1c86b
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x19610
movl $0x14, %edx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
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 $0x4, %esi
jmp 0x1c8d4
leaq 0x8(%rsp), %rdx
leaq 0xc(%rsp), %r14
movq %rbx, %rdi
movl $0x5, %esi
movq %r14, %rcx
callq 0x19a40
cmpl $0x0, (%r14)
je 0x1c8f1
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
movq %rax, %r14
callq 0x19610
movl 0x8(%rsp), %ecx
movl $0x14, %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 $0x5, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rcx
movq 0x50(%rcx), %r10
movl 0x8(%rsp), %r8d
movq %r15, %rdi
movq %r13, %rsi
movl %ebp, %edx
movq %r12, %rcx
movq %rax, %r14
movq %rax, %r9
callq *0x3a0(%r10)
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x19610
movl 0x8(%rsp), %ecx
movl $0x14, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d30
jmp 0x1c8df
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdClearDepthStencilImage
static int CmdClearDepthStencilImage(lua_State *L)
    {
    int err;
    uint32_t count;
    VkClearDepthStencilValue depthstencil;
    VkImageSubresourceRange* ranges;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkImage image = checkimage(L, 2, NULL);
    VkImageLayout imageLayout = checkimagelayout(L, 3);
    depthstencil.depth = luaL_checknumber(L, 4);
    depthstencil.stencil = luaL_checkinteger(L, 5);
#define CLEANUP zfreearrayVkImageSubresourceRange(L, ranges, count, 1)
    ranges = zcheckarrayVkImageSubresourceRange(L, 6, &count, &err);
    if(err) { CLEANUP; return argerror(L, 6); }
    ud->ddt->CmdClearDepthStencilImage(cb, image, imageLayout, &depthstencil, count, ranges);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x6ffa6(%rip), %rcx     # 0x8c909
leaq 0x18(%rsp), %rdx
movl $0x1, %esi
callq 0x1a4e0
movq %rax, 0x10(%rsp)
leaq 0x7001c(%rip), %rcx     # 0x8c99a
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r12
movq %rbx, %rdi
movl $0xa, %esi
movl $0x3, %edx
callq 0x19be0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x4, %esi
callq 0x18840
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x190e0
movl %eax, 0xc(%rsp)
leaq 0x4(%rsp), %rdx
leaq 0x24(%rsp), %r15
movq %rbx, %rdi
movl $0x6, %esi
movq %r15, %rcx
callq 0x19a40
movq %rax, %r13
cmpl $0x0, (%r15)
je 0x1ca33
movl 0x4(%rsp), %ecx
movl $0x14, %edx
movq %rbx, %rdi
movq %r13, %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 $0x6, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r14d
jmp 0x1ca76
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x4(%rsp), %r8d
leaq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r13, %r9
callq *0x3a8(%rax)
movl 0x4(%rsp), %ecx
movl $0x14, %edx
movq %rbx, %rdi
movq %r13, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d30
movl %r14d, %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: CmdClearAttachments
static int CmdClearAttachments(lua_State *L)
    {
    int err;
    ud_t *ud;
    uint32_t att_count=0;
    uint32_t rect_count=0;
    VkClearAttachment* attachments=NULL;
    VkClearRect* rects=NULL;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
#define CLEANUP do {                                            \
    zfreearrayVkClearRect(L, rects, rect_count, 1);             \
    zfreearrayVkClearAttachment(L, attachments, att_count, 1);  \
} while(0)
    attachments = zcheckarrayVkClearAttachment(L, 2, &att_count, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    rects = zcheckarrayVkClearRect(L, 3, &rect_count, &err);
    if(err) { CLEANUP; return argerror(L, 3); }
    ud->ddt->CmdClearAttachments(cb, att_count, attachments, rect_count, rects);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
movl %ebp, (%r14)
movl %ebp, 0x4(%rsp)
leaq 0x6fe5b(%rip), %rcx     # 0x8c909
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
callq 0x1a4e0
movq %rax, %r12
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
movq %r15, %rcx
callq 0x19b90
movq %rax, %r14
cmpl %ebp, (%r15)
je 0x1cb30
movl $0x18, %edx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d30
movl 0x8(%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
jmp 0x1cba5
leaq 0x4(%rsp), %rdx
leaq 0xc(%rsp), %r13
movq %rbx, %rdi
movl $0x3, %esi
movq %r13, %rcx
callq 0x18b30
movq %rax, %r15
cmpl $0x0, (%r13)
je 0x1cbc2
movl 0x4(%rsp), %ecx
movl $0x18, %edx
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d30
movl 0x8(%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 $0x3, %esi
movq %rax, %rdx
callq 0x18410
movl %eax, %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rsp), %esi
movl 0x4(%rsp), %ecx
movq %r12, %rdi
movq %r14, %rdx
movq %r15, %r8
callq *0x3b0(%rax)
movl 0x4(%rsp), %ecx
xorl %r12d, %r12d
movl $0x18, %edx
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d30
movl 0x8(%rsp), %ecx
movl $0x18, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d30
jmp 0x1cbb0
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetEvent
static int CmdSetEvent(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkEvent event = checkevent(L, 2, NULL);
    if(ud->ddt->CmdSetEvent2KHR && lua_type(L, 3)==LUA_TTABLE)
        {
        int err;
        VkDependencyInfoKHR *info = zcheckVkDependencyInfoKHR(L, 2, &err);
#define CLEANUP zfreeVkDependencyInfoKHR(L, info, 1)
        if(err) { CLEANUP; return argerror(L, 2); }
        ud->ddt->CmdSetEvent2KHR(cb, event, info);
        CLEANUP;
#undef CLEANUP
        }
    else
        {
        VkPipelineStageFlags stageMask = checkflags(L, 3);
        ud->ddt->CmdSetEvent(cb, event, stageMask);
        }
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x6fae4(%rip), %rcx     # 0x8c909
movq %rsp, %r13
movl $0x1, %esi
movq %r13, %rdx
callq 0x1a4e0
movq %rax, %r14
leaq 0x6fb6c(%rip), %rcx     # 0x8c9ab
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r12
movq (%r13), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x670(%rax)
je 0x1cecb
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1a0f0
cmpl $0x5, %eax
jne 0x1cecb
leaq 0xc(%rsp), %r13
movq %rbx, %rdi
movl $0x2, %esi
movq %r13, %rdx
callq 0x1a5e0
movq %rax, %r15
cmpl $0x0, (%r13)
je 0x1ceff
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
movl %eax, %r15d
jmp 0x1ceee
movq %rbx, %rdi
movl $0x3, %esi
callq 0x18f60
movq (%rsp), %rcx
movq 0x50(%rcx), %rcx
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %edx
callq *0x3c0(%rcx)
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%rsp), %rax
movq 0x50(%rax), %rax
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x670(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19160
xorl %r15d, %r15d
jmp 0x1ceee
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/cmd.c
// Function: CmdResetEvent
static int CmdResetEvent(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkEvent event = checkevent(L, 2, NULL);
    if(ud->ddt->CmdResetEvent2KHR)
        {
        VkPipelineStageFlags2KHR stageMask = checkflags(L, 3);
        ud->ddt->CmdResetEvent2KHR(cb, event, stageMask);
        }
    else
        {
        VkPipelineStageFlags stageMask = checkflags(L, 3);
        ud->ddt->CmdResetEvent(cb, event, stageMask);
        }
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x6f9cc(%rip), %rcx     # 0x8c909
movq %rsp, %r12
movl $0x1, %esi
movq %r12, %rdx
callq 0x1a4e0
movq %rax, %rbx
leaq 0x6fa54(%rip), %rcx     # 0x8c9ab
movq %r15, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r14
movq (%r12), %rax
movq 0x50(%rax), %rax
movq 0x678(%rax), %r12
movq %r15, %rdi
movl $0x3, %esi
callq 0x18f60
testq %r12, %r12
je 0x1cfa3
movq (%rsp), %rcx
movq 0x50(%rcx), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq *0x678(%rcx)
jmp 0x1cfb9
movq (%rsp), %rcx
movq 0x50(%rcx), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq *0x3c8(%rcx)
xorl %eax, %eax
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: CmdBeginQuery
static int CmdBeginQuery(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkQueryPool queryPool = checkquery_pool(L, 2, NULL);
    uint32_t query = luaL_checkinteger(L, 3);
    VkQueryControlFlags flags = checkflags(L, 4);
    ud->ddt->CmdBeginQuery(cb, queryPool, query, flags);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x6f030(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %rbx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x1a4e0
movq %rax, %r15
leaq 0x6f11a(%rip), %rcx     # 0x8ca0f
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x190e0
movq %rax, %r13
movq %r14, %rdi
movl $0x4, %esi
callq 0x18f60
movq (%rbx), %rcx
movq 0x50(%rcx), %r8
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
movl %eax, %ecx
callq *0x3e0(%r8)
xorl %eax, %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: CmdEndQuery
static int CmdEndQuery(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkQueryPool queryPool = checkquery_pool(L, 2, NULL);
    uint32_t query = luaL_checkinteger(L, 3);
    ud->ddt->CmdEndQuery(cb, queryPool, query);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6efaa(%rip), %rcx     # 0x8c909
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq %rax, %r15
leaq 0x6f096(%rip), %rcx     # 0x8ca0f
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x190e0
movq (%r14), %rcx
movq 0x50(%rcx), %rcx
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
callq *0x3e8(%rcx)
xorl %eax, %eax
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: CmdResetQueryPool
static int CmdResetQueryPool(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkQueryPool queryPool = checkquery_pool(L, 2, NULL);
    uint32_t firstQuery = luaL_checkinteger(L, 3);
    uint32_t queryCount = luaL_checkinteger(L, 4);
    ud->ddt->CmdResetQueryPool(cb, queryPool, firstQuery, queryCount);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x6ef37(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %rbx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x1a4e0
movq %rax, %r15
leaq 0x6f021(%rip), %rcx     # 0x8ca0f
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x190e0
movq %rax, %r13
movq %r14, %rdi
movl $0x4, %esi
callq 0x190e0
movq (%rbx), %rcx
movq 0x50(%rcx), %r8
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
movl %eax, %ecx
callq *0x3f0(%r8)
xorl %eax, %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: CmdWriteTimestamp
static int CmdWriteTimestamp(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkQueryPool queryPool = checkquery_pool(L, 3, NULL);
    uint32_t query = luaL_checkinteger(L, 4);
    if(ud->ddt->CmdWriteTimestamp2KHR)
        {
        VkPipelineStageFlags2KHR pipelineStage = checkflags(L, 2);
        ud->ddt->CmdWriteTimestamp2KHR(cb, pipelineStage, queryPool, query);
        }
    else
        {
        VkPipelineStageFlagBits pipelineStage = (VkPipelineStageFlagBits)checkflags(L, 2);
        ud->ddt->CmdWriteTimestamp(cb, pipelineStage, queryPool, query);
        }
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r12
leaq 0x6eeac(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %r13
movl $0x1, %esi
movq %r13, %rdx
callq 0x1a4e0
movq %rax, %rbx
leaq 0x6ef96(%rip), %rcx     # 0x8ca0f
movq %r12, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r14
movq %r12, %rdi
movl $0x4, %esi
callq 0x190e0
movq %rax, %r15
movq (%r13), %rax
movq 0x50(%rax), %rax
movq 0x690(%rax), %r13
movq %r12, %rdi
movl $0x2, %esi
callq 0x18f60
testq %r13, %r13
je 0x1dada
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %r8
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
movl %r15d, %ecx
callq *0x690(%r8)
jmp 0x1daf5
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %r8
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
movl %r15d, %ecx
callq *0x3f8(%r8)
xorl %eax, %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: CmdCopyQueryPoolResults
static int CmdCopyQueryPoolResults(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkQueryPool queryPool = checkquery_pool(L, 2, NULL);
    uint32_t firstQuery = luaL_checkinteger(L, 3);
    uint32_t queryCount = luaL_checkinteger(L, 4);
    VkBuffer dstBuffer = checkbuffer(L, 5, NULL);
    VkDeviceSize dstOffset  = luaL_checkinteger(L, 6);
    VkDeviceSize stride = luaL_checkinteger(L, 7);
    VkQueryResultFlags flags = checkflags(L, 8);
    ud->ddt->CmdCopyQueryPoolResults(cb, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x6edec(%rip), %rcx     # 0x8c909
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
callq 0x1a4e0
movq %rax, 0x8(%rsp)
leaq 0x6eed7(%rip), %rcx     # 0x8ca0f
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, (%rsp)
movq %r14, %rdi
movl $0x3, %esi
callq 0x190e0
movq %rax, %r13
movq %r14, %rdi
movl $0x4, %esi
callq 0x190e0
movq %rax, %rbp
leaq 0x6e48e(%rip), %rcx     # 0x8c000
movq %r14, %rdi
movl $0x5, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %rbx
movq %r14, %rdi
movl $0x6, %esi
callq 0x190e0
movq %rax, %r15
movq %r14, %rdi
movl $0x7, %esi
callq 0x190e0
movq %rax, %r12
movq %r14, %rdi
movl $0x8, %esi
callq 0x18f60
leaq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq 0x50(%rcx), %r10
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movl %r13d, %edx
movl %ebp, %ecx
movq %rbx, %r8
movq %r15, %r9
pushq %rax
pushq %r12
callq *0x400(%r10)
addq $0x10, %rsp
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: CmdPushConstants
static int CmdPushConstants(lua_State *L)
    {
    size_t size;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkPipelineLayout layout = checkpipeline_layout(L, 2, NULL);
    VkShaderStageFlags stageFlags = checkflags(L, 3);
    uint32_t offset = luaL_checkinteger(L, 4);
    const char* values = luaL_checklstring(L, 5, &size);
    ud->ddt->CmdPushConstants(cb, layout, stageFlags, offset, (uint32_t)size, values);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x6ed01(%rip), %rcx     # 0x8c909
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x1a4e0
movq %rax, %r15
leaq 0x6ed16(%rip), %rcx     # 0x8c937
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a4e0
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x18f60
movq %rax, %r13
movq %r14, %rdi
movl $0x4, %esi
callq 0x190e0
movq %rax, %rbp
leaq 0x10(%rsp), %rbx
movq %r14, %rdi
movl $0x5, %esi
movq %rbx, %rdx
callq 0x18d50
leaq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq 0x50(%rcx), %r10
movl (%rbx), %r8d
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
movl %ebp, %ecx
movq %rax, %r9
callq *0x408(%r10)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq