LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/atlas.c
// Function: Cursor
static int Cursor(lua_State *L)
    {
    ud_t *ud;
    nk_atlas_t *atlas = checkatlas(L, 1, &ud);
    enum nk_style_cursor what = checkstylecursor(L, 2);
    pushatlascursor(L, ud, &atlas->cursors[what]);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x53a11(%rip), %rcx     # 0x68000
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x120d0
movq %rax, %r15
movq %rbx, %rdi
movl $0x10, %esi
movl $0x2, %edx
callq 0x132f0
movq (%r14), %rsi
movl %eax, %eax
leaq (%rax,%rax,4), %rax
leaq (%r15,%rax,8), %rdx
addq $0x48, %rdx
movq %rbx, %rdi
callq 0x13c20
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/atlas.c
// Function: Init
static int Init(lua_State *L)
    {
    ud_t *ud;
    nk_atlas_t *atlas;
    atlas = (nk_atlas_t*)Malloc(L, sizeof(nk_atlas_t));
    nk_font_atlas_init_default(atlas);
    //void nk_font_atlas_init(nk_atlas_t*, nk_allocator_t*);
    //void nk_font_atlas_init_custom(nk_atlas_t*, nk_allocator_t*, nk_allocator_t*);
    ud = newuserdata(L, atlas, ATLAS_MT, "atlas");
    ud->parent_ud = NULL;
    ud->destructor = freefont_atlas;
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x190, %esi            # imm = 0x190
callq 0x13a00
movq %rax, %r14
movq %rax, %rdi
callq 0x129d0
leaq 0x5399f(%rip), %rdx     # 0x68000
leaq 0x539a4(%rip), %rcx     # 0x6800c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13e90
movq $0x0, 0x10(%rax)
leaq 0x7d(%rip), %rcx        # 0x146ff
movq %rcx, 0x8(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/atlas.c
// Function: freefont_atlas
static int freefont_atlas(lua_State *L, ud_t *ud)
    {
    nk_atlas_t *atlas = (nk_atlas_t*)ud->handle;
    freechildren(L, FONT_MT, ud);
    freechildren(L, CURSOR_MT, ud);
    if(!freeuserdata(L, ud, "atlas")) return 0;
    nk_font_atlas_clear(atlas);
    Free(L, atlas);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rbx
leaq 0x5399d(%rip), %rsi     # 0x680b1
movq %r15, %rdx
callq 0x121c0
leaq 0x5399f(%rip), %rsi     # 0x680c2
movq %r14, %rdi
movq %r15, %rdx
callq 0x121c0
leaq 0x538d7(%rip), %rdx     # 0x6800c
movq %r14, %rdi
movq %r15, %rsi
callq 0x13d00
testl %eax, %eax
je 0x14757
movq %rbx, %rdi
callq 0x13b00
movq %r14, %rdi
movq %rbx, %rsi
callq 0x130d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/buffer.c
// Function: Init
static int Init(lua_State *L)
    {
    ud_t *ud;
    nk_buffer_t *buffer = checkbuffer(L, 1, &ud);
    void *ptr = checklightuserdata(L, 2);
    nk_size size = luaL_checkinteger(L, 3);
    if(size <= 0) return argerrorc(L, 3, ERR_VALUE);
    if(!IsFixed(ud))
        return luaL_argerror(L, 1, "not a fixed buffer");
    if(IsInitialized(ud))
        nk_buffer_free(buffer);
    nk_buffer_init_fixed(buffer, ptr, size);
    MarkInitialized(ud);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x538ae(%rip), %rcx     # 0x680d5
movq %rsp, %rdx
movl $0x1, %esi
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13800
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
testq %rax, %rax
je 0x14878
movq %rax, %r12
movq (%rsp), %rax
movl 0x70(%rax), %eax
testb $0x4, %al
jne 0x14894
leaq 0x53885(%rip), %rdx     # 0x680f3
movq %rbx, %rdi
movl $0x1, %esi
jmp 0x1488d
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x148b8
testb $0x8, %al
je 0x148a0
movq %r14, %rdi
callq 0x13d60
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x12680
movq (%rsp), %rax
orl $0x8, 0x70(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/buffer.c
// Function: Buffer_ptr
static int Buffer_ptr(lua_State *L)
    {
    nk_buffer_t *buffer = checkbuffer(L, 1, NULL);
    void *ptr = nk_buffer_memory(buffer);
    if(!ptr) return 0;
    lua_pushlightuserdata(L, ptr);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x53803(%rip), %rcx     # 0x680d5
xorl %r14d, %r14d
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %rdi
callq 0x13080
testq %rax, %rax
je 0x148ff
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13450
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/buffer.c
// Function: New
static int New(lua_State *L)
    {
    enum nk_allocation_type type = checkallocationtype(L, 1);
    switch(type)
        {
        case NK_BUFFER_DYNAMIC: return CreateDefault(L);
        case NK_BUFFER_FIXED: return CreateFixed(L);
        default: break;
        }
    return unexpected(L);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x13, %esi
movl $0x1, %edx
callq 0x132f0
testl %eax, %eax
je 0x1497a
cmpl $0x1, %eax
jne 0x149b6
movl $0x78, %esi
movq %rbx, %rdi
callq 0x13a00
movq %rax, %r14
movq %rax, %rdi
callq 0x130a0
leaq 0x53785(%rip), %rdx     # 0x680d5
leaq 0x537a8(%rip), %rcx     # 0x680ff
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13e90
movq $0x0, 0x10(%rax)
leaq 0x151(%rip), %rcx       # 0x14ac2
movq %rcx, 0x8(%rax)
jmp 0x14a3c
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13df0
testl %eax, %eax
jle 0x149db
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13800
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
testq %rax, %rax
je 0x14a4a
movq %rax, %r15
jmp 0x149de
leaq 0x53762(%rip), %rsi     # 0x6811f
leaq 0x53775(%rip), %rdx     # 0x68139
movq %rbx, %rdi
movl $0x56, %ecx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x139b0
xorl %r14d, %r14d
movl $0x78, %esi
movq %rbx, %rdi
callq 0x13a00
movq %rax, %r12
testq %r14, %r14
je 0x14a08
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x12680
movl $0xc, %ebp
jmp 0x14a0d
movl $0x4, %ebp
leaq 0x536c1(%rip), %rdx     # 0x680d5
leaq 0x536e4(%rip), %rcx     # 0x680ff
movq %rbx, %rdi
movq %r12, %rsi
callq 0x13e90
movq $0x0, 0x10(%rax)
leaq 0x8d(%rip), %rcx        # 0x14ac2
movq %rcx, 0x8(%rax)
orl %ebp, 0x70(%rax)
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/buffer.c
// Function: Clear_buffers
static int Clear_buffers(lua_State *L)
    {
    nk_buffer_t *buffer;
    int arg = 1;
    while(!lua_isnoneornil(L, arg))
        {
        buffer = checkbuffer(L, arg++, NULL);
        nk_buffer_clear(buffer);
        }
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x13df0
testl %eax, %eax
jle 0x14aba
movl $0x2, %r14d
leaq 0x53646(%rip), %r15     # 0x680d5
leal -0x1(%r14), %esi
movq %rbx, %rdi
xorl %edx, %edx
movq %r15, %rcx
callq 0x120d0
movq %rax, %rdi
callq 0x12e10
movq %rbx, %rdi
movl %r14d, %esi
callq 0x13df0
incl %r14d
testl %eax, %eax
jg 0x14a8f
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/buffer.c
// Function: freebuffer
static int freebuffer(lua_State *L, ud_t *ud)
    {
    nk_buffer_t *buffer = (nk_buffer_t*)ud->handle;
    int is_initialized = IsInitialized(ud);
    if(!freeuserdata(L, ud, "buffer")) return 0;
    if(is_initialized) nk_buffer_free(buffer);
    Free(L, buffer);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rsi), %rbx
movl 0x70(%rsi), %ebp
leaq 0x53629(%rip), %rdx     # 0x680ff
callq 0x13d00
testl %eax, %eax
je 0x14af8
testb $0x8, %bpl
je 0x14aed
movq %rbx, %rdi
callq 0x13d60
movq %r14, %rdi
movq %rbx, %rsi
callq 0x130d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/canvas.c
// Function: moonnuklear_newanvasc
int newcanvas(lua_State *L, nk_canvas_t *canvas)
    {
    ud_t *ud = userdata(canvas);
    if(ud) /* already in */
        pushcanvas(L, canvas);
    else /* new */
        {
        ud = newuserdata(L, canvas, CANVAS_MT, "canvas");
        ud->parent_ud = NULL;
        ud->destructor = freecanvas;
        }
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x132d0
testq %rax, %rax
je 0x14b24
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13c10
jmp 0x14b50
leaq 0x53617(%rip), %rdx     # 0x68142
leaq 0x5361c(%rip), %rcx     # 0x6814e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13e90
movq $0x0, 0x10(%rax)
leaq 0x11(%rip), %rcx        # 0x14b5d
movq %rcx, 0x8(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/canvas.c
// Function: Stroke_line
static int Stroke_line(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 line_thickness = luaL_checknumber(L, 6);
    if(echeckcolor(L, 7, &color)) return argerror(L, 7);
    nk_stroke_line(canvas, x0, y0, x1, y1, line_thickness, color);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
leaq 0x5352c(%rip), %rcx     # 0x68142
xorl %ebx, %ebx
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
callq 0x12870
movsd %xmm0, 0x28(%rsp)
movq %r14, %rdi
movl $0x3, %esi
callq 0x12870
movsd %xmm0, 0x20(%rsp)
movq %r14, %rdi
movl $0x4, %esi
callq 0x12870
movsd %xmm0, 0x18(%rsp)
movq %r14, %rdi
movl $0x5, %esi
callq 0x12870
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
movl $0x6, %esi
callq 0x12870
movsd %xmm0, 0x8(%rsp)
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
movl $0x7, %esi
callq 0x12100
testl %eax, %eax
je 0x14cbf
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %r14, %rdi
movl $0x7, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %ebx
jmp 0x14cec
cvtsd2ss 0x8(%rsp), %xmm4
cvtsd2ss 0x10(%rsp), %xmm3
cvtsd2ss 0x18(%rsp), %xmm2
cvtsd2ss 0x20(%rsp), %xmm1
xorps %xmm0, %xmm0
cvtsd2ss 0x28(%rsp), %xmm0
movl 0x4(%rsp), %esi
movq %r15, %rdi
callq 0x12880
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/canvas.c
// Function: Stroke_curve
static int Stroke_curve(lua_State *L)
    {
    nk_color_t color;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    float ax = luaL_checknumber(L, 2);
    float ay = luaL_checknumber(L, 3);
    float ctrl0x = luaL_checknumber(L, 4);
    float ctrl0y = luaL_checknumber(L, 5);
    float ctrl1x = luaL_checknumber(L, 6);
    float ctrl1y = luaL_checknumber(L, 7);
    float bx = luaL_checknumber(L, 8);
    float by = luaL_checknumber(L, 9);
    float line_thickness = luaL_checknumber(L, 10);
    if(echeckcolor(L, 11, &color)) return argerror(L, 11);
    nk_stroke_curve(canvas, ax, ay, ctrl0x, ctrl0y, ctrl1x, ctrl1y, bx, by, line_thickness, color);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r14
leaq 0x53437(%rip), %rcx     # 0x68142
xorl %ebx, %ebx
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
callq 0x12870
movsd %xmm0, 0x58(%rsp)
movq %r14, %rdi
movl $0x3, %esi
callq 0x12870
movsd %xmm0, 0x50(%rsp)
movq %r14, %rdi
movl $0x4, %esi
callq 0x12870
movsd %xmm0, 0x48(%rsp)
movq %r14, %rdi
movl $0x5, %esi
callq 0x12870
movsd %xmm0, 0x40(%rsp)
movq %r14, %rdi
movl $0x6, %esi
callq 0x12870
movsd %xmm0, 0x38(%rsp)
movq %r14, %rdi
movl $0x7, %esi
callq 0x12870
movsd %xmm0, 0x30(%rsp)
movq %r14, %rdi
movl $0x8, %esi
callq 0x12870
movsd %xmm0, 0x28(%rsp)
movq %r14, %rdi
movl $0x9, %esi
callq 0x12870
movsd %xmm0, 0x20(%rsp)
movq %r14, %rdi
movl $0xa, %esi
callq 0x12870
movsd %xmm0, 0x18(%rsp)
leaq 0x14(%rsp), %rdx
movq %r14, %rdi
movl $0xb, %esi
callq 0x12100
testl %eax, %eax
je 0x14e00
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %r14, %rdi
movl $0xb, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %ebx
jmp 0x14e4c
cvtsd2ss 0x18(%rsp), %xmm8
cvtsd2ss 0x20(%rsp), %xmm7
cvtsd2ss 0x28(%rsp), %xmm6
cvtsd2ss 0x30(%rsp), %xmm5
cvtsd2ss 0x38(%rsp), %xmm4
cvtsd2ss 0x40(%rsp), %xmm3
cvtsd2ss 0x48(%rsp), %xmm2
cvtsd2ss 0x50(%rsp), %xmm1
xorps %xmm0, %xmm0
cvtsd2ss 0x58(%rsp), %xmm0
movl 0x14(%rsp), %esi
movss %xmm8, (%rsp)
movq %r15, %rdi
callq 0x13cc0
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/canvas.c
// Function: Stroke_rect
static int Stroke_rect(lua_State *L)
    {
    nk_rect_t r;
    nk_color_t color;
    float rounding, line_thickness;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    if(echeckrect(L, 2, &r)) return argerror(L, 2);
    rounding = luaL_checknumber(L, 3);
    line_thickness = luaL_checknumber(L, 4);
    if(echeckcolor(L, 5, &color)) return argerror(L, 5);
    nk_stroke_rect(canvas, r, rounding, line_thickness, color);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x532d9(%rip), %rcx     # 0x68142
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x139f0
movq %rbx, %rdi
testl %eax, %eax
je 0x14ea7
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x14ef7
movl $0x3, %esi
callq 0x12870
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12870
movsd %xmm0, 0x8(%rsp)
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
movl $0x5, %esi
callq 0x12100
testl %eax, %eax
je 0x14f07
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x5, %esi
movq %rax, %rdx
callq 0x12460
addq $0x28, %rsp
popq %rbx
popq %r14
retq
cvtsd2ss 0x8(%rsp), %xmm3
cvtsd2ss 0x10(%rsp), %xmm2
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movl 0x4(%rsp), %esi
movq %r14, %rdi
callq 0x12060
xorl %eax, %eax
jmp 0x14eff
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/canvas.c
// Function: Stroke_circle
static int Stroke_circle(lua_State *L)
    {
    nk_rect_t r;
    nk_color_t color;
    float line_thickness;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    if(echeckrect(L, 2, &r)) return argerror(L, 2);
    line_thickness = luaL_checknumber(L, 3);
    if(echeckcolor(L, 4, &color)) return argerror(L, 4);
    nk_stroke_circle(canvas, r, line_thickness, color);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x53202(%rip), %rcx     # 0x68142
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x139f0
movq %rbx, %rdi
testl %eax, %eax
je 0x14f7e
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x14fbb
movl $0x3, %esi
callq 0x12870
movsd %xmm0, 0x10(%rsp)
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12100
testl %eax, %eax
je 0x14fcb
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x12460
addq $0x28, %rsp
popq %rbx
popq %r14
retq
cvtsd2ss 0x10(%rsp), %xmm2
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movl 0xc(%rsp), %esi
movq %r14, %rdi
callq 0x13fa0
xorl %eax, %eax
jmp 0x14fc3
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/canvas.c
// Function: Stroke_arc
static int Stroke_arc(lua_State *L)
    {
    nk_color_t color;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    float cx = luaL_checknumber(L, 2);
    float cy = luaL_checknumber(L, 3);
    float radius = luaL_checknumber(L, 4);
    float a_min = luaL_checknumber(L, 5);
    float a_max = luaL_checknumber(L, 6);
    float line_thickness = luaL_checknumber(L, 7);
    if(echeckcolor(L, 8, &color)) return argerror(L, 8);
    nk_stroke_arc(canvas, cx, cy, radius, a_min, a_max, line_thickness, color);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x53142(%rip), %rcx     # 0x68142
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 0x150bc
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 0x150ef
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 0x12ee0
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/canvas.c
// Function: Stroke_triangle
static int Stroke_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);
    float line_thickness = luaL_checknumber(L, 8);
    if(echeckcolor(L, 9, &color)) return argerror(L, 9);
    nk_stroke_triangle(canvas, x0, y0, x1, y1, x2, y2, line_thickness, color);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x53034(%rip), %rcx     # 0x68142
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)
movq %r14, %rdi
movl $0x8, %esi
callq 0x12870
movsd %xmm0, 0x8(%rsp)
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
movl $0x9, %esi
callq 0x12100
testl %eax, %eax
je 0x151dd
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %r14, %rdi
movl $0x9, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %ebx
jmp 0x15216
cvtsd2ss 0x8(%rsp), %xmm6
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 0x4(%rsp), %esi
movq %r15, %rdi
callq 0x13ae0
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/canvas.c
// Function: Fill_rect
static int Fill_rect(lua_State *L)
    {
    nk_rect_t r;
    nk_color_t color;
    float rounding;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    if(echeckrect(L, 2, &r)) return argerror(L, 2);
    rounding = luaL_checknumber(L, 3);
    if(echeckcolor(L, 4, &color)) return argerror(L, 4);
    nk_fill_rect(canvas, r, rounding, color);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x52d7d(%rip), %rcx     # 0x68142
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x139f0
movq %rbx, %rdi
testl %eax, %eax
je 0x15403
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x15440
movl $0x3, %esi
callq 0x12870
movsd %xmm0, 0x10(%rsp)
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12100
testl %eax, %eax
je 0x15450
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x12460
addq $0x28, %rsp
popq %rbx
popq %r14
retq
cvtsd2ss 0x10(%rsp), %xmm2
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movl 0xc(%rsp), %esi
movq %r14, %rdi
callq 0x12de0
xorl %eax, %eax
jmp 0x15448
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/canvas.c
// Function: Fill_rect_multi_color
static int Fill_rect_multi_color(lua_State *L)
    {
    nk_rect_t r;
    nk_color_t left, top, right, bottom;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    if(echeckrect(L, 2, &r)) return argerror(L, 2);
    if(echeckcolor(L, 3, &left)) return argerror(L, 3);
    if(echeckcolor(L, 4, &top)) return argerror(L, 4);
    if(echeckcolor(L, 5, &right)) return argerror(L, 5);
    if(echeckcolor(L, 6, &bottom)) return argerror(L, 6);
    (void)canvas;
    return 0;
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x52cc0(%rip), %rcx     # 0x68142
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movl $0x2, %ebp
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x139f0
testl %eax, %eax
jne 0x15515
movl $0x3, %ebp
leaq 0x14(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12100
testl %eax, %eax
jne 0x15515
movl $0x4, %ebp
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12100
testl %eax, %eax
jne 0x15515
movl $0x5, %ebp
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl $0x5, %esi
callq 0x12100
testl %eax, %eax
jne 0x15515
movl $0x6, %ebp
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x6, %esi
callq 0x12100
testl %eax, %eax
je 0x15538
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x12460
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0x15531
// File: /workspace/github_c_makefile_star2_O1/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 0x52bf5(%rip), %rcx     # 0x68142
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 0x1558b
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x155b8
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12100
testl %eax, %eax
je 0x155c8
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 0x155c0
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/canvas.c
// Function: Fill_arc
static int Fill_arc(lua_State *L)
    {
    nk_color_t color;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    float cx = luaL_checknumber(L, 2);
    float cy = luaL_checknumber(L, 3);
    float radius = luaL_checknumber(L, 4);
    float a_min = luaL_checknumber(L, 5);
    float a_max = luaL_checknumber(L, 6);
    if(echeckcolor(L, 7, &color)) return argerror(L, 7);
    nk_fill_arc(canvas, cx, cy, radius, a_min, a_max, color);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
leaq 0x52b4b(%rip), %rcx     # 0x68142
xorl %ebx, %ebx
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
callq 0x12870
movsd %xmm0, 0x28(%rsp)
movq %r14, %rdi
movl $0x3, %esi
callq 0x12870
movsd %xmm0, 0x20(%rsp)
movq %r14, %rdi
movl $0x4, %esi
callq 0x12870
movsd %xmm0, 0x18(%rsp)
movq %r14, %rdi
movl $0x5, %esi
callq 0x12870
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
movl $0x6, %esi
callq 0x12870
movsd %xmm0, 0x8(%rsp)
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
movl $0x7, %esi
callq 0x12100
testl %eax, %eax
je 0x156a0
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %r14, %rdi
movl $0x7, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %ebx
jmp 0x156cd
cvtsd2ss 0x8(%rsp), %xmm4
cvtsd2ss 0x10(%rsp), %xmm3
cvtsd2ss 0x18(%rsp), %xmm2
cvtsd2ss 0x20(%rsp), %xmm1
xorps %xmm0, %xmm0
cvtsd2ss 0x28(%rsp), %xmm0
movl 0x4(%rsp), %esi
movq %r15, %rdi
callq 0x12590
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x52a56(%rip), %rcx     # 0x68142
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 0x157a8
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 0x157db
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_O1/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 0x52946(%rip), %rcx     # 0x68142
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 0x1583c
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x1586c
movq %rax, %r15
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12100
testl %eax, %eax
je 0x15880
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 0x15874
// File: /workspace/github_c_makefile_star2_O1/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 0x52896(%rip), %rcx     # 0x68142
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 0x158ea
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x15933
leaq 0x52953(%rip), %rcx     # 0x68244
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 0x1594d
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 0x1593e
// File: /workspace/github_c_makefile_star2_O1/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 0x527c3(%rip), %rcx     # 0x68142
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 0x159bd
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x15a06
leaq 0x52892(%rip), %rcx     # 0x68256
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 0x15a20
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 0x15a11
// File: /workspace/github_c_makefile_star2_O1/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 0x526f0(%rip), %rcx     # 0x68142
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x52649(%rip), %rcx     # 0x680b1
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 0x15aa9
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x15b1a
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 0x15aed
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x5, %esi
jmp 0x15b1a
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x6, %esi
callq 0x12100
testl %eax, %eax
je 0x15b2e
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 0x15b22
// File: /workspace/github_c_makefile_star2_O1/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 0x5256a(%rip), %rcx     # 0x68280
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x120d0
movq %rax, %r15
leaq 0x523a5(%rip), %r12     # 0x680d5
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_O1/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 0x524cb(%rip), %rcx     # 0x68280
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 0x15e1c
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 0x15de6
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x52440(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x5227f(%rip), %rcx     # 0x680d5
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 0x15ec5
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 0x15e8d
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_O1/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 0x52379(%rip), %rcx     # 0x68280
movq %rsp, %rdx
movl $0x1, %esi
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13df0
cmpl $0x6, %eax
jne 0x15f80
movq (%rsp), %rax
movl 0x74(%rax), %edx
cmpl $-0x2, %edx
je 0x15f4d
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       # 0x1642f
movq %rax, 0x2588(%r14)
xorl %eax, %eax
jmp 0x15f9a
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_O1/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 0x522d0(%rip), %rcx     # 0x68280
movq %rsp, %rdx
movl $0x1, %esi
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13df0
cmpl $0x6, %eax
jne 0x16029
movq (%rsp), %rax
movl 0x78(%rax), %edx
cmpl $-0x2, %edx
je 0x15ff6
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       # 0x1648e
movq %rax, 0x2590(%r14)
xorl %eax, %eax
jmp 0x16043
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_O1/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 0x52073(%rip), %rcx     # 0x68280
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 0x16255
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 0x1628a
movl $0x2, %esi
callq 0x13df0
movl %eax, %ecx
xorl %ebp, %ebp
movl $0x0, %eax
testl %ecx, %ecx
jle 0x16279
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_O1/stetre[P]moonnuklear/src/context.c
// Function: Vertex_layout
static int Vertex_layout(lua_State *L)
    {
#define element_t nk_draw_vertex_layout_element_t /* too long for me.. */
    int i, n, err;
    ud_t *ud; 
    element_t *layout;
    (void)checkcontext(L, 1, &ud);
    n = luaL_len(L, 2);
    layout =(element_t*)Malloc(L, (n+1)*sizeof(element_t));
    for(i=0; i< n; i++)
        {
        lua_rawgeti(L, 2, i+1);
        err = echeckdrawvertexlayoutelement(L, -1, &(layout[i]));
        if(err)
            { Free(L, layout); return argerror(L, 2); }
        lua_pop(L, 1);
        }
    layout[n].attribute = NK_VERTEX_ATTRIBUTE_COUNT;
    layout[n].format = NK_FORMAT_COUNT;
    layout[n].offset = 0;
    /* free old layout, if any */
    if(ud->config.vertex_layout) Free(L, (void*)ud->config.vertex_layout);
    ud->config.vertex_layout = layout;
    return 0;
#undef element_t
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x51fd8(%rip), %rcx     # 0x68280
movq %rsp, %rdx
movl $0x1, %esi
callq 0x120d0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13e10
movq %rax, %r15
movq %rax, %rbp
shlq $0x20, %rbp
movabsq $0x100000000, %rsi      # imm = 0x100000000
addq %rbp, %rsi
sarq $0x1c, %rsi
movq %rbx, %rdi
callq 0x13a00
movq %rax, %r14
testl %r15d, %r15d
jle 0x16345
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
negq %r15
movl $0x1, %r12d
movq %r14, %r13
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x12950
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r13, %rdx
callq 0x13830
movq %rbx, %rdi
testl %eax, %eax
jne 0x16381
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
addq $0x10, %r13
leaq (%r15,%r12), %rax
incq %rax
incq %r12
cmpq $0x1, %rax
jne 0x16300
sarq $0x1c, %rbp
movabsq $0x1300000003, %rax     # imm = 0x1300000003
movq %rax, (%r14,%rbp)
movq $0x0, 0x8(%r14,%rbp)
movq (%rsp), %rax
movq 0x50(%rax), %rsi
testq %rsi, %rsi
je 0x16375
movq %rbx, %rdi
callq 0x130d0
movq (%rsp), %rax
movq %r14, 0x50(%rax)
xorl %eax, %eax
jmp 0x163a8
movq %r14, %rsi
callq 0x130d0
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x12460
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x71bb3(%rip), %r14     # 0x87ff0
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 0x16486
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_O1/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 0x71b51(%rip), %r15     # 0x87ff0
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 0x164e9
movq (%r15), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x13780
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x51bb3(%rip), %rcx     # 0x680b1
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 0x16582
leaq 0x51d4d(%rip), %rdx     # 0x68280
leaq 0x51e9b(%rip), %rcx     # 0x683d5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13e90
movq $0x0, 0x10(%rax)
leaq 0xbf(%rip), %rcx        # 0x16613
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 0x51e33(%rip), %rsi     # 0x683c7
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x139b0
// File: /workspace/github_c_makefile_star2_O1/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 0x51cc2(%rip), %rdx     # 0x68280
leaq 0x51e3b(%rip), %rcx     # 0x68400
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13e90
movq $0x0, 0x10(%rax)
leaq 0x34(%rip), %rcx        # 0x16613
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