LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4b5af(%rip), %rcx     # 0x600d5
xorl %r14d, %r14d
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %rdi
callq 0x131d0
testq %rax, %rax
je 0x14b50
movq %rbx, %rdi
movq %rax, %rsi
callq 0x135e0
movl %ebp, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x13
popq %rsi
pushq $0x1
popq %rdx
callq 0x13450
testl %eax, %eax
je 0x14b9d
cmpl $0x1, %eax
jne 0x14bcf
pushq $0x78
popq %rsi
movq %rbx, %rdi
callq 0x13c00
movq %rax, %r14
movq %rax, %rdi
callq 0x131f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14ca7
jmp 0x14c2b
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x14030
testl %eax, %eax
jle 0x14bf2
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x139f0
movq %rax, %r14
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
testq %rax, %rax
je 0x14c37
movq %rax, %r15
jmp 0x14bf5
leaq 0x4b549(%rip), %rsi     # 0x6011f
leaq 0x4b55c(%rip), %rdx     # 0x60139
pushq $0x56
popq %rcx
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x13bb0
xorl %r14d, %r14d
pushq $0x78
popq %rsi
movq %rbx, %rdi
callq 0x13c00
movq %rax, %r12
testq %r14, %r14
je 0x14c1a
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x126f0
pushq $0xc
jmp 0x14c1c
pushq $0x4
popq %rbp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x14ca7
orl %ebp, 0x70(%rax)
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x3
popq %rdi
callq 0x13cc0
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x124a0
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %r15
leaq 0x4b46b(%rip), %r14     # 0x600d5
movq %rbx, %rdi
movl %r15d, %esi
callq 0x14030
testl %eax, %eax
jle 0x14c9a
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x120e0
movq %rax, %rdi
callq 0x12f30
movl %ebp, %r15d
jmp 0x14c6a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/buffer.c
// Function: new_buffer
static ud_t *new_buffer(lua_State *L, nk_buffer_t *buffer)
    {
    ud_t *ud;
    ud = newuserdata(L, buffer, BUFFER_MT, "buffer");
    ud->parent_ud = NULL;
    ud->destructor = freebuffer;
    return ud;
    }

// Assembly:
pushq %rax
leaq 0x4b426(%rip), %rdx     # 0x600d5
leaq 0x4b449(%rip), %rcx     # 0x600ff
callq 0x140d0
andq $0x0, 0x10(%rax)
leaq 0x6(%rip), %rcx         # 0x14ccd
movq %rcx, 0x8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4b41e(%rip), %rdx     # 0x600ff
callq 0x13f10
testl %eax, %eax
je 0x14d03
testb $0x8, %bpl
je 0x14cf8
movq %rbx, %rdi
callq 0x13f80
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13220
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x13430
testq %rax, %rax
je 0x14d30
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13e10
jmp 0x14d59
leaq 0x4b40b(%rip), %rdx     # 0x60142
leaq 0x4b410(%rip), %rcx     # 0x6014e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x140d0
andq $0x0, 0x10(%rax)
leaq 0xf(%rip), %rcx         # 0x14d64
movq %rcx, 0x8(%rax)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4b323(%rip), %rcx     # 0x60142
xorl %ebx, %ebx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x28(%rsp)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x20(%rsp)
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x18(%rsp)
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x10(%rsp)
pushq $0x6
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x8(%rsp)
pushq $0x7
popq %rsi
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
callq 0x12110
testl %eax, %eax
je 0x14eb6
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x7
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebx
jmp 0x14ee0
cvtsd2ss 0x8(%rsp), %xmm4
cvtsd2ss 0x10(%rsp), %xmm3
cvtsd2ss 0x18(%rsp), %xmm2
cvtsd2ss 0x20(%rsp), %xmm1
cvtsd2ss 0x28(%rsp), %xmm0
movl 0x4(%rsp), %esi
movq %r15, %rdi
callq 0x12930
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4b243(%rip), %rcx     # 0x60142
xorl %ebx, %ebx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x58(%rsp)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x50(%rsp)
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x48(%rsp)
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x40(%rsp)
pushq $0x6
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x38(%rsp)
pushq $0x7
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x30(%rsp)
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x28(%rsp)
pushq $0x9
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x20(%rsp)
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x18(%rsp)
pushq $0xb
popq %rsi
leaq 0x14(%rsp), %rdx
movq %r14, %rdi
callq 0x12110
testl %eax, %eax
je 0x14fda
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0xb
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebx
jmp 0x15023
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
cvtsd2ss 0x58(%rsp), %xmm0
movl 0x14(%rsp), %esi
movss %xmm8, (%rsp)
movq %r15, %rdi
callq 0x13ed0
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4b102(%rip), %rcx     # 0x60142
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x13bf0
testl %eax, %eax
je 0x15072
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x2
jmp 0x150b7
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x12920
movsd %xmm0, 0x10(%rsp)
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x12920
movsd %xmm0, 0x8(%rsp)
pushq $0x5
popq %rsi
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x12110
testl %eax, %eax
je 0x150cb
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x5
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
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 0x12070
xorl %eax, %eax
jmp 0x150c3
// File: /workspace/github_c_makefile_star2_O2/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 0x4b03e(%rip), %rcx     # 0x60142
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x13bf0
testl %eax, %eax
je 0x15136
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x2
jmp 0x1516a
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x12920
movsd %xmm0, 0x10(%rsp)
pushq $0x4
popq %rsi
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x12110
testl %eax, %eax
je 0x1517e
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
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 0x141e0
xorl %eax, %eax
jmp 0x15176
// File: /workspace/github_c_makefile_star2_O2/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 0x4af8f(%rip), %rcx     # 0x60142
xorl %ebx, %ebx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x38(%rsp)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x30(%rsp)
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x28(%rsp)
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x20(%rsp)
pushq $0x6
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x18(%rsp)
pushq $0x7
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x10(%rsp)
pushq $0x8
popq %rsi
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
callq 0x12110
testl %eax, %eax
je 0x1525b
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x8
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebx
jmp 0x1528b
cvtsd2ss 0x10(%rsp), %xmm5
cvtsd2ss 0x18(%rsp), %xmm4
cvtsd2ss 0x20(%rsp), %xmm3
cvtsd2ss 0x28(%rsp), %xmm2
cvtsd2ss 0x30(%rsp), %xmm1
cvtsd2ss 0x38(%rsp), %xmm0
movl 0xc(%rsp), %esi
movq %r15, %rdi
callq 0x13010
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4ae98(%rip), %rcx     # 0x60142
xorl %ebx, %ebx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x38(%rsp)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x30(%rsp)
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x28(%rsp)
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x20(%rsp)
pushq $0x6
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x18(%rsp)
pushq $0x7
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x10(%rsp)
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x8(%rsp)
pushq $0x9
popq %rsi
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
callq 0x12110
testl %eax, %eax
je 0x15363
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x9
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebx
jmp 0x15399
cvtsd2ss 0x8(%rsp), %xmm6
cvtsd2ss 0x10(%rsp), %xmm5
cvtsd2ss 0x18(%rsp), %xmm4
cvtsd2ss 0x20(%rsp), %xmm3
cvtsd2ss 0x28(%rsp), %xmm2
cvtsd2ss 0x30(%rsp), %xmm1
cvtsd2ss 0x38(%rsp), %xmm0
movl 0x4(%rsp), %esi
movq %r15, %rdi
callq 0x13ce0
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4ac24(%rip), %rcx     # 0x60142
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x13bf0
testl %eax, %eax
je 0x15550
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x2
jmp 0x15584
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x12920
movsd %xmm0, 0x10(%rsp)
pushq $0x4
popq %rsi
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x12110
testl %eax, %eax
je 0x15598
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
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 0x12f00
xorl %eax, %eax
jmp 0x15590
// File: /workspace/github_c_makefile_star2_O2/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 0x4ab78(%rip), %rcx     # 0x60142
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
pushq $0x2
popq %rbp
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13bf0
testl %eax, %eax
jne 0x15642
pushq $0x3
popq %rbp
leaq 0x14(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x12110
testl %eax, %eax
jne 0x15642
pushq $0x4
popq %rbp
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x12110
testl %eax, %eax
jne 0x15642
pushq $0x5
popq %rbp
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x12110
testl %eax, %eax
jne 0x15642
pushq $0x6
popq %rbp
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x12110
testl %eax, %eax
je 0x15663
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x124a0
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0x1565c
// File: /workspace/github_c_makefile_star2_O2/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 0x4aaca(%rip), %rcx     # 0x60142
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x13bf0
testl %eax, %eax
je 0x156aa
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x2
jmp 0x156cd
pushq $0x3
popq %rsi
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x12110
testl %eax, %eax
je 0x156e1
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movl 0x4(%rsp), %esi
movq %r14, %rdi
callq 0x13ff0
xorl %eax, %eax
jmp 0x156d9
// File: /workspace/github_c_makefile_star2_O2/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 0x4aa32(%rip), %rcx     # 0x60142
xorl %ebx, %ebx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x28(%rsp)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x20(%rsp)
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x18(%rsp)
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x10(%rsp)
pushq $0x6
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x8(%rsp)
pushq $0x7
popq %rsi
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
callq 0x12110
testl %eax, %eax
je 0x157a7
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x7
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebx
jmp 0x157d1
cvtsd2ss 0x8(%rsp), %xmm4
cvtsd2ss 0x10(%rsp), %xmm3
cvtsd2ss 0x18(%rsp), %xmm2
cvtsd2ss 0x20(%rsp), %xmm1
cvtsd2ss 0x28(%rsp), %xmm0
movl 0x4(%rsp), %esi
movq %r15, %rdi
callq 0x125f0
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4a952(%rip), %rcx     # 0x60142
xorl %ebx, %ebx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x38(%rsp)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x30(%rsp)
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x28(%rsp)
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x20(%rsp)
pushq $0x6
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x18(%rsp)
pushq $0x7
popq %rsi
movq %r14, %rdi
callq 0x12920
movsd %xmm0, 0x10(%rsp)
pushq $0x8
popq %rsi
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
callq 0x12110
testl %eax, %eax
je 0x15898
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x8
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebx
jmp 0x158c8
cvtsd2ss 0x10(%rsp), %xmm5
cvtsd2ss 0x18(%rsp), %xmm4
cvtsd2ss 0x20(%rsp), %xmm3
cvtsd2ss 0x28(%rsp), %xmm2
cvtsd2ss 0x30(%rsp), %xmm1
cvtsd2ss 0x38(%rsp), %xmm0
movl 0xc(%rsp), %esi
movq %r15, %rdi
callq 0x13ad0
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4a859(%rip), %rcx     # 0x60142
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x10(%rsp), %rdx
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rcx
callq 0x12960
movl (%r12), %edi
testl %edi, %edi
je 0x1591f
callq 0x13cc0
pushq $0x2
jmp 0x15945
movq %rax, %r15
pushq $0x3
popq %rsi
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x12110
testl %eax, %eax
je 0x1595d
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
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 0x12280
xorl %eax, %eax
jmp 0x15951
// File: /workspace/github_c_makefile_star2_O2/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 0x4a7b9(%rip), %rcx     # 0x60142
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r15
pushq $0x2
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x13bf0
testl %eax, %eax
je 0x159bb
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x2
jmp 0x159f8
leaq 0x4a882(%rip), %rcx     # 0x60244
xorl %r14d, %r14d
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r12
pushq $0x4
popq %rsi
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x12110
testl %eax, %eax
je 0x15a16
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
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 0x13660
jmp 0x15a07
// File: /workspace/github_c_makefile_star2_O2/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 0x4a6fa(%rip), %rcx     # 0x60142
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r15
pushq $0x2
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x13bf0
testl %eax, %eax
je 0x15a7a
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x2
jmp 0x15ab7
leaq 0x4a7d5(%rip), %rcx     # 0x60256
xorl %r14d, %r14d
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r12
pushq $0x4
popq %rsi
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x12110
testl %eax, %eax
je 0x15ad5
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
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 0x14230
jmp 0x15ac6
// File: /workspace/github_c_makefile_star2_O2/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 0x4a63b(%rip), %rcx     # 0x60142
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
leaq 0x4a596(%rip), %rcx     # 0x600b1
pushq $0x4
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r15
pushq $0x2
popq %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x13bf0
testl %eax, %eax
je 0x15b50
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x2
jmp 0x15bab
pushq $0x3
popq %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x12dd0
movq %rax, %r12
pushq $0x5
popq %rsi
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x12110
testl %eax, %eax
je 0x15b88
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x5
jmp 0x15bab
pushq $0x6
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x12110
testl %eax, %eax
je 0x15bc3
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x6
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
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 0x13ea0
xorl %eax, %eax
jmp 0x15bb7
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/canvas.c
// Function: Push_scissor
static int Push_scissor(lua_State *L)
    {
    nk_rect_t r;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    if(echeckrect(L, 2, &r)) return argerror(L, 2);
    nk_push_scissor(canvas, r);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x4a540(%rip), %rcx     # 0x60142
xorl %ebx, %ebx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rsp, %rdx
movq %r14, %rdi
callq 0x13bf0
testl %eax, %eax
je 0x15c42
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x2
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebx
jmp 0x15c55
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r15, %rdi
callq 0x13c50
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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, %r14
leaq 0x4a4d6(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
movq %rsp, %r15
movq %r15, %rdx
callq 0x120e0
movq %rax, %r12
leaq 0x4a313(%rip), %r13     # 0x600d5
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
movq %r13, %rcx
callq 0x120e0
movq %rax, %rbp
pushq $0x3
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
movq %r13, %rcx
callq 0x120e0
movq %rax, %rbx
pushq $0x4
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
movq %r13, %rcx
callq 0x120e0
movq (%r15), %r8
addq $0x28, %r8
movq %r12, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x13760
movl %eax, %esi
movq %r14, %rdi
callq 0x12c20
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4a43f(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
movq %rax, %rdi
callq 0x128c0
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x12870
pushq $0x1
popq %r12
pushq $-0x2
popq %rbp
testq %r15, %r15
je 0x15ea1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x12700
leaq 0x1(%r12), %r13
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x130d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x12480
movq %rax, %r15
movq %r13, %r12
jmp 0x15e6c
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/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 0x4a3b8(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
leaq 0x4a1f9(%rip), %rcx     # 0x600d5
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x13fc0
movq %rax, %r12
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x12870
pushq $0x1
popq %r13
testq %r12, %r12
je 0x15f42
movq %rbx, %rdi
movq %r12, %rsi
callq 0x123b0
leaq 0x1(%r13), %rbp
movq %rbx, %rdi
pushq $-0x2
popq %rsi
movq %r13, %rdx
callq 0x130d0
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x128d0
movq %rax, %r12
movq %rbp, %r13
jmp 0x15f0a
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/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 0x4a300(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
movq %rsp, %rdx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x14030
cmpl $0x6, %eax
jne 0x15ff3
movq (%rsp), %rax
movl 0x74(%rax), %edx
cmpl $-0x2, %edx
je 0x15fc2
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x14190
movq (%rsp), %rax
movl $0xfffffffe, 0x74(%rax) # imm = 0xFFFFFFFE
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x12e90
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12800
movq (%rsp), %rcx
movl %eax, 0x74(%rcx)
leaq 0x486(%rip), %rax       # 0x1646e
movq %rax, 0x2588(%r14)
xorl %eax, %eax
jmp 0x16009
pushq $-0x2
popq %rdi
callq 0x13cc0
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4a261(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
movq %rsp, %rdx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x14030
cmpl $0x6, %eax
jne 0x16092
movq (%rsp), %rax
movl 0x78(%rax), %edx
cmpl $-0x2, %edx
je 0x16061
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x14190
movq (%rsp), %rax
movl $0xfffffffe, 0x78(%rax) # imm = 0xFFFFFFFE
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x12e90
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12800
movq (%rsp), %rcx
movl %eax, 0x78(%rcx)
leaq 0x444(%rip), %rax       # 0x164cb
movq %rax, 0x2590(%r14)
xorl %eax, %eax
jmp 0x160a8
pushq $-0x2
popq %rdi
callq 0x13cc0
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4a028(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x120e0
pushq $0x3
popq %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x143f0
testl %eax, %eax
je 0x16298
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebp
jmp 0x162cc
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x14030
movl %eax, %ecx
xorl %ebp, %ebp
movl $0x0, %eax
testl %ecx, %ecx
jle 0x162bb
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x13060
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_O2/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
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x49f93(%rip), %rcx     # 0x60280
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x120e0
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x14050
movq %rax, %r14
shlq $0x20, %rax
movabsq $0x100000000, %rsi      # imm = 0x100000000
movq %rax, 0x10(%rsp)
addq %rax, %rsi
sarq $0x1c, %rsi
movq %rbx, %rdi
callq 0x13c00
xorl %ebp, %ebp
testl %r14d, %r14d
cmovgl %r14d, %ebp
negq %rbp
pushq $0x1
popq %r15
pushq $-0x1
popq %r12
pushq $-0x2
popq %r13
movq %rax, (%rsp)
movq %rax, %r14
leaq (%r15,%rbp), %rax
cmpq $0x1, %rax
je 0x16387
movq %rbx, %rdi
pushq $0x2
popq %rsi
movq %r15, %rdx
callq 0x12a00
movq %rbx, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x13a20
movq %rbx, %rdi
testl %eax, %eax
jne 0x163cb
movl %r13d, %esi
callq 0x12190
incq %r15
addq $0x10, %r14
jmp 0x16349
movq 0x10(%rsp), %rcx
sarq $0x1c, %rcx
movabsq $0x1300000003, %rax     # imm = 0x1300000003
movq (%rsp), %r14
movq %rax, (%r14,%rcx)
andq $0x0, 0x8(%r14,%rcx)
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rsi
testq %rsi, %rsi
je 0x163c3
movq %rbx, %rdi
callq 0x13220
movq 0x8(%rsp), %rax
movq %r14, 0x50(%rax)
xorl %eax, %eax
jmp 0x163ef
movq (%rsp), %rsi
callq 0x13220
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/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 0x6eb74(%rip), %r14     # 0x84ff0
movq (%r14), %rax
movslq 0x74(%rdi), %rdx
movq %rax, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12a00
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x13e10
movq (%r14), %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x14330
testl %eax, %eax
je 0x164c3
movq (%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13960
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6eb14(%rip), %r15     # 0x84ff0
movq (%r15), %rax
movslq 0x78(%rdi), %rdx
movq %rax, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12a00
movq (%r15), %rdi
movslq %ebx, %rdx
movq %r14, %rsi
callq 0x13840
movq (%r15), %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x14330
testl %eax, %eax
je 0x16524
movq (%r15), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x13960
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x49b78(%rip), %rcx     # 0x600b1
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x143e0
movq %rax, %r15
movl $0x4798, %esi           # imm = 0x4798
movq %rbx, %rdi
callq 0x13c00
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x124b0
testl %eax, %eax
je 0x165b4
leaq 0x49d14(%rip), %rdx     # 0x60280
leaq 0x49e62(%rip), %rcx     # 0x603d5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x140d0
andq $0x0, 0x10(%rax)
leaq 0xb2(%rip), %rcx        # 0x1663c
movq %rcx, 0x8(%rax)
movq %rax, 0x2580(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x120b0
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x12190
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13220
leaq 0x49e01(%rip), %rsi     # 0x603c7
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x13bb0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x139f0
movq %rax, %r15
leaq 0x49c8f(%rip), %rdx     # 0x60280
leaq 0x49e08(%rip), %rcx     # 0x60400
movq %r14, %rdi
movq %rax, %rsi
callq 0x140d0
andq $0x0, 0x10(%rax)
leaq 0x2d(%rip), %rcx        # 0x1663c
movq %rcx, 0x8(%rax)
movq %rax, 0x2580(%r15)
orb $0x40, 0x70(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x120b0
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x12190
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x49d7f(%rip), %rsi     # 0x603dd
movq %r12, %rdx
callq 0x121f0
leaq 0x49d82(%rip), %rsi     # 0x603ef
movq %r14, %rdi
movq %r12, %rdx
callq 0x121f0
leaq 0x49d56(%rip), %rdx     # 0x603d5
movq %r14, %rdi
movq %r12, %rsi
callq 0x13f10
testl %eax, %eax
je 0x166b7
testq %r15, %r15
je 0x1669e
movq %r14, %rdi
movq %r15, %rsi
callq 0x13220
testb $0x40, %bpl
jne 0x166b7
movq %rbx, %rdi
callq 0x12590
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13220
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x13430
testq %rax, %rax
je 0x166ec
movq %r15, %rdi
movq %r14, %rsi
callq 0x13e10
jmp 0x16718
leaq 0x499cf(%rip), %rdx     # 0x600c2
leaq 0x4f805(%rip), %rcx     # 0x65eff
movq %r15, %rdi
movq %r14, %rsi
callq 0x140d0
movq %rbx, 0x10(%rax)
leaq 0x11(%rip), %rcx        # 0x16721
movq %rcx, 0x8(%rax)
orb $0x10, 0x70(%rax)
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4f7ca(%rip), %rdx     # 0x65eff
callq 0x13f10
testl %eax, %eax
je 0x1674e
andl $0x10, %ebp
jne 0x1674e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13220
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq