LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: stetre[P]moonvulkan/src/physical_device.c
// Function: GetPhysicalDeviceExternalFenceProperties
static int GetPhysicalDeviceExternalFenceProperties(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkPhysicalDeviceExternalFenceInfoKHR* info = NULL;
    VkExternalFencePropertiesKHR* props = NULL;
    VkPhysicalDevice physical_device = checkphysical_device(L, 1, &ud);
    CheckInstancePfn(L, ud, GetPhysicalDeviceExternalFenceProperties);
#define CLEANUP do {                                        \
    zfreeVkPhysicalDeviceExternalFenceInfoKHR(L, info, 1);  \
    zfreeVkExternalFencePropertiesKHR(L, props, 1);     \
} while(0)
    info = zcheckVkPhysicalDeviceExternalFenceInfoKHR(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    props = znewchainVkExternalFencePropertiesKHR(L, &err);
    if(err) { CLEANUP; return lua_error(L); }
    ud->idt->GetPhysicalDeviceExternalFenceProperties(physical_device, info, props);
    zpushVkExternalFencePropertiesKHR(L, props);
    CLEANUP;
#undef CLEANUP
    return 1;
    }

// 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 0x74d2b(%rip), %rcx     # 0xd0eac
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x130(%rax)
jne 0x5c1ba
movq 0x38(%rsp), %rdi
leaq 0x86773(%rip), %rsi     # 0xe291d
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x44(%rsp)
jmp 0x5c2f3
jmp 0x5c1bc
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x34(%rsp), %rdx
callq 0x1a2b0
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x5c23e
jmp 0x5c1de
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
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 0x5c2f3
movq 0x38(%rsp), %rdi
leaq 0x34(%rsp), %rsi
callq 0x18e10
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x5c293
jmp 0x5c25b
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x38(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x44(%rsp)
jmp 0x5c2f3
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x130(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq *%rax
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x181b0
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/physical_device.c
// Function: GetPhysicalDeviceExternalSemaphoreProperties
static int GetPhysicalDeviceExternalSemaphoreProperties(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkPhysicalDeviceExternalSemaphoreInfo* info = NULL;
    VkExternalSemaphorePropertiesKHR* props = NULL;
    VkPhysicalDevice physical_device = checkphysical_device(L, 1, &ud);
    CheckInstancePfn(L, ud, GetPhysicalDeviceExternalSemaphoreProperties);
#define CLEANUP do {                                        \
    zfreeVkPhysicalDeviceExternalSemaphoreInfo(L, info, 1);  \
    zfreeVkExternalSemaphorePropertiesKHR(L, props, 1);     \
} while(0)
    info = zcheckVkPhysicalDeviceExternalSemaphoreInfo(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    props = znewchainVkExternalSemaphorePropertiesKHR(L, &err);
    if(err) { CLEANUP; return lua_error(L); }
    ud->idt->GetPhysicalDeviceExternalSemaphoreProperties(physical_device, info, props);
    zpushVkExternalSemaphorePropertiesKHR(L, props);
    CLEANUP;
#undef CLEANUP
    return 1;
    }

// 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 0x74b7b(%rip), %rcx     # 0xd0eac
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x128(%rax)
jne 0x5c36a
movq 0x38(%rsp), %rdi
leaq 0x86601(%rip), %rsi     # 0xe295b
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x44(%rsp)
jmp 0x5c4a3
jmp 0x5c36c
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x34(%rsp), %rdx
callq 0x18a80
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x5c3ee
jmp 0x5c38e
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
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 0x5c4a3
movq 0x38(%rsp), %rdi
leaq 0x34(%rsp), %rsi
callq 0x1a750
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x5c443
jmp 0x5c40b
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x38(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x44(%rsp)
jmp 0x5c4a3
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x128(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq *%rax
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x19d60
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/physical_device.c
// Function: GetPhysicalDeviceMultisampleProperties
static int GetPhysicalDeviceMultisampleProperties(lua_State *L)
    {
    int err;
    ud_t *ud;
    VkMultisamplePropertiesEXT* props;
    VkPhysicalDevice physical_device = checkphysical_device(L, 1, &ud);
    VkSampleCountFlagBits samples = checkflags(L, 2);
    CheckInstancePfn(L, ud, GetPhysicalDeviceMultisamplePropertiesEXT);
#define CLEANUP zfreeVkMultisamplePropertiesEXT(L, props, 1)
    props = znewchainVkMultisamplePropertiesEXT(L, &err);
    if(err) { CLEANUP; return lua_error(L); }
    ud->idt->GetPhysicalDeviceMultisamplePropertiesEXT(physical_device, samples, props);
    zpushVkMultisamplePropertiesEXT(L, props);
    CLEANUP;
#undef CLEANUP
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0x749dd(%rip), %rcx     # 0xd0eac
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x19010
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x1d0(%rax)
jne 0x5c51b
movq 0x28(%rsp), %rdi
leaq 0x86492(%rip), %rsi     # 0xe299d
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x34(%rsp)
jmp 0x5c5a7
jmp 0x5c51d
movq 0x28(%rsp), %rdi
leaq 0x24(%rsp), %rsi
callq 0x1a460
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x5c55c
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x28(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x34(%rsp)
jmp 0x5c5a7
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x1d0(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movq 0x10(%rsp), %rdx
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x191d0
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: stetre[P]moonvulkan/src/physical_device.c
// Function: GetPhysicalDeviceCalibrateableTimeDomains
static int GetPhysicalDeviceCalibrateableTimeDomains(lua_State *L)
    {
    ud_t *ud;
    VkResult ec;
    uint32_t i, count = 0;
    VkTimeDomainEXT* domains;
    VkPhysicalDevice physical_device = checkphysical_device(L, 1, &ud);
    CheckInstancePfn(L, ud, GetPhysicalDeviceCalibrateableTimeDomainsEXT);

    ec = ud->idt->GetPhysicalDeviceCalibrateableTimeDomainsEXT(physical_device, &count, NULL);
    CheckError(L, ec);

    lua_newtable(L);
    if(count==0) return 1;

    domains = (VkTimeDomainEXT*)Malloc(L, sizeof(VkTimeDomainEXT)*count);
    ec = ud->idt->GetPhysicalDeviceCalibrateableTimeDomainsEXT(physical_device, &count, domains);
    if(ec)
        { Free(L, domains); CheckError(L, ec); }
    for(i=0; i<count; i++)
        {
        pushtimedomain(L, domains[i]);
        lua_rawseti(L, -2, i+1);
        }
    Free(L, domains);
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x20(%rsp), %rdx
leaq 0x748d5(%rip), %rcx     # 0xd0eac
callq 0x1a640
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x1c8(%rax)
jne 0x5c60f
movq 0x28(%rsp), %rdi
leaq 0x863dd(%rip), %rsi     # 0xe29dc
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x34(%rsp)
jmp 0x5c76b
jmp 0x5c611
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x1c8(%rax), %rax
movq (%rsp), %rdi
leaq 0x14(%rsp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq *%rax
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x5c65e
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %edx
xorl %esi, %esi
callq 0x18a00
movq 0x28(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x34(%rsp)
jmp 0x5c76b
jmp 0x5c660
movq 0x28(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x18830
cmpl $0x0, 0x14(%rsp)
jne 0x5c682
movl $0x1, 0x34(%rsp)
jmp 0x5c76b
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
shlq $0x2, %rsi
callq 0x192c0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x1c8(%rax), %rax
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x14(%rsp), %rsi
callq *%rax
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x5c700
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x18300
cmpl $0x0, 0x1c(%rsp)
je 0x5c6fc
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %edx
xorl %esi, %esi
callq 0x18a00
movq 0x28(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x34(%rsp)
jmp 0x5c76b
jmp 0x5c6fe
jmp 0x5c700
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x5c754
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x18(%rsp), %ecx
movl (%rax,%rcx,4), %edx
movl $0x38, %esi
callq 0x18a00
movq 0x28(%rsp), %rdi
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x191e0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x5c708
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x18300
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/physical_device.c
// Function: GetPhysicalDeviceQueueFamilyPerformanceQueryPasses
static int GetPhysicalDeviceQueueFamilyPerformanceQueryPasses(lua_State *L)
    {
    int err;
    uint32_t num_passes;
    ud_t *ud;
    VkQueryPoolPerformanceCreateInfoKHR *info = NULL;
    VkPhysicalDevice physical_device = checkphysical_device(L, 1, &ud);
    CheckInstancePfn(L, ud, GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR);
#define CLEANUP zfreeVkQueryPoolPerformanceCreateInfoKHR (L, info, 1)
    info = zcheckVkQueryPoolPerformanceCreateInfoKHR (L, 2, &err);
    if(err) { CLEANUP; return lua_error(L); }
    ud->idt->GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physical_device, info, &num_passes);
    CLEANUP;
#undef CLEANUP
    lua_pushinteger(L, num_passes);
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0x73d94(%rip), %rcx     # 0xd0eac
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x1e0(%rax)
jne 0x5d151
movq 0x28(%rsp), %rdi
leaq 0x859a6(%rip), %rsi     # 0xe2ae7
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x34(%rsp)
jmp 0x5d1e4
jmp 0x5d153
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x24(%rsp), %rdx
callq 0x19af0
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x5d197
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x28(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x34(%rsp)
jmp 0x5d1e4
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x1e0(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0x18be0
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/physical_device.c
// Function: GetPhysicalDeviceProperties2
static int GetPhysicalDeviceProperties2(lua_State *L, VkPhysicalDevice physical_device, ud_t *ud)
    {
    int err;
    VkPhysicalDeviceProperties2* props;
#define CLEANUP zfreeVkPhysicalDeviceProperties2(L, props, 1)
    props = znewchainVkPhysicalDeviceProperties2(L, &err);
    if(err) { CLEANUP; return lua_error(L); }
    ud->idt->GetPhysicalDeviceProperties2(physical_device, props);
    zpushVkPhysicalDeviceProperties2(L, props);
    CLEANUP;
#undef CLEANUP
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x19bc0
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x5d242
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x28(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x34(%rsp)
jmp 0x5d289
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq 0xf0(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x18a10
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/physical_device.c
// Function: GetPhysicalDeviceFeatures2
static int GetPhysicalDeviceFeatures2(lua_State *L, VkPhysicalDevice physical_device, ud_t *ud)
    {
    int err;
    VkPhysicalDeviceFeatures2* features;
#define CLEANUP zfreeVkPhysicalDeviceFeatures2(L, features, 1)
    features = znewchainVkPhysicalDeviceFeatures2(L, &err);
    if(err) { CLEANUP; return lua_error(L); }
    ud->idt->GetPhysicalDeviceFeatures2(physical_device, features);
    zpushVkPhysicalDeviceFeatures2(L, features);
    CLEANUP;
#undef CLEANUP
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x19820
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x5d2f2
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x28(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x34(%rsp)
jmp 0x5d339
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq 0xe8(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x19780
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/physical_device.c
// Function: GetPhysicalDeviceFormatProperties2
static int GetPhysicalDeviceFormatProperties2(lua_State *L, VkPhysicalDevice physical_device, ud_t *ud)
    {
    int err;
    VkFormatProperties2* props;
    VkFormat format = checkformat(L, 2);
#define CLEANUP zfreeVkFormatProperties2(L, props, 1)
    props = znewchainVkFormatProperties2(L, &err);
    if(err) { CLEANUP; return lua_error(L); }
    ud->idt->GetPhysicalDeviceFormatProperties2(physical_device, format, props);
    zpushVkFormatProperties2(L, props);
    CLEANUP;
#undef CLEANUP
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x4, %esi
movl $0x2, %edx
callq 0x19d20
movl %eax, 0x4(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x18880
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x5d3ba
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x28(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x34(%rsp)
jmp 0x5d405
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq 0xf8(%rax), %rax
movq 0x20(%rsp), %rdi
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdx
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x19890
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/physical_device.c
// Function: GetPhysicalDeviceImageFormatProperties2
static int GetPhysicalDeviceImageFormatProperties2(lua_State *L, VkPhysicalDevice physical_device, ud_t *ud)
    {
    int err;
    VkResult ec;
    VkPhysicalDeviceImageFormatInfo2* info = NULL;
    VkImageFormatProperties2* props = NULL;
#define CLEANUP do {            \
    zfreeVkPhysicalDeviceImageFormatInfo2(L, info, 1);           \
    zfreeVkImageFormatProperties2(L, props, 1);                  \
} while(0)
    info = zcheckVkPhysicalDeviceImageFormatInfo2(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    props = znewchainVkImageFormatProperties2(L, &err);
    if(err) { CLEANUP; return lua_error(L); }
    ec = ud->idt->GetPhysicalDeviceImageFormatProperties2(physical_device, info, props);
    if(ec) { CLEANUP; CheckError(L, ec); return 0; }
    zpushVkImageFormatProperties2(L, props);
    CLEANUP;
#undef CLEANUP
    return 1;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x24(%rsp), %rdx
callq 0x18820
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x5d4b7
jmp 0x5d457
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
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 0x5d5d9
movq 0x38(%rsp), %rdi
leaq 0x24(%rsp), %rsi
callq 0x18780
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x5d50f
jmp 0x5d4d4
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x38(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x44(%rsp)
jmp 0x5d5d9
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x100(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq *%rax
movl %eax, 0x20(%rsp)
cmpl $0x0, 0x20(%rsp)
je 0x5d59a
jmp 0x5d53d
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
jmp 0x5d567
cmpl $0x0, 0x20(%rsp)
je 0x5d58e
movq 0x38(%rsp), %rdi
movl 0x20(%rsp), %edx
xorl %esi, %esi
callq 0x18a00
movq 0x38(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x44(%rsp)
jmp 0x5d5d9
jmp 0x5d590
movl $0x0, 0x44(%rsp)
jmp 0x5d5d9
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x180c0
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/physical_device.c
// Function: GetPhysicalDeviceQueueFamilyProperties2
static int GetPhysicalDeviceQueueFamilyProperties2
        (lua_State *L, VkPhysicalDevice physical_device, ud_t *ud)
    {
    int err;
    uint32_t i, count = 0;
    VkQueueFamilyProperties2* props;
    lua_newtable(L);
    ud->idt->GetPhysicalDeviceQueueFamilyProperties2(physical_device, &count, NULL);
    if(count == 0) return 1;
#define CLEANUP zfreearrayVkQueueFamilyProperties2(L, props, count, 1)
    props = znewchainarrayVkQueueFamilyProperties2(L, count, &err);
    if(err) { CLEANUP; return lua_error(L); }
    ud->idt->GetPhysicalDeviceQueueFamilyProperties2(physical_device, &count, props);
    for(i=0; i<count; i++)
        {
        zpushVkQueueFamilyProperties2(L, &props[i], i);
        lua_rawseti(L, -2, i+1);
        }
    CLEANUP;
#undef CLEANUP
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x28(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x18830
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x108(%rax), %rax
movq 0x20(%rsp), %rdi
leaq 0xc(%rsp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq *%rax
cmpl $0x0, 0xc(%rsp)
jne 0x5d64d
movl $0x1, 0x34(%rsp)
jmp 0x5d736
movq 0x28(%rsp), %rdi
movl 0xc(%rsp), %esi
leaq 0x14(%rsp), %rdx
callq 0x1a350
movq %rax, (%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x5d69b
movq 0x28(%rsp), %rdi
movq (%rsp), %rsi
movl 0xc(%rsp), %ecx
movl $0x28, %edx
movl $0x1, %r8d
callq 0x198d0
movq 0x28(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x34(%rsp)
jmp 0x5d736
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x108(%rax), %rax
movq 0x20(%rsp), %rdi
movq (%rsp), %rdx
leaq 0xc(%rsp), %rsi
callq *%rax
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
jae 0x5d711
movq 0x28(%rsp), %rdi
movq (%rsp), %rsi
movl 0x10(%rsp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rsi
movl 0x10(%rsp), %edx
callq 0x19e40
movq 0x28(%rsp), %rdi
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x191e0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x5d6c3
movq 0x28(%rsp), %rdi
movq (%rsp), %rsi
movl 0xc(%rsp), %ecx
movl $0x28, %edx
movl $0x1, %r8d
callq 0x198d0
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/physical_device.c
// Function: GetPhysicalDeviceMemoryProperties2
static int GetPhysicalDeviceMemoryProperties2(lua_State *L, VkPhysicalDevice physical_device, ud_t *ud)
    {
    int err;
    VkPhysicalDeviceMemoryProperties2* props;
#define CLEANUP zfreeVkPhysicalDeviceMemoryProperties2(L, props, 1)
    props = znewchainVkPhysicalDeviceMemoryProperties2(L, &err);
    if(err) { CLEANUP; return lua_error(L); }
    ud->idt->GetPhysicalDeviceMemoryProperties2(physical_device, props);
    zpushVkPhysicalDeviceMemoryProperties2(L, props);
    CLEANUP;
#undef CLEANUP
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x1a4c0
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x5d792
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x28(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x34(%rsp)
jmp 0x5d7d9
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x110(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x18930
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/pipeline.c
// Function: newpipeline
static int newpipeline(lua_State *L, VkPipeline  pipeline, VkDevice device, const VkAllocationCallbacks *allocator)
    {
    ud_t *ud;
    TRACE_CREATE(pipeline, "pipeline");
    ud = newuserdata_nondispatchable(L, pipeline, PIPELINE_MT);
    ud->parent_ud = UD(device);
    ud->device = device;
    ud->instance = UD(device)->instance;
    ud->allocator = allocator;
    ud->destructor = freepipeline;
    ud->ddt = UD(device)->ddt;
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x9e2b9(%rip), %rax     # 0xfcf98
cmpl $0x0, (%rax)
je 0x5ecf7
movq 0x18(%rsp), %rsi
leaq 0x83efd(%rip), %rdi     # 0xe2bed
movb $0x0, %al
callq 0x189d0
jmp 0x5ecf9
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x70c19(%rip), %rdx     # 0xcf923
xorl %ecx, %ecx
callq 0x18350
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x19fd0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rdi
callq 0x19fd0
movq 0x18(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x40(%rax)
movq (%rsp), %rax
leaq 0x2b(%rip), %rcx        # 0x5ed90
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rdi
callq 0x19fd0
movq 0x50(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x50(%rax)
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/pipeline.c
// Function: freepipeline
static int freepipeline(lua_State *L, ud_t *ud)
    {
    VkPipeline pipeline = (VkPipeline)ud->handle;
    const VkAllocationCallbacks *allocator = ud->allocator;
    PFN_vkDestroyPipeline DestroyPipeline = ud->ddt->DestroyPipeline;
    VkDevice device = ud->device;

    if(!freeuserdata(L, ud))
        return 0; /* double call */
    TRACE_DELETE(pipeline, "pipeline");
    DestroyPipeline(device, pipeline, 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 0x40(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x190(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x18dc0
cmpl $0x0, %eax
jne 0x5edf9
movl $0x0, 0x34(%rsp)
jmp 0x5ee39
jmp 0x5edfb
movq 0x9e196(%rip), %rax     # 0xfcf98
cmpl $0x0, (%rax)
je 0x5ee1a
movq 0x18(%rsp), %rsi
leaq 0x83df4(%rip), %rdi     # 0xe2c07
movb $0x0, %al
callq 0x189d0
jmp 0x5ee1c
movq 0x8(%rsp), %rax
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq *%rax
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: stetre[P]moonvulkan/src/pipeline_cache.c
// Function: GetPipelineCacheData
static int GetPipelineCacheData(lua_State *L)
    {
    VkResult ec;
    size_t size;
    char *data;
    ud_t *ud;
    VkPipelineCache pipeline_cache = checkpipeline_cache(L, 1, &ud);
    VkDevice device = ud->device;
    /* first, get the size */
    ec = ud->ddt->GetPipelineCacheData(device, pipeline_cache, &size, NULL);
    CheckError(L, ec);
    if(size == 0)
        { lua_pushstring(L, ""); return 1; }
    data = (char*)Malloc(L, size);
    ec = ud->ddt->GetPipelineCacheData(device, pipeline_cache, &size, data);
    if(ec) { Free(L, data); CheckError(L, ec); return 0; }
    lua_pushlstring(L, data, size);
    Free(L, data);
    return 1;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0x71b95(%rip), %rcx     # 0xd0f34
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x170(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x28(%rsp), %rdx
xorl %ecx, %ecx
callq *%rax
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x5f408
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %edx
xorl %esi, %esi
callq 0x18a00
movq 0x38(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x44(%rsp)
jmp 0x5f4e2
jmp 0x5f40a
cmpq $0x0, 0x28(%rsp)
jne 0x5f430
movq 0x38(%rsp), %rdi
leaq 0x7a6a3(%rip), %rsi     # 0xd9ac1
callq 0x1a420
movl $0x1, 0x44(%rsp)
jmp 0x5f4e2
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x192c0
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x170(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rcx
leaq 0x28(%rsp), %rdx
callq *%rax
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x5f4b7
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x18300
cmpl $0x0, 0x34(%rsp)
je 0x5f4ab
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %edx
xorl %esi, %esi
callq 0x18a00
movq 0x38(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x44(%rsp)
jmp 0x5f4e2
jmp 0x5f4ad
movl $0x0, 0x44(%rsp)
jmp 0x5f4e2
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x19860
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x18300
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: stetre[P]moonvulkan/src/pipeline_cache.c
// Function: MergePipelineCaches
static int MergePipelineCaches(lua_State *L)
    {
    int err;
    uint32_t count;
    VkResult ec;
    ud_t *ud;
    VkPipelineCache destination = checkpipeline_cache(L, 1, &ud);
    VkDevice device = ud->device;
    VkPipelineCache *source = checkpipeline_cachelist(L, 2, &count, &err, NULL);
    if(err) return argerrorc(L, 2, err);
    ec = ud->ddt->MergePipelineCaches(device, destination, count, source);
    Free(L, source);
    CheckError(L, ec);
    return 0;
# undef first
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x20(%rsp), %rdx
leaq 0x71a25(%rip), %rcx     # 0xd0f34
callq 0x1a640
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x30(%rsp), %rdx
leaq 0x34(%rsp), %rcx
xorl %eax, %eax
movl %eax, %r8d
leaq 0x719ed(%rip), %r9      # 0xd0f34
callq 0x191f0
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x5f581
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movl 0x34(%rsp), %edi
callq 0x19a60
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x18460
movl %eax, 0x44(%rsp)
jmp 0x5f5ea
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x178(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x30(%rsp), %edx
movq 0x8(%rsp), %rcx
callq *%rax
movl %eax, 0x2c(%rsp)
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x18300
cmpl $0x0, 0x2c(%rsp)
je 0x5f5e0
movq 0x38(%rsp), %rdi
movl 0x2c(%rsp), %edx
xorl %esi, %esi
callq 0x18a00
movq 0x38(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x44(%rsp)
jmp 0x5f5ea
jmp 0x5f5e2
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: stetre[P]moonvulkan/src/pipeline_cache.c
// Function: freepipeline_cache
static int freepipeline_cache(lua_State *L, ud_t *ud)
    {
    VkPipelineCache pipeline_cache = (VkPipelineCache)ud->handle;
    const VkAllocationCallbacks *allocator = ud->allocator;
    VkDevice device = ud->device;
    if(!freeuserdata(L, ud))
        return 0; /* double call */
    TRACE_DELETE(pipeline_cache, "pipeline_cache");
    UD(device)->ddt->DestroyPipelineCache(device, pipeline_cache, 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 0x40(%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 0x5f655
movl $0x0, 0x34(%rsp)
jmp 0x5f6a6
jmp 0x5f657
movq 0x9d93a(%rip), %rax     # 0xfcf98
cmpl $0x0, (%rax)
je 0x5f676
movq 0x18(%rsp), %rsi
leaq 0x836ef(%rip), %rdi     # 0xe2d5e
movb $0x0, %al
callq 0x189d0
jmp 0x5f678
movq 0x8(%rsp), %rdi
callq 0x19fd0
movq 0x50(%rax), %rax
movq 0x168(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq *%rax
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/pipeline_layout.c
// Function: freepipeline_layout
static int freepipeline_layout(lua_State *L, ud_t *ud)
    {
    VkPipelineLayout pipeline_layout = (VkPipelineLayout)ud->handle;
    const VkAllocationCallbacks *allocator = ud->allocator;
    VkDevice device = ud->device;

    if(!freeuserdata(L, ud))
        return 0; /* double call */
    TRACE_DELETE(pipeline_layout, "pipeline_layout");
    UD(device)->ddt->DestroyPipelineLayout(device, pipeline_layout, 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 0x40(%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 0x5fcf5
movl $0x0, 0x34(%rsp)
jmp 0x5fd46
jmp 0x5fcf7
movq 0x9d29a(%rip), %rax     # 0xfcf98
cmpl $0x0, (%rax)
je 0x5fd16
movq 0x18(%rsp), %rsi
leaq 0x830bf(%rip), %rdi     # 0xe2dce
movb $0x0, %al
callq 0x189d0
jmp 0x5fd18
movq 0x8(%rsp), %rdi
callq 0x19fd0
movq 0x50(%rax), %rax
movq 0x1a0(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq *%rax
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/query_pool.c
// Function: Create
static int Create(lua_State *L)
    {
    int err;
    ud_t *ud, *device_ud;
    VkResult ec;
    VkQueryPool query_pool;
    VkQueryPoolCreateInfo* info;
    VkDevice device = checkdevice(L, 1, &device_ud);
    const VkAllocationCallbacks *allocator = optallocator(L, 3);
#define CLEANUP zfreeVkQueryPoolCreateInfo(L, info, 1)
    info = zcheckVkQueryPoolCreateInfo(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ec = device_ud->ddt->CreateQueryPool(device, info, allocator, &query_pool);
    CLEANUP;
#undef CLEANUP
    CheckError(L, ec);
    TRACE_CREATE(query_pool, "query_pool");
    ud = newuserdata_nondispatchable(L, query_pool, QUERY_POOL_MT);
    ud->parent_ud = device_ud;
    ud->device = device;
    ud->instance = device_ud->instance;
    ud->allocator = allocator;
    ud->destructor = freequery_pool;
    ud->ddt = device_ud->ddt;
    return 1;
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
leaq 0x30(%rsp), %rdx
leaq 0x6f09c(%rip), %rcx     # 0xcf03b
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movl $0x3, %esi
callq 0x19260
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movl $0x2, %esi
leaq 0x44(%rsp), %rdx
callq 0x1a220
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x44(%rsp)
je 0x60027
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x18460
movl %eax, 0x54(%rsp)
jmp 0x60137
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq 0xf0(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq *%rax
movl %eax, 0x2c(%rsp)
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
cmpl $0x0, 0x2c(%rsp)
je 0x6008f
movq 0x48(%rsp), %rdi
movl 0x2c(%rsp), %edx
xorl %esi, %esi
callq 0x18a00
movq 0x48(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x54(%rsp)
jmp 0x60137
jmp 0x60091
jmp 0x60093
movq 0x9cefe(%rip), %rax     # 0xfcf98
cmpl $0x0, (%rax)
je 0x600b2
movq 0x20(%rsp), %rsi
leaq 0x82d80(%rip), %rdi     # 0xe2e2b
movb $0x0, %al
callq 0x189d0
jmp 0x600b4
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x6f94a(%rip), %rdx     # 0xcfa0f
xorl %ecx, %ecx
callq 0x18350
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x38(%rsp), %rax
leaq 0x297(%rip), %rcx       # 0x603b0
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x50(%rax)
movl $0x1, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
// File: stetre[P]moonvulkan/src/query_pool.c
// Function: GetQueryPoolResults
static int GetQueryPoolResults(lua_State *L)
    {
// @@ TODO: specialization for performance counters results (see VK_KHR_performance_query).
    VkResult ec;
    ud_t * ud;
    VkQueryPool query_pool  = checkquery_pool(L, 1, &ud);
    VkDevice device = ud->device;
    uint32_t first = luaL_checkinteger(L, 2);
    uint32_t count = luaL_checkinteger(L, 3);
    size_t size = luaL_checkinteger(L, 4);
    VkDeviceSize stride = luaL_checkinteger(L, 5);
    VkQueryResultFlags flags = checkflags(L, 6);

    char* data = (char*)Malloc(L, size);

    ec = ud->ddt->GetQueryPoolResults(device, query_pool, first, count, size, data, stride, flags);
    if(ec)
        {
        Free(L, data);
        CheckError(L, ec);
        return 0;
        }
    lua_pushlstring(L, data, size);
    Free(L, data);
    return 1;
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movl $0x1, %esi
leaq 0x48(%rsp), %rdx
leaq 0x6f870(%rip), %rcx     # 0xcfa0f
callq 0x1a640
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x58(%rsp), %rdi
movl $0x2, %esi
callq 0x19190
movl %eax, 0x34(%rsp)
movq 0x58(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movl %eax, 0x30(%rsp)
movq 0x58(%rsp), %rdi
movl $0x4, %esi
callq 0x19190
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdi
movl $0x5, %esi
callq 0x19190
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
movl $0x6, %esi
callq 0x19010
movl %eax, 0x1c(%rsp)
movq 0x58(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x192c0
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x100(%rax), %rax
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl 0x34(%rsp), %edx
movl 0x30(%rsp), %ecx
movq 0x28(%rsp), %r8
movq 0x10(%rsp), %r9
movq 0x20(%rsp), %r11
movl 0x1c(%rsp), %r10d
movq %r11, (%rsp)
movl %r10d, 0x8(%rsp)
callq *%rax
movl %eax, 0x54(%rsp)
cmpl $0x0, 0x54(%rsp)
je 0x602ba
movq 0x58(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x18300
cmpl $0x0, 0x54(%rsp)
je 0x602ae
movq 0x58(%rsp), %rdi
movl 0x54(%rsp), %edx
xorl %esi, %esi
callq 0x18a00
movq 0x58(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x64(%rsp)
jmp 0x602e5
jmp 0x602b0
movl $0x0, 0x64(%rsp)
jmp 0x602e5
movq 0x58(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x19860
movq 0x58(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x18300
movl $0x1, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/query_pool.c
// Function: ResetQueryPool
static int ResetQueryPool(lua_State *L)
    {
    ud_t *ud;
    VkQueryPool query_pool  = checkquery_pool(L, 1, &ud);
    VkDevice device = ud->device;
    uint32_t first = luaL_checkinteger(L, 2);
    uint32_t count = luaL_checkinteger(L, 3);
    CheckDevicePfn(L, ud, ResetQueryPool);
    ud->ddt->ResetQueryPool(device, query_pool, first, count);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x20(%rsp), %rdx
leaq 0x6f700(%rip), %rcx     # 0xcfa0f
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
callq 0x19190
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movl $0x3, %esi
callq 0x19190
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x608(%rax)
jne 0x60379
movq 0x28(%rsp), %rdi
leaq 0x82af7(%rip), %rsi     # 0xe2e63
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x34(%rsp)
jmp 0x603a7
jmp 0x6037b
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x608(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
callq *%rax
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: stetre[P]moonvulkan/src/query_pool.c
// Function: freequery_pool
static int freequery_pool(lua_State *L, ud_t *ud)
    {
    VkQueryPool query_pool = (VkQueryPool)ud->handle;
    const VkAllocationCallbacks *allocator = ud->allocator;
    VkDevice device = ud->device;

    if(!freeuserdata(L, ud))
        return 0; /* double call */
    TRACE_DELETE(query_pool, "query_pool");
    UD(device)->ddt->DestroyQueryPool(device, query_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 0x40(%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 0x60405
movl $0x0, 0x34(%rsp)
jmp 0x60456
jmp 0x60407
movq 0x9cb8a(%rip), %rax     # 0xfcf98
cmpl $0x0, (%rax)
je 0x60426
movq 0x18(%rsp), %rsi
leaq 0x82a28(%rip), %rdi     # 0xe2e47
movb $0x0, %al
callq 0x189d0
jmp 0x60428
movq 0x8(%rsp), %rdi
callq 0x19fd0
movq 0x50(%rax), %rax
movq 0xf8(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq *%rax
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/queue.c
// Function: moonvulkan_pushqueue
int pushqueue(lua_State *L, VkQueue queue, VkDevice device)
    { 
    ud_t *ud = UD(queue);
    if(!ud)
        {
        /* create the userdata associated with this object */
        ud = newuserdata_dispatchable(L, queue, QUEUE_MT);
        ud->parent_ud = UD(device);
        ud->instance = UD(device)->instance;
        ud->device = device;
        ud->destructor = freequeue;
        ud->ddt = UD(device)->ddt;
        TRACE_CREATE(queue, "queue");
        return 1;
        }
    return pushuserdata(L, ud);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x19fd0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x60533
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x70503(%rip), %rdx     # 0xd09a0
movl $0x1, %ecx
callq 0x18350
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x19fd0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rdi
callq 0x19fd0
movq 0x18(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
leaq 0x62(%rip), %rcx        # 0x60550
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rdi
callq 0x19fd0
movq 0x50(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x9ca89(%rip), %rax     # 0xfcf98
cmpl $0x0, (%rax)
je 0x60527
movq 0x10(%rsp), %rsi
leaq 0x82967(%rip), %rdi     # 0xe2e87
movb $0x0, %al
callq 0x189d0
jmp 0x60529
movl $0x1, 0x24(%rsp)
jmp 0x60545
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0x196b0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: stetre[P]moonvulkan/src/queue.c
// Function: freequeue
static int freequeue(lua_State *L, ud_t *ud)
    {
    VkQueue queue = (VkQueue)(uintptr_t)ud->handle;
    if(!freeuserdata(L, ud))
        return 0; /* double call */
    TRACE_DELETE(queue, "queue");
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x18dc0
cmpl $0x0, %eax
jne 0x60589
movl $0x0, 0x24(%rsp)
jmp 0x605b4
jmp 0x6058b
movq 0x9ca06(%rip), %rax     # 0xfcf98
cmpl $0x0, (%rax)
je 0x605aa
movq 0x8(%rsp), %rsi
leaq 0x828fb(%rip), %rdi     # 0xe2e9e
movb $0x0, %al
callq 0x189d0
jmp 0x605ac
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/queue.c
// Function: QueueWaitIdle
static int QueueWaitIdle(lua_State *L)
    {
    ud_t *ud;
    VkQueue queue = checkqueue(L, 1, &ud);
    VkResult ec = ud->ddt->QueueWaitIdle(queue);
    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 0x70191(%rip), %rcx     # 0xd09a0
callq 0x1a640
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x60858
movq 0x18(%rsp), %rdi
movl 0x4(%rsp), %edx
xorl %esi, %esi
callq 0x18a00
movq 0x18(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x24(%rsp)
jmp 0x60862
jmp 0x6085a
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: stetre[P]moonvulkan/src/queue.c
// Function: QueueSubmit
static int QueueSubmit(lua_State *L)
    {
    int err;
    uint32_t count;
    VkResult ec;
    ud_t *ud;
    VkSubmitInfo* submits;
    VkQueue queue = checkqueue(L, 1, &ud);
    VkFence fence = testfence(L, 3, NULL);
#define CLEANUP zfreearrayVkSubmitInfo(L, submits, count, 1)
    submits = zcheckarrayVkSubmitInfo(L, 2, &count, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ec = ud->ddt->QueueSubmit(queue, count, submits, fence);
    CLEANUP;
    CheckError(L, ec);
#undef CLEANUP
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x20(%rsp), %rdx
leaq 0x70111(%rip), %rcx     # 0xd09a0
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x706b5(%rip), %rcx     # 0xd0f63
callq 0x1a5f0
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x30(%rsp), %rdx
leaq 0x34(%rsp), %rcx
callq 0x1a410
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x6092e
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x30(%rsp), %ecx
movl $0x48, %edx
movl $0x1, %r8d
callq 0x198d0
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 0x609a3
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0x30(%rsp), %esi
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq *%rax
movl %eax, 0x2c(%rsp)
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x30(%rsp), %ecx
movl $0x48, %edx
movl $0x1, %r8d
callq 0x198d0
cmpl $0x0, 0x2c(%rsp)
je 0x60999
movq 0x38(%rsp), %rdi
movl 0x2c(%rsp), %edx
xorl %esi, %esi
callq 0x18a00
movq 0x38(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x44(%rsp)
jmp 0x609a3
jmp 0x6099b
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: stetre[P]moonvulkan/src/queue.c
// Function: QueueSubmit2
static int QueueSubmit2(lua_State *L)
    {
    int err;
    uint32_t count;
    VkResult ec;
    ud_t *ud;
    VkSubmitInfo2KHR* submits;
    VkQueue queue = checkqueue(L, 1, &ud);
    VkFence fence = testfence(L, 3, NULL);
    CheckDevicePfn(L, ud, QueueSubmit2KHR);
#define CLEANUP zfreearrayVkSubmitInfo2KHR(L, submits, count, 1)
    submits = zcheckarrayVkSubmitInfo2KHR(L, 2, &count, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ec = ud->ddt->QueueSubmit2KHR(queue, count, submits, fence);
    CLEANUP;
    CheckError(L, ec);
#undef CLEANUP
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x20(%rsp), %rdx
leaq 0x6ffd1(%rip), %rcx     # 0xd09a0
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x70575(%rip), %rcx     # 0xd0f63
callq 0x1a5f0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
cmpq $0x0, 0x698(%rax)
jne 0x60a27
movq 0x38(%rsp), %rdi
leaq 0x824db(%rip), %rsi     # 0xe2ef2
movb $0x0, %al
callq 0x19ce0
movl %eax, 0x44(%rsp)
jmp 0x60b17
jmp 0x60a29
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x30(%rsp), %rdx
leaq 0x34(%rsp), %rcx
callq 0x18710
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x60a9f
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x30(%rsp), %ecx
movl $0x40, %edx
movl $0x1, %r8d
callq 0x198d0
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 0x60b17
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x698(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0x30(%rsp), %esi
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq *%rax
movl %eax, 0x2c(%rsp)
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x30(%rsp), %ecx
movl $0x40, %edx
movl $0x1, %r8d
callq 0x198d0
cmpl $0x0, 0x2c(%rsp)
je 0x60b0d
movq 0x38(%rsp), %rdi
movl 0x2c(%rsp), %edx
xorl %esi, %esi
callq 0x18a00
movq 0x38(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x44(%rsp)
jmp 0x60b17
jmp 0x60b0f
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq