LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetStencilReference
static int CmdSetStencilReference(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkStencilFaceFlags faceMask = checkflags(L, 2);
    uint32_t reference = luaL_checkinteger(L, 3);
    ud->ddt->CmdSetStencilReference(cb, faceMask, reference);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6262e(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
movq %rsp, %r14
movq %r14, %rdx
callq 0x1a500
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x18f50
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq (%r14), %rcx
movq 0x50(%rcx), %rcx
movq %r15, %rdi
movl %r12d, %esi
movl %eax, %edx
callq *0x318(%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdBindDescriptorSets
static int CmdBindDescriptorSets(lua_State *L)
    {
    int err; 
    uint32_t sets_count, offsets_count = 0;
    VkDescriptorSet* sets; 
    uint32_t* offsets;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkPipelineBindPoint bindpoint = checkpipelinebindpoint(L, 2);
    VkPipelineLayout layout = checkpipeline_layout(L, 3, NULL);
    uint32_t firstSet = luaL_checkinteger(L, 4);

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
andl $0x0, 0xc(%rsp)
leaq 0x625c4(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x30(%rsp), %rdx
callq 0x1a500
movq %rax, 0x28(%rsp)
pushq $0x1e
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x19c00
movl %eax, %r15d
leaq 0x625c8(%rip), %rcx     # 0x7d937
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %r13
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq %rax, %rbp
leaq 0x625be(%rip), %r9      # 0x7d952
pushq $0x5
popq %rsi
leaq 0x14(%rsp), %rdx
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x19130
movl (%r14), %edi
testl %edi, %edi
je 0x1b3dc
callq 0x19950
pushq $0x5
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
movl %eax, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %rbp, 0x18(%rsp)
movq %r13, 0x20(%rsp)
pushq $0x6
popq %rsi
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rbp
movq %rbx, %rdi
movq %rbp, %rcx
callq 0x1a390
cmpl $0x0, (%rbp)
js 0x1b466
movq %rax, %r14
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x14(%rsp), %r8d
movl 0xc(%rsp), %r10d
movq 0x28(%rsp), %rdi
movl %r15d, %esi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %r12, %r9
pushq %r14
pushq %r10
callq *0x320(%rax)
addq $0x10, %rsp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x182e0
xorl %ebp, %ebp
testq %r14, %r14
je 0x1b3cb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x182e0
jmp 0x1b3cb
movq %rbx, %rdi
movq %r12, %rsi
callq 0x182e0
movl 0x10(%rsp), %edi
callq 0x19950
pushq $0x6
jmp 0x1b3bd
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdBindIndexBuffer
static int CmdBindIndexBuffer(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBuffer buffer = checkbuffer(L, 2, NULL);
    VkDeviceSize offset = luaL_checkinteger(L, 3);
    VkIndexType indexType = checkindextype(L, 4);
    ud->ddt->CmdBindIndexBuffer(cb, buffer, offset, indexType);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x62471(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdx
callq 0x1a500
movq %rax, %r15
leaq 0x61b4e(%rip), %rcx     # 0x7d000
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %r12
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %r13
pushq $0x20
popq %rsi
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x19c00
movq (%rbx), %rcx
movq 0x50(%rcx), %r8
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %eax, %ecx
callq *0x328(%r8)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdDraw
static int CmdDraw(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t vertexCount = luaL_checkinteger(L, 2);
    uint32_t instanceCount = luaL_checkinteger(L, 3);
    uint32_t firstVertex = luaL_checkinteger(L, 4);
    uint32_t firstInstance = luaL_checkinteger(L, 5);
    ud->ddt->CmdDraw(cb, vertexCount, instanceCount, firstVertex, firstInstance);
    return 0;
    }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x61f77(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
movq %rsp, %rdx
callq 0x1a500
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %r12
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %r13
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %rbp
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %rbx
pushq $0x6
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rsp, %rcx
movq (%rcx), %rcx
movq 0x50(%rcx), %r10
movq %r15, %rdi
movl %r12d, %esi
movl %r13d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
movl %eax, %r9d
callq *0x340(%r10)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdDrawIndirect
static int CmdDrawIndirect(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBuffer buffer = checkbuffer(L, 2, NULL);
    VkDeviceSize offset = luaL_checkinteger(L, 3);
    uint32_t drawCount = luaL_checkinteger(L, 4);
    uint32_t stride = luaL_checkinteger(L, 5);
    ud->ddt->CmdDrawIndirect(cb, buffer, offset, drawCount, stride);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x61ede(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
movq %rsp, %rbx
movq %rbx, %rdx
callq 0x1a500
movq %rax, %r15
leaq 0x615bd(%rip), %rcx     # 0x7d000
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %r12
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %r13
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %rbp
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq (%rbx), %rcx
movq 0x50(%rcx), %r9
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %ebp, %ecx
movl %eax, %r8d
callq *0x348(%r9)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdDrawIndexedIndirect
static int CmdDrawIndexedIndirect(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBuffer buffer = checkbuffer(L, 2, NULL);
    VkDeviceSize offset = luaL_checkinteger(L, 3);
    uint32_t drawCount = luaL_checkinteger(L, 4);
    uint32_t stride = luaL_checkinteger(L, 5);
    ud->ddt->CmdDrawIndexedIndirect(cb, buffer, offset, drawCount, stride);
    return 0;
    }

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x61dba(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdx
callq 0x1a500
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %r12
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %r13
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq (%rbx), %rcx
movq 0x50(%rcx), %r8
movq %r15, %rdi
movl %r12d, %esi
movl %r13d, %edx
movl %eax, %ecx
callq *0x358(%r8)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdDispatchIndirect
static int CmdDispatchIndirect(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBuffer buffer = checkbuffer(L, 2, NULL);
    VkDeviceSize offset = luaL_checkinteger(L, 3);
    ud->ddt->CmdDispatchIndirect(cb, buffer, offset);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x61d45(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
movq %rsp, %r14
movq %r14, %rdx
callq 0x1a500
movq %rax, %r15
leaq 0x61424(%rip), %rcx     # 0x7d000
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq (%r14), %rcx
movq 0x50(%rcx), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq *0x360(%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdCopyBuffer
static int CmdCopyBuffer(lua_State *L)
    {
    int err;
    uint32_t count;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    if(ud->ddt->CmdCopyBuffer2KHR && lua_type(L, 2)==LUA_TTABLE)
        {
        VkCopyBufferInfo2KHR *info = zcheckVkCopyBufferInfo2KHR(L, 2, &err);
#define CLEANUP zfreeVkCopyBufferInfo2KHR(L, info, 1)
        if(err) { CLEANUP; return argerror(L, 2); }
        ud->ddt->CmdCopyBuffer2KHR(cb, info);
        CLEANUP;
#undef CLEANUP
        }
    else
        {
        VkBuffer srcBuffer = checkbuffer(L, 2, NULL);
        VkBuffer dstBuffer = checkbuffer(L, 3, NULL);
#define CLEANUP zfreearrayVkBufferCopy(L, regions, count, 1)
        VkBufferCopy* regions = zcheckarrayVkBufferCopy(L, 4, &count, &err);
        if(err) { CLEANUP; return argerror(L, 4); }
        ud->ddt->CmdCopyBuffer(cb, srcBuffer, dstBuffer, count, regions);
        CLEANUP;
#undef CLEANUP
        }
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x61cd6(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
movq (%r15), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x6a0(%rax)
je 0x1bca7
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x1a110
cmpl $0x5, %eax
jne 0x1bca7
pushq $0x2
popq %rsi
leaq 0x4(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1a040
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1bd6d
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19150
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x2
jmp 0x1bd22
movq %r14, 0x10(%rsp)
leaq 0x6134d(%rip), %r12     # 0x7d000
xorl %r15d, %r15d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
movq %r12, %rcx
callq 0x1a500
movq %rax, %r13
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
movq %r12, %rcx
callq 0x1a500
movq %rax, %rbp
pushq $0x4
popq %rsi
movq %rsp, %rdx
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rcx
callq 0x1a1f0
movq %rax, %r12
cmpl $0x0, (%r14)
je 0x1bd33
movl (%rsp), %ecx
pushq $0x18
popq %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r12, %rsi
xorl %r9d, %r9d
callq 0x18d30
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
movl %eax, %r15d
jmp 0x1bd93
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl (%rsp), %ecx
movq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r12, %r8
callq *0x368(%rax)
movl (%rsp), %ecx
pushq $0x18
popq %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r12, %rsi
xorl %r9d, %r9d
callq 0x18d30
jmp 0x1bd93
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x6a0(%rax)
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19150
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdUpdateBuffer
static int CmdUpdateBuffer(lua_State *L)
    {
    size_t size;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBuffer dstBuffer = checkbuffer(L, 2, NULL);
    VkDeviceSize dstOffset = luaL_checkinteger(L, 3);
    const char *data = luaL_checklstring(L, 4, &size);
    if((size==0) || (size % 4)!=0)
        return argerrorc(L, 4, ERR_LENGTH);
    ud->ddt->CmdUpdateBuffer(cb, dstBuffer, dstOffset, (VkDeviceSize)size, data);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x61457(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x1a500
movq %rax, %r15
leaq 0x60b37(%rip), %rcx     # 0x7d000
xorl %r14d, %r14d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq %rax, %r13
pushq $0x4
popq %rsi
leaq 0x10(%rsp), %rbp
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x18d50
movq (%rbp), %rcx
testq %rcx, %rcx
setne %dl
testb $0x3, %cl
sete %sil
testb %sil, %dl
je 0x1c531
movq 0x8(%rsp), %rdx
movq 0x50(%rdx), %r9
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %r8
callq *0x390(%r9)
jmp 0x1c54a
pushq $-0x7
popq %rdi
callq 0x19950
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdFillBuffer
static int CmdFillBuffer(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBuffer dstBuffer = checkbuffer(L, 2, NULL);
    VkDeviceSize dstOffset = luaL_checkinteger(L, 3);
    VkDeviceSize size = checksizeorwholesize(L, 4);
    uint32_t data = luaL_checkinteger(L, 5);
    ud->ddt->CmdFillBuffer(cb, dstBuffer, dstOffset, size, data);
    return 0;
    }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
andl $0x0, 0x8(%rsp)
leaq 0x612fe(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %rdx
callq 0x1a500
movq %rax, %r14
leaq 0x61378(%rip), %rcx     # 0x7d99a
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %r13
pushq $0xa
popq %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x19c00
movl %eax, %ebp
pushq $0x4
popq %rsi
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x185b0
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1c697
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x19620
pushq $0x14
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x18d30
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x4
jmp 0x1c6f2
pushq $0x5
popq %rsi
leaq 0x8(%rsp), %rdx
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rcx
callq 0x19a60
cmpl $0x0, (%r12)
je 0x1c713
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
movq %rax, %r14
callq 0x19620
movl 0x8(%rsp), %ecx
pushq $0x14
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x18d30
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x5
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rcx
movq 0x50(%rcx), %r10
movl 0x8(%rsp), %r8d
movq %r14, %rdi
movq %r13, %rsi
movl %ebp, %edx
movq %r15, %rcx
movq %rax, %r12
movq %rax, %r9
callq *0x3a0(%r10)
xorl %r14d, %r14d
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x19620
movl 0x8(%rsp), %ecx
pushq $0x14
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x18d30
jmp 0x1c701
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdClearDepthStencilImage
static int CmdClearDepthStencilImage(lua_State *L)
    {
    int err;
    uint32_t count;
    VkClearDepthStencilValue depthstencil;
    VkImageSubresourceRange* ranges;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkImage image = checkimage(L, 2, NULL);
    VkImageLayout imageLayout = checkimagelayout(L, 3);
    depthstencil.depth = luaL_checknumber(L, 4);
    depthstencil.stencil = luaL_checkinteger(L, 5);
#define CLEANUP zfreearrayVkImageSubresourceRange(L, ranges, count, 1)
    ranges = zcheckarrayVkImageSubresourceRange(L, 6, &count, &err);
    if(err) { CLEANUP; return argerror(L, 6); }
    ud->ddt->CmdClearDepthStencilImage(cb, image, imageLayout, &depthstencil, count, ranges);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x61189(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x18(%rsp), %rdx
callq 0x1a500
movq %rax, 0x10(%rsp)
leaq 0x61201(%rip), %rcx     # 0x7d99a
xorl %r14d, %r14d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %r12
pushq $0xa
popq %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x19c00
movl %eax, %ebp
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x18840
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movl %eax, 0xc(%rsp)
pushq $0x6
popq %rsi
leaq 0x4(%rsp), %rdx
leaq 0x24(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rcx
callq 0x19a60
movq %rax, %r13
cmpl $0x0, (%r15)
je 0x1c83a
movl 0x4(%rsp), %ecx
pushq $0x14
popq %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r13, %rsi
xorl %r9d, %r9d
callq 0x18d30
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x6
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
jmp 0x1c879
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x4(%rsp), %r8d
leaq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r13, %r9
callq *0x3a8(%rax)
movl 0x4(%rsp), %ecx
pushq $0x14
popq %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r13, %rsi
xorl %r9d, %r9d
callq 0x18d30
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdClearAttachments
static int CmdClearAttachments(lua_State *L)
    {
    int err;
    ud_t *ud;
    uint32_t att_count=0;
    uint32_t rect_count=0;
    VkClearAttachment* attachments=NULL;
    VkClearRect* rects=NULL;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
#define CLEANUP do {                                            \
    zfreearrayVkClearRect(L, rects, rect_count, 1);             \
    zfreearrayVkClearAttachment(L, attachments, att_count, 1);  \
} while(0)
    attachments = zcheckarrayVkClearAttachment(L, 2, &att_count, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    rects = zcheckarrayVkClearRect(L, 3, &rect_count, &err);
    if(err) { CLEANUP; return argerror(L, 3); }
    ud->ddt->CmdClearAttachments(cb, att_count, attachments, rect_count, rects);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rsp), %r14
andl $0x0, (%r14)
movq %rdi, %rbx
andl $0x0, 0x4(%rsp)
leaq 0x61058(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %rdx
callq 0x1a500
movq %rax, %r15
pushq $0x2
popq %rsi
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movq %r14, %rdx
movq %r12, %rcx
callq 0x19bb0
movq %rax, %r14
xorl %eax, %eax
cmpl %eax, (%r12)
je 0x1c927
pushq $0x18
popq %r15
pushq $0x1
popq %rbp
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x18d30
movl 0x8(%rsp), %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x18d30
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x2
jmp 0x1c98f
pushq $0x3
popq %rsi
leaq 0x4(%rsp), %rdx
leaq 0xc(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rcx
callq 0x18b30
movq %rax, %r12
cmpl $0x0, (%r13)
je 0x1c9b0
movl 0x4(%rsp), %ecx
pushq $0x18
popq %r15
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x18d30
movl 0x8(%rsp), %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x18d30
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
movl %eax, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rsp), %esi
movl 0x4(%rsp), %ecx
movq %r15, %rdi
movq %r14, %rdx
movq %r12, %r8
callq *0x3b0(%rax)
movl 0x4(%rsp), %ecx
xorl %r15d, %r15d
pushq $0x18
popq %r13
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x18d30
movl 0x8(%rsp), %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x18d30
jmp 0x1c99e
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetEvent
static int CmdSetEvent(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkEvent event = checkevent(L, 2, NULL);
    if(ud->ddt->CmdSetEvent2KHR && lua_type(L, 3)==LUA_TTABLE)
        {
        int err;
        VkDependencyInfoKHR *info = zcheckVkDependencyInfoKHR(L, 2, &err);
#define CLEANUP zfreeVkDependencyInfoKHR(L, info, 1)
        if(err) { CLEANUP; return argerror(L, 2); }
        ud->ddt->CmdSetEvent2KHR(cb, event, info);
        CLEANUP;
#undef CLEANUP
        }
    else
        {
        VkPipelineStageFlags stageMask = checkflags(L, 3);
        ud->ddt->CmdSetEvent(cb, event, stageMask);
        }
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x60d21(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
movq %rsp, %r13
movq %r13, %rdx
callq 0x1a500
movq %rax, %r14
leaq 0x60dab(%rip), %rcx     # 0x7d9ab
xorl %r15d, %r15d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %r12
movq (%r13), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x670(%rax)
je 0x1cc80
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x1a110
cmpl $0x5, %eax
jne 0x1cc80
pushq $0x2
popq %rsi
leaq 0xc(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rdx
callq 0x1a600
movq %rax, %r15
cmpl $0x0, (%r13)
je 0x1ccb2
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19150
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
movl %eax, %r15d
jmp 0x1cca1
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x18f50
movq (%rsp), %rcx
movq 0x50(%rcx), %rcx
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %edx
callq *0x3c0(%rcx)
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%rsp), %rax
movq 0x50(%rax), %rax
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x670(%rax)
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19150
xorl %r15d, %r15d
jmp 0x1cca1
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdResetEvent
static int CmdResetEvent(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkEvent event = checkevent(L, 2, NULL);
    if(ud->ddt->CmdResetEvent2KHR)
        {
        VkPipelineStageFlags2KHR stageMask = checkflags(L, 3);
        ud->ddt->CmdResetEvent2KHR(cb, event, stageMask);
        }
    else
        {
        VkPipelineStageFlags stageMask = checkflags(L, 3);
        ud->ddt->CmdResetEvent(cb, event, stageMask);
        }
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x60c1b(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
movq %rsp, %r12
movq %r12, %rdx
callq 0x1a500
movq %rax, %rbx
leaq 0x60ca5(%rip), %rcx     # 0x7d9ab
pushq $0x2
popq %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %r14
movq (%r12), %rax
movq 0x50(%rax), %rax
movq 0x678(%rax), %r12
pushq $0x3
popq %rsi
movq %r15, %rdi
callq 0x18f50
testq %r12, %r12
je 0x1cd4e
movq (%rsp), %rcx
movq 0x50(%rcx), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq *0x678(%rcx)
jmp 0x1cd64
movq (%rsp), %rcx
movq 0x50(%rcx), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq *0x3c8(%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdBeginQuery
static int CmdBeginQuery(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkQueryPool queryPool = checkquery_pool(L, 2, NULL);
    uint32_t query = luaL_checkinteger(L, 3);
    VkQueryControlFlags flags = checkflags(L, 4);
    ud->ddt->CmdBeginQuery(cb, queryPool, query, flags);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x60369(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdx
callq 0x1a500
movq %rax, %r15
leaq 0x60455(%rip), %rcx     # 0x7da0f
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %r12
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %r13
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x18f50
movq (%rbx), %rcx
movq 0x50(%rcx), %r8
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
movl %eax, %ecx
callq *0x3e0(%r8)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdEndQuery
static int CmdEndQuery(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkQueryPool queryPool = checkquery_pool(L, 2, NULL);
    uint32_t query = luaL_checkinteger(L, 3);
    ud->ddt->CmdEndQuery(cb, queryPool, query);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x602eb(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
movq %rsp, %r14
movq %r14, %rdx
callq 0x1a500
movq %rax, %r15
leaq 0x603d9(%rip), %rcx     # 0x7da0f
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq (%r14), %rcx
movq 0x50(%rcx), %rcx
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
callq *0x3e8(%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdResetQueryPool
static int CmdResetQueryPool(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkQueryPool queryPool = checkquery_pool(L, 2, NULL);
    uint32_t firstQuery = luaL_checkinteger(L, 3);
    uint32_t queryCount = luaL_checkinteger(L, 4);
    ud->ddt->CmdResetQueryPool(cb, queryPool, firstQuery, queryCount);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x6027e(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdx
callq 0x1a500
movq %rax, %r15
leaq 0x6036a(%rip), %rcx     # 0x7da0f
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %r12
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %r13
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq (%rbx), %rcx
movq 0x50(%rcx), %r8
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
movl %eax, %ecx
callq *0x3f0(%r8)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdWriteTimestamp
static int CmdWriteTimestamp(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkQueryPool queryPool = checkquery_pool(L, 3, NULL);
    uint32_t query = luaL_checkinteger(L, 4);
    if(ud->ddt->CmdWriteTimestamp2KHR)
        {
        VkPipelineStageFlags2KHR pipelineStage = checkflags(L, 2);
        ud->ddt->CmdWriteTimestamp2KHR(cb, pipelineStage, queryPool, query);
        }
    else
        {
        VkPipelineStageFlagBits pipelineStage = (VkPipelineStageFlagBits)checkflags(L, 2);
        ud->ddt->CmdWriteTimestamp(cb, pipelineStage, queryPool, query);
        }
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
leaq 0x601fb(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r13
movq %r13, %rdx
callq 0x1a500
movq %rax, %rbx
leaq 0x602e7(%rip), %rcx     # 0x7da0f
pushq $0x3
popq %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %r14
pushq $0x4
popq %rsi
movq %r15, %rdi
callq 0x190d0
movq %rax, %r12
movq (%r13), %rax
movq 0x50(%rax), %rax
movq 0x690(%rax), %r13
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0x18f50
testq %r13, %r13
je 0x1d783
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %r8
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
movl %r12d, %ecx
callq *0x690(%r8)
jmp 0x1d79e
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %r8
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
movl %r12d, %ecx
callq *0x3f8(%r8)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdCopyQueryPoolResults
static int CmdCopyQueryPoolResults(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkQueryPool queryPool = checkquery_pool(L, 2, NULL);
    uint32_t firstQuery = luaL_checkinteger(L, 3);
    uint32_t queryCount = luaL_checkinteger(L, 4);
    VkBuffer dstBuffer = checkbuffer(L, 5, NULL);
    VkDeviceSize dstOffset  = luaL_checkinteger(L, 6);
    VkDeviceSize stride = luaL_checkinteger(L, 7);
    VkQueryResultFlags flags = checkflags(L, 8);
    ud->ddt->CmdCopyQueryPoolResults(cb, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x60143(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %rdx
callq 0x1a500
movq %rax, 0x8(%rsp)
leaq 0x60230(%rip), %rcx     # 0x7da0f
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, (%rsp)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %r13
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %rbp
leaq 0x5f7ed(%rip), %rcx     # 0x7d000
pushq $0x5
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %rbx
pushq $0x6
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %r15
pushq $0x7
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %r12
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x18f50
leaq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq 0x50(%rcx), %r10
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movl %r13d, %edx
movl %ebp, %ecx
movq %rbx, %r8
movq %r15, %r9
pushq %rax
pushq %r12
callq *0x400(%r10)
addq $0x10, %rsp
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdPushConstants
static int CmdPushConstants(lua_State *L)
    {
    size_t size;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkPipelineLayout layout = checkpipeline_layout(L, 2, NULL);
    VkShaderStageFlags stageFlags = checkflags(L, 3);
    uint32_t offset = luaL_checkinteger(L, 4);
    const char* values = luaL_checklstring(L, 5, &size);
    ud->ddt->CmdPushConstants(cb, layout, stageFlags, offset, (uint32_t)size, values);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x60068(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x1a500
movq %rax, %r15
leaq 0x6007f(%rip), %rcx     # 0x7d937
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %r12
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x18f50
movq %rax, %r13
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x190d0
movq %rax, %rbp
pushq $0x5
popq %rsi
leaq 0x10(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x18d50
leaq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq 0x50(%rcx), %r10
movl (%rbx), %r8d
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
movl %ebp, %ecx
movq %rax, %r9
callq *0x408(%r10)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdNextSubpass
static int CmdNextSubpass(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    if(ud->ddt->CmdNextSubpass2 && lua_type(L, 2) == LUA_TTABLE)
        {
#define CLEANUP do {                                    \
            zfreeVkSubpassBeginInfo(L, binfo, 1);    \
            zfreeVkSubpassEndInfo(L, einfo, 1);      \
} while(0)
        VkSubpassBeginInfo* binfo = NULL;
        VkSubpassEndInfo* einfo = NULL;
        binfo = zcheckVkSubpassBeginInfo(L, 2, &err);
        if(err) { CLEANUP; return argerror(L, 2); }
        einfo = zcheckVkSubpassEndInfo(L, 3, &err);
        if(err) { CLEANUP; return argerror(L, 3); }
        ud->ddt->CmdNextSubpass2(cb, binfo, einfo);
        CLEANUP;
#undef CLEANUP
        }
    else
        {
        VkSubpassContents contents = checksubpasscontents(L, 2);
        ud->ddt->CmdNextSubpass(cb, contents);
        }
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x5fe2e(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
movq (%r15), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x5c8(%rax)
je 0x1db59
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x1a110
cmpl $0x5, %eax
jne 0x1db59
pushq $0x2
popq %rsi
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x18250
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1db7f
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x19150
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x19150
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x2
jmp 0x1dbc8
pushq $0x21
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x19c00
movq 0x10(%rsp), %rcx
movq 0x50(%rcx), %rcx
movq %r14, %rdi
movl %eax, %esi
callq *0x418(%rcx)
xorl %eax, %eax
jmp 0x1dbd4
pushq $0x3
popq %rsi
leaq 0xc(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rdx
callq 0x1a0f0
movq %rax, %r12
cmpl $0x0, (%r13)
je 0x1dbe3
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x19150
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x19150
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x5c8(%rax)
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x19150
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x19150
jmp 0x1db7b
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdEndRenderPass
static int CmdEndRenderPass(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    if(ud->ddt->CmdEndRenderPass2 && lua_type(L, 2) == LUA_TTABLE)
        {
#define CLEANUP zfreeVkSubpassEndInfo(L, einfo, 1)
        VkSubpassEndInfo* einfo;
        einfo = zcheckVkSubpassEndInfo(L, 2, &err);
        if(err) { CLEANUP; return argerror(L, 2); }
        ud->ddt->CmdEndRenderPass2(cb, einfo);
        CLEANUP;
#undef CLEANUP
        }
    else
        {
        ud->ddt->CmdEndRenderPass(cb);
        }
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x5fcd7(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
movq (%r15), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x5d0(%rax)
je 0x1dcb7
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x1a110
cmpl $0x5, %eax
jne 0x1dcae
pushq $0x2
popq %rsi
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1a0f0
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1dcce
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19150
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
jmp 0x1dcc2
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %r14, %rdi
callq *0x420(%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x5d0(%rax)
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19150
jmp 0x1dcc0
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdExecuteCommands
static int CmdExecuteCommands(lua_State *L)
    {
    int err;
    uint32_t count;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkCommandBuffer *buffers = checkcommand_bufferlist(L, 2, &count, &err, NULL);
    if(err) return argerrorc(L, 2, err);

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x5fc01(%rip), %r15     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
movq %r15, %rcx
callq 0x1a500
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x4(%rsp), %rdx
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rcx
movq %r15, %r8
callq 0x199d0
movl (%r12), %edi
testl %edi, %edi
je 0x1dd53
callq 0x19950
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
jmp 0x1dd7c
movq %rax, %r15
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x4(%rsp), %esi
movq %r14, %rdi
movq %r15, %rdx
callq *0x428(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x182e0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdDebugMarkerBegin
static int CmdDebugMarkerBegin(lua_State *L) 

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x5fb6e(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
movq %rsp, %r15
movq %r15, %rdx
callq 0x1a500
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1fef3
movq (%r15), %rax
movq 0x50(%rax), %rax
movq 0x430(%rax), %rax
testq %rax, %rax
je 0x1ddda
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq *%rax
xorl %eax, %eax
jmp 0x1ddeb
leaq 0x5fc44(%rip), %rsi     # 0x7da25
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdDebugMarkerEnd
static int CmdDebugMarkerEnd(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdDebugMarkerEndEXT);
    ud->ddt->CmdDebugMarkerEndEXT(cb);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5fb06(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
movq %rsp, %r14
movq %r14, %rdx
callq 0x1a500
movq (%r14), %rcx
movq 0x50(%rcx), %rcx
movq 0x438(%rcx), %rcx
testq %rcx, %rcx
je 0x1de2d
movq %rax, %rdi
callq *%rcx
xorl %eax, %eax
jmp 0x1de3e
leaq 0x5fc1d(%rip), %rsi     # 0x7da51
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdDebugMarkerInsert
static int CmdDebugMarkerInsert(lua_State *L)
    {
    ud_t *ud;
    VkDebugMarkerMarkerInfoEXT info;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdDebugMarkerInsertEXT);
    checkdebugmarkermarkerinfo(L, 2, &info);
    ud->ddt->CmdDebugMarkerInsertEXT(cb, &info);
    return 0;
    }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x5fa33(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdx
callq 0x1a500
movq %rax, %r14
pushq $0x1e
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x19c00
movl %eax, %ebp
leaq 0x5fa37(%rip), %rcx     # 0x7d937
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1a500
movq %rax, %r15
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq %rax, %r13
movq (%r12), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x448(%rax)
je 0x1df88
movl %ebp, 0x4(%rsp)
movq %r14, %rbp
pushq $0x5
popq %rsi
movq %rsp, %rdx
leaq 0x14(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rcx
callq 0x1a3a0
movq %rax, %r12
cmpl $0x0, (%r14)
je 0x1df9b
movl (%rsp), %ecx
pushq $0x40
popq %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x197e0
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x5
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
jmp 0x1dfd5
leaq 0x5fb19(%rip), %rsi     # 0x7daa8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19bc0
jmp 0x1dfd5
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl (%rsp), %r8d
movq %rbp, %rdi
movl 0x4(%rsp), %esi
movq %r15, %rdx
movl %r13d, %ecx
movq %r12, %r9
callq *0x448(%rax)
movl (%rsp), %ecx
pushq $0x40
popq %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x197e0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq