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

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xb09ea(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x19190
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x4c0(%rax)
jne 0x1ef6b
movq 0x38(%rsp), %rdi
leaq 0xb0bd9(%rip), %rsi     # 0xcfb34
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x44(%rsp)
jmp 0x1f039
jmp 0x1ef6d
movq 0x38(%rsp), %rdi
movl $0x3, %esi
leaq 0x30(%rsp), %rdx
leaq 0x34(%rsp), %rcx
callq 0x1a5b0
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x1efea
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x30(%rsp), %ecx
movl $0x10, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%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, 0x44(%rsp)
jmp 0x1f039
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x4c0(%rax), %rax
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x30(%rsp), %edx
movq 0x20(%rsp), %rcx
callq *%rax
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x30(%rsp), %ecx
movl $0x10, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetSampleLocations
static int CmdSetSampleLocations(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkSampleLocationsInfoEXT* info;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdSetSampleLocationsEXT);
#define CLEANUP zfreeVkSampleLocationsInfoEXT(L, info, 1)
    info = zcheckVkSampleLocationsInfoEXT(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ud->ddt->CmdSetSampleLocationsEXT(cb, info);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xb089a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x4e0(%rax)
jne 0x1f0a8
movq 0x28(%rsp), %rdi
leaq 0xb0acb(%rip), %rsi     # 0xcfb63
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x34(%rsp)
jmp 0x1f149
jmp 0x1f0aa
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x24(%rsp), %rdx
callq 0x185a0
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x1f111
movq 0x28(%rsp), %rdi
movq 0x10(%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 0x1f149
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x4e0(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdBeginDebugUtilsLabel
static int CmdBeginDebugUtilsLabel(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkDebugUtilsLabelEXT* label;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckInstancePfn(L, ud, CmdBeginDebugUtilsLabelEXT);
#define CLEANUP zfreeVkDebugUtilsLabelEXT(L, label, 1)
    label = zcheckVkDebugUtilsLabelEXT(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ud->idt->CmdBeginDebugUtilsLabelEXT(cb, label);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xb078a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x170(%rax)
jne 0x1f1b8
movq 0x28(%rsp), %rdi
leaq 0xb09e9(%rip), %rsi     # 0xcfb91
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x34(%rsp)
jmp 0x1f259
jmp 0x1f1ba
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x24(%rsp), %rdx
callq 0x18380
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x1f221
movq 0x28(%rsp), %rdi
movq 0x10(%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 0x1f259
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x170(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdEndDebugUtilsLabel
static int CmdEndDebugUtilsLabel(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckInstancePfn(L, ud, CmdEndDebugUtilsLabelEXT);
    ud->idt->CmdEndDebugUtilsLabelEXT(cb);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xb067a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x178(%rax)
jne 0x1f2c5
movq 0x18(%rsp), %rdi
leaq 0xb0909(%rip), %rsi     # 0xcfbc1
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x24(%rsp)
jmp 0x1f2e6
jmp 0x1f2c7
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x178(%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: CmdInsertDebugUtilsLabel
static int CmdInsertDebugUtilsLabel(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkDebugUtilsLabelEXT* label;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckInstancePfn(L, ud, CmdInsertDebugUtilsLabelEXT);
#define CLEANUP zfreeVkDebugUtilsLabelEXT(L, label, 1)
    label = zcheckVkDebugUtilsLabelEXT(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ud->idt->CmdInsertDebugUtilsLabelEXT(cb, label);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xb05fa(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x180(%rax)
jne 0x1f348
movq 0x28(%rsp), %rdi
leaq 0xb08b7(%rip), %rsi     # 0xcfbef
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x34(%rsp)
jmp 0x1f3e9
jmp 0x1f34a
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x24(%rsp), %rdx
callq 0x18380
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x1f3b1
movq 0x28(%rsp), %rdi
movq 0x10(%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 0x1f3e9
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x180(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdBeginConditionalRendering
static int CmdBeginConditionalRendering(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkConditionalRenderingBeginInfoEXT* info;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
#define CLEANUP zfreeVkConditionalRenderingBeginInfoEXT(L, info, 1)
    info = zcheckVkConditionalRenderingBeginInfoEXT(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    CheckDevicePfn(L, ud, CmdBeginConditionalRenderingEXT);
    ud->ddt->CmdBeginConditionalRenderingEXT(cb, info);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xb04ea(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x24(%rsp), %rdx
callq 0x19130
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x1f490
movq 0x28(%rsp), %rdi
movq 0x10(%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 0x1f4f8
jmp 0x1f492
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x518(%rax)
jne 0x1f4be
movq 0x28(%rsp), %rdi
leaq 0xb076f(%rip), %rsi     # 0xcfc20
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x34(%rsp)
jmp 0x1f4f8
jmp 0x1f4c0
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x518(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdEndConditionalRendering
static int CmdEndConditionalRendering(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdEndConditionalRenderingEXT);
    ud->ddt->CmdEndConditionalRenderingEXT(cb);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xb03da(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x520(%rax)
jne 0x1f565
movq 0x18(%rsp), %rdi
leaq 0xb06fd(%rip), %rsi     # 0xcfc55
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x24(%rsp)
jmp 0x1f586
jmp 0x1f567
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x520(%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: CmdDrawIndirectCount
static int CmdDrawIndirectCount(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBuffer buffer = checkbuffer(L, 2, NULL);
    VkDeviceSize offset = luaL_checkinteger(L, 3);
    VkBuffer countBuffer = checkbuffer(L, 4, NULL);
    VkDeviceSize countBufferOffset = luaL_checkinteger(L, 5);
    uint32_t maxDrawCount = luaL_checkinteger(L, 6);
    uint32_t stride = luaL_checkinteger(L, 7);
    CheckDevicePfn(L, ud, CmdDrawIndirectCount);
    ud->ddt->CmdDrawIndirectCount(cb, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
    return 0;
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
leaq 0x40(%rsp), %rdx
leaq 0xb035a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xafa32(%rip), %rcx     # 0xcf000
callq 0x1a640
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movl $0x4, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xaf9ff(%rip), %rcx     # 0xcf000
callq 0x1a640
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movl $0x5, %esi
callq 0x19190
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movl $0x6, %esi
callq 0x19190
movl %eax, 0x14(%rsp)
movq 0x48(%rsp), %rdi
movl $0x7, %esi
callq 0x19190
movl %eax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x5a8(%rax)
jne 0x1f671
movq 0x48(%rsp), %rdi
leaq 0xb0624(%rip), %rsi     # 0xcfc88
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x54(%rsp)
jmp 0x1f6b4
jmp 0x1f673
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x5a8(%rax), %rax
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movl 0x14(%rsp), %r9d
movl 0x10(%rsp), %r10d
movl %r10d, (%rsp)
callq *%rax
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdDrawIndexedIndirectCount
static int CmdDrawIndexedIndirectCount(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBuffer buffer = checkbuffer(L, 2, NULL);
    VkDeviceSize offset = luaL_checkinteger(L, 3);
    VkBuffer countBuffer = checkbuffer(L, 4, NULL);
    VkDeviceSize countBufferOffset = luaL_checkinteger(L, 5);
    uint32_t maxDrawCount = luaL_checkinteger(L, 6);
    uint32_t stride = luaL_checkinteger(L, 7);
    CheckDevicePfn(L, ud, CmdDrawIndexedIndirectCount);
    ud->ddt->CmdDrawIndexedIndirectCount(cb, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
    return 0;
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
leaq 0x40(%rsp), %rdx
leaq 0xb022a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xaf902(%rip), %rcx     # 0xcf000
callq 0x1a640
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movl $0x4, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xaf8cf(%rip), %rcx     # 0xcf000
callq 0x1a640
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movl $0x5, %esi
callq 0x19190
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movl $0x6, %esi
callq 0x19190
movl %eax, 0x14(%rsp)
movq 0x48(%rsp), %rdi
movl $0x7, %esi
callq 0x19190
movl %eax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x5b0(%rax)
jne 0x1f7a1
movq 0x48(%rsp), %rdi
leaq 0xb051e(%rip), %rsi     # 0xcfcb2
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x54(%rsp)
jmp 0x1f7e4
jmp 0x1f7a3
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x5b0(%rax), %rax
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movl 0x14(%rsp), %r9d
movl 0x10(%rsp), %r10d
movl %r10d, (%rsp)
callq *%rax
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetDeviceMask
static int CmdSetDeviceMask(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t deviceMask = luaL_checkinteger(L, 2);
    CheckDevicePfn(L, ud, CmdSetDeviceMask);
    ud->ddt->CmdSetDeviceMask(cb, deviceMask);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xb00fa(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x19190
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x538(%rax)
jne 0x1f858
movq 0x18(%rsp), %rdi
leaq 0xb0498(%rip), %rsi     # 0xcfce3
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x24(%rsp)
jmp 0x1f87d
jmp 0x1f85a
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x538(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdDispatchBase
static int CmdDispatchBase(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t baseGroupX = luaL_checkinteger(L, 2);
    uint32_t baseGroupY = luaL_checkinteger(L, 3);
    uint32_t baseGroupZ = luaL_checkinteger(L, 4);
    uint32_t groupCountX = luaL_checkinteger(L, 5);
    uint32_t groupCountY = luaL_checkinteger(L, 6);
    uint32_t groupCountZ = luaL_checkinteger(L, 7);
    CheckDevicePfn(L, ud, CmdDispatchBase);
    ud->ddt->CmdDispatchBase(cb, baseGroupX, baseGroupY, baseGroupZ,
            groupCountX, groupCountY, groupCountZ);
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x30(%rsp), %rdx
leaq 0xb005a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x19190
movl %eax, 0x24(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movl %eax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x4, %esi
callq 0x19190
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
movl $0x5, %esi
callq 0x19190
movl %eax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x6, %esi
callq 0x19190
movl %eax, 0x14(%rsp)
movq 0x38(%rsp), %rdi
movl $0x7, %esi
callq 0x19190
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x540(%rax)
jne 0x1f957
movq 0x38(%rsp), %rdi
leaq 0xb03bf(%rip), %rsi     # 0xcfd09
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x44(%rsp)
jmp 0x1f997
jmp 0x1f959
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x540(%rax), %rax
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movl 0x1c(%rsp), %ecx
movl 0x18(%rsp), %r8d
movl 0x14(%rsp), %r9d
movl 0x10(%rsp), %r10d
movl %r10d, (%rsp)
callq *%rax
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdBeginTransformFeedback
static int CmdBeginTransformFeedback(lua_State *L)
    {
    ud_t *ud;
    int err = 0, errargc=1;
    uint32_t first, count, count1;
    VkBuffer* buffers = NULL;
    VkDeviceSize *offsets = NULL;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdBeginTransformFeedbackEXT);

    first = luaL_checkinteger(L, 2);

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

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

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

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl $0x0, 0x3c(%rsp)
movl $0x1, 0x38(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
leaq 0x40(%rsp), %rdx
leaq 0xafcc8(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x578(%rax)
jne 0x1fc7a
movq 0x48(%rsp), %rdi
leaq 0xb00fc(%rip), %rsi     # 0xcfd66
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x54(%rsp)
jmp 0x1fdd7
jmp 0x1fc7c
movq 0x48(%rsp), %rdi
movl $0x2, %esi
callq 0x19190
movl %eax, 0x34(%rsp)
movq 0x48(%rsp), %rdi
movl $0x3, %esi
leaq 0x30(%rsp), %rdx
leaq 0x3c(%rsp), %rcx
leaq 0xaf356(%rip), %r8      # 0xcf000
callq 0x19ae0
movq %rax, 0x20(%rsp)
cmpl $0x1, 0x3c(%rsp)
jne 0x1fcc5
movl $0x0, 0x3c(%rsp)
jmp 0x1fcdb
cmpl $0x0, 0x3c(%rsp)
je 0x1fcd9
movl $0x3, 0x38(%rsp)
jmp 0x1fd62
jmp 0x1fcdb
movq 0x48(%rsp), %rdi
movl $0x4, %esi
leaq 0x2c(%rsp), %rdx
leaq 0x3c(%rsp), %rcx
callq 0x19fb0
movq %rax, 0x18(%rsp)
cmpl $0x1, 0x3c(%rsp)
jne 0x1fd0a
movl $0x0, 0x3c(%rsp)
jmp 0x1fd1d
cmpl $0x0, 0x3c(%rsp)
je 0x1fd1b
movl $0x4, 0x38(%rsp)
jmp 0x1fd62
jmp 0x1fd1d
movl 0x2c(%rsp), %eax
cmpl 0x30(%rsp), %eax
je 0x1fd39
movl $0xfffffff9, 0x3c(%rsp) # imm = 0xFFFFFFF9
movl $0x4, 0x38(%rsp)
jmp 0x1fd62
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x578(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0x34(%rsp), %esi
movl 0x30(%rsp), %edx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
callq *%rax
cmpq $0x0, 0x20(%rsp)
je 0x1fd79
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x18300
cmpq $0x0, 0x18(%rsp)
je 0x1fd90
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x18300
cmpl $0x0, 0x3c(%rsp)
je 0x1fdc7
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movl 0x38(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x3c(%rsp), %edi
callq 0x19a60
movq (%rsp), %rdi
movl 0x8(%rsp), %esi
movq %rax, %rdx
callq 0x18460
movl %eax, 0xc(%rsp)
jmp 0x1fdcf
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x1fdcf
movl 0xc(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdBeginQueryIndexed
static int CmdBeginQueryIndexed(lua_State *L)
    {
    ud_t *ud;
    VkQueryPool query_pool;
    VkQueryControlFlags flags;
    uint32_t query, index;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdBeginQueryIndexedEXT);
    query_pool = checkquery_pool(L, 2, NULL);
    query = luaL_checkinteger(L, 3);
    flags = checkflags(L, 4);
    index = luaL_checkinteger(L, 5);
    ud->ddt->CmdBeginQueryIndexedEXT(cb, query_pool, query, flags, index);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x20(%rsp), %rdx
leaq 0xaf92a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x588(%rax)
jne 0x20017
movq 0x28(%rsp), %rdi
leaq 0xafdc1(%rip), %rsi     # 0xcfdc8
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x34(%rsp)
jmp 0x200a1
jmp 0x20019
movq 0x28(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xaf9e1(%rip), %rcx     # 0xcfa0f
callq 0x1a640
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movl %eax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0x4, %esi
callq 0x19010
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl $0x5, %esi
callq 0x19190
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x588(%rax), %rax
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x10(%rsp), %edx
movl 0x14(%rsp), %ecx
movl 0xc(%rsp), %r8d
callq *%rax
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdEndQueryIndexed
static int CmdEndQueryIndexed(lua_State *L)
    {
    ud_t *ud;
    VkQueryPool query_pool;
    uint32_t query, index;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdEndQueryIndexedEXT);
    query_pool = checkquery_pool(L, 2, NULL);
    query = luaL_checkinteger(L, 3);
    index = luaL_checkinteger(L, 4);
    ud->ddt->CmdEndQueryIndexedEXT(cb, query_pool, query, index);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x20(%rsp), %rdx
leaq 0xaf83a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x590(%rax)
jne 0x20105
movq 0x28(%rsp), %rdi
leaq 0xafcfd(%rip), %rsi     # 0xcfdf5
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x34(%rsp)
jmp 0x20178
jmp 0x20107
movq 0x28(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xaf8f3(%rip), %rcx     # 0xcfa0f
callq 0x1a640
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl $0x4, %esi
callq 0x19190
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x590(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
callq *%rax
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdDrawIndirectByteCount
static int CmdDrawIndirectByteCount(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t instanceCount = luaL_checkinteger(L, 2);
    uint32_t firstInstance = luaL_checkinteger(L, 3);
    VkBuffer counterBuffer = checkbuffer(L, 4, NULL);
    VkDeviceSize counterBufferOffset = checkdevicesize(L, 5);
    uint32_t counterOffset = luaL_checkinteger(L, 6);
    uint32_t vertexStride = luaL_checkinteger(L, 7);
    CheckDevicePfn(L, ud, CmdDrawIndirectByteCountEXT);
    ud->ddt->CmdDrawIndirectByteCountEXT(cb, instanceCount, firstInstance,
            counterBuffer, counterBufferOffset, counterOffset, vertexStride);
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x30(%rsp), %rdx
leaq 0xaf75a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x19190
movl %eax, 0x24(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movl %eax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x4, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xaee0c(%rip), %rcx     # 0xcf000
callq 0x1a640
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x5, %esi
callq 0x19d90
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0x6, %esi
callq 0x19190
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rdi
movl $0x7, %esi
callq 0x19190
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x598(%rax)
jne 0x20264
movq 0x38(%rsp), %rdi
leaq 0xafbc9(%rip), %rsi     # 0xcfe20
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x44(%rsp)
jmp 0x202a5
jmp 0x20266
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x598(%rax), %rax
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movl 0xc(%rsp), %r9d
movl 0x8(%rsp), %r10d
movl %r10d, (%rsp)
callq *%rax
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetLineStipple
static int CmdSetLineStipple(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t lineStippleFactor = luaL_checkinteger(L, 2);
    uint16_t lineStipplePattern = luaL_checkinteger(L, 3);
    CheckDevicePfn(L, ud, CmdSetLineStippleEXT);
    ud->ddt->CmdSetLineStippleEXT(cb, lineStippleFactor, lineStipplePattern);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xaf63a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x19190
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movw %ax, 0x2(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x788(%rax)
jne 0x2032c
movq 0x18(%rsp), %rdi
leaq 0xafb32(%rip), %rsi     # 0xcfe51
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x24(%rsp)
jmp 0x20356
jmp 0x2032e
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x788(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movzwl 0x2(%rsp), %edx
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetColorWriteEnable
static int CmdSetColorWriteEnable(lua_State *L)
    {
    int err;
    ud_t *ud;
    uint32_t count;
    VkBool32 *enables;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdSetColorWriteEnableEXT);
#define CLEANUP Free(L, enables)
    enables = checkbooleanlist(L, 2, &count, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ud->ddt->CmdSetColorWriteEnableEXT(cb, count, enables);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xaf58a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x840(%rax)
jne 0x203b8
movq 0x38(%rsp), %rdi
leaq 0xafad3(%rip), %rsi     # 0xcfe7b
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x44(%rsp)
jmp 0x2045a
jmp 0x203ba
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x24(%rsp), %rdx
leaq 0x34(%rsp), %rcx
callq 0x193b0
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x20423
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x18300
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x18460
movl %eax, 0x44(%rsp)
jmp 0x2045a
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x840(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x18(%rsp), %rdx
callq *%rax
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x18300
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetCullMode
static int CmdSetCullMode(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkCullModeFlags cullMode = checkflags(L, 2);
    CheckDevicePfn(L, ud, CmdSetCullModeEXT);
    ud->ddt->CmdSetCullModeEXT(cb, cullMode);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xaf47a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x19010
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x790(%rax)
jne 0x204d8
movq 0x18(%rsp), %rdi
leaq 0xaf9df(%rip), %rsi     # 0xcfeaa
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x24(%rsp)
jmp 0x204fd
jmp 0x204da
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x790(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetFrontFace
static int CmdSetFrontFace(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkFrontFace frontFace = checkfrontface(L, 2);
    CheckDevicePfn(L, ud, CmdSetFrontFaceEXT);
    ud->ddt->CmdSetFrontFaceEXT(cb, frontFace);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xaf3da(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x10, %esi
movl $0x2, %edx
callq 0x19d20
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x798(%rax)
jne 0x2057d
movq 0x18(%rsp), %rdi
leaq 0xaf961(%rip), %rsi     # 0xcfed1
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x24(%rsp)
jmp 0x205a2
jmp 0x2057f
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x798(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetPrimitiveTopology
static int CmdSetPrimitiveTopology(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkPrimitiveTopology primitiveTopology = checkprimitivetopology(L, 2);
    CheckDevicePfn(L, ud, CmdSetPrimitiveTopologyEXT);
    ud->ddt->CmdSetPrimitiveTopologyEXT(cb, primitiveTopology);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xaf33a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0xe, %esi
movl $0x2, %edx
callq 0x19d20
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x7a0(%rax)
jne 0x2061d
movq 0x18(%rsp), %rdi
leaq 0xaf8e9(%rip), %rsi     # 0xcfef9
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x24(%rsp)
jmp 0x20642
jmp 0x2061f
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x7a0(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetViewportWithCount
static int CmdSetViewportWithCount(lua_State *L)
    {
    int err;
    ud_t *ud;
    uint32_t count;
    VkViewport *viewports;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdSetViewportWithCountEXT);
#define CLEANUP zfreearrayVkViewport (L, viewports, count, 1)
    viewports = zcheckarrayVkViewport(L, 2, &count, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ud->ddt->CmdSetViewportWithCountEXT(cb, count, viewports);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xaf29a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x7a8(%rax)
jne 0x206a8
movq 0x38(%rsp), %rdi
leaq 0xaf891(%rip), %rsi     # 0xcff29
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x44(%rsp)
jmp 0x20772
jmp 0x206aa
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x24(%rsp), %rdx
leaq 0x34(%rsp), %rcx
callq 0x193e0
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x20727
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x24(%rsp), %ecx
movl $0x18, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x18460
movl %eax, 0x44(%rsp)
jmp 0x20772
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x7a8(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x18(%rsp), %rdx
callq *%rax
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x24(%rsp), %ecx
movl $0x18, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetScissorWithCount
static int CmdSetScissorWithCount(lua_State *L)
    {
    int err;
    ud_t *ud;
    uint32_t count;
    VkRect2D* scissors;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdSetScissorWithCountEXT);
#define CLEANUP zfreearrayVkRect2D(L, scissors, count, 1)
    scissors = zcheckarrayVkRect2D(L, 2, &count, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ud->ddt->CmdSetScissorWithCountEXT(cb, count, scissors);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xaf16a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x7b0(%rax)
jne 0x207d8
movq 0x38(%rsp), %rdi
leaq 0xaf791(%rip), %rsi     # 0xcff59
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x44(%rsp)
jmp 0x208a2
jmp 0x207da
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x24(%rsp), %rdx
leaq 0x34(%rsp), %rcx
callq 0x1a5b0
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x20857
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x24(%rsp), %ecx
movl $0x10, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x18460
movl %eax, 0x44(%rsp)
jmp 0x208a2
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x7b0(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x18(%rsp), %rdx
callq *%rax
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x24(%rsp), %ecx
movl $0x10, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetDepthTestEnable
static int CmdSetDepthTestEnable(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBool32 depthTestEnable = checkboolean(L, 2);
    CheckDevicePfn(L, ud, CmdSetDepthTestEnableEXT);
    ud->ddt->CmdSetDepthTestEnableEXT(cb, depthTestEnable);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xaf03a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x187f0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x7c0(%rax)
jne 0x20918
movq 0x18(%rsp), %rdi
leaq 0xaf67d(%rip), %rsi     # 0xcff88
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x24(%rsp)
jmp 0x2093d
jmp 0x2091a
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x7c0(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetDepthWriteEnable
static int CmdSetDepthWriteEnable(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBool32 depthWriteEnable = checkboolean(L, 2);
    CheckDevicePfn(L, ud, CmdSetDepthWriteEnableEXT);
    ud->ddt->CmdSetDepthWriteEnableEXT(cb, depthWriteEnable);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xaef9a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x187f0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x7c8(%rax)
jne 0x209b8
movq 0x18(%rsp), %rdi
leaq 0xaf60b(%rip), %rsi     # 0xcffb6
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x24(%rsp)
jmp 0x209dd
jmp 0x209ba
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x7c8(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetDepthCompareOp
static int CmdSetDepthCompareOp(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkCompareOp depthCompareOp = checkcompareop(L, 2);
    CheckDevicePfn(L, ud, CmdSetDepthCompareOpEXT);
    ud->ddt->CmdSetDepthCompareOpEXT(cb, depthCompareOp);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xaeefa(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x11, %esi
movl $0x2, %edx
callq 0x19d20
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x7d0(%rax)
jne 0x20a5d
movq 0x18(%rsp), %rdi
leaq 0xaf595(%rip), %rsi     # 0xcffe5
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x24(%rsp)
jmp 0x20a82
jmp 0x20a5f
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x7d0(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetDepthBoundsTestEnable
static int CmdSetDepthBoundsTestEnable(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBool32 depthBoundsTestEnable = checkboolean(L, 2);
    CheckDevicePfn(L, ud, CmdSetDepthBoundsTestEnableEXT);
    ud->ddt->CmdSetDepthBoundsTestEnableEXT(cb, depthBoundsTestEnable);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xaee5a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x187f0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x7d8(%rax)
jne 0x20af8
movq 0x18(%rsp), %rdi
leaq 0xaf527(%rip), %rsi     # 0xd0012
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x24(%rsp)
jmp 0x20b1d
jmp 0x20afa
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x7d8(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetStencilTestEnable
static int CmdSetStencilTestEnable(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBool32 stencilTestEnable = checkboolean(L, 2);
    CheckDevicePfn(L, ud, CmdSetStencilTestEnableEXT);
    ud->ddt->CmdSetStencilTestEnableEXT(cb, stencilTestEnable);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xaedba(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x187f0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x7e0(%rax)
jne 0x20b98
movq 0x18(%rsp), %rdi
leaq 0xaf4bb(%rip), %rsi     # 0xd0046
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x24(%rsp)
jmp 0x20bbd
jmp 0x20b9a
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x7e0(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetStencilOp
static int CmdSetStencilOp(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkStencilFaceFlags faceMask = checkflags(L, 2);
    VkStencilOp failOp = checkstencilop(L, 3);
    VkStencilOp passOp = checkstencilop(L, 4);
    VkStencilOp depthFailOp = checkstencilop(L, 5);
    VkCompareOp compareOp = checkcompareop(L, 6);
    CheckDevicePfn(L, ud, CmdSetStencilOpEXT);
    ud->ddt->CmdSetStencilOpEXT(cb, faceMask, failOp, passOp, depthFailOp, compareOp);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x20(%rsp), %rdx
leaq 0xaed1a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x19010
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl $0x12, %esi
movl $0x3, %edx
callq 0x19d20
movl %eax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0x12, %esi
movl $0x4, %edx
callq 0x19d20
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movl $0x12, %esi
movl $0x5, %edx
callq 0x19d20
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl $0x11, %esi
movl $0x6, %edx
callq 0x19d20
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x7e8(%rax)
jne 0x20c98
movq 0x28(%rsp), %rdi
leaq 0xaf3eb(%rip), %rsi     # 0xd0076
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x34(%rsp)
jmp 0x20ccf
jmp 0x20c9a
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x7e8(%rax), %rax
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movl 0x8(%rsp), %r8d
movl 0x4(%rsp), %r9d
callq *%rax
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetPatchControlPoints
static int CmdSetPatchControlPoints(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t patchControlPoints = luaL_checkinteger(L, 2);
    CheckDevicePfn(L, ud, CmdSetPatchControlPointsEXT);
    ud->ddt->CmdSetPatchControlPointsEXT(cb, patchControlPoints);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xaec0a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x19190
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x818(%rax)
jne 0x20d48
movq 0x18(%rsp), %rdi
leaq 0xaf363(%rip), %rsi     # 0xd009e
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x24(%rsp)
jmp 0x20d6d
jmp 0x20d4a
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x818(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetRasterizerDiscardEnable
static int CmdSetRasterizerDiscardEnable(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBool32 rasterizerDiscardEnable = checkboolean(L, 2);
    CheckDevicePfn(L, ud, CmdSetRasterizerDiscardEnableEXT);
    ud->ddt->CmdSetRasterizerDiscardEnableEXT(cb, rasterizerDiscardEnable);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xaeb6a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x187f0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x820(%rax)
jne 0x20de8
movq 0x18(%rsp), %rdi
leaq 0xaf2f4(%rip), %rsi     # 0xd00cf
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x24(%rsp)
jmp 0x20e0d
jmp 0x20dea
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x820(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetDepthBiasEnable
static int CmdSetDepthBiasEnable(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBool32 depthBiasEnable = checkboolean(L, 2);
    CheckDevicePfn(L, ud, CmdSetDepthBiasEnableEXT);
    ud->ddt->CmdSetDepthBiasEnableEXT(cb, depthBiasEnable);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xaeaca(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x187f0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x828(%rax)
jne 0x20e88
movq 0x18(%rsp), %rdi
leaq 0xaf28a(%rip), %rsi     # 0xd0105
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x24(%rsp)
jmp 0x20ead
jmp 0x20e8a
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x828(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetLogicOp
static int CmdSetLogicOp(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkLogicOp logicOp = checklogicop(L, 2);
    CheckDevicePfn(L, ud, CmdSetLogicOpEXT);
    ud->ddt->CmdSetLogicOpEXT(cb, logicOp);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xaea2a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x13, %esi
movl $0x2, %edx
callq 0x19d20
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x830(%rax)
jne 0x20f2d
movq 0x18(%rsp), %rdi
leaq 0xaf213(%rip), %rsi     # 0xd0133
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x24(%rsp)
jmp 0x20f52
jmp 0x20f2f
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x830(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetPrimitiveRestartEnable
static int CmdSetPrimitiveRestartEnable(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBool32 primitiveRestartEnable = checkboolean(L, 2);
    CheckDevicePfn(L, ud, CmdSetPrimitiveRestartEnableEXT);
    ud->ddt->CmdSetPrimitiveRestartEnableEXT(cb, primitiveRestartEnable);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xae98a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x187f0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x838(%rax)
jne 0x20fc8
movq 0x18(%rsp), %rdi
leaq 0xaf19e(%rip), %rsi     # 0xd0159
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x24(%rsp)
jmp 0x20fed
jmp 0x20fca
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x838(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)