LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x49a46(%rip), %rcx     # 0x60244
pushq $0x1
popq %rbp
leaq 0x18(%rsp), %rdx
movl %ebp, %esi
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x143f0
testl %eax, %eax
je 0x16835
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x2
jmp 0x16858
pushq $0x2
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x143f0
testl %eax, %eax
je 0x16871
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x13c00
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x20(%rax)
leaq 0x4981e(%rip), %rdx     # 0x600c2
leaq 0x4f654(%rip), %rcx     # 0x65eff
movq %rbx, %rdi
movq %rax, %rsi
callq 0x140d0
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq -0x1a5(%rip), %rcx      # 0x16721
movq %rcx, 0x8(%rax)
jmp 0x16866
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %r12
leaq 0x31d0(%r12), %r14
movq %r14, %rdi
callq 0x13430
testq %rax, %rax
je 0x16908
movq %r15, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x13e10
leaq 0x49ae0(%rip), %rdx     # 0x603ef
leaq 0x49ae5(%rip), %rcx     # 0x603fb
movq %r15, %rdi
movq %r14, %rsi
callq 0x140d0
movq %rbx, 0x10(%rax)
movq %r12, 0x18(%rax)
leaq 0x17(%rip), %rcx        # 0x16947
movq %rcx, 0x8(%rax)
orb $0x2, 0x70(%rax)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rsi), %rbx
movl 0x70(%rsi), %ebp
movq 0x88(%rsi), %r15
leaq 0x49a96(%rip), %rdx     # 0x603fb
callq 0x13f10
testl %eax, %eax
je 0x16997
testq %r15, %r15
je 0x1697e
movq %r14, %rdi
movq %r15, %rsi
callq 0x13220
testb $0x2, %bpl
jne 0x16997
movq %rbx, %rdi
callq 0x13ee0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13220
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x13430
movq 0x6e437(%rip), %r15     # 0x84ff0
movq (%r15), %rdi
movslq 0x74(%rax), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12a00
movq (%r15), %rdi
movq %r14, %rsi
callq 0x13e10
movq (%r15), %rdi
movl %ebx, %esi
callq 0x12c20
movq (%r15), %rdi
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x14330
movq (%r15), %rdi
testl %eax, %eax
je 0x16c05
callq 0x13960
xorl %eax, %eax
jmp 0x16c1c
pushq $-0x1
popq %rsi
callq 0x13950
movl %eax, %ebx
movq (%r15), %rdi
pushq $-0x2
popq %rsi
callq 0x12190
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4963a(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %r14, %rdi
movl %eax, %esi
callq 0x12e50
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x496eb(%rip), %rcx     # 0x603ef
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x12dd0
movl (%r15), %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x12aa0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x496a2(%rip), %rcx     # 0x603ef
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x123a0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x495e6(%rip), %rcx     # 0x603ef
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x12dd0
movl (%r15), %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x14380
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movl %esi, %ebp
xorl %r14d, %r14d
movl %edx, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x12970
testq %rax, %rax
je 0x17907
movl %ebp, %edi
movq %rax, %rsi
callq 0x17920
testq %rax, %rax
je 0x1790f
andl $0x0, (%rbx)
movl 0x44(%rax), %r14d
jmp 0x17918
movl $0x1, (%rbx)
jmp 0x17918
movl $0xfffffffd, (%rbx)     # imm = 0xFFFFFFFD
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl %edx, %esi
xorl %edx, %edx
callq 0x12dd0
movq %rax, %r15
movl %ebp, %edi
movq %rax, %rsi
callq 0x17920
testq %rax, %rax
je 0x179b0
movl 0x44(%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x48ada(%rip), %rsi     # 0x60491
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x12ea0
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x124a0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
movl %esi, %edi
movl %edx, %esi
callq 0x17a1c
testq %rax, %rax
je 0x179fe
movq 0x48(%rax), %rsi
movq %rbx, %rdi
callq 0x141d0
pushq $0x1
popq %rax
popq %rbx
retq
leaq 0x4871a(%rip), %rsi     # 0x6011f
leaq 0x48a98(%rip), %rdx     # 0x604a4
movq %rbx, %rdi
movl $0xca, %ecx
xorl %eax, %eax
popq %rbx
jmp 0x13bb0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x12870
movl %ebx, %edi
callq 0x17881
pushq $0x1
popq %r15
pushq $-0x2
popq %rbp
testq %rax, %rax
je 0x17aec
movq %rax, %r12
cmpl %ebx, 0x40(%rax)
jne 0x17aad
movq 0x48(%r12), %rsi
movq %r14, %rdi
callq 0x141d0
movslq %r15d, %rdx
incl %r15d
movq %r14, %rdi
movl %ebp, %esi
callq 0x130d0
movq 0x8(%r12), %rcx
testq %rcx, %rcx
je 0x17ac4
movq %rcx, %rax
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x17ab7
jmp 0x17a83
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x17ad3
cmpq %r12, (%rax)
je 0x17a83
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x17ae8
cmpq 0x8(%rax), %r12
movq %rax, %r12
je 0x17ad3
jmp 0x17a83
xorl %eax, %eax
jmp 0x17a83
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movl %edx, %ebp
movl %esi, 0x14(%rsp)
movq %rcx, 0x8(%rsp)
andl $0x0, (%rcx)
movq %rdi, %r12
andl $0x0, (%r8)
movl %edx, %esi
callq 0x14030
testl %eax, %eax
jle 0x17bcf
movq %r12, %rdi
movl %ebp, %esi
callq 0x14030
cmpl $0x5, %eax
jne 0x17bd8
movq %r12, %rdi
movl %ebp, %esi
callq 0x14050
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
testl %eax, %eax
je 0x17bcf
movl %eax, %esi
shlq $0x2, %rsi
movq %r12, %rdi
callq 0x12c70
testq %rax, %rax
je 0x17bf4
movq %rax, %r13
xorl %r15d, %r15d
movq 0x8(%rsp), %rax
movl (%rax), %eax
cmpq %rax, %r15
jae 0x17be2
leaq 0x1(%r15), %rbx
movq %r12, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x12a00
movq %r12, %rdi
movl 0x14(%rsp), %esi
pushq $-0x1
popq %rdx
movq %r14, %rcx
callq 0x135b0
movl %eax, (%r13,%r15,4)
movq %r12, %rdi
pushq $-0x2
popq %rsi
callq 0x12190
cmpl $0x0, (%r14)
movq %rbx, %r15
je 0x17b72
movq %r12, %rdi
movq %r13, %rsi
callq 0x13220
movq 0x8(%rsp), %rax
andl $0x0, (%rax)
jmp 0x17bdf
movl $0x1, (%r14)
jmp 0x17bdf
movl $0xfffffffc, (%r14)     # imm = 0xFFFFFFFC
xorl %r13d, %r13d
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rax
andl $0x0, (%rax)
movl $0xfffffffa, (%r14)     # imm = 0xFFFFFFFA
jmp 0x17bdf
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %r12
movl %r12d, %esi
callq 0x14030
cmpl $0x3, %eax
jne 0x1eb9c
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13060
movq %rax, %r14
leaq 0x47291(%rip), %rsi     # 0x65dbf
movq %rbx, %rdi
callq 0x141d0
testb $0x1, %r14b
je 0x1eb4e
leaq 0x47284(%rip), %rsi     # 0x65dc7
movq %rbx, %rdi
callq 0x141d0
pushq $0x2
popq %rbp
testb $0x2, %r14b
je 0x1eb65
leaq 0x4727a(%rip), %rsi     # 0x65dd5
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x4, %r14b
je 0x1eb7c
leaq 0x47277(%rip), %rsi     # 0x65de9
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x8, %r14b
je 0x1ec90
leaq 0x4726f(%rip), %rsi     # 0x65dfc
movq %rbx, %rdi
callq 0x141d0
incl %ebp
jmp 0x1ec90
xorl %r14d, %r14d
leaq 0x47219(%rip), %r15     # 0x65dbf
movq %rbx, %rdi
movl %r12d, %esi
callq 0x14440
testl %eax, %eax
je 0x1ec82
leal 0x1(%r12), %ebp
movq %rbx, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x12690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x12fb0
movl %ebp, %r12d
testl %eax, %eax
je 0x1eba6
movq %r13, %rdi
leaq 0x471dd(%rip), %rsi     # 0x65dc7
callq 0x12fb0
testl %eax, %eax
je 0x1ec38
movq %r13, %rdi
leaq 0x471d8(%rip), %rsi     # 0x65dd5
callq 0x12fb0
testl %eax, %eax
je 0x1ec44
movq %r13, %rdi
leaq 0x471d9(%rip), %rsi     # 0x65de9
callq 0x12fb0
testl %eax, %eax
je 0x1ec50
movq %r13, %rdi
leaq 0x471d9(%rip), %rsi     # 0x65dfc
callq 0x12fb0
testl %eax, %eax
jne 0x1ec5c
orl $0x8, %r14d
movl %ebp, %r12d
jmp 0x1eba6
orl $0x1, %r14d
movl %ebp, %r12d
jmp 0x1eba6
orl $0x2, %r14d
movl %ebp, %r12d
jmp 0x1eba6
orl $0x4, %r14d
movl %ebp, %r12d
jmp 0x1eba6
leaq 0x4182e(%rip), %rsi     # 0x60491
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x12ea0
decl %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x124a0
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x12c20
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x14030
cmpl $0x3, %eax
jne 0x1f067
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13060
movq %rax, %r14
xorl %ebp, %ebp
testb $0x2, %r14b
je 0x1efba
leaq 0x46ebf(%rip), %rsi     # 0x65e6e
movq %rbx, %rdi
callq 0x141d0
movl %r15d, %ebp
testb $0x4, %r14b
je 0x1efd1
leaq 0x46eb0(%rip), %rsi     # 0x65e77
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x8, %r14b
je 0x1efe8
leaq 0x46ebc(%rip), %rsi     # 0x65e9a
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x10, %r14b
je 0x1efff
leaq 0x42648(%rip), %rsi     # 0x6163d
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x20, %r14b
je 0x1f016
leaq 0x46e74(%rip), %rsi     # 0x65e80
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x40, %r14b
je 0x1f02d
leaq 0x4166d(%rip), %rsi     # 0x60690
movq %rbx, %rdi
callq 0x141d0
incl %ebp
notl %r14d
testb $0x12, %r14b
jne 0x1f047
leaq 0x4d836(%rip), %rsi     # 0x6c873
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x22, %r14b
jne 0x1f186
leaq 0x42dc3(%rip), %rsi     # 0x61e1b
movq %rbx, %rdi
callq 0x141d0
incl %ebp
jmp 0x1f186
xorl %r14d, %r14d
leaq 0x46dfd(%rip), %r15     # 0x65e6e
pushq $0x2
popq %r12
movq %rbx, %rdi
movl %ebp, %esi
callq 0x14440
testl %eax, %eax
je 0x1f178
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x12690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x12fb0
movl %r12d, %ecx
testl %eax, %eax
je 0x1f14a
movq %r13, %rdi
leaq 0x46dc1(%rip), %rsi     # 0x65e77
callq 0x12fb0
pushq $0x4
popq %rcx
testl %eax, %eax
je 0x1f14a
movq %r13, %rdi
leaq 0x46dca(%rip), %rsi     # 0x65e9a
callq 0x12fb0
pushq $0x8
popq %rcx
testl %eax, %eax
je 0x1f14a
movq %r13, %rdi
leaq 0x42557(%rip), %rsi     # 0x6163d
callq 0x12fb0
pushq $0x10
popq %rcx
testl %eax, %eax
je 0x1f14a
movq %r13, %rdi
leaq 0x46d84(%rip), %rsi     # 0x65e80
callq 0x12fb0
pushq $0x20
popq %rcx
testl %eax, %eax
je 0x1f14a
movq %r13, %rdi
leaq 0x4157e(%rip), %rsi     # 0x60690
callq 0x12fb0
pushq $0x40
popq %rcx
testl %eax, %eax
je 0x1f14a
movq %r13, %rdi
leaq 0x4d74b(%rip), %rsi     # 0x6c873
callq 0x12fb0
pushq $0x12
popq %rcx
testl %eax, %eax
je 0x1f14a
movq %r13, %rdi
leaq 0x42cdd(%rip), %rsi     # 0x61e1b
callq 0x12fb0
pushq $0x22
popq %rcx
testl %eax, %eax
jne 0x1f154
orl %ecx, %r14d
incl %ebp
jmp 0x1f075
leaq 0x41336(%rip), %rsi     # 0x60491
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x12ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x124a0
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x12c20
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x14030
cmpl $0x3, %eax
jne 0x1f260
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13060
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x1f1e4
leaq 0x46caf(%rip), %rsi     # 0x65e88
movq %rbx, %rdi
callq 0x141d0
movl %r15d, %ebp
testb $0x2, %r14b
je 0x1f1fb
leaq 0x46ca2(%rip), %rsi     # 0x65e93
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x4, %r14b
je 0x1f212
leaq 0x46c9a(%rip), %rsi     # 0x65ea2
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x8, %r14b
je 0x1f229
leaq 0x46c8f(%rip), %rsi     # 0x65eae
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x10, %r14b
je 0x1f240
leaq 0x46c82(%rip), %rsi     # 0x65eb8
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x20, %r14b
je 0x1f39b
leaq 0x46c74(%rip), %rsi     # 0x65ec5
movq %rbx, %rdi
callq 0x141d0
incl %ebp
jmp 0x1f39b
xorl %r14d, %r14d
leaq 0x46c1e(%rip), %r15     # 0x65e88
movl %ebp, %r13d
movq %rbx, %rdi
movl %r13d, %esi
callq 0x14440
testl %eax, %eax
je 0x1f38d
movq %rbx, %rdi
movl %r13d, %esi
xorl %edx, %edx
callq 0x12690
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x12fb0
movl %ebp, %ecx
testl %eax, %eax
je 0x1f35d
movq %r12, %rdi
leaq 0x46be4(%rip), %rsi     # 0x65e93
callq 0x12fb0
pushq $0x2
popq %rcx
testl %eax, %eax
je 0x1f35d
movq %r12, %rdi
leaq 0x46bd9(%rip), %rsi     # 0x65ea2
callq 0x12fb0
pushq $0x4
popq %rcx
testl %eax, %eax
je 0x1f35d
movq %r12, %rdi
leaq 0x46bcb(%rip), %rsi     # 0x65eae
callq 0x12fb0
pushq $0x8
popq %rcx
testl %eax, %eax
je 0x1f35d
movq %r12, %rdi
leaq 0x46bbf(%rip), %rsi     # 0x65eb8
callq 0x12fb0
pushq $0x10
popq %rcx
testl %eax, %eax
je 0x1f35d
movq %r12, %rdi
leaq 0x46bb6(%rip), %rsi     # 0x65ec5
callq 0x12fb0
pushq $0x20
popq %rcx
testl %eax, %eax
je 0x1f35d
movq %r12, %rdi
leaq 0x4136b(%rip), %rsi     # 0x60690
callq 0x12fb0
pushq $0x11
popq %rcx
testl %eax, %eax
je 0x1f35d
movq %r12, %rdi
leaq 0x46b5e(%rip), %rsi     # 0x65e99
callq 0x12fb0
pushq $0x12
popq %rcx
testl %eax, %eax
je 0x1f35d
movq %r12, %rdi
leaq 0x41361(%rip), %rsi     # 0x606b2
callq 0x12fb0
pushq $0x14
popq %rcx
testl %eax, %eax
jne 0x1f368
orl %ecx, %r14d
incl %r13d
jmp 0x1f26d
leaq 0x41122(%rip), %rsi     # 0x60491
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x12ea0
movq %rbx, %rdi
movl %r13d, %esi
movq %rax, %rdx
callq 0x124a0
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x12c20
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x14030
cmpl $0x3, %eax
jne 0x1f475
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13060
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x1f3f9
leaq 0x46a9a(%rip), %rsi     # 0x65e88
movq %rbx, %rdi
callq 0x141d0
movl %r15d, %ebp
testb $0x2, %r14b
je 0x1f410
leaq 0x46a8d(%rip), %rsi     # 0x65e93
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x4, %r14b
je 0x1f427
leaq 0x46a85(%rip), %rsi     # 0x65ea2
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x8, %r14b
je 0x1f43e
leaq 0x46a7a(%rip), %rsi     # 0x65eae
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x10, %r14b
je 0x1f455
leaq 0x46a6d(%rip), %rsi     # 0x65eb8
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x20, %r14b
je 0x1f5b0
leaq 0x46a5f(%rip), %rsi     # 0x65ec5
movq %rbx, %rdi
callq 0x141d0
incl %ebp
jmp 0x1f5b0
xorl %r14d, %r14d
leaq 0x46a09(%rip), %r15     # 0x65e88
movl %ebp, %r13d
movq %rbx, %rdi
movl %r13d, %esi
callq 0x14440
testl %eax, %eax
je 0x1f5a2
movq %rbx, %rdi
movl %r13d, %esi
xorl %edx, %edx
callq 0x12690
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x12fb0
movl %ebp, %ecx
testl %eax, %eax
je 0x1f572
movq %r12, %rdi
leaq 0x469cf(%rip), %rsi     # 0x65e93
callq 0x12fb0
pushq $0x2
popq %rcx
testl %eax, %eax
je 0x1f572
movq %r12, %rdi
leaq 0x469c4(%rip), %rsi     # 0x65ea2
callq 0x12fb0
pushq $0x4
popq %rcx
testl %eax, %eax
je 0x1f572
movq %r12, %rdi
leaq 0x469b6(%rip), %rsi     # 0x65eae
callq 0x12fb0
pushq $0x8
popq %rcx
testl %eax, %eax
je 0x1f572
movq %r12, %rdi
leaq 0x469aa(%rip), %rsi     # 0x65eb8
callq 0x12fb0
pushq $0x10
popq %rcx
testl %eax, %eax
je 0x1f572
movq %r12, %rdi
leaq 0x469a1(%rip), %rsi     # 0x65ec5
callq 0x12fb0
pushq $0x20
popq %rcx
testl %eax, %eax
je 0x1f572
movq %r12, %rdi
leaq 0x41156(%rip), %rsi     # 0x60690
callq 0x12fb0
pushq $0x11
popq %rcx
testl %eax, %eax
je 0x1f572
movq %r12, %rdi
leaq 0x46949(%rip), %rsi     # 0x65e99
callq 0x12fb0
pushq $0x12
popq %rcx
testl %eax, %eax
je 0x1f572
movq %r12, %rdi
leaq 0x4114c(%rip), %rsi     # 0x606b2
callq 0x12fb0
pushq $0x14
popq %rcx
testl %eax, %eax
jne 0x1f57d
orl %ecx, %r14d
incl %r13d
jmp 0x1f482
leaq 0x40f0d(%rip), %rsi     # 0x60491
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x12ea0
movq %rbx, %rdi
movl %r13d, %esi
movq %rax, %rdx
callq 0x124a0
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x12c20
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x14030
cmpl $0x3, %eax
jne 0x1fa37
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13060
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x1f9d2
leaq 0x42454(%rip), %rsi     # 0x61e1b
movq %rbx, %rdi
callq 0x141d0
movl %r15d, %ebp
testb $0x2, %r14b
je 0x1f9e9
leaq 0x46498(%rip), %rsi     # 0x65e77
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x4, %r14b
je 0x1fa00
leaq 0x4658f(%rip), %rsi     # 0x65f85
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x8, %r14b
je 0x1fa17
leaq 0x46576(%rip), %rsi     # 0x65f83
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x10, %r14b
je 0x1fb0e
leaq 0x46567(%rip), %rsi     # 0x65f8f
movq %rbx, %rdi
callq 0x141d0
incl %ebp
jmp 0x1fb0e
xorl %r14d, %r14d
leaq 0x423da(%rip), %r12     # 0x61e1b
movl %ebp, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x14440
testl %eax, %eax
je 0x1fb00
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x12690
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x12fb0
movl %ebp, %ecx
testl %eax, %eax
je 0x1fad0
movq %r13, %rdi
leaq 0x463f5(%rip), %rsi     # 0x65e77
callq 0x12fb0
pushq $0x2
popq %rcx
testl %eax, %eax
je 0x1fad0
movq %r13, %rdi
leaq 0x464ed(%rip), %rsi     # 0x65f85
callq 0x12fb0
pushq $0x4
popq %rcx
testl %eax, %eax
je 0x1fad0
movq %r13, %rdi
leaq 0x464d5(%rip), %rsi     # 0x65f83
callq 0x12fb0
pushq $0x8
popq %rcx
testl %eax, %eax
je 0x1fad0
movq %r13, %rdi
leaq 0x464cb(%rip), %rsi     # 0x65f8f
callq 0x12fb0
pushq $0x10
popq %rcx
testl %eax, %eax
jne 0x1fadb
orl %ecx, %r14d
incl %r15d
jmp 0x1fa44
leaq 0x409af(%rip), %rsi     # 0x60491
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x12ea0
movq %rbx, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x124a0
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x12c20
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x14030
cmpl $0x3, %eax
jne 0x1fbfe
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13060
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x1fb6c
leaq 0x46437(%rip), %rsi     # 0x65f98
movq %rbx, %rdi
callq 0x141d0
movl %r15d, %ebp
testb $0x2, %r14b
je 0x1fb83
leaq 0x46426(%rip), %rsi     # 0x65f9f
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x4, %r14b
je 0x1fb9a
leaq 0x46444(%rip), %rsi     # 0x65fd4
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x10, %r14b
je 0x1fbb1
leaq 0x463fe(%rip), %rsi     # 0x65fa5
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x20, %r14b
je 0x1fbc8
leaq 0x463f2(%rip), %rsi     # 0x65fb0
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb $0x40, %r14b
je 0x1fbdf
leaq 0x463e1(%rip), %rsi     # 0x65fb6
movq %rbx, %rdi
callq 0x141d0
incl %ebp
testb %r14b, %r14b
jns 0x1fd61
leaq 0x463cc(%rip), %rsi     # 0x65fbb
movq %rbx, %rdi
callq 0x141d0
incl %ebp
jmp 0x1fd61
xorl %r14d, %r14d
leaq 0x46390(%rip), %r15     # 0x65f98
movl %ebp, %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x14440
testl %eax, %eax
je 0x1fd53
movq %rbx, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x12690
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x12fb0
movl %ebp, %ecx
testl %eax, %eax
je 0x1fd23
movq %r13, %rdi
leaq 0x46352(%rip), %rsi     # 0x65f9f
callq 0x12fb0
pushq $0x2
popq %rcx
testl %eax, %eax
je 0x1fd23
movq %r13, %rdi
leaq 0x4636d(%rip), %rsi     # 0x65fd4
callq 0x12fb0
pushq $0x4
popq %rcx
testl %eax, %eax
je 0x1fd23
movq %r13, %rdi
leaq 0x46324(%rip), %rsi     # 0x65fa5
callq 0x12fb0
pushq $0x10
popq %rcx
testl %eax, %eax
je 0x1fd23
movq %r13, %rdi
leaq 0x46315(%rip), %rsi     # 0x65fb0
callq 0x12fb0
pushq $0x20
popq %rcx
testl %eax, %eax
je 0x1fd23
movq %r13, %rdi
leaq 0x46305(%rip), %rsi     # 0x65fb6
callq 0x12fb0
pushq $0x40
popq %rcx
testl %eax, %eax
je 0x1fd23
movq %r13, %rdi
leaq 0x462f4(%rip), %rsi     # 0x65fbb
callq 0x12fb0
testl %eax, %eax
je 0x1fd10
movq %r13, %rdi
leaq 0x462e9(%rip), %rsi     # 0x65fc3
callq 0x12fb0
testl %eax, %eax
je 0x1fd17
movq %r13, %rdi
leaq 0x462e3(%rip), %rsi     # 0x65fd0
callq 0x12fb0
testl %eax, %eax
je 0x1fd1e
movq %r13, %rdi
leaq 0x462da(%rip), %rsi     # 0x65fda
callq 0x12fb0
movl $0xf6, %ecx
testl %eax, %eax
je 0x1fd23
jmp 0x1fd2e
movl $0x80, %ecx
jmp 0x1fd23
movl $0xf0, %ecx
jmp 0x1fd23
movl $0xf4, %ecx
orl %ecx, %r14d
incl %r12d
jmp 0x1fc0b
leaq 0x4075c(%rip), %rsi     # 0x60491
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x12ea0
movq %rbx, %rdi
movl %r12d, %esi
movq %rax, %rdx
callq 0x124a0
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x12c20
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %r14
movl %r14d, %esi
callq 0x14030
cmpl $0x3, %eax
jne 0x2001b
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x13060
movq %rax, %r15
xorl %ebp, %ebp
testb $0x1, %r15b
je 0x1fffb
leaq 0x46015(%rip), %rsi     # 0x66005
movq %rbx, %rdi
callq 0x141d0
movl %r14d, %ebp
testb $0x2, %r15b
je 0x200a6
leaq 0x4c87f(%rip), %rsi     # 0x6c88b
movq %rbx, %rdi
callq 0x141d0
incl %ebp
jmp 0x200a6
xorl %r15d, %r15d
leaq 0x45fe0(%rip), %r12     # 0x66005
movl %r14d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x14440
testl %eax, %eax
je 0x20098
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x12690
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x12fb0
movl %r14d, %ecx
testl %eax, %eax
je 0x2006d
movq %r13, %rdi
leaq 0x4c82a(%rip), %rsi     # 0x6c88b
callq 0x12fb0
pushq $0x2
popq %rcx
testl %eax, %eax
jne 0x20074
orl %ecx, %r15d
incl %ebp
jmp 0x20028
leaq 0x40416(%rip), %rsi     # 0x60491
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x12ea0
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x124a0
movl %eax, %r15d
movl %r15d, %esi
movq %rbx, %rdi
callq 0x12c20
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x14030
cmpl $0x3, %eax
jne 0x20145
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13060
movq %rax, %r14
leaq 0x45f23(%rip), %rsi     # 0x6600e
movq %rbx, %rdi
callq 0x141d0
testb $0x1, %r14b
je 0x2010b
leaq 0x45f10(%rip), %rsi     # 0x66010
movq %rbx, %rdi
callq 0x141d0
pushq $0x2
popq %rbp
testb $0x2, %r14b
je 0x20122
leaq 0x45ee9(%rip), %rsi     # 0x66001
movq %rbx, %rdi
callq 0x141d0
incl %ebp
notl %r14d
testb $0x3, %r14b
jne 0x20213
leaq 0x45ee0(%rip), %rsi     # 0x66016
movq %rbx, %rdi
callq 0x141d0
incl %ebp
jmp 0x20213
xorl %r15d, %r15d
leaq 0x45ebf(%rip), %r14     # 0x6600e
movl %ebp, %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x14440
testl %eax, %eax
je 0x20205
leal 0x1(%r12), %ebp
movq %rbx, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x12690
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
callq 0x12fb0
movl %ebp, %r12d
testl %eax, %eax
je 0x20152
movq %r13, %rdi
leaq 0x45e7a(%rip), %rsi     # 0x66010
callq 0x12fb0
testl %eax, %eax
je 0x201cd
movq %r13, %rdi
leaq 0x45e58(%rip), %rsi     # 0x66001
callq 0x12fb0
testl %eax, %eax
je 0x201d6
movq %r13, %rdi
leaq 0x45e5a(%rip), %rsi     # 0x66016
callq 0x12fb0
pushq $0x3
popq %rcx
movl %ecx, %r15d
testl %eax, %eax
je 0x2014f
jmp 0x201df
orl $0x1, %r15d
jmp 0x2014f
orl $0x2, %r15d
jmp 0x2014f
leaq 0x402ab(%rip), %rsi     # 0x60491
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x12ea0
decl %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x124a0
movl %eax, %r15d
movl %r15d, %esi
movq %rbx, %rdi
callq 0x12c20
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %r14
movl %r14d, %esi
callq 0x14030
cmpl $0x3, %eax
jne 0x20282
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13060
movq %rax, %r14
leaq 0x40436(%rip), %rsi     # 0x60690
movq %rbx, %rdi
callq 0x141d0
testb $0x1, %r14b
je 0x20311
leaq 0x4043f(%rip), %rsi     # 0x606b2
movq %rbx, %rdi
callq 0x141d0
pushq $0x2
jmp 0x20310
xorl %r13d, %r13d
leaq 0x40404(%rip), %r15     # 0x60690
movl %r14d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x14440
testl %eax, %eax
je 0x20303
leal 0x1(%rbp), %r14d
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x12690
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x12fb0
movl %r14d, %ebp
testl %eax, %eax
je 0x2028f
movq %r12, %rdi
leaq 0x403e6(%rip), %rsi     # 0x606b2
callq 0x12fb0
pushq $0x1
popq %rcx
movl %ecx, %r13d
testl %eax, %eax
je 0x2028c
leaq 0x401af(%rip), %rsi     # 0x60491
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x12ea0
decl %r14d
movq %rbx, %rdi
movl %r14d, %esi
movq %rax, %rdx
callq 0x124a0
movl %eax, %r13d
movl %r13d, %esi
movq %rbx, %rdi
callq 0x12c20
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/font.c
// Function: moonnuklear_pushatlasfont
int pushatlasfont(lua_State *L, ud_t *atlas_ud, nk_font_t *atlas_font, nk_font_config_t *cfg)
/* Pushes the user font embedded in an atlas font, possibly creating the
 * associated ud if it is not yet known by MoonNuklear */
    {
    nk_user_font_t *font = &atlas_font->handle;
    ud_t *ud = moonnuklear_userdata(font);
    if(ud) /* already known */
        { 
        if(cfg) { return unexpected(L); }
        pushfont(L, font); return 1; 
        }
    /* not yet known, create ud */
    ud = newuserdata(L, font, FONT_MT, "font");
    ud->parent_ud = atlas_ud;
    ud->font = atlas_font;
    ud->font_config = cfg;
    ud->destructor = freefont;
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x8(%rdx), %r13
movq %r13, %rdi
callq 0x13430
testq %rax, %rax
je 0x20373
testq %rbx, %rbx
je 0x203a5
leaq 0x3fdc9(%rip), %rsi     # 0x6011f
leaq 0x45cc2(%rip), %rdx     # 0x6601f
pushq $0x3b
popq %rcx
movq %r14, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x13bb0
leaq 0x3fd37(%rip), %rdx     # 0x600b1
leaq 0x4c01e(%rip), %rcx     # 0x6c39f
movq %r14, %rdi
movq %r13, %rsi
callq 0x140d0
movq %r12, 0x10(%rax)
movq %r15, 0x20(%rax)
movq %rbx, 0x68(%rax)
leaq 0x1e(%rip), %rcx        # 0x203bd
movq %rcx, 0x8(%rax)
jmp 0x203b0
movq %r14, %rdi
movq %r13, %rsi
callq 0x13e10
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/font.c
// Function: freefont
static int freefont(lua_State *L, ud_t *ud)
    {
    nk_user_font_t *font = (nk_user_font_t*)ud->handle;
    nk_font_config_t *cfg = ud->font_config;
    int allocated = IsAllocated(ud);
    if(!freeuserdata(L, ud, "font")) return 0;
    if(cfg) freefontconfig(L, cfg);
    if(allocated) Free(L, font);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rsi), %rbx
movq 0x68(%rsi), %r15
movl 0x70(%rsi), %ebp
leaq 0x4bfc7(%rip), %rdx     # 0x6c39f
callq 0x13f10
testl %eax, %eax
je 0x20402
testq %r15, %r15
je 0x203f1
movq %r14, %rdi
movq %r15, %rsi
callq 0x13e30
testb $0x20, %bpl
je 0x20402
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13220
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/font.c
// Function: Width
static int Width(lua_State *L)
    {
    size_t len;
    nk_user_font_t *font = checkfont(L, 1, NULL);
    float height = luaL_checknumber(L, 2);
    const char *text = luaL_checklstring(L, 3, &len);
    lua_pushnumber(L, font->width(font->userdata, height, text, (int)len));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x3fbc8(%rip), %rcx     # 0x600b1
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
pushq $0x3
popq %rsi
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x12dd0
movl (%r15), %edx
movq (%r14), %rdi
movss 0xc(%rsp), %xmm0
movq %rax, %rsi
callq *0x10(%r14)
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x132d0
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/font.c
// Function: Ranges
static int Ranges(lua_State *L)
    {
    ud_t *ud;
    nk_font_t *font;
    (void*)checkfont(L, 1, &ud);
    if((font = ud->font) == NULL)
        return luaL_argerror(L, 1, "function not available for user created fonts"); //@@
    pushrunelist(L, font->config->range);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x3fb52(%rip), %rcx     # 0x600b1
pushq $0x1
popq %rbx
leaq 0x8(%rsp), %r15
movl %ebx, %esi
movq %r15, %rdx
callq 0x120e0
movq (%r15), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x2058f
movq 0x78(%rax), %rax
movq 0x30(%rax), %rsi
movq %r14, %rdi
callq 0x13230
jmp 0x205a3
leaq 0x45a9b(%rip), %rdx     # 0x66031
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x124a0
movl %eax, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/font.c
// Function: FindGlyph
static int FindGlyph(lua_State *L)
    {
    ud_t *ud;
    nk_font_t *font;
    const nk_font_glyph_t *glyph;
    nk_rune unicode;
    (void*)checkfont(L, 1, &ud);
    if((font = ud->font) == NULL)
        return luaL_argerror(L, 1, "function not available for user created fonts"); //@@
    unicode = luaL_checkinteger(L, 2);
    glyph = nk_font_find_glyph(font, unicode);
    if(!glyph) return 0; /* not found */
    return pushfontglyph(L, glyph);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3faf4(%rip), %rcx     # 0x600b1
pushq $0x1
popq %rsi
movq %rsp, %r14
movq %r14, %rdx
callq 0x120e0
movq (%r14), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x205fe
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %r14, %rdi
movl %eax, %esi
callq 0x141f0
testq %rax, %rax
je 0x20612
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12380
jmp 0x20614
leaq 0x45a2c(%rip), %rdx     # 0x66031
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x124a0
jmp 0x20614
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/font.c
// Function: New
static int New(lua_State *L)
/* user_font = user_font(height, width_func, texture_id, query_func) */
    {
    ud_t *ud;
    int ref1, ref2;
    nk_user_font_t *font;
    float height = luaL_checknumber(L, 1);
    int texture_id = luaL_checknumber(L, 3);
    if(!lua_isfunction(L, 2)) return argerrorc(L, 2, ERR_TYPE);
    if(!lua_isfunction(L, 4)) return argerrorc(L, 4, ERR_TYPE);
    lua_pushvalue(L, 2); ref1 = luaL_ref(L, LUA_REGISTRYINDEX);
    lua_pushvalue(L, 4); ref2 = luaL_ref(L, LUA_REGISTRYINDEX);

    font = (nk_user_font_t*)Malloc(L, sizeof(nk_user_font_t));
    ud = newuserdata(L, font, FONT_MT, "font (user)");
    ud->parent_ud = NULL;
    ud->font = NULL;
    ud->ref1 = ref1;
    ud->ref2 = ref2;
    ud->destructor = freefont;
    MarkAllocated(ud);

    font->userdata.ptr = ud;
    font->height = height; /* max height of the font */
    font->width = WidthCallback; /* font string width in pixel callback */
    font->query = QueryCallback; /* font glyph callback to query drawing info */
    font->texture.id = texture_id; /* texture handle to the used font atlas or texture */
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x12920
movsd %xmm0, (%rsp)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x12920
movsd %xmm0, 0x8(%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x14030
cmpl $0x6, %eax
jne 0x20736
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x14030
cmpl $0x6, %eax
jne 0x20742
cvtsd2ss (%rsp), %xmm0
movss %xmm0, (%rsp)
cvttsd2si 0x8(%rsp), %r12d
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x12e90
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12800
movl %eax, %ebp
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x12e90
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12800
movl %eax, %r14d
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x13c00
movq %rax, %r15
leaq 0x3f9e5(%rip), %rdx     # 0x600b1
leaq 0x459a8(%rip), %rcx     # 0x6607b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x140d0
andq $0x0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movl %ebp, 0x74(%rax)
movl %r14d, 0x78(%rax)
leaq -0x339(%rip), %rcx      # 0x203bd
movq %rcx, 0x8(%rax)
orb $0x20, 0x70(%rax)
movq %rax, (%r15)
movss (%rsp), %xmm0
movss %xmm0, 0x8(%r15)
leaq 0x9f(%rip), %rax        # 0x207b2
movq %rax, 0x10(%r15)
leaq 0x133(%rip), %rax       # 0x20851
movq %rax, 0x18(%r15)
movl %r12d, 0x20(%r15)
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x2
popq %rdi
callq 0x13cc0
pushq $0x2
jmp 0x2074c
pushq $-0x2
popq %rdi
callq 0x13cc0
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x124a0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/font.c
// Function: FontFromPtr
static int FontFromPtr(lua_State *L)
    {
    nk_font_t *ptr = (nk_font_t*)checklightuserdata(L, 1);
    nk_user_font_t *font = &ptr->handle;
    ud_t *ud = newuserdata(L, font, FONT_MT, "font (ptr)");
    ud->parent_ud = NULL;
    ud->font = ptr;
    ud->font_config = NULL;
    ud->destructor = freefont;
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x139f0
movq %rax, %r14
leaq 0x8(%rax), %rsi
leaq 0x3f92e(%rip), %rdx     # 0x600b1
leaq 0x458fd(%rip), %rcx     # 0x66087
movq %rbx, %rdi
callq 0x140d0
andq $0x0, 0x10(%rax)
movq %r14, 0x20(%rax)
andq $0x0, 0x68(%rax)
leaq -0x3ea(%rip), %rcx      # 0x203bd
movq %rcx, 0x8(%rax)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/font.c
// Function: WidthCallback
static float WidthCallback(nk_handle handle, float height, const char* text, int len) // nk_text_width_f
    {
#define L moonnuklear_L
    float width;
    ud_t *ud = (ud_t*)(handle.ptr);
    pushvalue(L, ud->ref1);    // function
    lua_pushnumber(L, height); // arg1
    lua_pushlstring(L, text, len); // arg2
    if(lua_pcall(L, 2, 1, 0) != LUA_OK)
        { lua_error(L); return 0; }
    width = luaL_checknumber(L, -1); // retval1
    lua_pop(L, 1);
    return width;
#undef L
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r14
movss %xmm0, 0xc(%rsp)
movq 0x64823(%rip), %r15     # 0x84ff0
movq (%r15), %rax
movslq 0x74(%rdi), %rdx
movq %rax, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12a00
movq (%r15), %rdi
cvtss2sd 0xc(%rsp), %xmm0
callq 0x132d0
movq (%r15), %rdi
movslq %ebx, %rdx
movq %r14, %rsi
callq 0x13840
movq (%r15), %rdi
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x14330
movq (%r15), %rdi
testl %eax, %eax
je 0x20824
callq 0x13960
xorps %xmm0, %xmm0
jmp 0x20847
pushq $-0x1
popq %rsi
callq 0x12920
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq (%r15), %rdi
pushq $-0x2
popq %rsi
callq 0x12190
movss 0xc(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq