LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdBindDescriptorSets
static int CmdBindDescriptorSets(lua_State *L)
    {
    int err; 
    uint32_t sets_count, offsets_count = 0;
    VkDescriptorSet* sets; 
    uint32_t* offsets;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkPipelineBindPoint bindpoint = checkpipelinebindpoint(L, 2);
    VkPipelineLayout layout = checkpipeline_layout(L, 3, NULL);
    uint32_t firstSet = luaL_checkinteger(L, 4);

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl $0x0, 0xc(%rsp)
leaq 0x7452b(%rip), %rcx     # 0x8f909
leaq 0x30(%rsp), %rdx
movl $0x1, %esi
callq 0x1a520
movq %rax, 0x28(%rsp)
movq %rbx, %rdi
movl $0x1e, %esi
movl $0x2, %edx
callq 0x19c20
movl %eax, %r15d
leaq 0x74529(%rip), %rcx     # 0x8f937
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r13
movq %rbx, %rdi
movl $0x4, %esi
callq 0x190f0
movq %rax, %rbp
leaq 0x7451b(%rip), %r9      # 0x8f952
leaq 0x14(%rsp), %rdx
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movl $0x5, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x19150
movl (%r14), %edi
testl %edi, %edi
je 0x1b483
callq 0x19970
movq %rbx, %rdi
movl $0x5, %esi
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)
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rbp
movq %rbx, %rdi
movl $0x6, %esi
movq %rbp, %rcx
callq 0x1a3b0
cmpl $0x0, (%rbp)
js 0x1b50f
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 0x1b472
movq %rbx, %rdi
movq %r14, %rsi
callq 0x182e0
jmp 0x1b472
movq %rbx, %rdi
movq %r12, %rsi
callq 0x182e0
movl 0x10(%rsp), %edi
callq 0x19970
movq %rbx, %rdi
movl $0x6, %esi
jmp 0x1b468
// File: /workspace/github_cpp_makefile_star2_O1/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 0x743c2(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %rbx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x1a520
movq %rax, %r15
leaq 0x73a9d(%rip), %rcx     # 0x8f000
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x190f0
movq %rax, %r13
movq %r14, %rdi
movl $0x20, %esi
movl $0x4, %edx
callq 0x19c20
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_O1/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 0x73f1d(%rip), %rcx     # 0x8f909
movq %rsp, %rbx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x1a520
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
callq 0x190f0
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x190f0
movq %rax, %r13
movq %r14, %rdi
movl $0x4, %esi
callq 0x190f0
movq %rax, %rbp
movq %r14, %rdi
movl $0x5, %esi
callq 0x190f0
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_O1/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 0x73e8b(%rip), %rcx     # 0x8f909
movq %rsp, %rdx
movl $0x1, %esi
callq 0x1a520
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
callq 0x190f0
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x190f0
movq %rax, %r13
movq %r14, %rdi
movl $0x4, %esi
callq 0x190f0
movq %rax, %rbp
movq %r14, %rdi
movl $0x5, %esi
callq 0x190f0
movq %rax, %rbx
movq %r14, %rdi
movl $0x6, %esi
callq 0x190f0
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_O1/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 0x73de6(%rip), %rcx     # 0x8f909
movq %rsp, %rbx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x1a520
movq %rax, %r15
leaq 0x734c3(%rip), %rcx     # 0x8f000
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x190f0
movq %rax, %r13
movq %r14, %rdi
movl $0x4, %esi
callq 0x190f0
movq %rax, %rbp
movq %r14, %rdi
movl $0x5, %esi
callq 0x190f0
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_O1/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 0x73d4b(%rip), %rcx     # 0x8f909
movq %rsp, %rbx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x1a520
movq %rax, %r15
leaq 0x73428(%rip), %rcx     # 0x8f000
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x190f0
movq %rax, %r13
movq %r14, %rdi
movl $0x4, %esi
callq 0x190f0
movq %rax, %rbp
movq %r14, %rdi
movl $0x5, %esi
callq 0x190f0
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_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdDispatch
static int CmdDispatch(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t x = luaL_checkinteger(L, 2);
    uint32_t y = luaL_checkinteger(L, 3);
    uint32_t z = luaL_checkinteger(L, 4);
    ud->ddt->CmdDispatch(cb, x, y, z);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x73cae(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x190f0
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x190f0
movq %rax, %r13
movq %rbx, %rdi
movl $0x4, %esi
callq 0x190f0
movq (%r14), %rcx
movq 0x50(%rcx), %r8
movq %r15, %rdi
movl %r12d, %esi
movl %r13d, %edx
movl %eax, %ecx
callq *0x358(%r8)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x73c31(%rip), %rcx     # 0x8f909
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq %rax, %r15
leaq 0x7330e(%rip), %rcx     # 0x8f000
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x190f0
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_O1/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 0x73bbc(%rip), %rcx     # 0x8f909
leaq 0x10(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq (%r15), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x6a0(%rax)
je 0x1bdd5
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1a130
cmpl $0x5, %eax
jne 0x1bdd5
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x1a060
movq %rax, %r15
movl (%r12), %ebp
testl %ebp, %ebp
je 0x1bea6
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19170
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x1be5e
leaq 0x73224(%rip), %r15     # 0x8f000
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x1a520
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x1a520
movq %rax, %r13
leaq 0x8(%rsp), %rdx
leaq 0xc(%rsp), %rbp
movq %rbx, %rdi
movl $0x4, %esi
movq %rbp, %rcx
callq 0x1a210
movq %rax, %r15
movl (%rbp), %ebp
testl %ebp, %ebp
je 0x1be68
movl 0x8(%rsp), %ecx
movl $0x18, %edx
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x1becb
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rsp), %ecx
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %r8
callq *0x368(%rax)
movl 0x8(%rsp), %ecx
movl $0x18, %edx
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
jmp 0x1becb
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x6a0(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19170
testl %ebp, %ebp
jne 0x1bed1
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_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdUpdateBuffer
static int CmdUpdateBuffer(lua_State *L)
    {
    size_t size;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkBuffer dstBuffer = checkbuffer(L, 2, NULL);
    VkDeviceSize dstOffset = luaL_checkinteger(L, 3);
    const char *data = luaL_checklstring(L, 4, &size);
    if((size==0) || (size % 4)!=0)
        return argerrorc(L, 4, ERR_LENGTH);
    ud->ddt->CmdUpdateBuffer(cb, dstBuffer, dstOffset, (VkDeviceSize)size, data);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x73276(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x1a520
movq %rax, %r15
leaq 0x72954(%rip), %rcx     # 0x8f000
xorl %ebx, %ebx
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x190f0
movq %rax, %r13
leaq 0x10(%rsp), %rbp
movq %r14, %rdi
movl $0x4, %esi
movq %rbp, %rdx
callq 0x18d60
movq (%rbp), %rcx
testq %rcx, %rcx
setne %dl
testb $0x3, %cl
sete %sil
testb %sil, %dl
je 0x1c719
movq 0x8(%rsp), %rdx
movq 0x50(%rdx), %r9
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %r8
callq *0x390(%r9)
jmp 0x1c735
movl $0xfffffff9, %edi       # imm = 0xFFFFFFF9
callq 0x19970
movq %r14, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x731ae(%rip), %rcx     # 0x8f909
movq %rsp, %rbx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x1a520
movq %rax, %r15
leaq 0x7288b(%rip), %rcx     # 0x8f000
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x190f0
movq %rax, %r13
movq %r14, %rdi
movl $0x4, %esi
callq 0x1a650
movq %rax, %rbp
movq %r14, %rdi
movl $0x5, %esi
callq 0x190f0
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_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdClearColorImage
static int CmdClearColorImage(lua_State *L)
    {
    int err;
    ud_t *ud;
    uint32_t count=0;
    VkImageSubresourceRange* ranges=NULL;
    VkClearColorValue* color=NULL;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkImage image = checkimage(L, 2, NULL);
    VkImageLayout imageLayout = checkimagelayout(L, 3);
#define CLEANUP do {                                            \
    zfreeVkClearColorValue(L, color, 1);                        \
    zfreearrayVkImageSubresourceRange(L, ranges, count, 1);     \
} while(0)
    color = zcheckVkClearColorValue(L, 4, &err);
    if(err) { CLEANUP; return argerror(L, 4); }
    ranges = zcheckarrayVkImageSubresourceRange(L, 5, &count, &err);
    if(err) { CLEANUP; return argerror(L, 5); }
    ud->ddt->CmdClearColorImage(cb, image, imageLayout, color, count, ranges);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x0, 0x8(%rsp)
leaq 0x73107(%rip), %rcx     # 0x8f909
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
callq 0x1a520
movq %rax, %r15
leaq 0x7317f(%rip), %rcx     # 0x8f99a
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r13
movq %rbx, %rdi
movl $0xa, %esi
movl $0x3, %edx
callq 0x19c20
movl %eax, %ebp
leaq 0xc(%rsp), %r14
movq %rbx, %rdi
movl $0x4, %esi
movq %r14, %rdx
callq 0x185b0
movq %rax, %r12
cmpl $0x0, (%r14)
je 0x1c8a6
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x19640
movl 0x8(%rsp), %ecx
movl $0x14, %edx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x4, %esi
jmp 0x1c90f
leaq 0x8(%rsp), %rdx
leaq 0xc(%rsp), %r14
movq %rbx, %rdi
movl $0x5, %esi
movq %r14, %rcx
callq 0x19a80
cmpl $0x0, (%r14)
je 0x1c92c
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
movq %rax, %r14
callq 0x19640
movl 0x8(%rsp), %ecx
movl $0x14, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x5, %esi
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), %rcx
movq 0x50(%rcx), %r10
movl 0x8(%rsp), %r8d
movq %r15, %rdi
movq %r13, %rsi
movl %ebp, %edx
movq %r12, %rcx
movq %rax, %r14
movq %rax, %r9
callq *0x3a0(%r10)
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x19640
movl 0x8(%rsp), %ecx
movl $0x14, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
jmp 0x1c91a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x72f6b(%rip), %rcx     # 0x8f909
leaq 0x18(%rsp), %rdx
movl $0x1, %esi
callq 0x1a520
movq %rax, 0x10(%rsp)
leaq 0x72fe1(%rip), %rcx     # 0x8f99a
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r12
movq %rbx, %rdi
movl $0xa, %esi
movl $0x3, %edx
callq 0x19c20
movl %eax, %ebp
movq %rbx, %rdi
movl $0x4, %esi
callq 0x18850
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x190f0
movl %eax, 0xc(%rsp)
leaq 0x4(%rsp), %rdx
leaq 0x24(%rsp), %r15
movq %rbx, %rdi
movl $0x6, %esi
movq %r15, %rcx
callq 0x19a80
movq %rax, %r13
cmpl $0x0, (%r15)
je 0x1ca6e
movl 0x4(%rsp), %ecx
movl $0x14, %edx
movq %rbx, %rdi
movq %r13, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x6, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r14d
jmp 0x1cab1
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x4(%rsp), %r8d
leaq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r13, %r9
callq *0x3a8(%rax)
movl 0x4(%rsp), %ecx
movl $0x14, %edx
movq %rbx, %rdi
movq %r13, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
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_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdClearAttachments
static int CmdClearAttachments(lua_State *L)
    {
    int err;
    ud_t *ud;
    uint32_t att_count=0;
    uint32_t rect_count=0;
    VkClearAttachment* attachments=NULL;
    VkClearRect* rects=NULL;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
#define CLEANUP do {                                            \
    zfreearrayVkClearRect(L, rects, rect_count, 1);             \
    zfreearrayVkClearAttachment(L, attachments, att_count, 1);  \
} while(0)
    attachments = zcheckarrayVkClearAttachment(L, 2, &att_count, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    rects = zcheckarrayVkClearRect(L, 3, &rect_count, &err);
    if(err) { CLEANUP; return argerror(L, 3); }
    ud->ddt->CmdClearAttachments(cb, att_count, attachments, rect_count, rects);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
movl %ebp, (%r14)
movl %ebp, 0x4(%rsp)
leaq 0x72e20(%rip), %rcx     # 0x8f909
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
callq 0x1a520
movq %rax, %r12
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
movq %r15, %rcx
callq 0x19bd0
movq %rax, %r14
cmpl %ebp, (%r15)
je 0x1cb6d
movl 0x4(%rsp), %ecx
movl $0x18, %edx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movl 0x8(%rsp), %ecx
movl $0x18, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x1cbe2
leaq 0x4(%rsp), %rdx
leaq 0xc(%rsp), %r13
movq %rbx, %rdi
movl $0x3, %esi
movq %r13, %rcx
callq 0x18b40
movq %rax, %r15
cmpl $0x0, (%r13)
je 0x1cbff
movl 0x4(%rsp), %ecx
movl $0x18, %edx
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movl 0x8(%rsp), %ecx
movl $0x18, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rsp), %esi
movl 0x4(%rsp), %ecx
movq %r12, %rdi
movq %r14, %rdx
movq %r15, %r8
callq *0x3b0(%rax)
movl 0x4(%rsp), %ecx
xorl %r12d, %r12d
movl $0x18, %edx
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movl 0x8(%rsp), %ecx
movl $0x18, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
jmp 0x1cbed
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x72aa0(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r12
movl $0x1, %esi
movq %r12, %rdx
callq 0x1a520
movq %rax, %r14
leaq 0x72b26(%rip), %rcx     # 0x8f9ab
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r15
movq (%r12), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x670(%rax)
je 0x1cf0c
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1a130
cmpl $0x5, %eax
jne 0x1cf0c
leaq 0x14(%rsp), %r13
movq %rbx, %rdi
movl $0x2, %esi
movq %r13, %rdx
callq 0x1a620
movq %rax, %r12
movl (%r13), %ebp
testl %ebp, %ebp
je 0x1cf41
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19170
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x1cf69
movq %rbx, %rdi
movl $0x3, %esi
callq 0x18f70
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %rcx
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
callq *0x3c0(%rcx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x670(%rax)
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19170
testl %ebp, %ebp
jne 0x1cf32
jmp 0x1cf30
// File: /workspace/github_cpp_makefile_star2_O1/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 0x72988(%rip), %rcx     # 0x8f909
movq %rsp, %r12
movl $0x1, %esi
movq %r12, %rdx
callq 0x1a520
movq %rax, %rbx
leaq 0x72a10(%rip), %rcx     # 0x8f9ab
movq %r15, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r14
movq (%r12), %rax
movq 0x50(%rax), %rax
movq 0x678(%rax), %r12
movq %r15, %rdi
movl $0x3, %esi
callq 0x18f70
testq %r12, %r12
je 0x1cfe7
movq (%rsp), %rcx
movq 0x50(%rcx), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq *0x678(%rcx)
jmp 0x1cffd
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_O1/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 0x71fdd(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %rbx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x1a520
movq %rax, %r15
leaq 0x720c7(%rip), %rcx     # 0x8fa0f
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x190f0
movq %rax, %r13
movq %r14, %rdi
movl $0x4, %esi
callq 0x18f70
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_O1/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 0x71f57(%rip), %rcx     # 0x8f909
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq %rax, %r15
leaq 0x72043(%rip), %rcx     # 0x8fa0f
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x190f0
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_O1/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 0x71ee4(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %rbx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x1a520
movq %rax, %r15
leaq 0x71fce(%rip), %rcx     # 0x8fa0f
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x190f0
movq %rax, %r13
movq %r14, %rdi
movl $0x4, %esi
callq 0x190f0
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_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdWriteTimestamp
static int CmdWriteTimestamp(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkQueryPool queryPool = checkquery_pool(L, 3, NULL);
    uint32_t query = luaL_checkinteger(L, 4);
    if(ud->ddt->CmdWriteTimestamp2KHR)
        {
        VkPipelineStageFlags2KHR pipelineStage = checkflags(L, 2);
        ud->ddt->CmdWriteTimestamp2KHR(cb, pipelineStage, queryPool, query);
        }
    else
        {
        VkPipelineStageFlagBits pipelineStage = (VkPipelineStageFlagBits)checkflags(L, 2);
        ud->ddt->CmdWriteTimestamp(cb, pipelineStage, queryPool, query);
        }
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r12
leaq 0x71e59(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r13
movl $0x1, %esi
movq %r13, %rdx
callq 0x1a520
movq %rax, %rbx
leaq 0x71f43(%rip), %rcx     # 0x8fa0f
movq %r12, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r14
movq %r12, %rdi
movl $0x4, %esi
callq 0x190f0
movq %rax, %r15
movq (%r13), %rax
movq 0x50(%rax), %rax
movq 0x690(%rax), %r13
movq %r12, %rdi
movl $0x2, %esi
callq 0x18f70
testq %r13, %r13
je 0x1db2d
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %r8
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
movl %r15d, %ecx
callq *0x690(%r8)
jmp 0x1db48
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %r8
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
movl %r15d, %ecx
callq *0x3f8(%r8)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x71d99(%rip), %rcx     # 0x8f909
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
callq 0x1a520
movq %rax, 0x8(%rsp)
leaq 0x71e84(%rip), %rcx     # 0x8fa0f
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, (%rsp)
movq %r14, %rdi
movl $0x3, %esi
callq 0x190f0
movq %rax, %r13
movq %r14, %rdi
movl $0x4, %esi
callq 0x190f0
movq %rax, %rbp
leaq 0x7143b(%rip), %rcx     # 0x8f000
movq %r14, %rdi
movl $0x5, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %rbx
movq %r14, %rdi
movl $0x6, %esi
callq 0x190f0
movq %rax, %r15
movq %r14, %rdi
movl $0x7, %esi
callq 0x190f0
movq %rax, %r12
movq %r14, %rdi
movl $0x8, %esi
callq 0x18f70
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_O1/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 0x71cae(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x1a520
movq %rax, %r15
leaq 0x71cc3(%rip), %rcx     # 0x8f937
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x18f70
movq %rax, %r13
movq %r14, %rdi
movl $0x4, %esi
callq 0x190f0
movq %rax, %rbp
leaq 0x10(%rsp), %rbx
movq %r14, %rdi
movl $0x5, %esi
movq %rbx, %rdx
callq 0x18d60
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_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdNextSubpass
static int CmdNextSubpass(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    if(ud->ddt->CmdNextSubpass2 && lua_type(L, 2) == LUA_TTABLE)
        {
#define CLEANUP do {                                    \
            zfreeVkSubpassBeginInfo(L, binfo, 1);    \
            zfreeVkSubpassEndInfo(L, einfo, 1);      \
} while(0)
        VkSubpassBeginInfo* binfo = NULL;
        VkSubpassEndInfo* einfo = NULL;
        binfo = zcheckVkSubpassBeginInfo(L, 2, &err);
        if(err) { CLEANUP; return argerror(L, 2); }
        einfo = zcheckVkSubpassEndInfo(L, 3, &err);
        if(err) { CLEANUP; return argerror(L, 3); }
        ud->ddt->CmdNextSubpass2(cb, binfo, einfo);
        CLEANUP;
#undef CLEANUP
        }
    else
        {
        VkSubpassContents contents = checksubpasscontents(L, 2);
        ud->ddt->CmdNextSubpass(cb, contents);
        }
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x71a09(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq (%r15), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x5c8(%rax)
je 0x1df95
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1a130
cmpl $0x5, %eax
jne 0x1df95
leaq 0x4(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x18250
movq %rax, %r15
cmpl $0x0, (%r12)
je 0x1dfcb
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19170
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x19170
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x1e024
movq %rbx, %rdi
movl $0x21, %esi
movl $0x2, %edx
callq 0x19c20
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %rcx
movq %r14, %rdi
movl %eax, %esi
callq *0x418(%rcx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x4(%rsp), %r13
movq %rbx, %rdi
movl $0x3, %esi
movq %r13, %rdx
callq 0x1a110
movq %rax, %r12
cmpl $0x0, (%r13)
je 0x1e033
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19170
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19170
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x18420
testb %r14b, %r14b
jne 0x1dfbb
jmp 0x1dfbd
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x5c8(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19170
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19170
movb $0x1, %r14b
jmp 0x1e02c
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x71883(%rip), %rcx     # 0x8f909
movq %rsp, %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq (%r15), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x5d0(%rax)
je 0x1e10d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1a130
cmpl $0x5, %eax
jne 0x1e10d
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x1a110
movq %rax, %r15
movl (%r12), %ebp
testl %ebp, %ebp
je 0x1e12d
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19170
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x1e151
movq (%rsp), %rax
movq 0x50(%rax), %rax
movq %r14, %rdi
callq *0x420(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rax
movq 0x50(%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x5d0(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x19170
testl %ebp, %ebp
jne 0x1e120
jmp 0x1e11e
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7179d(%rip), %r15     # 0x8f909
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
movq %r15, %rcx
callq 0x1a520
movq %rax, %r14
leaq 0x4(%rsp), %rdx
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rcx
movq %r15, %r8
callq 0x199f0
movl (%r12), %edi
testl %edi, %edi
je 0x1e1bd
callq 0x19970
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x1e1e6
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_O1/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 0x71704(%rip), %rcx     # 0x8f909
movq %rsp, %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x20574
movq (%r15), %rax
movq 0x50(%rax), %rax
movq 0x430(%rax), %rax
testq %rax, %rax
je 0x1e246
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq *%rax
xorl %eax, %eax
jmp 0x1e257
leaq 0x717d8(%rip), %rsi     # 0x8fa25
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7169a(%rip), %rcx     # 0x8f909
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq (%r14), %rcx
movq 0x50(%rcx), %rcx
movq 0x438(%rcx), %rcx
testq %rcx, %rcx
je 0x1e29b
movq %rax, %rdi
callq *%rcx
xorl %eax, %eax
jmp 0x1e2ac
leaq 0x717af(%rip), %rsi     # 0x8fa51
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x71642(%rip), %rcx     # 0x8f909
movq %rsp, %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x1a520
movq %rax, %r14
movq (%r15), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x440(%rax)
je 0x1e313
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20574
movq (%rsp), %rax
movq 0x50(%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x440(%rax)
xorl %eax, %eax
jmp 0x1e324
leaq 0x71761(%rip), %rsi     # 0x8fa7b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x715c3(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r12
movl $0x1, %esi
movq %r12, %rdx
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x1e, %esi
movl $0x2, %edx
callq 0x19c20
movl %eax, %ebp
leaq 0x715c1(%rip), %rcx     # 0x8f937
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x190f0
movq %rax, %r13
movq (%r12), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x448(%rax)
je 0x1e40c
movl %ebp, 0x4(%rsp)
movq %r14, %rbp
movq %rsp, %rdx
leaq 0x14(%rsp), %r14
movq %rbx, %rdi
movl $0x5, %esi
movq %r14, %rcx
callq 0x1a3c0
movq %rax, %r12
cmpl $0x0, (%r14)
je 0x1e41f
movl (%rsp), %ecx
movl $0x40, %edx
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %r8d
callq 0x19800
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x5, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x1e45d
leaq 0x71695(%rip), %rsi     # 0x8faa8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19be0
jmp 0x1e45d
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl (%rsp), %r8d
movq %rbp, %rdi
movl 0x4(%rsp), %esi
movq %r15, %rdx
movl %r13d, %ecx
movq %r12, %r9
callq *0x448(%rax)
movl (%rsp), %ecx
movl $0x40, %edx
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %r8d
callq 0x19800
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_O1/stetre[P]moonvulkan/src/cmd.c
// Function: CmdPushDescriptorSetWithTemplate
static int CmdPushDescriptorSetWithTemplate(lua_State *L)
    {
    size_t len;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkDescriptorUpdateTemplate desc_template = checkdescriptor_update_template(L, 2, NULL);
    VkPipelineLayout layout = checkpipeline_layout(L, 3, NULL);
    uint32_t set = luaL_checkinteger(L, 4);
    const void* data = luaL_checklstring(L, 5, &len);
    CheckDevicePfn(L, ud, CmdPushDescriptorSetWithTemplateKHR);
    ud->ddt->CmdPushDescriptorSetWithTemplateKHR(cb, desc_template, layout, set, data);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x71485(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r12
movl $0x1, %esi
movq %r12, %rdx
callq 0x1a520
movq %rax, (%rsp)
leaq 0x71634(%rip), %rcx     # 0x8fad5
xorl %ebx, %ebx
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %r13
leaq 0x7147b(%rip), %rcx     # 0x8f937
movq %r14, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x1a520
movq %rax, %rbp
movq %r14, %rdi
movl $0x4, %esi
callq 0x190f0
movq %rax, %r15
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movl $0x5, %esi
callq 0x18d60
movq (%r12), %rcx
movq 0x50(%rcx), %rcx
movq 0x470(%rcx), %r9
testq %r9, %r9
je 0x1e519
movq (%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movl %r15d, %ecx
movq %rax, %r8
callq *%r9
jmp 0x1e52c
leaq 0x715db(%rip), %rsi     # 0x8fafb
movq %r14, %rdi
xorl %eax, %eax
callq 0x19be0
movl %eax, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq