LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/style.c
// Function: Style_set_color
static int Style_set_color(lua_State *L)
    {
    nk_color_t value;
    nk_color_t *address = NULL;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    if(echeckcolor(L, 3, &value)) return argerror(L, 3);
    address = address_color(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    *address = value;
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xe4d9(%rip), %rcx      # 0xa7280
callq 0x130f0
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x14470
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
leaq 0x34(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x98e17
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl $0x3, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x98e71
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x9be20
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x98e5e
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x14d10
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x98e71
movq 0x28(%rsp), %rax
movl 0x34(%rsp), %ecx
movl %ecx, (%rax)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/style.c
// Function: Style_get_color
static int Style_get_color(lua_State *L)
    {
    nk_color_t *address = NULL;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    address = address_color(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    pushcolor(L, address);
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xe3d9(%rip), %rcx      # 0xa7280
callq 0x130f0
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x14470
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x9be20
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x98f10
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x14d10
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x34(%rsp)
jmp 0x98f27
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x14a50
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/style.c
// Function: Style_push_style_item
static int Style_push_style_item(lua_State *L)
    {
    nk_style_item_t *address = NULL;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    nk_style_item_t value = checkstyleitem(L, 3);
    address = address_styleitem(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    lua_pushboolean(L, nk_style_push_style_item(context, address, value));
    return 1;
    }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq $0x0, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xe326(%rip), %rcx      # 0xa7280
callq 0x130f0
movq %rax, 0x68(%rsp)
movq 0x78(%rsp), %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x14470
movl %eax, 0x64(%rsp)
movq 0x78(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movl $0x3, %edx
callq 0x14610
movq 0x68(%rsp), %rdi
movl 0x64(%rsp), %esi
callq 0x9d750
movq %rax, 0x70(%rsp)
cmpq $0x0, 0x70(%rsp)
jne 0x98fda
movq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x14d10
movq 0x30(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x84(%rsp)
jmp 0x99027
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x58(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups 0x38(%rsp), %xmm0
movups 0x48(%rsp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x14dc0
movq 0x28(%rsp), %rdi
movl %eax, %esi
callq 0x143e0
movl $0x1, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/style.c
// Function: Style_set_style_item
static int Style_set_style_item(lua_State *L)
    {
    nk_style_item_t *address = NULL;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    nk_style_item_t value = checkstyleitem(L, 3);
    address = address_styleitem(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    *address = value;
    return 0;
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xe1c9(%rip), %rcx      # 0xa7280
callq 0x130f0
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x14470
movl %eax, 0x34(%rsp)
movq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdi
movl $0x3, %edx
callq 0x14610
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x9d750
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x99132
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x14d10
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x54(%rsp)
jmp 0x9914e
movq 0x40(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x28, %edx
callq 0x14160
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/style.c
// Function: Style_set_boolean
static int Style_set_boolean(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    int value = checkboolean(L, 3);
    int *address = address_boolean(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    *address = value;
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xe052(%rip), %rcx      # 0xa7280
callq 0x130f0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x14470
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movl $0x3, %esi
callq 0x14990
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x9e7d0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x992aa
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x14d10
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x34(%rsp)
jmp 0x992bd
movl 0x18(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/style.c
// Function: Style_get_boolean
static int Style_get_boolean(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    int *address = address_boolean(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    lua_pushboolean(L, *address);
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xdf92(%rip), %rcx      # 0xa7280
callq 0x130f0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x14470
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x9e7d0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x99357
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x14d10
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x34(%rsp)
jmp 0x99370
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %esi
callq 0x143e0
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/style.c
// Function: Style_set_symboltype
static int Style_set_symboltype(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    enum nk_symbol_type value = checksymboltype(L, 3);
    enum nk_symbol_type *address = address_symboltype(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    *address = value;
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xdee2(%rip), %rcx      # 0xa7280
callq 0x130f0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x14470
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movl $0xe, %esi
movl $0x3, %edx
callq 0x14470
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x9e8a0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x9941f
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x14d10
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x34(%rsp)
jmp 0x99432
movl 0x18(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/style.c
// Function: Style_get_symboltype
static int Style_get_symboltype(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nonnk_style what = checkstylefield(L, 2);
    enum nk_symbol_type *address = address_symboltype(context, what);
    if(!address) return argerrorc(L, 2, ERR_VALUE);
    pushsymboltype(L, *address);
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xde22(%rip), %rcx      # 0xa7280
callq 0x130f0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl $0x65, %esi
movl $0x2, %edx
callq 0x14470
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x9e8a0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x994c7
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x14d10
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x34(%rsp)
jmp 0x994e5
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %edx
movl $0xe, %esi
callq 0x13660
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/style.c
// Function: address_boolean
static int* address_boolean(nk_context_t *context, enum nonnk_style what)
    {
    switch(what)
        { 
        CASE_NONNK_STYLE_BOOL
        default: return NULL;
        }
    return NULL;
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movl -0x14(%rsp), %eax
movl %eax, -0x18(%rsp)
subl $0x84, %eax
je 0x9e811
jmp 0x9e7ea
movl -0x18(%rsp), %eax
subl $0xcf, %eax
je 0x9e82f
jmp 0x9e7f7
movl -0x18(%rsp), %eax
subl $0xe4, %eax
je 0x9e84d
jmp 0x9e804
movl -0x18(%rsp), %eax
subl $0x15c, %eax            # imm = 0x15C
je 0x9e86b
jmp 0x9e88f
movq -0x10(%rsp), %rax
addq $0x168, %rax            # imm = 0x168
addq $0x680, %rax            # imm = 0x680
addq $0x134, %rax            # imm = 0x134
movq %rax, -0x8(%rsp)
jmp 0x9e898
movq -0x10(%rsp), %rax
addq $0x168, %rax            # imm = 0x168
addq $0x1510, %rax           # imm = 0x1510
addq $0x11c, %rax            # imm = 0x11C
movq %rax, -0x8(%rsp)
jmp 0x9e898
movq -0x10(%rsp), %rax
addq $0x168, %rax            # imm = 0x168
addq $0x1800, %rax           # imm = 0x1800
addq $0x11c, %rax            # imm = 0x11C
movq %rax, -0x8(%rsp)
jmp 0x9e898
movq -0x10(%rsp), %rax
addq $0x168, %rax            # imm = 0x168
addq $0x10f8, %rax           # imm = 0x10F8
addq $0x80, %rax
addq $0x11c, %rax            # imm = 0x11C
movq %rax, -0x8(%rsp)
jmp 0x9e898
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/tracing.c
// Function: Type
static int Type(lua_State *L)
    {
#define TRY(xxx) do { if(test##xxx(L, 1, NULL) != 0) { lua_pushstring(L, ""#xxx); return 1; } } while(0)
    TRY(context);
    TRY(atlas);
    TRY(font);
    TRY(image);
    TRY(cursor);
    TRY(buffer);
    TRY(edit);
    TRY(panel);
    TRY(canvas);
    return 0;
#undef TRY
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8602(%rip), %rcx      # 0xa7280
callq 0x15450
cmpq $0x0, %rax
je 0x9eca7
movq 0x8(%rsp), %rdi
leaq 0x8740(%rip), %rsi      # 0xa73d5
callq 0x15240
movl $0x1, 0x14(%rsp)
jmp 0x9eebb
jmp 0x9eca9
jmp 0x9ecab
movq 0x8(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8340(%rip), %rcx      # 0xa7000
callq 0x15450
cmpq $0x0, %rax
je 0x9ece9
movq 0x8(%rsp), %rdi
leaq 0x8335(%rip), %rsi      # 0xa700c
callq 0x15240
movl $0x1, 0x14(%rsp)
jmp 0x9eebb
jmp 0x9eceb
jmp 0x9eced
movq 0x8(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x83af(%rip), %rcx      # 0xa70b1
callq 0x15450
cmpq $0x0, %rax
je 0x9ed2b
movq 0x8(%rsp), %rdi
leaq 0x128ab(%rip), %rsi     # 0xb15c4
callq 0x15240
movl $0x1, 0x14(%rsp)
jmp 0x9eebb
jmp 0x9ed2d
jmp 0x9ed2f
movq 0x8(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8500(%rip), %rcx      # 0xa7244
callq 0x15450
cmpq $0x0, %rax
je 0x9ed6d
movq 0x8(%rsp), %rdi
leaq 0x84f5(%rip), %rsi      # 0xa7250
callq 0x15240
movl $0x1, 0x14(%rsp)
jmp 0x9eebb
jmp 0x9ed6f
jmp 0x9ed71
movq 0x8(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x833c(%rip), %rcx      # 0xa70c2
callq 0x15450
cmpq $0x0, %rax
je 0x9edaf
movq 0x8(%rsp), %rdi
leaq 0xe162(%rip), %rsi      # 0xaceff
callq 0x15240
movl $0x1, 0x14(%rsp)
jmp 0x9eebb
jmp 0x9edb1
jmp 0x9edb3
movq 0x8(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x830d(%rip), %rcx      # 0xa70d5
callq 0x15450
cmpq $0x0, %rax
je 0x9edf1
movq 0x8(%rsp), %rdi
leaq 0x8320(%rip), %rsi      # 0xa70ff
callq 0x15240
movl $0x1, 0x14(%rsp)
jmp 0x9eebb
jmp 0x9edf3
jmp 0x9edf5
movq 0x8(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x85e5(%rip), %rcx      # 0xa73ef
callq 0x15450
cmpq $0x0, %rax
je 0x9ee33
movq 0x8(%rsp), %rdi
leaq 0x85da(%rip), %rsi      # 0xa73fb
callq 0x15240
movl $0x1, 0x14(%rsp)
jmp 0x9eebb
jmp 0x9ee35
jmp 0x9ee37
movq 0x8(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8591(%rip), %rcx      # 0xa73dd
callq 0x15450
cmpq $0x0, %rax
je 0x9ee72
movq 0x8(%rsp), %rdi
leaq 0x8586(%rip), %rsi      # 0xa73e9
callq 0x15240
movl $0x1, 0x14(%rsp)
jmp 0x9eebb
jmp 0x9ee74
jmp 0x9ee76
movq 0x8(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x82b7(%rip), %rcx      # 0xa7142
callq 0x15450
cmpq $0x0, %rax
je 0x9eeb1
movq 0x8(%rsp), %rdi
leaq 0x82ac(%rip), %rsi      # 0xa714e
callq 0x15240
movl $0x1, 0x14(%rsp)
jmp 0x9eebb
jmp 0x9eeb3
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/udata.c
// Function: moonnuklear_udata_unref
int udata_unref(lua_State *L, uint64_t id)
/* unreference udata so that it will be garbage collected */
    {
//  printf("unref object %lu\n", id);
    udata_t *udata = udata_search(id);
    if(!udata) 
        return luaL_error(L, "invalid object identifier %p", (void*)id);
    if(udata->ref != LUA_NOREF)
        {
        luaL_unref(L, LUA_REGISTRYINDEX, udata->ref);
        udata->ref = LUA_NOREF;
        }
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x9f0c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x9f193
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x160da(%rip), %rsi     # 0xb5260
movb $0x0, %al
callq 0x14bf0
movl %eax, 0x24(%rsp)
jmp 0x9f1c9
movq 0x8(%rsp), %rax
cmpl $-0x2, 0x28(%rax)
je 0x9f1c1
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x28(%rax), %edx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x15200
movq 0x8(%rsp), %rax
movl $0xfffffffe, 0x28(%rax) # imm = 0xFFFFFFFE
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/udata.c
// Function: moonnuklear_udata_free
int udata_free(lua_State *L, uint64_t id)
/* this should be called in the __gc metamethod
 */
    {
    udata_t *udata = udata_search(id);
//  printf("free object %lu\n", id);
    if(!udata) 
        return luaL_error(L, "invalid object identifier %p", (void*)id);
    /* release all references */
    if(udata->ref != LUA_NOREF)
        luaL_unref(L, LUA_REGISTRYINDEX, udata->ref);
    udata_remove(udata);
    Free(L, udata);
    /* mem is released by Lua at garbage collection */
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x9f0c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x9f223
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x1604a(%rip), %rsi     # 0xb5260
movb $0x0, %al
callq 0x14bf0
movl %eax, 0x24(%rsp)
jmp 0x9f266
movq 0x8(%rsp), %rax
cmpl $-0x2, 0x28(%rax)
je 0x9f245
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x28(%rax), %edx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x15200
movq 0x8(%rsp), %rdi
callq 0x9f270
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14230
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/udata.c
// Function: moonnuklear_udata_push
int udata_push(lua_State *L, uint64_t id)
    {
    udata_t *udata = udata_search(id);
    if(!udata) 
        return luaL_error(L, "invalid object identifier %p", (void*)id);
    if(udata->ref == LUA_NOREF)
        return luaL_error(L, "unreferenced object");
    if(lua_rawgeti(L, LUA_REGISTRYINDEX, udata->ref) != LUA_TUSERDATA)
        return luaL_error(L, UNEXPECTED_ERROR);
    return 1; /* one value pushed */
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x9f0c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x9f2d3
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x15f9a(%rip), %rsi     # 0xb5260
movb $0x0, %al
callq 0x14bf0
movl %eax, 0x24(%rsp)
jmp 0x9f341
movq 0x8(%rsp), %rax
cmpl $-0x2, 0x28(%rax)
jne 0x9f2f7
movq 0x18(%rsp), %rdi
leaq 0x15f93(%rip), %rsi     # 0xb527d
movb $0x0, %al
callq 0x14bf0
movl %eax, 0x24(%rsp)
jmp 0x9f341
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq 0x28(%rax), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x13a30
cmpl $0x7, %eax
je 0x9f339
movq 0x18(%rsp), %rdi
leaq 0x7dff(%rip), %rsi      # 0xa711f
leaq 0x15f6a(%rip), %rdx     # 0xb5291
movl $0xa3, %ecx
movb $0x0, %al
callq 0x14bf0
movl %eax, 0x24(%rsp)
jmp 0x9f341
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/udata.c
// Function: moonnuklear_udata_free_all
void udata_free_all(lua_State *L)
/* free all without unreferencing (for atexit()) */
    {
    udata_t *udata;
    while((udata = udata_first(0)))
        {
        udata_remove(udata);
        Free(L, udata);
        }
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x9f390
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x9f388
movq 0x8(%rsp), %rdi
callq 0x9f270
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14230
jmp 0x9f359
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/udata.c
// Function: moonnuklear_udata_scan
int udata_scan(lua_State *L, const char *mt,  
            void *info, int (*func)(lua_State *L, const void *mem, const char* mt, const void *info))
/* scans the udata database, and calls the func callback for every 'mt' object found
 * (the object may be deleted in the callback).
 * func must return 0 to continue the scan, !=0 to interrupt it.
 * returns 1 if interrupted, 0 otherwise
 */
    {
    int stop = 0;
    uint64_t id = 0;
    udata_t *udata;
    while((udata = udata_first(id)))
        {
        id = udata->id + 1;
        if(mt == udata->mt)
            {
            stop = func(L, (const void*)(udata->mem), mt, info);
            if(stop) return 1;
            }
        }
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x9f390
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x9f458
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jne 0x9f456
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rcx
movq 0x30(%rcx), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq *%rax
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x9f454
movl $0x1, 0x44(%rsp)
jmp 0x9f460
jmp 0x9f456
jmp 0x9f3e9
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/udata.c
// Function: moonnuklear_udata_test
void *udata_test(lua_State *L, int arg, const char *mt)
/* same as luaL_testudata(), but succeeds also if the userdata has not
 * mt as metatable but as ancestor
 */ 
    {
    void *mem;
    int ok;
    if((mem = luaL_testudata(L, arg, mt)))
        return mem;
    
    if((mem = lua_touserdata(L, arg)) == NULL)
        return NULL;

    if(luaL_getmetatable(L, mt)!=LUA_TTABLE)
        { luaL_error(L, "cannot find metatable '%s'", mt); return NULL; }
    ok = is_subclass(L, arg, lua_gettop(L));
    lua_pop(L, 1);
    return ok ? mem : NULL;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x28(%rsp), %rdx
callq 0x144f0
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x9f4af
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x9f577
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x133f0
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
jne 0x9f4d6
movq $0x0, 0x40(%rsp)
jmp 0x9f577
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x15310
cmpl $0x5, %eax
je 0x9f512
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rdx
leaq 0x15d99(%rip), %rsi     # 0xb5299
movb $0x0, %al
callq 0x14bf0
movq $0x0, 0x40(%rsp)
jmp 0x9f577
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x13110
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %esi
movl %eax, %edx
callq 0x9f590
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
cmpl $0x0, 0x1c(%rsp)
je 0x9f564
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x9f56d
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x9f56d
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/udata.c
// Function: is_subclass
static int is_subclass(lua_State *L, int arg, int mt_index)
    {
    int ok;
    if(luaL_getmetafield(L, arg, "__index") == LUA_TNIL)
        return 0;
    if(lua_rawequal(L, mt_index, lua_gettop(L)))
        {
        lua_pop(L, 1);
        return 1;
        }
    ok = is_subclass(L, lua_gettop(L), mt_index);
    lua_pop(L, 1);
    return ok;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
leaq 0x15d20(%rip), %rdx     # 0xb52d1
callq 0x14aa0
cmpl $0x0, %eax
jne 0x9f5c8
movl $0x0, 0x34(%rsp)
jmp 0x9f651
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x13110
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %esi
movl %eax, %edx
callq 0x14940
cmpl $0x0, %eax
je 0x9f612
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
movl $0x1, 0x34(%rsp)
jmp 0x9f651
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x13110
movq 0x8(%rsp), %rdi
movl %eax, %esi
movl 0x20(%rsp), %edx
callq 0x9f590
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/udata.c
// Function: moonnuklear_udata_define
int udata_define(lua_State *L, const char* mt, const luaL_Reg* methods, const luaL_Reg* metamethods)
    {
    /* create the metatable */
    if(!luaL_newmetatable(L, mt))
        return luaL_error(L, "cannot create metatable '%s'", mt);
    lua_pushvalue(L, -1);
    lua_setfield(L, -2, "__index");
    if(metamethods)
        /* add metamethods */
        luaL_setfuncs(L, metamethods, 0);
    if(methods)
        {
        /* add methods */
        luaL_getsubtable(L, -1, "__index");
        luaL_setfuncs(L, methods, 0);
        lua_pop(L, 1);
        }
    lua_pop(L, 1);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x15180
cmpl $0x0, %eax
jne 0x9f6ac
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x15c18(%rip), %rsi     # 0xb52b4
movb $0x0, %al
callq 0x14bf0
movl %eax, 0x24(%rsp)
jmp 0x9f73d
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x13eb0
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x15c05(%rip), %rdx     # 0xb52d1
callq 0x13b80
cmpq $0x0, (%rsp)
je 0x9f6e8
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq 0x13410
cmpq $0x0, 0x8(%rsp)
je 0x9f726
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x15bd0(%rip), %rdx     # 0xb52d1
callq 0x13da0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x13410
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/udata.c
// Function: moonnuklear_udata_inherit
int udata_inherit(lua_State *L, const char *sub, const char *super)
/* Sets  metatable(sub).__index = metatable(super)
 *
 * This way, if one accesses a field/method of a 'sub' object which is not defined in
 * the 'sub' metatable, Lua searches for it in the 'super' metatable (i.e., the 'sub'
 * type inherits from 'super').
 */
    {
    if(luaL_getmetatable(L, sub)!=LUA_TTABLE)
        return luaL_error(L, "cannot find metatable '%s'", sub);
    luaL_getsubtable(L, -1, "__index");
    if(luaL_getmetatable(L, super)!=LUA_TTABLE)
        return luaL_error(L, "cannot find metatable '%s'", super);
    lua_setmetatable(L, -2);
    lua_pop(L, 2);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x15310
cmpl $0x5, %eax
je 0x9f79a
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x15b0c(%rip), %rsi     # 0xb5299
movb $0x0, %al
callq 0x14bf0
movl %eax, 0x24(%rsp)
jmp 0x9f80d
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x15b26(%rip), %rdx     # 0xb52d1
callq 0x13da0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x15310
cmpl $0x5, %eax
je 0x9f7e7
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x15abf(%rip), %rsi     # 0xb5299
movb $0x0, %al
callq 0x14bf0
movl %eax, 0x24(%rsp)
jmp 0x9f80d
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x14080
movq 0x18(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x131a0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/udata.c
// Function: moonnuklear_udata_addmethods
int udata_addmethods(lua_State *L, const char* mt, const luaL_Reg* methods)
/* Adds methods to the metatable mt */
    {
    if(luaL_getmetatable(L, mt)!=LUA_TTABLE)
        return luaL_error(L, "cannot find metatable '%s'", mt);
    if(methods)
        {
        /* add methods */
        luaL_getsubtable(L, -1, "__index");
        luaL_setfuncs(L, methods, 0);
        lua_pop(L, 1);
        }
    lua_pop(L, 1);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x15310
cmpl $0x5, %eax
je 0x9f86a
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x15a3c(%rip), %rsi     # 0xb5299
movb $0x0, %al
callq 0x14bf0
movl %eax, 0x24(%rsp)
jmp 0x9f8bf
cmpq $0x0, 0x8(%rsp)
je 0x9f8a8
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x15a4e(%rip), %rdx     # 0xb52d1
callq 0x13da0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x13410
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_Malloc
void *Malloc(lua_State *L, size_t size)
    {
    void *ptr;
    if(size == 0)
        { luaL_error(L, errstring(ERR_MALLOC_ZERO)); return NULL; }
    ptr = Malloc_(size);
    if(ptr==NULL)
        { luaL_error(L, errstring(ERR_MEMORY)); return NULL; }
    memset(ptr, 0, size);
    //DBG("Malloc %p\n", ptr);
    return ptr;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xa0b54
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0xfffffff9, %edi       # imm = 0xFFFFFFF9
callq 0x14d10
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x14bf0
movq $0x0, 0x30(%rsp)
jmp 0xa0bb4
movq 0x20(%rsp), %rdi
callq 0xa0d00
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xa0b99
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xfffffffa, %edi       # imm = 0xFFFFFFFA
callq 0x14d10
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x14bf0
movq $0x0, 0x30(%rsp)
jmp 0xa0bb4
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
xorl %esi, %esi
callq 0x13c40
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_errstring
const char* errstring(int err)
    {
    switch(err)
        {
        case 0: return "success";
        case ERR_GENERIC: return "generic error";
        case ERR_TABLE: return "not a table";
        case ERR_EMPTY: return "empty list";
        case ERR_TYPE: return "invalid type";
        case ERR_VALUE: return "invalid value";
        case ERR_NOTPRESENT: return "missing";
        case ERR_MEMORY: return "out of memory";
        case ERR_MALLOC_ZERO: return "zero bytes malloc";
        case ERR_LENGTH: return "invalid length";
        case ERR_POOL: return "elements are not from the same pool";
        case ERR_BOUNDARIES: return "invalid boundaries";
        case ERR_UNKNOWN: return "unknown field name";
        case ERR_FAILED: return "operation failed";
        case ERR_COUNT: return "invalid no. of items";
        case ERR_RANGE: return "out of range";
        default:
            return "???";
        }
    return NULL; /* unreachable */
    }

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
addl $0xe, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rsp)
subl $0xf, %eax
ja 0xa0ce5
movq -0x18(%rsp), %rax
leaq 0x146f5(%rip), %rcx     # 0xb52dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xc1c8(%rip), %rax      # 0xacdbf
movq %rax, -0x8(%rsp)
jmp 0xa0cf1
leaq 0x14799(%rip), %rax     # 0xb53a1
movq %rax, -0x8(%rsp)
jmp 0xa0cf1
leaq 0x14796(%rip), %rax     # 0xb53af
movq %rax, -0x8(%rsp)
jmp 0xa0cf1
leaq 0x14791(%rip), %rax     # 0xb53bb
movq %rax, -0x8(%rsp)
jmp 0xa0cf1
leaq 0x1478b(%rip), %rax     # 0xb53c6
movq %rax, -0x8(%rsp)
jmp 0xa0cf1
leaq 0x14787(%rip), %rax     # 0xb53d3
movq %rax, -0x8(%rsp)
jmp 0xa0cf1
leaq 0x14784(%rip), %rax     # 0xb53e1
movq %rax, -0x8(%rsp)
jmp 0xa0cf1
leaq 0x1477b(%rip), %rax     # 0xb53e9
movq %rax, -0x8(%rsp)
jmp 0xa0cf1
leaq 0x1477b(%rip), %rax     # 0xb53f7
movq %rax, -0x8(%rsp)
jmp 0xa0cf1
leaq 0x1477f(%rip), %rax     # 0xb5409
movq %rax, -0x8(%rsp)
jmp 0xa0cf1
leaq 0x14780(%rip), %rax     # 0xb5418
movq %rax, -0x8(%rsp)
jmp 0xa0cf1
leaq 0x14796(%rip), %rax     # 0xb543c
movq %rax, -0x8(%rsp)
jmp 0xa0cf1
leaq 0x1479b(%rip), %rax     # 0xb544f
movq %rax, -0x8(%rsp)
jmp 0xa0cf1
leaq 0x147a0(%rip), %rax     # 0xb5462
movq %rax, -0x8(%rsp)
jmp 0xa0cf1
leaq 0x147a3(%rip), %rax     # 0xb5473
movq %rax, -0x8(%rsp)
jmp 0xa0cf1
leaq 0x147aa(%rip), %rax     # 0xb5488
movq %rax, -0x8(%rsp)
jmp 0xa0cf1
leaq 0x147a9(%rip), %rax     # 0xb5495
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_MallocNoErr
void *MallocNoErr(lua_State *L, size_t size) /* do not raise errors (check the retval) */
    {
    void *ptr = Malloc_(size);
    (void)L;
    if(ptr==NULL)
        return NULL;
    memset(ptr, 0, size);
    //DBG("MallocNoErr %p\n", ptr);
    return ptr;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xa0d00
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xa0d80
movq $0x0, 0x20(%rsp)
jmp 0xa0d9b
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
xorl %esi, %esi
callq 0x13c40
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_Strdup
char *Strdup(lua_State *L, const char *s)
    {
    size_t len = strnlen(s, 256);
    char *ptr = (char*)Malloc(L, len + 1);
    if(len>0)
        memcpy(ptr, s, len);
    ptr[len]='\0';
    return ptr;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x13cd0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0x14c40
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jbe 0xa0e06
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x14160
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_checklightuserdataorzero
void *checklightuserdataorzero(lua_State *L, int arg)
    {
    int val, isnum;
    val = lua_tointegerx(L, arg, &isnum);
    if(!isnum)
        return checklightuserdata(L, arg);
    if(val != 0)
        luaL_argerror(L, arg, "expected lightuserdata or 0");
    return NULL;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
leaq 0xc(%rsp), %rdx
callq 0x13670
movl %eax, 0x10(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0xa0f70
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x14a30
movq %rax, 0x20(%rsp)
jmp 0xa0f95
cmpl $0x0, 0x10(%rsp)
je 0xa0f8c
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
leaq 0x143d6(%rip), %rdx     # 0xb535d
callq 0x134c0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_testboolean
int testboolean(lua_State *L, int arg, int *err)
    {
    if(!lua_isboolean(L, arg))
        { *err = ERR_TYPE; return 0; }
    *err = 0;
    return lua_toboolean(L, arg); // ? nk_true : nk_false;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x15090
cmpl $0x1, %eax
je 0xa103a
movq 0x8(%rsp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
movl $0x0, 0x24(%rsp)
jmp 0xa1057
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x13320
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_testindex
int testindex(lua_State *L, int arg, int *err)
    {
    int val;
    if(!lua_isinteger(L, arg))
        { *err = ERR_TYPE; return 0; }
    val = lua_tointeger(L, arg);
    if(val < 1)
        { *err = ERR_GENERIC; return 0; }
    *err = 0;
    return val - 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x15470
cmpl $0x0, %eax
jne 0xa10ea
movq 0x8(%rsp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
movl $0x0, 0x24(%rsp)
jmp 0xa1132
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x13670
movl %eax, 0x4(%rsp)
cmpl $0x1, 0x4(%rsp)
jge 0xa111c
movq 0x8(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x0, 0x24(%rsp)
jmp 0xa1132
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
movl 0x4(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_checkindex
int checkindex(lua_State *L, int arg)
    {
    int val = luaL_checkinteger(L, arg);
    if(val < 1)
        return luaL_argerror(L, arg, "expected 1-based index");
    return val - 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x14070
movl %eax, (%rsp)
cmpl $0x1, (%rsp)
jge 0xa117f
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
leaq 0x14216(%rip), %rdx     # 0xb538a
callq 0x134c0
movl %eax, 0x14(%rsp)
jmp 0xa1189
movl (%rsp), %eax
subl $0x1, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_optindex
int optindex(lua_State *L, int arg, int optval /* 0-based */)
    {
    int val = luaL_optinteger(L, arg, optval + 1);
    if(val < 1)
        return luaL_argerror(L, arg, "expected 1-based index");
    return val - 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x14490
movl %eax, 0xc(%rsp)
cmpl $0x1, 0xc(%rsp)
jge 0xa11ef
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
leaq 0x141a6(%rip), %rdx     # 0xb538a
callq 0x134c0
movl %eax, 0x24(%rsp)
jmp 0xa11fa
movl 0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_freestringlist
void freestringlist(lua_State *L, char** list, int count)
    {
    int i;
    if(!list)
        return;
    for(i=0; i<count; i++)
        Free(L, list[i]);
    Free(L, list);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xa144c
jmp 0xa148d
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0xa147e
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x14230
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0xa1453
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14230
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_pushstringlist
void pushstringlist(lua_State *L, char** list, int count)
    {
    int i;
    lua_newtable(L);
    for(i=0; i<count; i++)
        {
        lua_pushstring(L, list[i]);
        lua_rawseti(L, -2, i+1);
        }
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x138b0
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0xa150a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x15240
movq 0x10(%rsp), %rdi
movl (%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x140e0
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0xa14c7
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_checkfloatlist
float* checkfloatlist(lua_State *L, int arg, int *count, int *err)
    {
    float* list;
    int i;

    *count = 0;
    *err = 0;
    if(lua_isnoneornil(L, arg))
        { *err = ERR_NOTPRESENT; return NULL; }
    if(lua_type(L, arg) != LUA_TTABLE)
        { *err = ERR_TABLE; return NULL; }

    *count = luaL_len(L, arg);
    if(*count == 0)
        { *err = ERR_EMPTY; return NULL; }

    list = (float*)MallocNoErr(L, sizeof(float) * (*count));
    if(!list)
        { *count = 0; *err = ERR_MEMORY; return NULL; }

    for(i=0; i<*count; i++)
        {
        lua_rawgeti(L, arg, i+1);
        if(!lua_isnumber(L, -1))
            { lua_pop(L, 1); Free(L, list); *count = 0; *err = ERR_TYPE; return NULL; }
        list[i] = lua_tonumber(L, -1);
        lua_pop(L, 1);
        }
    return list;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x15090
cmpl $0x0, %eax
jg 0xa1569
movq 0x10(%rsp), %rax
movl $0x1, (%rax)
movq $0x0, 0x30(%rsp)
jmp 0xa16e9
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x15090
cmpl $0x5, %eax
je 0xa1595
movq 0x10(%rsp), %rax
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movq $0x0, 0x30(%rsp)
jmp 0xa16e9
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x150b0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
jne 0xa15cf
movq 0x10(%rsp), %rax
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movq $0x0, 0x30(%rsp)
jmp 0xa16e9
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movslq (%rax), %rsi
shlq $0x2, %rsi
callq 0x13ca0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xa1616
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x10(%rsp), %rax
movl $0xfffffffa, (%rax)     # imm = 0xFFFFFFFA
movq $0x0, 0x30(%rsp)
jmp 0xa16e9
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xa16df
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x4(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x13a30
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x13d30
cmpl $0x0, %eax
jne 0xa169a
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14230
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x10(%rsp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
movq $0x0, 0x30(%rsp)
jmp 0xa16e9
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x13ee0
cvtsd2ss %xmm0, %xmm0
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xa161e
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_pushfloatlist
void pushfloatlist(lua_State *L, float *list, int count)
    {
    int i;
    lua_newtable(L);
    for(i=0; i<count; i++)
        {
        lua_pushnumber(L, list[i]);
        lua_rawseti(L, -2, i+1);
        }
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x138b0
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0xa179f
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x142e0
movq 0x10(%rsp), %rdi
movl (%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x140e0
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0xa1757
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/utils.c
// Function: moonnuklear_checkvec2list
float* checkvec2list(lua_State *L, int arg, int *count, int *err)
    {
    nk_vec2_t* list;
    int i;

    *count = 0;
    *err = 0;
    if(lua_isnoneornil(L, arg))
        { *err = ERR_NOTPRESENT; return NULL; }
    if(lua_type(L, arg) != LUA_TTABLE)
        { *err = ERR_TABLE; return NULL; }

    *count = luaL_len(L, arg);
    if(*count == 0)
        { *err = ERR_EMPTY; return NULL; }

    list = (nk_vec2_t*)MallocNoErr(L, sizeof(nk_vec2_t)*(*count));
    if(!list)
        { *count = 0; *err = ERR_MEMORY; return NULL; }

    for(i=0; i<*count; i++)
        {
        lua_rawgeti(L, arg, i+1);
        *err = echeckvec2(L, -1, &list[i]);
        if(*err)
            { lua_pop(L, 2); Free(L, list); *count = 0; *err=ERR_TYPE; return NULL; }
        lua_pop(L, 1);
        }
    return (float*)list;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x15090
cmpl $0x0, %eax
jg 0xa1809
movq 0x10(%rsp), %rax
movl $0x1, (%rax)
movq $0x0, 0x30(%rsp)
jmp 0xa1982
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x15090
cmpl $0x5, %eax
je 0xa1835
movq 0x10(%rsp), %rax
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movq $0x0, 0x30(%rsp)
jmp 0xa1982
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x150b0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
jne 0xa186f
movq 0x10(%rsp), %rax
movl $0xfffffffb, (%rax)     # imm = 0xFFFFFFFB
movq $0x0, 0x30(%rsp)
jmp 0xa1982
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movslq (%rax), %rsi
shlq $0x3, %rsi
callq 0x13ca0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xa18b6
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x10(%rsp), %rax
movl $0xfffffffa, (%rax)     # imm = 0xFFFFFFFA
movq $0x0, 0x30(%rsp)
jmp 0xa1982
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xa1978
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x4(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x13a30
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rdx
movslq 0x4(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15460
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
je 0xa1959
movq 0x28(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x131a0
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14230
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x10(%rsp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
movq $0x0, 0x30(%rsp)
jmp 0xa1982
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xa18be
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)