LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdDrawMulti
static int CmdDrawMulti(lua_State *L)
    {
    int err;
    uint32_t count;
    ud_t *ud;
    VkMultiDrawInfoEXT *info = NULL;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t instanceCount = luaL_checkinteger(L, 3);
    uint32_t firstInstance = luaL_checkinteger(L, 4);
    uint32_t stride = luaL_checkinteger(L, 5);
    CheckDevicePfn(L, ud, CmdDrawMultiEXT);
#define CLEANUP do {                                            \
    if(info) zfreearrayVkMultiDrawInfoEXT(L, info, count, 1);   \
} while(0)
    info = zcheckarrayVkMultiDrawInfoEXT(L, 2, &count, &err);
    if(err < 0 && err != ERR_EMPTY) { CLEANUP; return argerror(L, 2); }
    ud->ddt->CmdDrawMultiEXT(cb, count, info, instanceCount, firstInstance, stride);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xae671(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movl %eax, 0x14(%rsp)
movq 0x38(%rsp), %rdi
movl $0x4, %esi
callq 0x19190
movl %eax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0x5, %esi
callq 0x19190
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x848(%rax)
jne 0x2130a
movq 0x38(%rsp), %rdi
leaq 0xaeebe(%rip), %rsi     # 0xd01b8
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x44(%rsp)
jmp 0x213fd
jmp 0x2130c
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x30(%rsp), %rdx
leaq 0x34(%rsp), %rcx
callq 0x18f60
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x34(%rsp)
jge 0x2139a
cmpl $-0x5, 0x34(%rsp)
je 0x2139a
jmp 0x2133a
cmpq $0x0, 0x20(%rsp)
je 0x21365
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x30(%rsp), %ecx
movl $0x8, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
jmp 0x21367
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x18460
movl %eax, 0x44(%rsp)
jmp 0x213fd
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x848(%rax), %rax
movq 0x18(%rsp), %rdi
movl 0x30(%rsp), %esi
movq 0x20(%rsp), %rdx
movl 0x14(%rsp), %ecx
movl 0x10(%rsp), %r8d
movl 0xc(%rsp), %r9d
callq *%rax
cmpq $0x0, 0x20(%rsp)
je 0x213f3
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x30(%rsp), %ecx
movl $0x8, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
jmp 0x213f5
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdDrawMultiIndexed
static int CmdDrawMultiIndexed(lua_State *L)
    {
    int err;
    uint32_t count;
    ud_t *ud;
    int32_t *pVertexOffset = NULL;
    int32_t vertex_offset;
    VkMultiDrawIndexedInfoEXT *info = NULL;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t instanceCount = luaL_checkinteger(L, 3);
    uint32_t firstInstance = luaL_checkinteger(L, 4);
    uint32_t stride = luaL_checkinteger(L, 5);
    if(!lua_isnoneornil(L, 6))
        {
        vertex_offset = luaL_checkinteger(L, 6);
        pVertexOffset = &vertex_offset;
        }
    CheckDevicePfn(L, ud, CmdDrawMultiIndexedEXT);
#define CLEANUP do {                                                    \
    if(info) zfreearrayVkMultiDrawIndexedInfoEXT(L, info, count, 1);    \
} while(0)
    info = zcheckarrayVkMultiDrawIndexedInfoEXT(L, 2, &count, &err);
    if(err < 0 && err != ERR_EMPTY) { CLEANUP; return argerror(L, 2); }
    ud->ddt->CmdDrawMultiIndexedEXT(cb, count, info, instanceCount, firstInstance, stride, pVertexOffset);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq $0x0, 0x40(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x58(%rsp), %rdi
movl $0x1, %esi
leaq 0x48(%rsp), %rdx
leaq 0xae4c8(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movl %eax, 0x24(%rsp)
movq 0x58(%rsp), %rdi
movl $0x4, %esi
callq 0x19190
movl %eax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
movl $0x5, %esi
callq 0x19190
movl %eax, 0x1c(%rsp)
movq 0x58(%rsp), %rdi
movl $0x6, %esi
callq 0x1a240
cmpl $0x0, %eax
jle 0x214b5
movq 0x58(%rsp), %rdi
movl $0x6, %esi
callq 0x19190
movl %eax, 0x3c(%rsp)
leaq 0x3c(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x214b7
movq 0x48(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x850(%rax)
jne 0x214e6
movq 0x58(%rsp), %rdi
leaq 0xaed07(%rip), %rsi     # 0xd01dd
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x64(%rsp)
jmp 0x215e4
jmp 0x214e8
movq 0x58(%rsp), %rdi
movl $0x2, %esi
leaq 0x50(%rsp), %rdx
leaq 0x54(%rsp), %rcx
callq 0x19b20
movq %rax, 0x30(%rsp)
cmpl $0x0, 0x54(%rsp)
jge 0x21578
cmpl $-0x5, 0x54(%rsp)
je 0x21578
jmp 0x21516
cmpq $0x0, 0x30(%rsp)
je 0x21541
movq 0x58(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x50(%rsp), %ecx
movl $0xc, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
jmp 0x21543
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x18460
movl %eax, 0x64(%rsp)
jmp 0x215e4
movq 0x48(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x850(%rax), %rax
movq 0x28(%rsp), %rdi
movl 0x50(%rsp), %esi
movq 0x30(%rsp), %rdx
movl 0x24(%rsp), %ecx
movl 0x20(%rsp), %r8d
movl 0x1c(%rsp), %r9d
movq 0x40(%rsp), %r10
movq %r10, (%rsp)
callq *%rax
cmpq $0x0, 0x30(%rsp)
je 0x215da
movq 0x58(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x50(%rsp), %ecx
movl $0xc, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
jmp 0x215dc
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetFragmentShadingRate
static int CmdSetFragmentShadingRate(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkExtent2D* size = NULL;
    VkFragmentShadingRateCombinerOpKHR ops[2];
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdSetFragmentShadingRateKHR);
    ops[0] = checkfragmentshadingratecombinerop(L, 3);
    ops[1] = checkfragmentshadingratecombinerop(L, 4);
#define CLEANUP do { if(size) zfreeVkExtent2D(L, size, 1); } while(0)
    size = zcheckVkExtent2D(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ud->ddt->CmdSetFragmentShadingRateKHR(cb, size, ops);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xae2f1(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x620(%rax)
jne 0x21651
movq 0x38(%rsp), %rdi
leaq 0xaebc8(%rip), %rsi     # 0xd0209
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x44(%rsp)
jmp 0x21747
jmp 0x21653
movq 0x38(%rsp), %rdi
movl $0x41, %esi
movl $0x3, %edx
callq 0x19d20
movl %eax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x41, %esi
movl $0x4, %edx
callq 0x19d20
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x34(%rsp), %rdx
callq 0x18b50
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x216fc
jmp 0x216a5
cmpq $0x0, 0x20(%rsp)
je 0x216c5
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x19710
jmp 0x216c7
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x18460
movl %eax, 0x44(%rsp)
jmp 0x21747
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x620(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq *%rax
cmpq $0x0, 0x20(%rsp)
je 0x2173d
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x19710
jmp 0x2173f
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdBeginRendering
static int CmdBeginRendering(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkRenderingInfoKHR *info;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdBeginRenderingKHR);
#define CLEANUP do { if(info) zfreeVkRenderingInfoKHR(L, info, 1); } while(0)
    info = zcheckVkRenderingInfoKHR(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ud->ddt->CmdBeginRenderingKHR(cb, info);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xae19a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x858(%rax)
jne 0x217a8
movq 0x28(%rsp), %rdi
leaq 0xaeaa3(%rip), %rsi     # 0xd023b
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x34(%rsp)
jmp 0x2185f
jmp 0x217aa
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x24(%rsp), %rdx
callq 0x1a120
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x2181d
jmp 0x217cc
cmpq $0x0, 0x10(%rsp)
je 0x217e8
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
jmp 0x217ea
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x2185f
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x858(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq *%rax
cmpq $0x0, 0x10(%rsp)
je 0x21855
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
jmp 0x21857
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdEndRendering
static int CmdEndRendering(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdEndRenderingKHR);
    ud->ddt->CmdEndRenderingKHR(cb);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xae07a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x860(%rax)
jne 0x218c5
movq 0x18(%rsp), %rdi
leaq 0xae9ad(%rip), %rsi     # 0xd0265
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x24(%rsp)
jmp 0x218e6
jmp 0x218c7
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x860(%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdWaitEvents2
static int CmdWaitEvents2(lua_State *L)
    {
    int err;
    uint32_t count;
    ud_t *ud;
    VkEvent *events = NULL;
    VkDependencyInfoKHR *info = NULL;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdWaitEvents2KHR);
#define CLEANUP do {                                    \
    if(events) Free(L, events);                         \
    if(info) zfreeVkDependencyInfoKHR(L, info, 1);      \
} while(0)
    events = checkeventlist(L, 2, &count, &err, NULL);
    if(err) { CLEANUP; return argerrorc(L, 2, err); }
    info = zcheckVkDependencyInfoKHR (L, 3, &err);
    if(err) { CLEANUP; return argerrorc(L, 3, err); }
    ud->ddt->CmdWaitEvents2KHR(cb, count, events, info);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xadfe8(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x680(%rax)
jne 0x2195a
movq 0x38(%rsp), %rdi
leaq 0xae072(%rip), %rsi     # 0xcf9bc
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x44(%rsp)
jmp 0x21ad4
jmp 0x2195c
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x30(%rsp), %rdx
leaq 0x34(%rsp), %rcx
xorl %eax, %eax
movl %eax, %r8d
leaq 0xae02f(%rip), %r9      # 0xcf9ab
callq 0x191f0
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x219f2
jmp 0x2198f
cmpq $0x0, 0x20(%rsp)
je 0x219a6
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x18300
cmpq $0x0, 0x18(%rsp)
je 0x219c2
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
jmp 0x219c4
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %edi
callq 0x19a60
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x18460
movl %eax, 0x44(%rsp)
jmp 0x21ad4
movq 0x38(%rsp), %rdi
movl $0x3, %esi
leaq 0x34(%rsp), %rdx
callq 0x1a740
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x21a72
jmp 0x21a14
cmpq $0x0, 0x20(%rsp)
je 0x21a2b
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x18300
cmpq $0x0, 0x18(%rsp)
je 0x21a47
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
jmp 0x21a49
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movl 0x34(%rsp), %edi
callq 0x19a60
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x3, %esi
callq 0x18460
movl %eax, 0x44(%rsp)
jmp 0x21ad4
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x680(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0x30(%rsp), %esi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq *%rax
cmpq $0x0, 0x20(%rsp)
je 0x21aae
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x18300
cmpq $0x0, 0x18(%rsp)
je 0x21aca
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
jmp 0x21acc
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: CmdPipelineBarrier2
static int CmdPipelineBarrier2(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkDependencyInfoKHR *info = NULL;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    CheckDevicePfn(L, ud, CmdPipelineBarrier2KHR);
#define CLEANUP do {                                    \
    if(info) zfreeVkDependencyInfoKHR(L, info, 1);      \
} while(0)
    info = zcheckVkDependencyInfoKHR (L, 2, &err);
    if(err) { CLEANUP; return argerrorc(L, 2, err); }
    ud->ddt->CmdPipelineBarrier2KHR(cb, info);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xad821(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x688(%rax)
jne 0x22121
movq 0x28(%rsp), %rdi
leaq 0xad8d2(%rip), %rsi     # 0xcf9e3
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x34(%rsp)
jmp 0x221ce
jmp 0x22123
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x24(%rsp), %rdx
callq 0x1a740
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x2218c
jmp 0x22145
cmpq $0x0, 0x10(%rsp)
je 0x22161
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
jmp 0x22163
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl 0x24(%rsp), %edi
callq 0x19a60
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x221ce
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x688(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq *%rax
cmpq $0x0, 0x10(%rsp)
je 0x221c4
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
jmp 0x221c6
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: stetre[P]moonvulkan/src/cmd.c
// Function: checkdebugmarkermarkerinfo
static int checkdebugmarkermarkerinfo(lua_State *L, int arg, VkDebugMarkerMarkerInfoEXT *info)
    {
    int i, argcolor = arg+1;
    info->sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT;
    info->pNext = NULL;
    info->pMarkerName = luaL_checkstring(L, arg);
    if(lua_isnoneornil(L, argcolor))
        {
        memset(info->color, 0, 4*sizeof(float));
        return 0;
        }
    if(!lua_istable(L, argcolor))
        return argerrorc(L, arg, ERR_TABLE);
    for(i = 0; i < 4; i++)
        {
        if(lua_rawgeti(L, argcolor, i+1) != LUA_TNUMBER)
            {
            lua_pop(L, 1);
            return argerrorc(L, argcolor, ERR_TYPE);
            }
        info->color[i] = lua_tonumber(L, -1);
        lua_pop(L, 1);
        }
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl $0x3b9b1ff2, (%rax)     # imm = 0x3B9B1FF2
movq 0x28(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x18df0
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x38(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x1a240
cmpl $0x0, %eax
jg 0x226c8
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x18bd0
movl $0x0, 0x44(%rsp)
jmp 0x227cf
movq 0x38(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x1a240
cmpl $0x5, %eax
je 0x22711
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
callq 0x19a60
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq %rax, %rdx
callq 0x18460
movl %eax, 0x44(%rsp)
jmp 0x227cf
movl $0x0, 0x24(%rsp)
cmpl $0x4, 0x24(%rsp)
jge 0x227c7
movq 0x38(%rsp), %rdi
movl 0x20(%rsp), %esi
movl 0x24(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x189e0
cmpl $0x3, %eax
je 0x22781
movq 0x38(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x18170
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x19a60
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movq %rax, %rdx
callq 0x18460
movl %eax, 0x44(%rsp)
jmp 0x227cf
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x18f80
cvtsd2ss %xmm0, %xmm0
movq 0x28(%rsp), %rax
movslq 0x24(%rsp), %rcx
movss %xmm0, 0x18(%rax,%rcx,4)
movq 0x38(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x18170
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x22719
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: stetre[P]moonvulkan/src/command_buffer.c
// Function: FreeCmdBuffers
static int FreeCmdBuffers(lua_State *L)
    {
    int err;
    uint32_t count, i;
    ud_t *ud;
    VkDevice device;
    VkCommandPool command_pool;
    VkCommandBuffer *command_buffer = checkcommand_bufferlist(L, 1, &count, &err, NULL);
    if(err) return argerrorc(L, 1, err);
    
    ud = UD(command_buffer[0]);
    /* check that they all are from the same pool */
    for(i = 1; i < count; i++)
        {
        if(UD(command_buffer[i])->parent_ud != ud->parent_ud)
            {
            Free(L, command_buffer);
            return argerrorc(L, 1, ERR_POOL);
            }
        }
    command_pool = (VkCommandPool)ud->parent_ud->handle;
    device = ud->device;
    for(i = 0; i < count; i++)
        {
        freeuserdata(L, UD(command_buffer[i]));
        TRACE_DELETE(command_buffer[i], "command_buffer");
        }
    
    UD(device)->ddt->FreeCommandBuffers(device, command_pool, count, command_buffer);
    Free(L, command_buffer);
    return 0;
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
leaq 0x40(%rsp), %rdx
leaq 0x44(%rsp), %rcx
leaq 0xacb55(%rip), %r8      # 0xcf909
callq 0x19ae0
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x44(%rsp)
je 0x22df3
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x44(%rsp), %edi
callq 0x19a60
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl $0x1, %esi
callq 0x18460
movl %eax, 0x54(%rsp)
jmp 0x22f56
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x19fd0
movq %rax, 0x30(%rsp)
movl $0x1, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x40(%rsp), %eax
jae 0x22e85
movq 0x18(%rsp), %rax
movl 0x3c(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x19fd0
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x22e76
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x18300
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xfffffff8, %edi       # imm = 0xFFFFFFF8
callq 0x19a60
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x1, %esi
callq 0x18460
movl %eax, 0x54(%rsp)
jmp 0x22f56
jmp 0x22e78
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x22e0d
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x40(%rsp), %eax
jae 0x22f15
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movl 0x3c(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x19fd0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x18dc0
movq 0xda0b4(%rip), %rax     # 0xfcf98
cmpl $0x0, (%rax)
je 0x22f04
movq 0x18(%rsp), %rax
movl 0x3c(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
leaq 0xad441(%rip), %rdi     # 0xd033e
movb $0x0, %al
callq 0x189d0
jmp 0x22f06
jmp 0x22f08
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x22eac
movq 0x28(%rsp), %rdi
callq 0x19fd0
movq 0x50(%rax), %rax
movq 0x240(%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x40(%rsp), %edx
movq 0x18(%rsp), %rcx
callq *%rax
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x18300
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/command_buffer.c
// Function: BeginCommandBuffer
static int BeginCommandBuffer(lua_State *L)
    {
    int err;
    VkResult ec;
    ud_t *ud;
    VkCommandBufferBeginInfo* info;
    VkCommandBuffer command_buffer = checkcommand_buffer(L, 1, &ud);

#define CLEANUP zfreeVkCommandBufferBeginInfo(L, info, 1)
    if(lua_istable(L, 2))
        {
        info = zcheckVkCommandBufferBeginInfo(L, 2, &err);
        if(err) { CLEANUP; return argerror(L, 2); }
        }
    else
        {
        info = znewVkCommandBufferBeginInfo(L, &err);
        if(err) { CLEANUP; return lua_error(L); }
        info->flags = optflags(L, 2, 0);
        }

    ec = ud->ddt->BeginCommandBuffer(command_buffer, info);
    CLEANUP;
    CheckError(L, ec);
#undef CLEANUP
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xac98a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x1a240
cmpl $0x5, %eax
jne 0x23009
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x24(%rsp), %rdx
callq 0x187c0
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x23007
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x18460
movl %eax, 0x34(%rsp)
jmp 0x230d7
jmp 0x23072
movq 0x28(%rsp), %rdi
movl $0x2a, %esi
movl $0x20, %edx
leaq 0x24(%rsp), %rcx
callq 0x19ee0
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x23055
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x28(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x34(%rsp)
jmp 0x230d7
movq 0x28(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x19370
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x2b8(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq *%rax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
cmpl $0x0, 0x20(%rsp)
je 0x230cd
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %edx
xorl %esi, %esi
callq 0x18a00
movq 0x28(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x34(%rsp)
jmp 0x230d7
jmp 0x230cf
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: stetre[P]moonvulkan/src/command_buffer.c
// Function: EndCommandBuffer
static int EndCommandBuffer(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer command_buffer = checkcommand_buffer(L, 1, &ud);
    VkResult ec = ud->ddt->EndCommandBuffer(command_buffer);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xac80a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x2c0(%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x2314b
movq 0x18(%rsp), %rdi
movl 0x4(%rsp), %edx
xorl %esi, %esi
callq 0x18a00
movq 0x18(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x24(%rsp)
jmp 0x23155
jmp 0x2314d
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/command_buffer.c
// Function: ResetCommandBuffer
static int ResetCommandBuffer(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer command_buffer = checkcommand_buffer(L, 1, &ud);
    VkCommandBufferResetFlags flags = optflags(L, 2, 0);
    VkResult ec = ud->ddt->ResetCommandBuffer(command_buffer, flags);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xac78a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x19370
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x2c8(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq *%rax
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
je 0x231e3
movq 0x18(%rsp), %rdi
movl (%rsp), %edx
xorl %esi, %esi
callq 0x18a00
movq 0x18(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x24(%rsp)
jmp 0x231ed
jmp 0x231e5
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/command_buffer.c
// Function: freecommand_buffer
static int freecommand_buffer(lua_State *L, ud_t *ud)
    {
    VkCommandBuffer command_buffer = (VkCommandBuffer)(uintptr_t)ud->handle;
    VkCommandPool command_pool = (VkCommandPool)ud->parent_ud->handle;
    VkDevice device = ud->device;
    if(!freeuserdata(L, ud))
        return 0; /* double call */
    TRACE_DELETE(command_buffer, "command_buffer");
    UD(device)->ddt->FreeCommandBuffers(device, command_pool, 1, &command_buffer);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x18dc0
cmpl $0x0, %eax
jne 0x23258
movl $0x0, 0x34(%rsp)
jmp 0x232ae
jmp 0x2325a
movq 0xd9d37(%rip), %rax     # 0xfcf98
cmpl $0x0, (%rax)
je 0x23279
movq 0x18(%rsp), %rsi
leaq 0xad0cc(%rip), %rdi     # 0xd033e
movb $0x0, %al
callq 0x189d0
jmp 0x2327b
movq 0x8(%rsp), %rdi
callq 0x19fd0
movq 0x50(%rax), %rax
movq 0x240(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
leaq 0x18(%rsp), %rcx
callq *%rax
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: stetre[P]moonvulkan/src/command_pool.c
// Function: ResetCommandPool
static int ResetCommandPool(lua_State *L)
    {
    VkResult ec;
    ud_t *ud;
    VkCommandPool command_pool = checkcommand_pool(L, 1, &ud);
    VkDevice device = ud->device;
    VkCommandPoolResetFlags flags = optflags(L, 2, 0);
    ec = ud->ddt->ResetCommandPool(device, command_pool, flags);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xacb29(%rip), %rcx     # 0xd02f8
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x19370
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x230(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x4(%rsp), %edx
callq *%rax
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x23849
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %edx
xorl %esi, %esi
callq 0x18a00
movq 0x28(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x34(%rsp)
jmp 0x23853
jmp 0x2384b
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/command_pool.c
// Function: TrimCommandPool
static int TrimCommandPool(lua_State *L)
    {
    ud_t *ud;
    VkCommandPool command_pool = checkcommand_pool(L, 1, &ud);
    VkDevice device = ud->device;
    VkCommandPoolTrimFlags flags = optflags(L, 2, 0);
    CheckDevicePfn(L, ud, TrimCommandPool);
    ud->ddt->TrimCommandPool(device, command_pool, flags);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x20(%rsp), %rdx
leaq 0xaca79(%rip), %rcx     # 0xd02f8
callq 0x1a640
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x19370
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x280(%rax)
jne 0x238da
movq 0x28(%rsp), %rdi
leaq 0xacb1b(%rip), %rsi     # 0xd03e8
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x34(%rsp)
jmp 0x23904
jmp 0x238dc
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x280(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0xc(%rsp), %edx
callq *%rax
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/command_pool.c
// Function: freecommand_pool
static int freecommand_pool(lua_State *L, ud_t *ud)
    {
    VkCommandPool command_pool = (VkCommandPool)ud->handle;
    VkDevice device = ud->device;
    const VkAllocationCallbacks *allocator = ud->allocator;
    freechildren(L, COMMAND_BUFFER_MT, ud);
    if(!freeuserdata(L, ud))
        return 0; /* double call */
    TRACE_DELETE(command_pool, "command_pool");
    UD(device)->ddt->DestroyCommandPool(device, command_pool, allocator);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0xabfb1(%rip), %rsi     # 0xcf909
callq 0x18fa0
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x18dc0
cmpl $0x0, %eax
jne 0x2397b
movl $0x0, 0x34(%rsp)
jmp 0x239cc
jmp 0x2397d
movq 0xd9614(%rip), %rax     # 0xfcf98
cmpl $0x0, (%rax)
je 0x2399c
movq 0x18(%rsp), %rsi
leaq 0xaca35(%rip), %rdi     # 0xd03ca
movb $0x0, %al
callq 0x189d0
jmp 0x2399e
movq 0x10(%rsp), %rdi
callq 0x19fd0
movq 0x50(%rax), %rax
movq 0x228(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq *%rax
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
nopl (%rax,%rax)
// File: stetre[P]moonvulkan/src/datahandling.c
// Function: Flatten
static int Flatten(lua_State *L)
    {
    int n, i, table_index;
    n = Flatten_(L, 1);
    table_index = lua_gettop(L);
    luaL_checkstack(L, n, "too many elements, cannot grow Lua stack");
    for(i = 0; i < n; i++)
        lua_rawgeti(L, table_index, i+1);
    return n;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x23f50
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x180a0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
leaq 0xacb15(%rip), %rdx     # 0xd054f
callq 0x194f0
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x23a76
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
movl 0x8(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x189e0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x23a47
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/datahandling.c
// Function: PackDescriptorImageInfo
static int PackDescriptorImageInfo(lua_State *L)
    {
    VkDescriptorImageInfo info;
    info.sampler = checksampler(L, 1, NULL);
    info.imageView = checkimage_view(L, 2, NULL);
    info.imageLayout = checkimagelayout(L, 3);
    lua_pushlstring(L, (char*)&info, sizeof(info));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xac808(%rip), %rcx     # 0xd05f6
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xac7fc(%rip), %rcx     # 0xd0609
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0xa, %esi
movl $0x3, %edx
callq 0x19d20
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x18, %edx
callq 0x19860
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/datahandling.c
// Function: PackDescriptorBufferInfo
static int PackDescriptorBufferInfo(lua_State *L)
    {
    VkDescriptorBufferInfo info;
    info.buffer = checkbuffer(L, 1, NULL);
    info.offset = luaL_checkinteger(L, 2);
    info.range = checksizeorwholesize(L, 3);
    lua_pushlstring(L, (char*)&info, sizeof(info));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xab192(%rip), %rcx     # 0xcf000
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x19190
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x1a770
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x18, %edx
callq 0x19860
movl $0x1, %eax
addq $0x28, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/datahandling.c
// Function: PackBufferView
static int PackBufferView(lua_State *L)
    {
    size_t len;
    VkBufferView buffer_view = checkbuffer_view(L, 1, NULL);
    const char* data = luaL_checklstring(L, 2, &len);
    lua_pushlstring(L, (char*)&buffer_view, sizeof(buffer_view));
    if(data)
        {
        lua_pushvalue(L, 2);
        lua_concat(L, 2);
        }
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xab187(%rip), %rcx     # 0xcf065
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
leaq 0x18(%rsp), %rdx
callq 0x18df0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x8, %edx
callq 0x19860
cmpq $0x0, 0x8(%rsp)
je 0x23f3b
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x18f40
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x1a070
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/datahandling.c
// Function: Flatten_
static int Flatten_(lua_State *L, int arg)
    {
    int table_index, last_arg, i, n;
    //DBG("top = %d\n", lua_gettop(L));
    if(lua_type(L, arg) == LUA_TTABLE)
        {
        lua_newtable(L);
        n = Flatten1_(L, lua_gettop(L), 0, arg);
        }
    else
        {
        /* create a table with all the arguments, and flatten it */
        last_arg = lua_gettop(L);
        lua_newtable(L);
        table_index = lua_gettop(L);
        for(i=arg; i <= last_arg; i++)
            {
            lua_pushvalue(L, i);
            lua_rawseti(L, table_index, i-arg+1);
            }
        lua_newtable(L);
        n = Flatten1_(L, lua_gettop(L), 0, table_index);
        }
    //DBG("top = %d n = %d\n", lua_gettop(L), n);
    return n;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x1a240
cmpl $0x5, %eax
jne 0x23fad
movq 0x30(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x18830
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x180a0
movq 0x10(%rsp), %rdi
movl %eax, %esi
movl 0x2c(%rsp), %ecx
xorl %edx, %edx
callq 0x24070
movl %eax, 0x1c(%rsp)
jmp 0x24058
movq 0x30(%rsp), %rdi
callq 0x180a0
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x18830
movq 0x30(%rsp), %rdi
callq 0x180a0
movl %eax, 0x28(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x24(%rsp), %eax
jg 0x24020
movq 0x30(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x18f40
movq 0x30(%rsp), %rdi
movl 0x28(%rsp), %esi
movl 0x20(%rsp), %eax
subl 0x2c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x191e0
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x23fdf
movq 0x30(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x18830
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x180a0
movq 0x8(%rsp), %rdi
movl %eax, %esi
movl 0x28(%rsp), %ecx
xorl %edx, %edx
callq 0x24070
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/datahandling.c
// Function: Flatten1_
static int Flatten1_(lua_State *L, int table_index, int cur_index, int arg)
    {
    int len, i, top, m, n=0;

    if(lua_type(L, arg) != LUA_TTABLE)
        return luaL_error(L, "table expected");

    lua_len(L, arg);
    len = lua_tointeger(L, -1);
    lua_pop(L, 1);

    if(len==0) return n;

    for(i=1; i<=len; i++)
        {
        lua_geti(L, arg, i);
        top = lua_gettop(L);
        if(lua_type(L, top) == LUA_TTABLE)
            {
            m = Flatten1_(L, table_index, cur_index, top);
            n += m;
            cur_index += m;
            lua_remove(L, top);
            }
        else
            {
            n++;
            cur_index++;
#if 0 /* no, we'll check this later */
            if(!lua_isnumber(L, lua_gettop(L)))
                return luaL_argerror(L, cur_index, "number expected");
#endif
            lua_rawseti(L, table_index, cur_index);
            }
        }
    return n;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl $0x0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x1a240
cmpl $0x5, %eax
je 0x240bc
movq 0x28(%rsp), %rdi
leaq 0xac4cc(%rip), %rsi     # 0xd0578
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x34(%rsp)
jmp 0x241e7
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x19410
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x18690
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x18170
cmpl $0x0, 0x18(%rsp)
jne 0x24104
movl 0x8(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x241e7
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
jg 0x241df
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %esi
movslq 0x14(%rsp), %rdx
callq 0x1a4f0
movq 0x28(%rsp), %rdi
callq 0x180a0
movl %eax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x1a240
cmpl $0x5, %eax
jne 0x241a4
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movl 0x10(%rsp), %ecx
callq 0x24070
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
addl 0x20(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl 0x10(%rsp), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x19800
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x18170
jmp 0x241cd
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movslq 0x20(%rsp), %rdx
callq 0x191e0
jmp 0x241cf
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2410c
movl 0x8(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: stetre[P]moonvulkan/src/datahandling.c
// Function: Sizeoftype
static size_t Sizeoftype(lua_State *L, int type)
    {
    switch(type)
        {
        case NONVK_TYPE_BYTE:
        case NONVK_TYPE_UBYTE: 
        case NONVK_TYPE_INT8:
        case NONVK_TYPE_UINT8:  return 1;
        case NONVK_TYPE_SHORT:
        case NONVK_TYPE_USHORT: 
        case NONVK_TYPE_INT16:
        case NONVK_TYPE_UINT16: return 2;
        case NONVK_TYPE_INT:
        case NONVK_TYPE_UINT: 
        case NONVK_TYPE_INT32:
        case NONVK_TYPE_UINT32: return 4;
        case NONVK_TYPE_LONG:
        case NONVK_TYPE_ULONG: 
        case NONVK_TYPE_INT64:
        case NONVK_TYPE_UINT64: return 8;
        case NONVK_TYPE_FLOAT: return 4;
        case NONVK_TYPE_DOUBLE: return 8;
        default:
            return unexpected(L);
        }
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl 0x14(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x11, %eax
ja 0x24266
movq 0x8(%rsp), %rax
leaq 0xac285(%rip), %rcx     # 0xd04a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x1, 0x20(%rsp)
jmp 0x2428c
movq $0x2, 0x20(%rsp)
jmp 0x2428c
movq $0x4, 0x20(%rsp)
jmp 0x2428c
movq $0x8, 0x20(%rsp)
jmp 0x2428c
movq $0x4, 0x20(%rsp)
jmp 0x2428c
movq $0x8, 0x20(%rsp)
jmp 0x2428c
movq 0x18(%rsp), %rdi
leaq 0xac315(%rip), %rsi     # 0xd0587
leaq 0xac328(%rip), %rdx     # 0xd05a1
movl $0x33, %ecx
movb $0x0, %al
callq 0x19ce0
cltq
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/debug_report_callback.c
// Function: DebugReportMessage
static int DebugReportMessage(lua_State *L)
    {
    ud_t *ud;
    VkInstance instance = checkinstance(L, 1, &ud);
    VkDebugReportFlagsEXT flags = checkflags(L, 2);
    VkDebugReportObjectTypeEXT objectType = checkdebugreportobjecttype(L, 3);
    uint64_t object = luaL_checkinteger(L, 4);
    size_t location = luaL_checkinteger(L, 5);
    int32_t messageCode = luaL_checkinteger(L, 6);
    const char* pLayerPrefix = luaL_checkstring(L, 7);
    const char* pMessage = luaL_checkstring(L, 8);
    CheckInstancePfn(L, ud, DebugReportMessageEXT);
    ud->idt->DebugReportMessageEXT(instance, flags, 
        objectType, object, location, messageCode, pLayerPrefix, pMessage);
    return 0;
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movl $0x1, %esi
leaq 0x50(%rsp), %rdx
leaq 0xaaaca(%rip), %rcx     # 0xd06c9
callq 0x1a640
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rdi
movl $0x2, %esi
callq 0x19010
movl %eax, 0x44(%rsp)
movq 0x58(%rsp), %rdi
movl $0x24, %esi
movl $0x3, %edx
callq 0x19d20
movl %eax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
movl $0x4, %esi
callq 0x19190
movq %rax, 0x38(%rsp)
movq 0x58(%rsp), %rdi
movl $0x5, %esi
callq 0x19190
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rdi
movl $0x6, %esi
callq 0x19190
movl %eax, 0x2c(%rsp)
movq 0x58(%rsp), %rdi
movl $0x7, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x18df0
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
movl $0x8, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x18df0
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0xe0(%rax)
jne 0x25ccb
movq 0x58(%rsp), %rdi
leaq 0xaaab7(%rip), %rsi     # 0xd0775
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x64(%rsp)
jmp 0x25d16
jmp 0x25ccd
movq 0x50(%rsp), %rax
movq 0x48(%rax), %rax
movq 0xe0(%rax), %rax
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %esi
movl 0x40(%rsp), %edx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
movl 0x2c(%rsp), %r9d
movq 0x20(%rsp), %r11
movq 0x18(%rsp), %r10
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
callq *%rax
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/debug_report_callback.c
// Function: DebugMarkerSetObjectTag
static int DebugMarkerSetObjectTag(lua_State *L)
    {
    ud_t *ud;
    VkResult ec;
    VkDebugMarkerObjectTagInfoEXT info;
    VkDevice device = checkdevice(L, 1, &ud);
    info.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT;
    info.pNext = NULL;
    info.objectType = checkdebugreportobjecttype(L, 2);
    info.object = luaL_checkinteger(L, 3);
    info.tagName = luaL_checkinteger(L, 4);
    info.pTag = luaL_checklstring(L, 5, &info.tagSize);
    if(info.tagSize == 0)
        return argerrorc(L, 5, ERR_LENGTH);
    CheckDevicePfn(L, ud, DebugMarkerSetObjectTagEXT);
    ec = ud->ddt->DebugMarkerSetObjectTagEXT(device, &info);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movl $0x1, %esi
leaq 0x50(%rsp), %rdx
leaq 0xa92fc(%rip), %rcx     # 0xcf03b
callq 0x1a640
movq %rax, 0x8(%rsp)
movl $0x3b9b1ff1, 0x10(%rsp) # imm = 0x3B9B1FF1
movq $0x0, 0x18(%rsp)
movq 0x58(%rsp), %rdi
movl $0x24, %esi
movl $0x2, %edx
callq 0x19d20
movl %eax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdi
movl $0x4, %esi
callq 0x19190
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rdx
addq $0x28, %rdx
movl $0x5, %esi
callq 0x18df0
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x25dec
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movl $0xfffffff9, %edi       # imm = 0xFFFFFFF9
callq 0x19a60
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x5, %esi
callq 0x18460
movl %eax, 0x64(%rsp)
jmp 0x25e6d
jmp 0x25dee
movq 0x50(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x288(%rax)
jne 0x25e1a
movq 0x58(%rsp), %rdi
leaq 0xaa993(%rip), %rsi     # 0xd07a0
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x64(%rsp)
jmp 0x25e6d
jmp 0x25e1c
movq 0x50(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x288(%rax), %rax
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq *%rax
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
je 0x25e63
movq 0x58(%rsp), %rdi
movl 0x4c(%rsp), %edx
xorl %esi, %esi
callq 0x18a00
movq 0x58(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x64(%rsp)
jmp 0x25e6d
jmp 0x25e65
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/debug_report_callback.c
// Function: DebugMarkerSetObjectName
static int DebugMarkerSetObjectName(lua_State *L)
    {
    ud_t *ud;
    VkResult ec;
    VkDebugMarkerObjectNameInfoEXT info;
    VkDevice device = checkdevice(L, 1, &ud);
    info.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT;
    info.pNext = NULL;
    info.objectType = checkdebugreportobjecttype(L, 2);
    info.object = luaL_checkinteger(L, 3);
    info.pObjectName = luaL_checkstring(L, 4);
    CheckDevicePfn(L, ud, DebugMarkerSetObjectNameEXT);
    ec = ud->ddt->DebugMarkerSetObjectNameEXT(device, &info);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
leaq 0x40(%rsp), %rdx
leaq 0xa919c(%rip), %rcx     # 0xcf03b
callq 0x1a640
movq %rax, 0x8(%rsp)
movl $0x3b9b1ff0, 0x10(%rsp) # imm = 0x3B9B1FF0
movq $0x0, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movl $0x24, %esi
movl $0x2, %edx
callq 0x19d20
movl %eax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movl $0x4, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x18df0
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x290(%rax)
jne 0x25f2a
movq 0x48(%rsp), %rdi
leaq 0xaa8b3(%rip), %rsi     # 0xd07d0
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x54(%rsp)
jmp 0x25f7d
jmp 0x25f2c
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x290(%rax), %rax
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq *%rax
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
je 0x25f73
movq 0x48(%rsp), %rdi
movl 0x3c(%rsp), %edx
xorl %esi, %esi
callq 0x18a00
movq 0x48(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x54(%rsp)
jmp 0x25f7d
jmp 0x25f75
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)