LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/context.c
// Function: PluginCopy
static void PluginCopy(nk_handle handle, const char *text, int len) /* nk_plugin_copy */
    {
#define L moonnuklear_L
    ud_t *ud = (ud_t*)(handle.ptr);
    pushvalue(L, ud->ref2);
    lua_pushlstring(L, text, len);
    if(lua_pcall(L, 1, 0, 0) != LUA_OK)
        { lua_error(L); return; }
#undef L
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xac93d(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movslq 0x78(%rax), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x13a30
movq 0xac920(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movslq 0x14(%rsp), %rdx
callq 0x14860
movq 0xac907(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
movl $0x1, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movq %r9, %r8
callq 0x153a0
cmpl $0x0, %eax
je 0x18716
movq 0xac8e2(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/context.c
// Function: Init
static int Init(lua_State *L)
    {
    ud_t *ud;
    nk_context_t *context;
    nk_user_font_t *font = testfont(L, 1, NULL);
    context = (nk_context_t*)Malloc(L, sizeof(nk_context_t));
    if(!nk_init_default(context, font))
        {
        Free(L, context);
        return luaL_error(L, "cannot create context");
        }
    //int nk_init(nk_context_t*, nk_allocator_t*, const nk_user_font_t*);
    //int nk_init_fixed(nk_context_t*, void *memory, nk_size size, const nk_user_font_t*);
    //int nk_init_custom(nk_context_t*, nk_buffer_t *cmds, nk_buffer_t *pool, const nk_user_font_t*);
    ud = newuserdata(L, context, CONTEXT_MT, "context");
    ud->parent_ud = NULL;
    ud->destructor = freecontext;
    context->clip.userdata.ptr = ud;
    /* create also the associated edit, but pop its userdata */
    newedit(L, ud);
    lua_pop(L, 1);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8e973(%rip), %rcx     # 0xa70b1
callq 0x15450
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movl $0x4798, %esi           # imm = 0x4798
callq 0x14c40
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x134d0
cmpl $0x0, %eax
jne 0x18796
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14230
movq 0x18(%rsp), %rdi
leaq 0x8ec3e(%rip), %rsi     # 0xa73c7
movb $0x0, %al
callq 0x14bf0
movl %eax, 0x24(%rsp)
jmp 0x1880c
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x8ead9(%rip), %rdx     # 0xa7280
leaq 0x8ec27(%rip), %rcx     # 0xa73d5
callq 0x15130
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
leaq 0xff(%rip), %rcx        # 0x188d0
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x2580(%rax)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x130c0
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
movl $0x1, 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/context.c
// Function: InitFromPtr
static int InitFromPtr(lua_State *L)
    {
    ud_t *ud;
    nk_context_t *context = (nk_context_t*)checklightuserdata(L, 1);
    ud = newuserdata(L, context, CONTEXT_MT, "context (ptr)");
    ud->parent_ud = NULL;
    ud->destructor = freecontext;
    context->clip.userdata.ptr = ud;
    MarkBorrowed(ud);
    /* create also the associated edit, but pop its userdata */
    newedit(L, ud);
    lua_pop(L, 1);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x14a30
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
leaq 0x8ea34(%rip), %rdx     # 0xa7280
leaq 0x8ebad(%rip), %rcx     # 0xa7400
callq 0x15130
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
leaq 0x5a(%rip), %rcx        # 0x188d0
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x2580(%rax)
movq 0x8(%rsp), %rax
movl 0x70(%rax), %ecx
orl $0x40, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x70(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x130c0
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/context.c
// Function: freecontext
static int freecontext(lua_State *L, ud_t *ud)
    {
    nk_context_t *context = (nk_context_t*)ud->handle;
    float *ratio = ud->ratio;   
    int borrowed = IsBorrowed(ud);
    freechildren(L, PANEL_MT, ud);
    freechildren(L, EDIT_MT, ud);
    if(!freeuserdata(L, ud, "context")) return 0;
    if(ratio) Free(L, ratio);
    if(!borrowed)
        {
        nk_free(context);
        Free(L, context);
        }
    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 0x80(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl 0x70(%rax), %eax
andl $0x40, %eax
cmpl $0x40, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0x8eab6(%rip), %rsi     # 0xa73dd
callq 0x131f0
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0x8eab2(%rip), %rsi     # 0xa73ef
callq 0x131f0
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x8ea82(%rip), %rdx     # 0xa73d5
callq 0x14f50
cmpl $0x0, %eax
jne 0x18967
movl $0x0, 0x34(%rsp)
jmp 0x189a6
cmpq $0x0, 0x10(%rsp)
je 0x1897e
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x14230
cmpl $0x0, 0xc(%rsp)
jne 0x1899e
movq 0x18(%rsp), %rdi
callq 0x135b0
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x14230
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/cursor.c
// Function: moonnuklear_pushatlascursor
int pushatlascursor(lua_State *L, ud_t* atlas_ud, nk_cursor_t *cursor)
    {
    ud_t *ud = moonnuklear_userdata(cursor);
    if(ud) /* already in */
        { pushfont(L, cursor); return 1; }
    /* cursor is not yet known, create userdata and push it */
    ud = newuserdata(L, cursor, CURSOR_MT, "cursor");
    ud->parent_ud = atlas_ud;
    ud->destructor = freecursor;
    MarkAtlasCursor(ud);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x14450
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x189f1
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14e50
movl $0x1, 0x24(%rsp)
jmp 0x18a47
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x8e6c0(%rip), %rdx     # 0xa70c2
leaq 0x944f6(%rip), %rcx     # 0xaceff
callq 0x15130
movq %rax, (%rsp)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
leaq 0x26(%rip), %rcx        # 0x18a50
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movl 0x70(%rax), %ecx
orl $0x10, %ecx
movq (%rsp), %rax
movl %ecx, 0x70(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/cursor.c
// Function: freecursor
static int freecursor(lua_State *L, ud_t *ud)
    {
    nk_cursor_t *cursor = (nk_cursor_t*)ud->handle;
    int is_atlas_cursor = IsAtlasCursor(ud);
    if(!freeuserdata(L, ud, "cursor")) return 0;
    if(is_atlas_cursor) return 0;
    Free(L, cursor);
    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 0x10(%rsp), %rax
movl 0x70(%rax), %eax
andl $0x10, %eax
cmpl $0x10, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x94469(%rip), %rdx     # 0xaceff
callq 0x14f50
cmpl $0x0, %eax
jne 0x18aaa
movl $0x0, 0x24(%rsp)
jmp 0x18ad2
cmpl $0x0, 0x4(%rsp)
je 0x18abb
movl $0x0, 0x24(%rsp)
jmp 0x18ad2
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14230
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/cursor.c
// Function: Create
static int Create(lua_State *L)
/* cursor = cursor(image, size, offset) */
    {
    ud_t *ud, *image_ud;
    nk_cursor_t *cursor;
    nk_image_t *image;
    nk_vec2_t size, offset;

    image = checkimage(L, 1, &image_ud);
    if(echeckvec2(L, 2, &size)) return argerror(L, 2);
    if(echeckvec2(L, 2, &offset)) return argerror(L, 3);

    cursor = (nk_cursor_t*)Malloc(L, sizeof(nk_cursor_t));
    cursor->img = *image;
    cursor->size = size;
    cursor->offset = offset;

    ud = newuserdata(L, cursor, CURSOR_MT, "cursor");
    ud->parent_ud = image_ud;
    ud->destructor = freecursor;
    return 1;
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
leaq 0x38(%rsp), %rdx
leaq 0x8e665(%rip), %rcx     # 0xa7244
callq 0x130f0
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movl $0x2, %esi
leaq 0x20(%rsp), %rdx
callq 0x15460
cmpl $0x0, %eax
je 0x18c3a
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x54(%rsp)
jmp 0x18d23
movq 0x48(%rsp), %rdi
movl $0x2, %esi
leaq 0x18(%rsp), %rdx
callq 0x15460
cmpl $0x0, %eax
je 0x18c8b
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x3, %esi
callq 0x134c0
movl %eax, 0x54(%rsp)
jmp 0x18d23
movq 0x48(%rsp), %rdi
movl $0x28, %esi
callq 0x14c40
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
leaq 0x8e3d6(%rip), %rdx     # 0xa70c2
leaq 0x9420c(%rip), %rcx     # 0xaceff
callq 0x15130
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x40(%rsp), %rax
leaq -0x2c7(%rip), %rcx      # 0x18a50
movq %rcx, 0x8(%rax)
movl $0x1, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/edit.c
// Function: moonnuklear_newedit
int newedit(lua_State *L, ud_t *ud_context)
/* pushes the edit associated with the context */
    {
    nk_context_t *context = (nk_context_t*)ud_context->handle;
    nk_edit_t *edit = &context->text_edit;
    ud_t *ud = userdata(edit);

    if(ud) /* already in */
        return pushedit(L, edit);
    ud = newuserdata(L, edit, EDIT_MT, "edit");
    ud->parent_ud = ud_context;
    ud->context = context;
    ud->destructor = freeedit;
    MarkAssociatedWithContext(ud);
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x31d0, %rax           # imm = 0x31D0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x14450
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x18d87
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x14e50
movl %eax, 0x34(%rsp)
jmp 0x18df0
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x8e657(%rip), %rdx     # 0xa73ef
leaq 0x8e65c(%rip), %rcx     # 0xa73fb
callq 0x15130
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
leaq 0x2f(%rip), %rcx        # 0x18e00
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl 0x70(%rax), %ecx
orl $0x2, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x70(%rax)
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/edit.c
// Function: freeedit
static int freeedit(lua_State *L, ud_t *ud)
    {
    nk_edit_t *edit = (nk_edit_t*)ud->handle;
    int associated_with_context = IsAssociatedWithContext(ud);
    char * buf = ud->buf;
    if(!freeuserdata(L, ud, "edit")) return 0;
    if(buf) Free(L, buf);
    if(associated_with_context) return 0; /* don't free it, because it is owned by Nuklear */
    nk_textedit_free(edit);
    Free(L, edit);
    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
movl 0x70(%rax), %eax
andl $0x2, %eax
cmpl $0x2, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq 0x88(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x8e5a4(%rip), %rdx     # 0xa73fb
callq 0x14f50
cmpl $0x0, %eax
jne 0x18e6b
movl $0x0, 0x34(%rsp)
jmp 0x18eb4
cmpq $0x0, 0x8(%rsp)
je 0x18e82
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14230
cmpl $0x0, 0x14(%rsp)
je 0x18e93
movl $0x0, 0x34(%rsp)
jmp 0x18eb4
movq 0x18(%rsp), %rdi
callq 0x14f20
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x14230
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/edit.c
// Function: Filter
static int Filter(const nk_edit_t *edit, nk_rune unicode) /* nk_plugin_filter */
    {
#define L moonnuklear_L
    int rc;
    ud_t *ud = userdata((void*)edit);
    pushvalue(L, ud->ref1);
    pushedit(L, (nk_edit_t*)edit);
    lua_pushinteger(L, unicode);
    if(lua_pcall(L, 2, 1, 0) != LUA_OK)
        { lua_error(L); return 0; }
    rc = checkboolean(L, -1);
    lua_pop(L, 1);
    return rc;
#undef L
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0x14450
movq %rax, 0x8(%rsp)
movq 0xabd9d(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movslq 0x74(%rax), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x13a30
movq 0xabd80(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x14e50
movq 0xabd6c(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x13c50
movq 0xabd57(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
movl $0x2, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %r8
callq 0x153a0
cmpl $0x0, %eax
je 0x192d3
movq 0xabd2f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
movl $0x0, 0x24(%rsp)
jmp 0x19307
movq 0xabd16(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14990
movl %eax, 0x10(%rsp)
movq 0xabcfe(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
movl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/edit.c
// Function: moonnuklear_edit_focus
int edit_focus(lua_State *L)
    {
    nk_flags flags;
    nk_context_t *context = checkcontext(L, 1, NULL);
    flags = checkflags(L, 2);
    nk_edit_focus(context, flags); /* editflags */
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8df22(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x14070
movl %eax, 0xc(%rsp)
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x13e70
xorl %eax, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/edit.c
// Function: Edit_text
static int Edit_text(lua_State *L)
    {
    size_t len;
    nk_edit_t *edit = checkedit(L, 1, NULL);
    const char *s = luaL_checklstring(L, 2, &len);
    nk_textedit_text(edit, s, len);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8df81(%rip), %rcx     # 0xa73ef
callq 0x130f0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
leaq 0x18(%rsp), %rdx
callq 0x13df0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movl %eax, %edx
callq 0x13ad0
xorl %eax, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/edit.c
// Function: Edit_delete
static int Edit_delete(lua_State *L)
    {
    nk_edit_t *edit = checkedit(L, 1, NULL);
    int where = luaL_checkinteger(L, 2);
    int len = luaL_checkinteger(L, 3);
    nk_textedit_delete(edit, where, len);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8df21(%rip), %rcx     # 0xa73ef
callq 0x130f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x14070
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x14070
movl %eax, (%rsp)
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movl (%rsp), %edx
callq 0x133b0
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/edit.c
// Function: Edit_paste
static int Edit_paste(lua_State *L)
    {
    size_t len;
    nk_edit_t *edit = checkedit(L, 1, NULL);
    const char *s = luaL_checklstring(L, 2, &len);
    lua_pushboolean(L, nk_textedit_paste(edit, s, (int)len));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8dde1(%rip), %rcx     # 0xa73ef
callq 0x130f0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
leaq 0x18(%rsp), %rdx
callq 0x13df0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movl %eax, %edx
callq 0x153f0
movq (%rsp), %rdi
movl %eax, %esi
callq 0x143e0
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/enums.c
// Function: enums_free
static void enums_free(lua_State *L, rec_t* rec)
    {
    if(code_search(rec->domain, rec->code) == rec)
        code_remove(rec);
    if(str_search(rec->domain, rec->str) == rec)
        str_remove(rec);
    Free(L, rec->str);
    Free(L, rec);   
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x40(%rax), %edi
movq 0x8(%rsp), %rax
movl 0x44(%rax), %esi
callq 0x19d60
cmpq 0x8(%rsp), %rax
jne 0x19b04
movq 0x8(%rsp), %rdi
callq 0x21510
movq 0x8(%rsp), %rax
movl 0x40(%rax), %edi
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rsi
callq 0x19c00
cmpq 0x8(%rsp), %rax
jne 0x19b2b
movq 0x8(%rsp), %rdi
callq 0x21530
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rsi
callq 0x14230
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/enums.c
// Function: moonnuklear_enums_test
uint32_t enums_test(lua_State *L, uint32_t domain, int arg, int *err)
    {
    rec_t *rec;
    const char *s = luaL_optstring(L, arg, NULL);

    if(!s)
        { *err = ERR_NOTPRESENT; return 0; }

    rec = str_search(domain, s);
    if(!rec)
        { *err = ERR_VALUE; return 0; }
    
    *err = ERR_SUCCESS;
    return rec->code;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x139a0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x19bad
movq 0x18(%rsp), %rax
movl $0x1, (%rax)
movl $0x0, 0x34(%rsp)
jmp 0x19bf4
movl 0x24(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x19c00
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x19bdd
movq 0x18(%rsp), %rax
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
movl $0x0, 0x34(%rsp)
jmp 0x19bf4
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x10(%rsp), %rax
movl 0x44(%rax), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/enums.c
// Function: moonnuklear_enums_check
uint32_t enums_check(lua_State *L, uint32_t domain, int arg)
    {
    rec_t *rec;
    const char *s = luaL_checkstring(L, arg);

    rec = str_search(domain, s);
    if(!rec)
        return luaL_argerror(L, arg, badvalue(L, s));
    
    return rec->code;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x13df0
movq %rax, 0x10(%rsp)
movl 0x24(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x19c00
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x19cc2
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x8d7ec(%rip), %rsi     # 0xa7491
movb $0x0, %al
callq 0x13ec0
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movq %rax, %rdx
callq 0x134c0
movl %eax, 0x34(%rsp)
jmp 0x19cce
movq 0x18(%rsp), %rax
movl 0x44(%rax), %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/enums.c
// Function: moonnuklear_enums_push
int enums_push(lua_State *L, uint32_t domain, uint32_t code)
    {
    rec_t *rec = code_search(domain, code);

    if(!rec)
        return unexpected(L);

    lua_pushstring(L, rec->str);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
callq 0x19d60
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x19d30
movq 0x18(%rsp), %rdi
leaq 0x8d408(%rip), %rsi     # 0xa711f
leaq 0x8d786(%rip), %rdx     # 0xa74a4
movl $0xca, %ecx
movb $0x0, %al
callq 0x14bf0
movl %eax, 0x24(%rsp)
jmp 0x19d4b
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rsi
callq 0x15240
movl $0x1, 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/enums.c
// Function: moonnuklear_enums_values
int enums_values(lua_State *L, uint32_t domain)
    {
    int i;
    rec_t *rec;

    lua_newtable(L);
    i = 1;
    rec = code_first(domain, 0);
    while(rec)
        {
        if(rec->domain == domain)
            {
            lua_pushstring(L, rec->str);
            lua_rawseti(L, -2, i++);
            }
        rec = code_next(rec);
        }

    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x138b0
movl $0x1, 0x8(%rsp)
movl 0xc(%rsp), %edi
xorl %esi, %esi
callq 0x19aa0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x19e16
movq (%rsp), %rax
movl 0x40(%rax), %eax
cmpl 0xc(%rsp), %eax
jne 0x19e07
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x48(%rax), %rsi
callq 0x15240
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rsp)
movslq %eax, %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x140e0
movq (%rsp), %rdi
callq 0x19e20
movq %rax, (%rsp)
jmp 0x19dc2
movl $0x1, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/enums.c
// Function: moonnuklear_enums_checklist
uint32_t* enums_checklist(lua_State *L, uint32_t domain, int arg, uint32_t *count, int *err)
    {
    uint32_t* list;
    uint32_t 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_NOTPRESENT; return NULL; }

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

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x15090
cmpl $0x0, %eax
jg 0x19e8d
movq 0x10(%rsp), %rax
movl $0x1, (%rax)
movq $0x0, 0x30(%rsp)
jmp 0x19fed
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x15090
cmpl $0x5, %eax
je 0x19eb9
movq 0x10(%rsp), %rax
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movq $0x0, 0x30(%rsp)
jmp 0x19fed
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x150b0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x19ef3
movq 0x10(%rsp), %rax
movl $0x1, (%rax)
movq $0x0, 0x30(%rsp)
jmp 0x19fed
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, %esi
shlq $0x2, %rsi
callq 0x13ca0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x19f3b
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x10(%rsp), %rax
movl $0xfffffffa, (%rax)     # imm = 0xFFFFFFFA
movq $0x0, 0x30(%rsp)
jmp 0x19fed
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x19fe3
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
callq 0x13a30
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x10(%rsp), %rcx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x145d0
movl %eax, %edx
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
je 0x19fd1
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14230
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq $0x0, 0x30(%rsp)
jmp 0x19fed
jmp 0x19fd3
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x19f43
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/enums.c
// Function: enums_new
static int enums_new(lua_State *L, uint32_t domain, uint32_t code, const char *str)
    {
    rec_t *rec;
    if((rec = (rec_t*)Malloc(L, sizeof(rec_t))) == NULL) 
        return luaL_error(L, errstring(ERR_MEMORY));

    memset(rec, 0, sizeof(rec_t));
    rec->domain = domain;
    rec->code = code;
    rec->str = Strdup(L, str);
    if(code_search(domain, code) || str_search(domain, str))
        { 
        Free(L, rec->str);
        Free(L, rec); 
        return unexpected(L); /* duplicate value */
        }
    code_insert(rec);
    str_insert(rec);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x50, %esi
callq 0x14c40
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0x212dc
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
movl %eax, 0x34(%rsp)
jmp 0x213aa
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x13c40
movl 0x24(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x40(%rax)
movl 0x20(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x44(%rax)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x148e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x48(%rax)
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
callq 0x19d60
cmpq $0x0, %rax
jne 0x21347
movl 0x24(%rsp), %edi
movq 0x18(%rsp), %rsi
callq 0x19c00
cmpq $0x0, %rax
je 0x2138e
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rsi
callq 0x14230
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x14230
movq 0x28(%rsp), %rdi
leaq 0x85daa(%rip), %rsi     # 0xa711f
leaq 0x86128(%rip), %rdx     # 0xa74a4
movl $0x7c, %ecx
movb $0x0, %al
callq 0x14bf0
movl %eax, 0x34(%rsp)
jmp 0x213aa
movq 0x10(%rsp), %rdi
callq 0x23230
movq 0x10(%rsp), %rdi
callq 0x23250
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/flags.c
// Function: ConvertResult
static int ConvertResult(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushconvertresult(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkconvertresult(L, 1));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x15090
cmpl $0x3, %eax
jne 0x24c58
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x14070
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x25210
movl %eax, 0x24(%rsp)
jmp 0x24c87
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x25310
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x13c50
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/flags.c
// Function: PanelFlags
static int PanelFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushpanelflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkpanelflags(L, 1));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x15090
cmpl $0x3, %eax
jne 0x24cd8
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x14070
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x25480
movl %eax, 0x24(%rsp)
jmp 0x24d07
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x25690
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x13c50
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/flags.c
// Function: WidgetStates
static int WidgetStates(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushwidgetstates(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkwidgetstates(L, 1));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x15090
cmpl $0x3, %eax
jne 0x24d58
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x14070
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x25900
movl %eax, 0x24(%rsp)
jmp 0x24d87
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x25a80
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x13c50
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/flags.c
// Function: WidgetAlign
static int WidgetAlign(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushwidgetalign(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkwidgetalign(L, 1));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x15090
cmpl $0x3, %eax
jne 0x24dd8
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x14070
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x25c70
movl %eax, 0x24(%rsp)
jmp 0x24e07
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x25da0
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x13c50
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/flags.c
// Function: TextAlign
static int TextAlign(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushtextalign(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checktextalign(L, 1));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x15090
cmpl $0x3, %eax
jne 0x24e58
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x14070
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x25fb0
movl %eax, 0x24(%rsp)
jmp 0x24e87
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x260e0
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x13c50
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/flags.c
// Function: EditFlags
static int EditFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pusheditflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkeditflags(L, 1));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x15090
cmpl $0x3, %eax
jne 0x24ed8
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x14070
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x262f0
movl %eax, 0x24(%rsp)
jmp 0x24f07
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x26560
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x13c50
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/flags.c
// Function: EditEvents
static int EditEvents(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pusheditevents(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkeditevents(L, 1));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x15090
cmpl $0x3, %eax
jne 0x24f58
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x14070
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x268c0
movl %eax, 0x24(%rsp)
jmp 0x24f87
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x269c0
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x13c50
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/flags.c
// Function: PanelType
static int PanelType(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushpaneltype(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkpaneltype(L, 1));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x15090
cmpl $0x3, %eax
jne 0x24fd8
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x14070
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x26b30
movl %eax, 0x24(%rsp)
jmp 0x25007
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x26c90
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x13c50
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/flags.c
// Function: WindowFlags
static int WindowFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushwindowflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkwindowflags(L, 1));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x15090
cmpl $0x3, %eax
jne 0x25058
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x14070
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x26ed0
movl %eax, 0x24(%rsp)
jmp 0x25087
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x27070
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x13c50
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/flags.c
// Function: ChartEvent
static int ChartEvent(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushchartevent(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkchartevent(L, 1));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x15090
cmpl $0x3, %eax
jne 0x250d8
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x14070
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x27270
movl %eax, 0x24(%rsp)
jmp 0x25107
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x272f0
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x13c50
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/flags.c
// Function: WidgetLayoutStates
static int WidgetLayoutStates(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushwidgetlayoutstates(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkwidgetlayoutstates(L, 1));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x15090
cmpl $0x3, %eax
jne 0x25158
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x14070
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x273f0
movl %eax, 0x24(%rsp)
jmp 0x25187
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x274c0
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x13c50
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/flags.c
// Function: StyleHeaderAlign
static int StyleHeaderAlign(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushstyleheaderalign(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkstyleheaderalign(L, 1));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x15090
cmpl $0x3, %eax
jne 0x251d8
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x14070
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x27610
movl %eax, 0x24(%rsp)
jmp 0x25207
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x27690
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x13c50
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/flags.c
// Function: pushconvertresult
static int pushconvertresult(lua_State *L, nk_flags flags)
    {
    int n = 0;

#define CASE(CODE,str) do { if((flags & CODE)==CODE) { lua_pushstring(L, str); n++; } } while(0)
        CASE(NK_CONVERT_SUCCESS, "success");
        CASE(NK_CONVERT_INVALID_PARAM, "invalid param");
        CASE(NK_CONVERT_COMMAND_BUFFER_FULL, "command buffer full");
        CASE(NK_CONVERT_VERTEX_BUFFER_FULL, "vertex buffer full");
        CASE(NK_CONVERT_ELEMENT_BUFFER_FULL, "element buffer full");
#undef CASE

    return n;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %eax
andl $0x0, %eax
cmpl $0x0, %eax
jne 0x2524d
movq 0x10(%rsp), %rdi
leaq 0x87b82(%rip), %rsi     # 0xacdbf
callq 0x15240
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2524f
jmp 0x25251
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x25279
movq 0x10(%rsp), %rdi
leaq 0x87b5e(%rip), %rsi     # 0xacdc7
callq 0x15240
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2527b
jmp 0x2527d
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x2, %eax
jne 0x252a5
movq 0x10(%rsp), %rdi
leaq 0x87b40(%rip), %rsi     # 0xacdd5
callq 0x15240
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x252a7
jmp 0x252a9
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x4, %eax
jne 0x252d1
movq 0x10(%rsp), %rdi
leaq 0x87b28(%rip), %rsi     # 0xacde9
callq 0x15240
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x252d3
jmp 0x252d5
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x8, %eax
jne 0x252fd
movq 0x10(%rsp), %rdi
leaq 0x87b0f(%rip), %rsi     # 0xacdfc
callq 0x15240
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x252ff
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/flags.c
// Function: checkconvertresult
static nk_flags checkconvertresult(lua_State *L, int arg) 
    {
    const char *s;
    nk_flags flags = 0;
    
    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
        CASE(NK_CONVERT_SUCCESS, "success");
        CASE(NK_CONVERT_INVALID_PARAM, "invalid param");
        CASE(NK_CONVERT_COMMAND_BUFFER_FULL, "command buffer full");
        CASE(NK_CONVERT_VERTEX_BUFFER_FULL, "vertex buffer full");
        CASE(NK_CONVERT_ELEMENT_BUFFER_FULL, "element buffer full");
#undef CASE
        return (nk_flags)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }

    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x154b0
cmpl $0x0, %eax
je 0x2546b
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x87a57(%rip), %rsi     # 0xacdbf
callq 0x13fc0
cmpl $0x0, %eax
jne 0x25384
jmp 0x25374
movl 0x14(%rsp), %eax
orl $0x0, %eax
movl %eax, 0x14(%rsp)
jmp 0x25466
movq 0x18(%rsp), %rdi
leaq 0x87a37(%rip), %rsi     # 0xacdc7
callq 0x13fc0
cmpl $0x0, %eax
jne 0x253ac
jmp 0x2539c
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x25466
movq 0x18(%rsp), %rdi
leaq 0x87a1d(%rip), %rsi     # 0xacdd5
callq 0x13fc0
cmpl $0x0, %eax
jne 0x253d4
jmp 0x253c4
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x25466
movq 0x18(%rsp), %rdi
leaq 0x87a09(%rip), %rsi     # 0xacde9
callq 0x13fc0
cmpl $0x0, %eax
jne 0x253f9
jmp 0x253ec
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x25466
movq 0x18(%rsp), %rdi
leaq 0x879f7(%rip), %rsi     # 0xacdfc
callq 0x13fc0
cmpl $0x0, %eax
jne 0x2541e
jmp 0x25411
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x25466
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x82049(%rip), %rsi     # 0xa7491
movb $0x0, %al
callq 0x13ec0
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rax, %rdx
callq 0x134c0
movl %eax, 0x34(%rsp)
jmp 0x25473
jmp 0x25325
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/flags.c
// Function: pushwidgetstates
static int pushwidgetstates(lua_State *L, nk_flags flags)
    {
    int n = 0;

#define CASE(CODE,str) do { if((flags & CODE)==CODE) { lua_pushstring(L, str); n++; } } while(0)
    CASE(NK_WIDGET_STATE_MODIFIED, "modified");
    CASE(NK_WIDGET_STATE_INACTIVE, "inactive");
    CASE(NK_WIDGET_STATE_ENTERED, "entered");
    CASE(NK_WIDGET_STATE_HOVER, "hover");
    CASE(NK_WIDGET_STATE_ACTIVED, "actived");
    CASE(NK_WIDGET_STATE_LEFT, "left");
    CASE(NK_WIDGET_STATE_HOVERED, "hovered");
    CASE(NK_WIDGET_STATE_ACTIVE, "active");
#undef CASE

    return n;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x2, %eax
jne 0x2593d
movq 0x10(%rsp), %rdi
leaq 0x87541(%rip), %rsi     # 0xace6e
callq 0x15240
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2593f
jmp 0x25941
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x4, %eax
jne 0x25969
movq 0x10(%rsp), %rdi
leaq 0x8751e(%rip), %rsi     # 0xace77
callq 0x15240
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2596b
jmp 0x2596d
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x8, %eax
jne 0x25995
movq 0x10(%rsp), %rdi
leaq 0x87515(%rip), %rsi     # 0xace9a
callq 0x15240
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x25997
jmp 0x25999
movl 0xc(%rsp), %eax
andl $0x10, %eax
cmpl $0x10, %eax
jne 0x259c1
movq 0x10(%rsp), %rdi
leaq 0x82c8c(%rip), %rsi     # 0xa863d
callq 0x15240
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x259c3
jmp 0x259c5
movl 0xc(%rsp), %eax
andl $0x20, %eax
cmpl $0x20, %eax
jne 0x259ed
movq 0x10(%rsp), %rdi
leaq 0x874a3(%rip), %rsi     # 0xace80
callq 0x15240
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x259ef
jmp 0x259f1
movl 0xc(%rsp), %eax
andl $0x40, %eax
cmpl $0x40, %eax
jne 0x25a19
movq 0x10(%rsp), %rdi
leaq 0x81c87(%rip), %rsi     # 0xa7690
callq 0x15240
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x25a1b
jmp 0x25a1d
movl 0xc(%rsp), %eax
andl $0x12, %eax
cmpl $0x12, %eax
jne 0x25a45
movq 0x10(%rsp), %rdi
leaq 0x8fafe(%rip), %rsi     # 0xb5533
callq 0x15240
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x25a47
jmp 0x25a49
movl 0xc(%rsp), %eax
andl $0x22, %eax
cmpl $0x22, %eax
jne 0x25a71
movq 0x10(%rsp), %rdi
leaq 0x833ba(%rip), %rsi     # 0xa8e1b
callq 0x15240
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x25a73
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)