LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/buffer.c
// Function: CreateFixed
static int CreateFixed(lua_State *L)
    {
    ud_t *ud;
    nk_size size;
    void *ptr = NULL;
    nk_buffer_t *buffer;
    if(!lua_isnoneornil(L, 2))
        {
        ptr = checklightuserdata(L, 2);
        size = luaL_checkinteger(L, 3);
        if(size <= 0) return argerrorc(L, 3, ERR_VALUE);
        }
    buffer = (nk_buffer_t*)Malloc(L, sizeof(nk_buffer_t));
    if(ptr) nk_buffer_init_fixed(buffer, ptr, size);
    ud = new_buffer(L, buffer);
    MarkFixed(ud);
    if(ptr) MarkInitialized(ud);
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x15090
cmpl $0x0, %eax
jle 0x16145
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x14a30
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0x3, %esi
callq 0x14070
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
ja 0x16143
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x14d10
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x3, %esi
callq 0x134c0
movl %eax, 0x34(%rsp)
jmp 0x161c3
jmp 0x16145
movq 0x28(%rsp), %rdi
movl $0x78, %esi
callq 0x14c40
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x16175
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x13720
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x161d0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl 0x70(%rax), %ecx
orl $0x4, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x70(%rax)
cmpq $0x0, 0x10(%rsp)
je 0x161bb
jmp 0x161a6
movq 0x20(%rsp), %rax
movl 0x70(%rax), %ecx
orl $0x8, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x70(%rax)
jmp 0x161bb
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x90ee6(%rip), %rdx     # 0xa70d5
leaq 0x90f09(%rip), %rcx     # 0xa70ff
callq 0x15130
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
leaq 0x1a(%rip), %rcx        # 0x16230
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x70(%rax), %eax
andl $0x8, %eax
cmpl $0x8, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x90e89(%rip), %rdx     # 0xa70ff
callq 0x14f50
cmpl $0x0, %eax
jne 0x1628a
movl $0x0, 0x24(%rsp)
jmp 0x162b2
cmpl $0x0, 0x4(%rsp)
je 0x1629b
movq 0x8(%rsp), %rdi
callq 0x14fc0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14230
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x14450
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x162f4
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14e50
jmp 0x16330
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x90e3d(%rip), %rdx     # 0xa7142
leaq 0x90e42(%rip), %rcx     # 0xa714e
callq 0x15130
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
leaq 0x14(%rip), %rcx        # 0x16340
movq %rcx, 0x8(%rax)
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x90cb4(%rip), %rcx     # 0xa7142
callq 0x130f0
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x4, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
movl $0x5, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x6, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x38(%rsp), %rdi
movl $0x7, %esi
leaq 0x34(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x16563
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x7, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x16597
movq 0x28(%rsp), %rdi
movss 0x24(%rsp), %xmm0
movss 0x20(%rsp), %xmm1
movss 0x1c(%rsp), %xmm2
movss 0x18(%rsp), %xmm3
movss 0x14(%rsp), %xmm4
movl 0x34(%rsp), %esi
callq 0x13960
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x90b84(%rip), %rcx     # 0xa7142
callq 0x130f0
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movl $0x2, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x34(%rsp)
movq 0x48(%rsp), %rdi
movl $0x3, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x30(%rsp)
movq 0x48(%rsp), %rdi
movl $0x4, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x2c(%rsp)
movq 0x48(%rsp), %rdi
movl $0x5, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movl $0x6, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x48(%rsp), %rdi
movl $0x7, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movl $0x8, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rsp)
movq 0x48(%rsp), %rdi
movl $0x9, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movl $0xa, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x48(%rsp), %rdi
movl $0xb, %esi
leaq 0x44(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x166f7
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0xb, %esi
callq 0x134c0
movl %eax, 0x54(%rsp)
jmp 0x1674a
movq 0x38(%rsp), %rdi
movss 0x34(%rsp), %xmm0
movss 0x30(%rsp), %xmm1
movss 0x2c(%rsp), %xmm2
movss 0x28(%rsp), %xmm3
movss 0x24(%rsp), %xmm4
movss 0x20(%rsp), %xmm5
movss 0x1c(%rsp), %xmm6
movss 0x18(%rsp), %xmm7
movss 0x14(%rsp), %xmm8
movl 0x44(%rsp), %esi
movss %xmm8, (%rsp)
callq 0x14f10
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x909c4(%rip), %rcx     # 0xa7142
callq 0x130f0
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x28(%rsp), %rdx
callq 0x14c30
cmpl $0x0, %eax
je 0x167d9
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x16885
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x4, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
movl $0x5, %esi
leaq 0x24(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x16857
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x5, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x16885
movq 0x10(%rsp), %rdi
movss 0x20(%rsp), %xmm2
movss 0x1c(%rsp), %xmm3
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movl 0x24(%rsp), %esi
callq 0x13070
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x90894(%rip), %rcx     # 0xa7142
callq 0x130f0
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x28(%rsp), %rdx
callq 0x14c30
cmpl $0x0, %eax
je 0x16909
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x16998
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x4, %esi
leaq 0x24(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x16970
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x4, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x16998
movq 0x18(%rsp), %rdi
movss 0x20(%rsp), %xmm2
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movl 0x24(%rsp), %esi
callq 0x15250
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x90774(%rip), %rcx     # 0xa7142
callq 0x130f0
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x4, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
movl $0x5, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x6, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x38(%rsp), %rdi
movl $0x7, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0x8, %esi
leaq 0x34(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x16abc
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x8, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x16af6
movq 0x28(%rsp), %rdi
movss 0x24(%rsp), %xmm0
movss 0x20(%rsp), %xmm1
movss 0x1c(%rsp), %xmm2
movss 0x18(%rsp), %xmm3
movss 0x14(%rsp), %xmm4
movss 0x10(%rsp), %xmm5
movl 0x34(%rsp), %esi
callq 0x14020
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x90624(%rip), %rcx     # 0xa7142
callq 0x130f0
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x4, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
movl $0x5, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x6, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x38(%rsp), %rdi
movl $0x7, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0x8, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x38(%rsp), %rdi
movl $0x9, %esi
leaq 0x34(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x16c23
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x9, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x16c63
movq 0x28(%rsp), %rdi
movss 0x24(%rsp), %xmm0
movss 0x20(%rsp), %xmm1
movss 0x1c(%rsp), %xmm2
movss 0x18(%rsp), %xmm3
movss 0x14(%rsp), %xmm4
movss 0x10(%rsp), %xmm5
movss 0xc(%rsp), %xmm6
movl 0x34(%rsp), %esi
callq 0x14d30
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x90294(%rip), %rcx     # 0xa7142
callq 0x130f0
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x28(%rsp), %rdx
callq 0x14c30
cmpl $0x0, %eax
je 0x16f09
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x16f98
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x4, %esi
leaq 0x24(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x16f70
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x4, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x16f98
movq 0x18(%rsp), %rdi
movss 0x20(%rsp), %xmm2
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movl 0x24(%rsp), %esi
callq 0x13f10
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x90174(%rip), %rcx     # 0xa7142
callq 0x130f0
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rdi
movl $0x2, %esi
leaq 0x48(%rsp), %rdx
callq 0x14c30
cmpl $0x0, %eax
je 0x17029
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x28(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x64(%rsp)
jmp 0x1716f
movq 0x58(%rsp), %rdi
movl $0x3, %esi
leaq 0x44(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x1707a
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x20(%rsp), %rdi
movq %rax, %rdx
movl $0x3, %esi
callq 0x134c0
movl %eax, 0x64(%rsp)
jmp 0x1716f
movq 0x58(%rsp), %rdi
movl $0x4, %esi
leaq 0x40(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x170cb
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x18(%rsp), %rdi
movq %rax, %rdx
movl $0x4, %esi
callq 0x134c0
movl %eax, 0x64(%rsp)
jmp 0x1716f
movq 0x58(%rsp), %rdi
movl $0x5, %esi
leaq 0x3c(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x17119
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl $0x5, %esi
callq 0x134c0
movl %eax, 0x64(%rsp)
jmp 0x1716f
movq 0x58(%rsp), %rdi
movl $0x6, %esi
leaq 0x38(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x17167
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x6, %esi
callq 0x134c0
movl %eax, 0x64(%rsp)
jmp 0x1716f
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8ffa4(%rip), %rcx     # 0xa7142
callq 0x130f0
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x28(%rsp), %rdx
callq 0x14c30
cmpl $0x0, %eax
je 0x171f6
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x17266
movq 0x38(%rsp), %rdi
movl $0x3, %esi
leaq 0x24(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x17244
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x3, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x17266
movq 0x18(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movl 0x24(%rsp), %esi
callq 0x15030
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8feb4(%rip), %rcx     # 0xa7142
callq 0x130f0
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x4, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
movl $0x5, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x6, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x38(%rsp), %rdi
movl $0x7, %esi
leaq 0x34(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x17363
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x7, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x17397
movq 0x28(%rsp), %rdi
movss 0x24(%rsp), %xmm0
movss 0x20(%rsp), %xmm1
movss 0x1c(%rsp), %xmm2
movss 0x18(%rsp), %xmm3
movss 0x14(%rsp), %xmm4
movl 0x34(%rsp), %esi
callq 0x13610
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8fd84(%rip), %rcx     # 0xa7142
callq 0x130f0
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x4, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
movl $0x5, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x6, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x38(%rsp), %rdi
movl $0x7, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0x8, %esi
leaq 0x34(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x174ac
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x8, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x174e6
movq 0x28(%rsp), %rdi
movss 0x24(%rsp), %xmm0
movss 0x20(%rsp), %xmm1
movss 0x1c(%rsp), %xmm2
movss 0x18(%rsp), %xmm3
movss 0x14(%rsp), %xmm4
movss 0x10(%rsp), %xmm5
movl 0x34(%rsp), %esi
callq 0x14b10
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8fc34(%rip), %rcx     # 0xa7142
callq 0x130f0
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x30(%rsp), %rdx
leaq 0x34(%rsp), %rcx
callq 0x13990
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x17568
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x34(%rsp), %edi
callq 0x14d10
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x175d5
movq 0x38(%rsp), %rdi
movl $0x3, %esi
leaq 0x2c(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x175b6
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x3, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x175d5
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x30(%rsp), %edx
movl 0x2c(%rsp), %ecx
callq 0x13280
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8fb44(%rip), %rcx     # 0xa7142
callq 0x130f0
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x28(%rsp), %rdx
callq 0x14c30
cmpl $0x0, %eax
je 0x17659
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x176eb
movq 0x38(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8fbd6(%rip), %rcx     # 0xa7244
callq 0x130f0
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x4, %esi
leaq 0x24(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x176c4
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x4, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x176eb
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movl 0x24(%rsp), %edx
callq 0x14690
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8fa24(%rip), %rcx     # 0xa7142
callq 0x130f0
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x28(%rsp), %rdx
callq 0x14c30
cmpl $0x0, %eax
je 0x17779
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x1780b
movq 0x38(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8fac8(%rip), %rcx     # 0xa7256
callq 0x130f0
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x4, %esi
leaq 0x24(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x177e4
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x4, %esi
callq 0x134c0
movl %eax, 0x44(%rsp)
jmp 0x1780b
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movl 0x24(%rsp), %edx
callq 0x152a0
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8f904(%rip), %rcx     # 0xa7142
callq 0x130f0
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdi
movl $0x4, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8f854(%rip), %rcx     # 0xa70b1
callq 0x130f0
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
movl $0x2, %esi
leaq 0x40(%rsp), %rdx
callq 0x14c30
cmpl $0x0, %eax
je 0x178b8
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x18(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x64(%rsp)
jmp 0x179a6
movq 0x58(%rsp), %rdi
movl $0x3, %esi
leaq 0x50(%rsp), %rdx
callq 0x13df0
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rdi
movl $0x5, %esi
leaq 0x3c(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x17922
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl $0x5, %esi
callq 0x134c0
movl %eax, 0x64(%rsp)
jmp 0x179a6
movq 0x58(%rsp), %rdi
movl $0x6, %esi
leaq 0x38(%rsp), %rdx
callq 0x13120
cmpl $0x0, %eax
je 0x17970
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x6, %esi
callq 0x134c0
movl %eax, 0x64(%rsp)
jmp 0x179a6
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x50(%rsp), %edx
movq 0x20(%rsp), %rcx
movsd 0x40(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
movl 0x3c(%rsp), %r8d
movl 0x38(%rsp), %r9d
callq 0x14ee0
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8f774(%rip), %rcx     # 0xa7142
callq 0x130f0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x18(%rsp), %rdx
callq 0x14c30
cmpl $0x0, %eax
je 0x17a26
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x34(%rsp)
jmp 0x17a44
movq 0x10(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x14c90
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/context.c
// Function: Font
static int Font(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    if(!context->style.font)
        return 0;
    pushfont(L, (void*)context->style.font);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8f692(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x168(%rax)
jne 0x17c0f
movl $0x0, 0x14(%rsp)
jmp 0x17c2c
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq 0x168(%rax), %rsi
callq 0x14e50
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0x8f621(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8f457(%rip), %rcx     # 0xa70d5
callq 0x130f0
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8f438(%rip), %rcx     # 0xa70d5
callq 0x130f0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl $0x4, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8f419(%rip), %rcx     # 0xa70d5
callq 0x130f0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %r8
addq $0x28, %r8
callq 0x14780
movl %eax, 0x4(%rsp)
movq 0x30(%rsp), %rdi
movl 0x4(%rsp), %eax
movl %eax, %esi
callq 0x13c50
movl $0x1, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x1, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8f54a(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x138f0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x138b0
cmpq $0x0, 0x8(%rsp)
je 0x17da9
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x13730
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rsp)
movslq %eax, %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x140e0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x134a0
movq %rax, 0x8(%rsp)
jmp 0x17d5d
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x1, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8f49a(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x8f2d0(%rip), %rcx     # 0xa70d5
callq 0x130f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x15000
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x138b0
cmpq $0x0, (%rsp)
je 0x17e7d
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0x133c0
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rsp)
movslq %eax, %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x140e0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x13900
movq %rax, (%rsp)
jmp 0x17e30
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0x8f391(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x15090
cmpl $0x6, %eax
je 0x17f37
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x14d10
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x24(%rsp)
jmp 0x17fac
jmp 0x17f39
movq 0x10(%rsp), %rax
cmpl $-0x2, 0x74(%rax)
je 0x17f67
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x74(%rax), %edx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x15200
movq 0x10(%rsp), %rax
movl $0xfffffffe, 0x74(%rax) # imm = 0xFFFFFFFE
jmp 0x17f69
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x13eb0
movq 0x18(%rsp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x13840
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x74(%rax)
movq 0x8(%rsp), %rax
leaq 0x673(%rip), %rcx       # 0x18610
movq %rcx, 0x2588(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/context.c
// Function: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0x8f2a1(%rip), %rcx     # 0xa7280
callq 0x130f0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x15090
cmpl $0x6, %eax
je 0x18027
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x14d10
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x24(%rsp)
jmp 0x1809c
jmp 0x18029
movq 0x10(%rsp), %rax
cmpl $-0x2, 0x78(%rax)
je 0x18057
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x78(%rax), %edx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x15200
movq 0x10(%rsp), %rax
movl $0xfffffffe, 0x78(%rax) # imm = 0xFFFFFFFE
jmp 0x18059
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x13eb0
movq 0x18(%rsp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x13840
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x78(%rax)
movq 0x8(%rsp), %rax
leaq 0x603(%rip), %rcx       # 0x18690
movq %rcx, 0x2590(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/context.c
// Function: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0x8ef71(%rip), %rcx     # 0xa7280
callq 0x130f0
movq 0x28(%rsp), %rdi
movl $0x3, %esi
leaq 0x18(%rsp), %rdx
callq 0x15460
cmpl $0x0, %eax
je 0x18362
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x3, %esi
callq 0x134c0
movl %eax, 0x34(%rsp)
jmp 0x183bb
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x15090
cmpl $0x0, %eax
jg 0x18384
movq 0x10(%rsp), %rax
movl $0x0, 0x40(%rax)
jmp 0x183a5
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x14070
movl %eax, 0x20(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x40(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x48(%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0x8ee91(%rip), %rcx     # 0xa7280
callq 0x130f0
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x150b0
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x4, %rsi
callq 0x14c40
movq %rax, 0x8(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x184e2
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movl $0x2, %esi
callq 0x13a30
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rdx
movslq 0x24(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14a60
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x184c3
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14230
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x134c0
movl %eax, 0x34(%rsp)
jmp 0x1855f
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1842c
movq 0x8(%rsp), %rax
movslq 0x20(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x3, (%rax)
movq 0x8(%rsp), %rax
movslq 0x20(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x13, 0x4(%rax)
movq 0x8(%rsp), %rax
movslq 0x20(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x18549
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rsi
callq 0x14230
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x50(%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0xac9c2(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
movq (%rsp), %rax
movslq 0x74(%rax), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x13a30
movq 0xac9a6(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x14e50
movq 0xac992(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
movl $0x1, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movq %r9, %r8
callq 0x153a0
cmpl $0x0, %eax
je 0x1868b
movq 0xac96d(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
addq $0x18, %rsp
retq