LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x8(%rsp), %rdx
leaq 0xb422a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x188a0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x188a0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x188a0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x5, %esi
callq 0x188a0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rsp)
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x2f8(%rax), %rax
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq *%rax
xorl %eax, %eax
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xb417a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x188a0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x188a0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x300(%rax), %rax
movq 0x10(%rsp), %rdi
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq *%rax
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xb40ea(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x19010
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x308(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
callq *%rax
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xb406a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x19010
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x310(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
callq *%rax
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movl $0x0, 0x5c(%rsp)
movq 0x68(%rsp), %rdi
movl $0x1, %esi
leaq 0x40(%rsp), %rdx
leaq 0xb3f62(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rdi
movl $0x1e, %esi
movl $0x2, %edx
callq 0x19d20
movl %eax, 0x34(%rsp)
movq 0x68(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb3f59(%rip), %rcx     # 0xcf937
callq 0x1a640
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rdi
movl $0x4, %esi
callq 0x19190
movl %eax, 0x24(%rsp)
movq 0x68(%rsp), %rdi
movl $0x5, %esi
leaq 0x60(%rsp), %rdx
leaq 0x64(%rsp), %rcx
xorl %eax, %eax
movl %eax, %r8d
leaq 0xb3f37(%rip), %r9      # 0xcf952
callq 0x191f0
movq %rax, 0x50(%rsp)
cmpl $0x0, 0x64(%rsp)
je 0x1ba5a
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x64(%rsp), %edi
callq 0x19a60
movq 0x18(%rsp), %rdi
movq %rax, %rdx
movl $0x5, %esi
callq 0x18460
movl %eax, 0x74(%rsp)
jmp 0x1bb28
movq 0x68(%rsp), %rdi
movl $0x6, %esi
leaq 0x5c(%rsp), %rdx
leaq 0x64(%rsp), %rcx
callq 0x1a4d0
movq %rax, 0x48(%rsp)
cmpl $0x0, 0x64(%rsp)
jge 0x1bab9
movq 0x68(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x18300
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x64(%rsp), %edi
callq 0x19a60
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl $0x6, %esi
callq 0x18460
movl %eax, 0x74(%rsp)
jmp 0x1bb28
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x320(%rax), %rax
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x28(%rsp), %rdx
movl 0x24(%rsp), %ecx
movl 0x60(%rsp), %r8d
movq 0x50(%rsp), %r9
movl 0x5c(%rsp), %r11d
movq 0x48(%rsp), %r10
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
callq *%rax
movq 0x68(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x18300
cmpq $0x0, 0x48(%rsp)
je 0x1bb20
movq 0x68(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x18300
movl $0x0, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xb3daa(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb3482(%rip), %rcx     # 0xcf000
callq 0x1a640
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl $0x20, %esi
movl $0x4, %edx
callq 0x19d20
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x328(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
callq *%rax
xorl %eax, %eax
addq $0x38, %rsp
retq
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xb351a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x19190
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x19190
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movl $0x5, %esi
callq 0x19190
movl %eax, (%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x338(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
movl 0x4(%rsp), %ecx
movl (%rsp), %r8d
callq *%rax
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xb346a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x19190
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movl %eax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl $0x4, %esi
callq 0x19190
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movl $0x5, %esi
callq 0x19190
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl $0x6, %esi
callq 0x19190
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x340(%rax), %rax
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
movl 0x14(%rsp), %ecx
movl 0x10(%rsp), %r8d
movl 0xc(%rsp), %r9d
callq *%rax
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xb33aa(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb2a82(%rip), %rcx     # 0xcf000
callq 0x1a640
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl $0x4, %esi
callq 0x19190
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movl $0x5, %esi
callq 0x19190
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x348(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
movl 0x8(%rsp), %r8d
callq *%rax
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xb32ea(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb29c2(%rip), %rcx     # 0xcf000
callq 0x1a640
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl $0x4, %esi
callq 0x19190
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movl $0x5, %esi
callq 0x19190
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x350(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
movl 0x8(%rsp), %r8d
callq *%rax
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xb322a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x19190
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x19190
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x358(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
movl 0x4(%rsp), %ecx
callq *%rax
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xb319a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb2872(%rip), %rcx     # 0xcf000
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x360(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xb25ca(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb1ca2(%rip), %rcx     # 0xcf000
callq 0x1a640
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0x4, %esi
leaq 0x30(%rsp), %rdx
callq 0x18df0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x1d3ac
movq 0x30(%rsp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0x1d3d6
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movl $0xfffffff9, %edi       # imm = 0xFFFFFFF9
callq 0x19a60
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x4, %esi
callq 0x18460
movl %eax, 0x44(%rsp)
jmp 0x1d409
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x390(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x8(%rsp), %r8
callq *%rax
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xb24ca(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb1ba2(%rip), %rcx     # 0xcf000
callq 0x1a640
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl $0x4, %esi
callq 0x1a770
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl $0x5, %esi
callq 0x19190
movl %eax, 0x4(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x398(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movl 0x4(%rsp), %r8d
callq *%rax
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xb21da(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb224c(%rip), %rcx     # 0xcf99a
callq 0x1a640
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movl $0xa, %esi
movl $0x3, %edx
callq 0x19d20
movl %eax, 0x14(%rsp)
movq 0x48(%rsp), %rdi
movl $0x4, %esi
callq 0x188a0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movl $0x5, %esi
callq 0x19190
movl %eax, 0x3c(%rsp)
movq 0x48(%rsp), %rdi
movl $0x6, %esi
leaq 0x40(%rsp), %rdx
leaq 0x44(%rsp), %rcx
callq 0x19b70
movq %rax, 0x30(%rsp)
cmpl $0x0, 0x44(%rsp)
je 0x1d819
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x40(%rsp), %ecx
movl $0x14, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x6, %esi
callq 0x18460
movl %eax, 0x54(%rsp)
jmp 0x1d873
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x3a8(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
movl 0x40(%rsp), %r8d
movq 0x30(%rsp), %r9
leaq 0x38(%rsp), %rcx
callq *%rax
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x40(%rsp), %ecx
movl $0x14, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl $0x0, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
leaq 0x38(%rsp), %rdx
leaq 0xb2048(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movl $0x2, %esi
leaq 0x34(%rsp), %rdx
leaq 0x44(%rsp), %rcx
callq 0x19cd0
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x44(%rsp)
je 0x1d974
jmp 0x1d8f6
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x30(%rsp), %ecx
movl $0x18, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x34(%rsp), %ecx
movl $0x18, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x18460
movl %eax, 0x54(%rsp)
jmp 0x1da8d
movq 0x48(%rsp), %rdi
movl $0x3, %esi
leaq 0x30(%rsp), %rdx
leaq 0x44(%rsp), %rcx
callq 0x18bc0
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x44(%rsp)
je 0x1da16
jmp 0x1d99b
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x30(%rsp), %ecx
movl $0x18, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x34(%rsp), %ecx
movl $0x18, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x3, %esi
callq 0x18460
movl %eax, 0x54(%rsp)
jmp 0x1da8d
movq 0x38(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x3b0(%rax), %rax
movq 0x18(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x28(%rsp), %rdx
movl 0x30(%rsp), %ecx
movq 0x20(%rsp), %r8
callq *%rax
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x30(%rsp), %ecx
movl $0x18, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x34(%rsp), %ecx
movl $0x18, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x30(%rsp), %rdx
leaq 0xb1bfa(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb1c7d(%rip), %rcx     # 0xcf9ab
callq 0x1a640
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x670(%rax)
je 0x1de05
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x1a240
cmpl $0x5, %eax
jne 0x1de05
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x1c(%rsp), %rdx
callq 0x1a740
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x1ddce
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x18460
movl %eax, 0x44(%rsp)
jmp 0x1de40
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x670(%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq *%rax
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
jmp 0x1de38
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x19010
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x3c0(%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0xc(%rsp), %edx
callq *%rax
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xb1a9a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb1b1d(%rip), %rcx     # 0xcf9ab
callq 0x1a640
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x678(%rax)
je 0x1dee2
movq 0x30(%rsp), %rdi
movl $0x3, %esi
callq 0x19010
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x678(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq *%rax
jmp 0x1df15
movq 0x30(%rsp), %rdi
movl $0x3, %esi
callq 0x19010
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x3c8(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0xc(%rsp), %edx
callq *%rax
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xb192a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb1a11(%rip), %rcx     # 0xcfa0f
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x19010
movl %eax, (%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x3e0(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
movl (%rsp), %ecx
callq *%rax
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xb188a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb1971(%rip), %rcx     # 0xcfa0f
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x3e8(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq *%rax
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xb17fa(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb18e1(%rip), %rcx     # 0xcfa0f
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x19190
movl %eax, (%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x3f0(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
movl (%rsp), %ecx
callq *%rax
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xb175a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb1841(%rip), %rcx     # 0xcfa0f
callq 0x1a640
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl $0x4, %esi
callq 0x19190
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x690(%rax)
je 0x1e239
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x19010
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x690(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ecx
callq *%rax
jmp 0x1e270
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x19010
movl %eax, 0x4(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x3f8(%rax), %rax
movq 0x20(%rsp), %rdi
movl 0x4(%rsp), %esi
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ecx
callq *%rax
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movl $0x1, %esi
leaq 0x48(%rsp), %rdx
leaq 0xb166a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb1751(%rip), %rcx     # 0xcfa0f
callq 0x1a640
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movl %eax, 0x34(%rsp)
movq 0x50(%rsp), %rdi
movl $0x4, %esi
callq 0x19190
movl %eax, 0x30(%rsp)
movq 0x50(%rsp), %rdi
movl $0x5, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb0cfd(%rip), %rcx     # 0xcf000
callq 0x1a640
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
movl $0x6, %esi
callq 0x19190
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movl $0x7, %esi
callq 0x19190
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movl $0x8, %esi
callq 0x19010
movl %eax, 0x14(%rsp)
movq 0x48(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x400(%rax), %rax
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl 0x34(%rsp), %edx
movl 0x30(%rsp), %ecx
movq 0x28(%rsp), %r8
movq 0x20(%rsp), %r9
movq 0x18(%rsp), %r11
movl 0x14(%rsp), %r10d
movq %r11, (%rsp)
movl %r10d, 0x8(%rsp)
callq *%rax
xorl %eax, %eax
addq $0x58, %rsp
retq
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
leaq 0x20(%rsp), %rdx
leaq 0xb155a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb1569(%rip), %rcx     # 0xcf937
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl $0x3, %esi
callq 0x19010
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movl $0x4, %esi
callq 0x19190
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl $0x5, %esi
leaq 0x28(%rsp), %rdx
callq 0x18df0
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x408(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
movq 0x28(%rsp), %r8
movq (%rsp), %r9
callq *%rax
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
leaq 0x38(%rsp), %rdx
leaq 0xb120a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x5c8(%rax)
je 0x1e899
movq 0x48(%rsp), %rdi
movl $0x2, %esi
callq 0x1a240
cmpl $0x5, %eax
jne 0x1e899
movq $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movl $0x2, %esi
leaq 0x44(%rsp), %rdx
callq 0x18270
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x44(%rsp)
je 0x1e7cc
jmp 0x1e76c
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x18460
movl %eax, 0x54(%rsp)
jmp 0x1e8d4
movq 0x48(%rsp), %rdi
movl $0x3, %esi
leaq 0x44(%rsp), %rdx
callq 0x1a210
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x44(%rsp)
je 0x1e84e
jmp 0x1e7ee
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x3, %esi
callq 0x18460
movl %eax, 0x54(%rsp)
jmp 0x1e8d4
movq 0x38(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x5c8(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq *%rax
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
jmp 0x1e8cc
movq 0x48(%rsp), %rdi
movl $0x21, %esi
movl $0x2, %edx
callq 0x19d20
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x418(%rax), %rax
movq 0x30(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq *%rax
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xb100a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x5d0(%rax)
je 0x1e9d1
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x1a240
cmpl $0x5, %eax
jne 0x1e9d1
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x24(%rsp), %rdx
callq 0x1a210
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x1e99f
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x1e9f0
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x5d0(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
jmp 0x1e9e8
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x420(%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xb0eea(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x20(%rsp), %rdx
leaq 0x24(%rsp), %rcx
leaq 0xb0ec5(%rip), %r8      # 0xcf909
callq 0x19ae0
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x1ea7e
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl 0x24(%rsp), %edi
callq 0x19a60
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x1eab5
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x428(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0x20(%rsp), %esi
movq 0x8(%rsp), %rdx
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x18300
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x30(%rsp), %rdx
leaq 0xb0e2a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x8(%rsp), %rdx
callq 0x22640
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x430(%rax)
jne 0x1eb28
movq 0x38(%rsp), %rdi
leaq 0xb0f0a(%rip), %rsi     # 0xcfa25
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x44(%rsp)
jmp 0x1eb4d
jmp 0x1eb2a
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x430(%rax), %rax
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq *%rax
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xb0d8a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x438(%rax)
jne 0x1ebb5
movq 0x18(%rsp), %rdi
leaq 0xb0ea9(%rip), %rsi     # 0xcfa51
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x24(%rsp)
jmp 0x1ebd6
jmp 0x1ebb7
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x438(%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x30(%rsp), %rdx
leaq 0xb0d0a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x440(%rax)
jne 0x1ec34
movq 0x38(%rsp), %rdi
leaq 0xb0e54(%rip), %rsi     # 0xcfa7b
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x44(%rsp)
jmp 0x1ec6d
jmp 0x1ec36
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x8(%rsp), %rdx
callq 0x22640
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x440(%rax), %rax
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq *%rax
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
leaq 0x38(%rsp), %rdx
leaq 0xb0c6a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1e, %esi
movl $0x2, %edx
callq 0x19d20
movl %eax, 0x1c(%rsp)
movq 0x48(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb0c61(%rip), %rcx     # 0xcf937
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movl $0x4, %esi
callq 0x19190
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x448(%rax)
jne 0x1ed22
movq 0x48(%rsp), %rdi
leaq 0xb0d96(%rip), %rsi     # 0xcfaa8
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x54(%rsp)
jmp 0x1edee
jmp 0x1ed24
movq 0x48(%rsp), %rdi
movl $0x5, %esi
leaq 0x34(%rsp), %rdx
leaq 0x44(%rsp), %rcx
callq 0x1a4e0
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x44(%rsp)
je 0x1ed9a
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x34(%rsp), %ecx
movl $0x40, %edx
movl $0x1, %r8d
callq 0x198d0
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x5, %esi
callq 0x18460
movl %eax, 0x54(%rsp)
jmp 0x1edee
movq 0x38(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x448(%rax), %rax
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
movl 0x34(%rsp), %r8d
movq 0x28(%rsp), %r9
callq *%rax
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x34(%rsp), %ecx
movl $0x40, %edx
movl $0x1, %r8d
callq 0x198d0
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xb0aea(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb0c97(%rip), %rcx     # 0xcfad5
callq 0x1a640
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb0ada(%rip), %rcx     # 0xcf937
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0x4, %esi
callq 0x19190
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rdi
movl $0x5, %esi
leaq 0x30(%rsp), %rdx
callq 0x18df0
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x470(%rax)
jne 0x1eebe
movq 0x38(%rsp), %rdi
leaq 0xb0c4a(%rip), %rsi     # 0xcfafb
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x44(%rsp)
jmp 0x1eef1
jmp 0x1eec0
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x470(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
movq (%rsp), %r8
callq *%rax
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)