LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/canvas.c
// Function: Fill_circle
static int Fill_circle(lua_State *L)
    {
    nk_rect_t r;
    nk_color_t color;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    if(echeckrect(L, 2, &r)) return argerror(L, 2);
    if(echeckcolor(L, 3, &color)) return argerror(L, 3);
    nk_fill_circle(canvas, r, color);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x51be9(%rip), %rcx     # 0x67142
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x139f0
testl %eax, %eax
je 0x15597
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x155c4
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12100
testl %eax, %eax
je 0x155d4
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x12460
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movl 0x4(%rsp), %esi
movq %r14, %rdi
callq 0x13dd0
xorl %eax, %eax
jmp 0x155cc
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/canvas.c
// Function: Fill_triangle
static int Fill_triangle(lua_State *L)
    {
    nk_color_t color;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    float x0 = luaL_checknumber(L, 2);
    float y0 = luaL_checknumber(L, 3);
    float x1 = luaL_checknumber(L, 4);
    float y1 = luaL_checknumber(L, 5);
    float x2 = luaL_checknumber(L, 6);
    float y2 = luaL_checknumber(L, 7);
    if(echeckcolor(L, 8, &color)) return argerror(L, 8);
    nk_fill_triangle(canvas, x0, y0, x1, y1, x2, y2, color);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x51a4a(%rip), %rcx     # 0x67142
xorl %ebx, %ebx
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
callq 0x12870
movsd %xmm0, 0x38(%rsp)
movq %r14, %rdi
movl $0x3, %esi
callq 0x12870
movsd %xmm0, 0x30(%rsp)
movq %r14, %rdi
movl $0x4, %esi
callq 0x12870
movsd %xmm0, 0x28(%rsp)
movq %r14, %rdi
movl $0x5, %esi
callq 0x12870
movsd %xmm0, 0x20(%rsp)
movq %r14, %rdi
movl $0x6, %esi
callq 0x12870
movsd %xmm0, 0x18(%rsp)
movq %r14, %rdi
movl $0x7, %esi
callq 0x12870
movsd %xmm0, 0x10(%rsp)
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
movl $0x8, %esi
callq 0x12100
testl %eax, %eax
je 0x157b4
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %r14, %rdi
movl $0x8, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %ebx
jmp 0x157e7
cvtsd2ss 0x10(%rsp), %xmm5
cvtsd2ss 0x18(%rsp), %xmm4
cvtsd2ss 0x20(%rsp), %xmm3
cvtsd2ss 0x28(%rsp), %xmm2
cvtsd2ss 0x30(%rsp), %xmm1
xorps %xmm0, %xmm0
cvtsd2ss 0x38(%rsp), %xmm0
movl 0xc(%rsp), %esi
movq %r15, %rdi
callq 0x138e0
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/canvas.c
// Function: Fill_polygon
static int Fill_polygon(lua_State *L)
    {
    int err, point_count;
    nk_color_t color;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    float *points = checkvec2list(L, 2, &point_count, &err);
    if(err) return argerrorc(L, 2, err);
    if(echeckcolor(L, 3, &color)) return argerror(L, 3);
    nk_fill_polygon(canvas, points, point_count, color);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x5193a(%rip), %rcx     # 0x67142
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x10(%rsp), %rdx
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rcx
callq 0x128b0
movl (%r12), %edi
testl %edi, %edi
je 0x15848
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x15878
movq %rax, %r15
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12100
testl %eax, %eax
je 0x1588c
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x12460
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movq %r14, %rdi
movq %r15, %rsi
callq 0x12240
xorl %eax, %eax
jmp 0x15880
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/canvas.c
// Function: Draw_image
static int Draw_image(lua_State *L)
    {
    nk_rect_t r;
    nk_color_t color;
    nk_image_t *image;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    if(echeckrect(L, 2, &r)) return argerror(L, 2);
    image = checkimage(L, 3, NULL);
    if(echeckcolor(L, 4, &color)) return argerror(L, 4);
    nk_draw_image(canvas, r, image, color);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x5188a(%rip), %rcx     # 0x67142
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x139f0
testl %eax, %eax
je 0x158f6
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x1593f
leaq 0x51947(%rip), %rcx     # 0x67244
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r12
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12100
testl %eax, %eax
je 0x15959
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movl 0x4(%rsp), %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x134d0
jmp 0x1594a
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/canvas.c
// Function: Draw_nine_slice
static int Draw_nine_slice(lua_State *L)
    {
    nk_rect_t r;
    nk_color_t color;
    nk_nine_slice_t *nine_slice;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    if(echeckrect(L, 2, &r)) return argerror(L, 2);
    nine_slice = checknine_slice(L, 3, NULL);
    if(echeckcolor(L, 4, &color)) return argerror(L, 4);
    nk_draw_nine_slice(canvas, r, nine_slice, color);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x517b7(%rip), %rcx     # 0x67142
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x139f0
testl %eax, %eax
je 0x159c9
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x15a12
leaq 0x51886(%rip), %rcx     # 0x67256
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r12
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12100
testl %eax, %eax
je 0x15a2c
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movl 0x4(%rsp), %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x13fe0
jmp 0x15a1d
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/canvas.c
// Function: Draw_text
static int Draw_text(lua_State *L)
    {
    size_t len;
    nk_rect_t r;
    nk_color_t bg, fg;
    const char *s;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    nk_user_font_t *font = checkfont(L, 4, NULL);
    if(echeckrect(L, 2, &r)) return argerror(L, 2);
    s = luaL_checklstring(L, 3, &len);
    if(echeckcolor(L, 5, &bg)) return argerror(L, 5);
    if(echeckcolor(L, 6, &fg)) return argerror(L, 6);
    nk_draw_text(canvas, r, s, (int)len, font, bg, fg);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x516e4(%rip), %rcx     # 0x67142
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x5163d(%rip), %rcx     # 0x670b1
movq %rbx, %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x139f0
testl %eax, %eax
je 0x15ab5
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x15b26
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12cd0
movq %rax, %r12
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl $0x5, %esi
callq 0x12100
testl %eax, %eax
je 0x15af9
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x5, %esi
jmp 0x15b26
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x6, %esi
callq 0x12100
testl %eax, %eax
je 0x15b3a
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x6, %esi
movq %rax, %rdx
callq 0x12460
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl 0x10(%rsp), %edx
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movl 0xc(%rsp), %r8d
movl 0x8(%rsp), %r9d
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0x13ca0
xorl %eax, %eax
jmp 0x15b2e
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/context.c
// Function: Convert
static int Convert(lua_State *L)
    {
    ud_t *ud;
    nk_context_t *context = checkcontext(L, 1, &ud);
    nk_buffer_t *cmds = checkbuffer(L, 2, NULL);
    nk_buffer_t *vertices = checkbuffer(L, 3, NULL);
    nk_buffer_t *elements = checkbuffer(L, 4, NULL);
    //BUFFER_PRINT(vertices, 16);
    //BUFFER_PRINT(elements, 16);
    nk_flags result = nk_convert(context, cmds, vertices, elements, &ud->config);
    pushflags(L, result);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5155e(%rip), %rcx     # 0x67280
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x120d0
movq %rax, %r15
leaq 0x51399(%rip), %r12     # 0x670d5
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x120d0
movq %rax, %r13
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x120d0
movq %rax, %rbp
movq %rbx, %rdi
movl $0x4, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x120d0
movq (%r14), %r8
addq $0x28, %r8
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rax, %rcx
callq 0x135a0
movl %eax, %esi
movq %rbx, %rdi
callq 0x12b60
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/context.c
// Function: Commands
static int Commands(lua_State *L)
    {
    int i = 1;
    nk_context_t *context = checkcontext(L, 1, NULL);
    nk_command_t *cmd = (nk_command_t*)nk__begin(context);
    lua_newtable(L);
    while(cmd)
        {
        pushcommand(L, cmd);
        lua_rawseti(L, -2, i++);
        cmd = (nk_command_t*)nk__next(context, cmd);
        }
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x514bf(%rip), %rcx     # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rax, %rdi
callq 0x12810
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x127c0
testq %r15, %r15
je 0x15e28
movl $0x1, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x12690
leaq 0x1(%r12), %r13
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r12, %rdx
callq 0x12f90
movq %r14, %rdi
movq %r15, %rsi
callq 0x12440
movq %rax, %r15
movq %r13, %r12
testq %rax, %rax
jne 0x15df2
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/context.c
// Function: DrawCommands
static int DrawCommands(lua_State *L)
    {
    int i = 1;
    nk_context_t *context = checkcontext(L, 1, NULL);
    nk_buffer_t *cmds = checkbuffer(L, 2, NULL);
    nk_draw_command_t *cmd = (nk_draw_command_t*)nk__draw_begin(context, cmds);
    lua_newtable(L);
    while(cmd)
        {
        pushdrawcommand(L, cmd);
        lua_rawseti(L, -2, i++);
        cmd = (nk_draw_command_t*)nk__draw_next(cmd, cmds, context);
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x51434(%rip), %rcx     # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x51273(%rip), %rcx     # 0x670d5
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x13da0
movq %rax, %r12
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x127c0
testq %r12, %r12
je 0x15ed1
movl $0x1, %r13d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x12370
leaq 0x1(%r13), %rbp
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r13, %rdx
callq 0x12f90
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12820
movq %rax, %r12
movq %rbp, %r13
testq %rax, %rax
jne 0x15e99
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/context.c
// Function: Set_clipboard_paste
static int Set_clipboard_paste(lua_State *L)
    {
    ud_t *ud;
    nk_context_t *context = checkcontext(L, 1, &ud);
    if(!lua_isfunction(L, 2))
        return argerrorc(L, 2, ERR_TYPE);
    unreference(L, ud->ref1);
    lua_pushvalue(L, 2);
    ud->ref1 = luaL_ref(L, LUA_REGISTRYINDEX);
    context->clip.paste = PluginPaste;
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5136d(%rip), %rcx     # 0x67280
movq %rsp, %rdx
movl $0x1, %esi
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13df0
cmpl $0x6, %eax
jne 0x15f8c
movq (%rsp), %rax
movl 0x74(%rax), %edx
cmpl $-0x2, %edx
je 0x15f59
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x13f50
movq (%rsp), %rax
movl $0xfffffffe, 0x74(%rax) # imm = 0xFFFFFFFE
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12d70
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12780
movq (%rsp), %rcx
movl %eax, 0x74(%rcx)
leaq 0x4ba(%rip), %rax       # 0x1643b
movq %rax, 0x2588(%r14)
xorl %eax, %eax
jmp 0x15fa6
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x12460
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/context.c
// Function: Set_clipboard_copy
static int Set_clipboard_copy(lua_State *L)
    {
    ud_t *ud;
    nk_context_t *context = checkcontext(L, 1, &ud);
    if(!lua_isfunction(L, 2))
        return argerrorc(L, 2, ERR_TYPE);
    unreference(L, ud->ref2);
    lua_pushvalue(L, 2);
    ud->ref2 = luaL_ref(L, LUA_REGISTRYINDEX);
    context->clip.copy = PluginCopy;
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x512c4(%rip), %rcx     # 0x67280
movq %rsp, %rdx
movl $0x1, %esi
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13df0
cmpl $0x6, %eax
jne 0x16035
movq (%rsp), %rax
movl 0x78(%rax), %edx
cmpl $-0x2, %edx
je 0x16002
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x13f50
movq (%rsp), %rax
movl $0xfffffffe, 0x78(%rax) # imm = 0xFFFFFFFE
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12d70
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12780
movq (%rsp), %rcx
movl %eax, 0x78(%rcx)
leaq 0x470(%rip), %rax       # 0x1649a
movq %rax, 0x2590(%r14)
xorl %eax, %eax
jmp 0x1604f
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x12460
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/context.c
// Function: Null_texture
static int Null_texture(lua_State *L)
    {
    nk_handle_t handle;
    nk_vec2_t uv;
    ud_t *ud; (void)checkcontext(L, 1, &ud);
    if(echeckvec2(L, 3, &uv)) return argerror(L, 3);
    if(lua_isnoneornil(L, 2))
        ud->config.tex_null.texture.id = 0;
    else
        {
        handle.id = luaL_checkinteger(L, 2);
        ud->config.tex_null.texture = handle;
        }
    ud->config.tex_null.uv = uv;
    return 0;
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x51067(%rip), %rcx     # 0x67280
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x120d0
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x14160
movq %rbx, %rdi
testl %eax, %eax
je 0x16261
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %ebp
jmp 0x16296
movl $0x2, %esi
callq 0x13df0
movl %eax, %ecx
xorl %ebp, %ebp
movl $0x0, %eax
testl %ecx, %ecx
jle 0x16285
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12f30
movq 0x8(%rsp), %rcx
movl %eax, 0x40(%rcx)
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rcx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/context.c
// Function: PluginPaste
static void PluginPaste(nk_handle handle, nk_edit_t *edit) /* nk_plugin_paste */
    {
#define L moonnuklear_L
    ud_t *ud = (ud_t*)(handle.ptr);
    pushvalue(L, ud->ref1);
    pushedit(L, edit);
    if(lua_pcall(L, 1, 0, 0) != LUA_OK)
        { lua_error(L); return; }
#undef L
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x70ba7(%rip), %r14     # 0x86ff0
movq (%r14), %rax
movslq 0x74(%rdi), %rdx
movq %rax, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12950
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x13c10
movq (%r14), %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x140b0
testl %eax, %eax
je 0x16492
movq (%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13780
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq 0x70b45(%rip), %r15     # 0x86ff0
movq (%r15), %rax
movslq 0x78(%rdi), %rdx
movq %rax, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12950
movq (%r15), %rdi
movslq %ebx, %rdx
movq %r14, %rsi
callq 0x13670
movq (%r15), %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x140b0
testl %eax, %eax
je 0x164f5
movq (%r15), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x13780
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x50ba7(%rip), %rcx     # 0x670b1
movl $0x1, %esi
xorl %edx, %edx
callq 0x14150
movq %rax, %r15
movl $0x4798, %esi           # imm = 0x4798
movq %rbx, %rdi
callq 0x13a00
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x12470
testl %eax, %eax
je 0x1658e
leaq 0x50d41(%rip), %rdx     # 0x67280
leaq 0x50e8f(%rip), %rcx     # 0x673d5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13e90
movq $0x0, 0x10(%rax)
leaq 0xbf(%rip), %rcx        # 0x1661f
movq %rcx, 0x8(%rax)
movq %rax, 0x2580(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x120a0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x130d0
leaq 0x50e27(%rip), %rsi     # 0x673c7
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x139b0
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x13800
movq %rax, %r14
leaq 0x50cb6(%rip), %rdx     # 0x67280
leaq 0x50e2f(%rip), %rcx     # 0x67400
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13e90
movq $0x0, 0x10(%rax)
leaq 0x34(%rip), %rcx        # 0x1661f
movq %rcx, 0x8(%rax)
movq %rax, 0x2580(%r14)
orb $0x40, 0x70(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x120a0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %r14
movq (%rsi), %rbx
movq 0x80(%rsi), %r15
movl 0x70(%rsi), %ebp
leaq 0x50d9c(%rip), %rsi     # 0x673dd
movq %r12, %rdx
callq 0x121c0
leaq 0x50d9f(%rip), %rsi     # 0x673ef
movq %r14, %rdi
movq %r12, %rdx
callq 0x121c0
leaq 0x50d73(%rip), %rdx     # 0x673d5
movq %r14, %rdi
movq %r12, %rsi
callq 0x13d00
testl %eax, %eax
je 0x1669a
testq %r15, %r15
je 0x16681
movq %r14, %rdi
movq %r15, %rsi
callq 0x130d0
testb $0x40, %bpl
jne 0x1669a
movq %rbx, %rdi
callq 0x12530
movq %r14, %rdi
movq %rbx, %rsi
callq 0x130d0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %rdi
callq 0x132d0
testq %rax, %rax
je 0x166d0
movq %r15, %rdi
movq %r14, %rsi
callq 0x13c10
jmp 0x166fc
leaq 0x509eb(%rip), %rdx     # 0x670c2
leaq 0x56821(%rip), %rcx     # 0x6ceff
movq %r15, %rdi
movq %r14, %rsi
callq 0x13e90
movq %rbx, 0x10(%rax)
leaq 0x13(%rip), %rcx        # 0x16707
movq %rcx, 0x8(%rax)
orb $0x10, 0x70(%rax)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rsi), %rbx
movl 0x70(%rsi), %ebp
leaq 0x567e4(%rip), %rdx     # 0x6ceff
callq 0x13d00
testl %eax, %eax
je 0x16734
andl $0x10, %ebp
jne 0x16734
movq %r14, %rdi
movq %rbx, %rsi
callq 0x130d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x50a63(%rip), %rcx     # 0x67244
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
callq 0x120d0
movq %rax, %r14
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x14160
testl %eax, %eax
je 0x16822
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x1684d
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x14160
testl %eax, %eax
je 0x1685d
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x12460
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl $0x28, %esi
movq %rbx, %rdi
callq 0x13a00
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq (%rsp), %rcx
movq %rcx, 0x20(%rax)
leaq 0x50831(%rip), %rdx     # 0x670c2
leaq 0x56667(%rip), %rcx     # 0x6ceff
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13e90
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq -0x1ac(%rip), %rcx      # 0x16707
movq %rcx, 0x8(%rax)
movl $0x1, %eax
jmp 0x16855
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x132d0
testq %rax, %rax
je 0x168fc
movq %r15, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x13c10
leaq 0x50aec(%rip), %rdx     # 0x673ef
leaq 0x50af1(%rip), %rcx     # 0x673fb
movq %r15, %rdi
movq %r14, %rsi
callq 0x13e90
movq %rbx, 0x10(%rax)
movq %r12, 0x18(%rax)
leaq 0x19(%rip), %rcx        # 0x1693d
movq %rcx, 0x8(%rax)
orb $0x2, 0x70(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x50aa0(%rip), %rdx     # 0x673fb
callq 0x13d00
testl %eax, %eax
je 0x1698d
testq %r15, %r15
je 0x16974
movq %r14, %rdi
movq %r15, %rsi
callq 0x130d0
testb $0x2, %bpl
jne 0x1698d
movq %rbx, %rdi
callq 0x13cd0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x130d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x132d0
movq 0x70437(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
movslq 0x74(%rax), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12950
movq (%r15), %rdi
movq %r14, %rsi
callq 0x13c10
movq (%r15), %rdi
movl %ebx, %esi
callq 0x12b60
movq (%r15), %rdi
movl $0x2, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x140b0
movq (%r15), %rdi
testl %eax, %eax
je 0x16c09
callq 0x13780
xorl %eax, %eax
jmp 0x16c24
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x13770
movl %eax, %ebx
movq (%r15), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x50630(%rip), %rcx     # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12f30
movq %r14, %rdi
movl %eax, %esi
callq 0x12d30
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x506df(%rip), %rcx     # 0x673ef
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x12cd0
movl (%r15), %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x129e0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x50692(%rip), %rcx     # 0x673ef
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12f30
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x12360
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x505ce(%rip), %rcx     # 0x673ef
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x12cd0
movl (%r15), %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x14100
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x128c0
testq %rax, %rax
je 0x179d6
movl %ebp, %edi
movq %rax, %rsi
callq 0x179ef
testq %rax, %rax
je 0x179de
movl $0x0, (%rbx)
movl 0x44(%rax), %r14d
jmp 0x179e7
movl $0x1, (%rbx)
jmp 0x179e7
movl $0xfffffffd, (%rbx)     # imm = 0xFFFFFFFD
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x12cd0
movq %rax, %r15
movl %ebp, %edi
movq %rax, %rsi
callq 0x179ef
testq %rax, %rax
je 0x17a80
movl 0x44(%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4fa0a(%rip), %rsi     # 0x67491
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x12d80
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq 0x7064d(%rip), %rax     # 0x88100
testq %rax, %rax
je 0x17ad2
cmpl %esi, 0x40(%rax)
jne 0x17ac0
cmpl %edx, 0x44(%rax)
setb %cl
ja 0x17acd
testb %cl, %cl
je 0x17aee
addq $0x8, %rax
movq (%rax), %rax
jmp 0x17ab3
leaq 0x4f646(%rip), %rsi     # 0x6711f
leaq 0x4f9c4(%rip), %rdx     # 0x674a4
movl $0xca, %ecx
xorl %eax, %eax
popq %r8
jmp 0x139b0
movq 0x48(%rax), %rsi
callq 0x13f90
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x127c0
movq 0x705e6(%rip), %rax     # 0x88100
testq %rax, %rax
je 0x17bb7
xorl %ecx, %ecx
movl 0x40(%rax), %edx
cmpl %ebx, %edx
jne 0x17b37
cmpl $0x0, 0x44(%rax)
movq %rax, %rcx
jne 0x17b44
jmp 0x17b54
jbe 0x17b3e
movq %rax, %rcx
jmp 0x17b44
jae 0x17b54
addq $0x8, %rax
movq (%rax), %rax
testq %rax, %rax
jne 0x17b25
movq %rcx, %rax
testq %rcx, %rcx
je 0x17bb7
movl $0x1, %ebp
movq %rax, %r15
cmpl %ebx, 0x40(%rax)
jne 0x17b7f
movq 0x48(%r15), %rsi
movq %r14, %rdi
callq 0x13f90
movslq %ebp, %rdx
incl %ebp
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12f90
movq 0x8(%r15), %rcx
testq %rcx, %rcx
je 0x17b95
movq %rcx, %rax
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x17b88
jmp 0x17b59
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x17ba3
cmpq %r15, (%rax)
je 0x17b59
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x17bb7
cmpq 0x8(%rax), %r15
movq %rax, %r15
je 0x17ba3
jmp 0x17b59
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rdi, %r15
xorl %eax, %eax
movq %rcx, 0x8(%rsp)
movl %eax, (%rcx)
movl %eax, (%r8)
movl %edx, %esi
callq 0x13df0
testl %eax, %eax
jle 0x17caa
movq %r15, %rdi
movl %ebp, %esi
callq 0x13df0
cmpl $0x5, %eax
jne 0x17cb3
movq %r15, %rdi
movl %ebp, %esi
callq 0x13e10
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
testl %eax, %eax
je 0x17caa
movl %eax, %esi
shlq $0x2, %rsi
movq %r15, %rdi
callq 0x12ba0
testq %rax, %rax
je 0x17ccf
movq %rax, %r13
xorl %r12d, %r12d
movq 0x8(%rsp), %rax
movl (%rax), %eax
cmpq %rax, %r12
jae 0x17cbd
leaq 0x1(%r12), %rbx
movq %r15, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x12950
movq %r15, %rdi
movl 0x14(%rsp), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r14, %rcx
callq 0x13420
movl %eax, (%r13,%r12,4)
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
cmpl $0x0, (%r14)
movq %rbx, %r12
je 0x17c45
movq %r15, %rdi
movq %r13, %rsi
callq 0x130d0
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
jmp 0x17cba
movl $0x1, (%r14)
jmp 0x17cba
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
movl $0x0, (%rax)
movl $0xfffffffa, (%r14)     # imm = 0xFFFFFFFA
jmp 0x17cba
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %ebp
movl $0x1, %esi
callq 0x13df0
cmpl $0x3, %eax
jne 0x1f73a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12f30
movq %rax, %r14
leaq 0x4d6f5(%rip), %rsi     # 0x6cdbf
movq %rbx, %rdi
callq 0x13f90
testb $0x1, %r14b
je 0x1f6ec
leaq 0x4d6e8(%rip), %rsi     # 0x6cdc7
movq %rbx, %rdi
callq 0x13f90
movl $0x2, %ebp
testb $0x2, %r14b
je 0x1f703
leaq 0x4d6dc(%rip), %rsi     # 0x6cdd5
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x4, %r14b
je 0x1f71a
leaq 0x4d6d9(%rip), %rsi     # 0x6cde9
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x8, %r14b
je 0x1f805
leaq 0x4d6d1(%rip), %rsi     # 0x6cdfc
movq %rbx, %rdi
callq 0x13f90
incl %ebp
jmp 0x1f805
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x141b0
xorl %r14d, %r14d
testl %eax, %eax
je 0x1f7f5
leaq 0x4d661(%rip), %r15     # 0x6cdbf
leaq 0x4d662(%rip), %r12     # 0x6cdc7
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x12630
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x12e90
testl %eax, %eax
je 0x1f7e1
movq %r13, %rdi
movq %r12, %rsi
callq 0x12e90
testl %eax, %eax
je 0x1f7d1
movq %r13, %rdi
leaq 0x4d639(%rip), %rsi     # 0x6cdd5
callq 0x12e90
testl %eax, %eax
je 0x1f7d7
movq %r13, %rdi
leaq 0x4d63a(%rip), %rsi     # 0x6cde9
callq 0x12e90
testl %eax, %eax
je 0x1f7dd
movq %r13, %rdi
leaq 0x4d63a(%rip), %rsi     # 0x6cdfc
callq 0x12e90
testl %eax, %eax
jne 0x1f816
orl $0x8, %r14d
jmp 0x1f7e1
orl $0x1, %r14d
jmp 0x1f7e1
orl $0x2, %r14d
jmp 0x1f7e1
orl $0x4, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x141b0
testl %eax, %eax
jne 0x1f765
movl %r14d, %esi
movq %rbx, %rdi
callq 0x12b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x47c74(%rip), %rsi     # 0x67491
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x12d80
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %r14d
jmp 0x1f7f5
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x13df0
cmpl $0x3, %eax
jne 0x1fc38
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12f30
movq %rax, %r14
xorl %ebp, %ebp
testb $0x2, %r14b
je 0x1fb8b
leaq 0x4d2f0(%rip), %rsi     # 0x6ce6e
movq %rbx, %rdi
callq 0x13f90
movl $0x1, %ebp
testb $0x4, %r14b
je 0x1fba2
leaq 0x4d2df(%rip), %rsi     # 0x6ce77
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x8, %r14b
je 0x1fbb9
leaq 0x4d2eb(%rip), %rsi     # 0x6ce9a
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x10, %r14b
je 0x1fbd0
leaq 0x48a77(%rip), %rsi     # 0x6863d
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x20, %r14b
je 0x1fbe7
leaq 0x4d2a3(%rip), %rsi     # 0x6ce80
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x40, %r14b
je 0x1fbfe
leaq 0x47a9c(%rip), %rsi     # 0x67690
movq %rbx, %rdi
callq 0x13f90
incl %ebp
notl %r14d
testb $0x12, %r14b
jne 0x1fc18
leaq 0x53cf5(%rip), %rsi     # 0x73903
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x22, %r14b
jne 0x1fd67
leaq 0x491f2(%rip), %rsi     # 0x68e1b
movq %rbx, %rdi
callq 0x13f90
incl %ebp
jmp 0x1fd67
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x141b0
xorl %r14d, %r14d
testl %eax, %eax
je 0x1fd57
leaq 0x4d212(%rip), %r15     # 0x6ce6e
leaq 0x4d214(%rip), %r12     # 0x6ce77
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x12630
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x12e90
testl %eax, %eax
je 0x1fd11
movq %r13, %rdi
movq %r12, %rsi
callq 0x12e90
testl %eax, %eax
je 0x1fd18
movq %r13, %rdi
leaq 0x4d1f8(%rip), %rsi     # 0x6ce9a
callq 0x12e90
testl %eax, %eax
je 0x1fd1f
movq %r13, %rdi
leaq 0x48988(%rip), %rsi     # 0x6863d
callq 0x12e90
testl %eax, %eax
je 0x1fd26
movq %r13, %rdi
leaq 0x4d1b8(%rip), %rsi     # 0x6ce80
callq 0x12e90
testl %eax, %eax
je 0x1fd2d
movq %r13, %rdi
leaq 0x479b5(%rip), %rsi     # 0x67690
callq 0x12e90
testl %eax, %eax
je 0x1fd34
movq %r13, %rdi
leaq 0x53c15(%rip), %rsi     # 0x73903
callq 0x12e90
testl %eax, %eax
je 0x1fd3b
movq %r13, %rdi
leaq 0x4911a(%rip), %rsi     # 0x68e1b
callq 0x12e90
movl $0x22, %ecx
testl %eax, %eax
je 0x1fd40
jmp 0x1fd78
movl $0x2, %ecx
jmp 0x1fd40
movl $0x4, %ecx
jmp 0x1fd40
movl $0x8, %ecx
jmp 0x1fd40
movl $0x10, %ecx
jmp 0x1fd40
movl $0x20, %ecx
jmp 0x1fd40
movl $0x40, %ecx
jmp 0x1fd40
movl $0x12, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x141b0
testl %eax, %eax
jne 0x1fc63
movl %r14d, %esi
movq %rbx, %rdi
callq 0x12b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x47712(%rip), %rsi     # 0x67491
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x12d80
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %r14d
jmp 0x1fd57
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x13df0
cmpl $0x3, %eax
jne 0x1fe67
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12f30
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x1fdeb
leaq 0x4d0aa(%rip), %rsi     # 0x6ce88
movq %rbx, %rdi
callq 0x13f90
movl $0x1, %ebp
testb $0x2, %r14b
je 0x1fe02
leaq 0x4d09b(%rip), %rsi     # 0x6ce93
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x4, %r14b
je 0x1fe19
leaq 0x4d093(%rip), %rsi     # 0x6cea2
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x8, %r14b
je 0x1fe30
leaq 0x4d088(%rip), %rsi     # 0x6ceae
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x10, %r14b
je 0x1fe47
leaq 0x4d07b(%rip), %rsi     # 0x6ceb8
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x20, %r14b
je 0x1ffb4
leaq 0x4d06d(%rip), %rsi     # 0x6cec5
movq %rbx, %rdi
callq 0x13f90
incl %ebp
jmp 0x1ffb4
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x141b0
xorl %r14d, %r14d
testl %eax, %eax
je 0x1ffa4
leaq 0x4cffd(%rip), %r15     # 0x6ce88
leaq 0x4d001(%rip), %r12     # 0x6ce93
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x12630
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x12e90
testl %eax, %eax
je 0x1ff57
movq %r13, %rdi
movq %r12, %rsi
callq 0x12e90
testl %eax, %eax
je 0x1ff5e
movq %r13, %rdi
leaq 0x4cfd1(%rip), %rsi     # 0x6cea2
callq 0x12e90
testl %eax, %eax
je 0x1ff65
movq %r13, %rdi
leaq 0x4cfc6(%rip), %rsi     # 0x6ceae
callq 0x12e90
testl %eax, %eax
je 0x1ff6c
movq %r13, %rdi
leaq 0x4cfbd(%rip), %rsi     # 0x6ceb8
callq 0x12e90
testl %eax, %eax
je 0x1ff73
movq %r13, %rdi
leaq 0x4cfb7(%rip), %rsi     # 0x6cec5
callq 0x12e90
testl %eax, %eax
je 0x1ff7a
movq %r13, %rdi
leaq 0x4776f(%rip), %rsi     # 0x67690
callq 0x12e90
testl %eax, %eax
je 0x1ff81
movq %r13, %rdi
leaq 0x4cf65(%rip), %rsi     # 0x6ce99
callq 0x12e90
testl %eax, %eax
je 0x1ff88
movq %r13, %rdi
leaq 0x4776b(%rip), %rsi     # 0x676b2
callq 0x12e90
movl $0x14, %ecx
testl %eax, %eax
je 0x1ff8d
jmp 0x1ffc5
movl $0x1, %ecx
jmp 0x1ff8d
movl $0x2, %ecx
jmp 0x1ff8d
movl $0x4, %ecx
jmp 0x1ff8d
movl $0x8, %ecx
jmp 0x1ff8d
movl $0x10, %ecx
jmp 0x1ff8d
movl $0x20, %ecx
jmp 0x1ff8d
movl $0x11, %ecx
jmp 0x1ff8d
movl $0x12, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x141b0
testl %eax, %eax
jne 0x1fe92
movl %r14d, %esi
movq %rbx, %rdi
callq 0x12b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x474c5(%rip), %rsi     # 0x67491
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x12d80
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %r14d
jmp 0x1ffa4