LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x51da8(%rip), %rsi     # 0x683dd
movq %r12, %rdx
callq 0x121c0
leaq 0x51dab(%rip), %rsi     # 0x683ef
movq %r14, %rdi
movq %r12, %rdx
callq 0x121c0
leaq 0x51d7f(%rip), %rdx     # 0x683d5
movq %r14, %rdi
movq %r12, %rsi
callq 0x13d00
testl %eax, %eax
je 0x1668e
testq %r15, %r15
je 0x16675
movq %r14, %rdi
movq %r15, %rsi
callq 0x130d0
testb $0x40, %bpl
jne 0x1668e
movq %rbx, %rdi
callq 0x12530
movq %r14, %rdi
movq %rbx, %rsi
callq 0x130d0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/cursor.c
// Function: moonnuklear_pushatlascursor
int pushatlascursor(lua_State *L, ud_t* atlas_ud, nk_cursor_t *cursor)
    {
    ud_t *ud = moonnuklear_userdata(cursor);
    if(ud) /* already in */
        { pushfont(L, cursor); return 1; }
    /* cursor is not yet known, create userdata and push it */
    ud = newuserdata(L, cursor, CURSOR_MT, "cursor");
    ud->parent_ud = atlas_ud;
    ud->destructor = freecursor;
    MarkAtlasCursor(ud);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %rdi
callq 0x132d0
testq %rax, %rax
je 0x166c4
movq %r15, %rdi
movq %r14, %rsi
callq 0x13c10
jmp 0x166f0
leaq 0x519f7(%rip), %rdx     # 0x680c2
leaq 0x5782d(%rip), %rcx     # 0x6deff
movq %r15, %rdi
movq %r14, %rsi
callq 0x13e90
movq %rbx, 0x10(%rax)
leaq 0x13(%rip), %rcx        # 0x166fb
movq %rcx, 0x8(%rax)
orb $0x10, 0x70(%rax)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x577f0(%rip), %rdx     # 0x6deff
callq 0x13d00
testl %eax, %eax
je 0x16728
andl $0x10, %ebp
jne 0x16728
movq %r14, %rdi
movq %rbx, %rsi
callq 0x130d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/cursor.c
// Function: Create
static int Create(lua_State *L)
/* cursor = cursor(image, size, offset) */
    {
    ud_t *ud, *image_ud;
    nk_cursor_t *cursor;
    nk_image_t *image;
    nk_vec2_t size, offset;

    image = checkimage(L, 1, &image_ud);
    if(echeckvec2(L, 2, &size)) return argerror(L, 2);
    if(echeckvec2(L, 2, &offset)) return argerror(L, 3);

    cursor = (nk_cursor_t*)Malloc(L, sizeof(nk_cursor_t));
    cursor->img = *image;
    cursor->size = size;
    cursor->offset = offset;

    ud = newuserdata(L, cursor, CURSOR_MT, "cursor");
    ud->parent_ud = image_ud;
    ud->destructor = freecursor;
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x51a6f(%rip), %rcx     # 0x68244
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
callq 0x120d0
movq %rax, %r14
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x14160
testl %eax, %eax
je 0x16816
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x16841
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x14160
testl %eax, %eax
je 0x16851
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x12460
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl $0x28, %esi
movq %rbx, %rdi
callq 0x13a00
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq (%rsp), %rcx
movq %rcx, 0x20(%rax)
leaq 0x5183d(%rip), %rdx     # 0x680c2
leaq 0x57673(%rip), %rcx     # 0x6deff
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13e90
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq -0x1ac(%rip), %rcx      # 0x166fb
movq %rcx, 0x8(%rax)
movl $0x1, %eax
jmp 0x16849
nop
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/edit.c
// Function: moonnuklear_newedit
int newedit(lua_State *L, ud_t *ud_context)
/* pushes the edit associated with the context */
    {
    nk_context_t *context = (nk_context_t*)ud_context->handle;
    nk_edit_t *edit = &context->text_edit;
    ud_t *ud = userdata(edit);

    if(ud) /* already in */
        return pushedit(L, edit);
    ud = newuserdata(L, edit, EDIT_MT, "edit");
    ud->parent_ud = ud_context;
    ud->context = context;
    ud->destructor = freeedit;
    MarkAssociatedWithContext(ud);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %r12
leaq 0x31d0(%r12), %r14
movq %r14, %rdi
callq 0x132d0
testq %rax, %rax
je 0x168f0
movq %r15, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x13c10
leaq 0x51af8(%rip), %rdx     # 0x683ef
leaq 0x51afd(%rip), %rcx     # 0x683fb
movq %r15, %rdi
movq %r14, %rsi
callq 0x13e90
movq %rbx, 0x10(%rax)
movq %r12, 0x18(%rax)
leaq 0x19(%rip), %rcx        # 0x16931
movq %rcx, 0x8(%rax)
orb $0x2, 0x70(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/edit.c
// Function: freeedit
static int freeedit(lua_State *L, ud_t *ud)
    {
    nk_edit_t *edit = (nk_edit_t*)ud->handle;
    int associated_with_context = IsAssociatedWithContext(ud);
    char * buf = ud->buf;
    if(!freeuserdata(L, ud, "edit")) return 0;
    if(buf) Free(L, buf);
    if(associated_with_context) return 0; /* don't free it, because it is owned by Nuklear */
    nk_textedit_free(edit);
    Free(L, edit);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rsi), %rbx
movl 0x70(%rsi), %ebp
movq 0x88(%rsi), %r15
leaq 0x51aac(%rip), %rdx     # 0x683fb
callq 0x13d00
testl %eax, %eax
je 0x16981
testq %r15, %r15
je 0x16968
movq %r14, %rdi
movq %r15, %rsi
callq 0x130d0
testb $0x2, %bpl
jne 0x16981
movq %rbx, %rdi
callq 0x13cd0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x130d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/edit.c
// Function: Filter
static int Filter(const nk_edit_t *edit, nk_rune unicode) /* nk_plugin_filter */
    {
#define L moonnuklear_L
    int rc;
    ud_t *ud = userdata((void*)edit);
    pushvalue(L, ud->ref1);
    pushedit(L, (nk_edit_t*)edit);
    lua_pushinteger(L, unicode);
    if(lua_pcall(L, 2, 1, 0) != LUA_OK)
        { lua_error(L); return 0; }
    rc = checkboolean(L, -1);
    lua_pop(L, 1);
    return rc;
#undef L
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x132d0
movq 0x71447(%rip), %r15     # 0x87ff0
movq (%r15), %rdi
movslq 0x74(%rax), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12950
movq (%r15), %rdi
movq %r14, %rsi
callq 0x13c10
movq (%r15), %rdi
movl %ebx, %esi
callq 0x12b60
movq (%r15), %rdi
movl $0x2, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x140b0
movq (%r15), %rdi
testl %eax, %eax
je 0x16bf9
callq 0x13780
xorl %eax, %eax
jmp 0x16c14
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x13770
movl %eax, %ebx
movq (%r15), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/edit.c
// Function: moonnuklear_edit_focus
int edit_focus(lua_State *L)
    {
    nk_flags flags;
    nk_context_t *context = checkcontext(L, 1, NULL);
    flags = checkflags(L, 2);
    nk_edit_focus(context, flags); /* editflags */
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x51640(%rip), %rcx     # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12f30
movq %r14, %rdi
movl %eax, %esi
callq 0x12d30
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/edit.c
// Function: Edit_text
static int Edit_text(lua_State *L)
    {
    size_t len;
    nk_edit_t *edit = checkedit(L, 1, NULL);
    const char *s = luaL_checklstring(L, 2, &len);
    nk_textedit_text(edit, s, len);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x516ef(%rip), %rcx     # 0x683ef
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x12cd0
movl (%r15), %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x129e0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/edit.c
// Function: Edit_delete
static int Edit_delete(lua_State *L)
    {
    nk_edit_t *edit = checkedit(L, 1, NULL);
    int where = luaL_checkinteger(L, 2);
    int len = luaL_checkinteger(L, 3);
    nk_textedit_delete(edit, where, len);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x516a2(%rip), %rcx     # 0x683ef
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12f30
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x12360
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/edit.c
// Function: Edit_paste
static int Edit_paste(lua_State *L)
    {
    size_t len;
    nk_edit_t *edit = checkedit(L, 1, NULL);
    const char *s = luaL_checklstring(L, 2, &len);
    lua_pushboolean(L, nk_textedit_paste(edit, s, (int)len));
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x515de(%rip), %rcx     # 0x683ef
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x12cd0
movl (%r15), %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x14100
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/enums.c
// Function: moonnuklear_enums_test
uint32_t enums_test(lua_State *L, uint32_t domain, int arg, int *err)
    {
    rec_t *rec;
    const char *s = luaL_optstring(L, arg, NULL);

    if(!s)
        { *err = ERR_NOTPRESENT; return 0; }

    rec = str_search(domain, s);
    if(!rec)
        { *err = ERR_VALUE; return 0; }
    
    *err = ERR_SUCCESS;
    return rec->code;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movl %esi, %ebp
xorl %r14d, %r14d
movl %edx, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x128c0
testq %rax, %rax
je 0x1799c
movl %ebp, %edi
movq %rax, %rsi
callq 0x179b5
testq %rax, %rax
je 0x179a4
movl $0x0, (%rbx)
movl 0x44(%rax), %r14d
jmp 0x179ad
movl $0x1, (%rbx)
jmp 0x179ad
movl $0xfffffffd, (%rbx)     # imm = 0xFFFFFFFD
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/enums.c
// Function: moonnuklear_enums_check
uint32_t enums_check(lua_State *L, uint32_t domain, int arg)
    {
    rec_t *rec;
    const char *s = luaL_checkstring(L, arg);

    rec = str_search(domain, s);
    if(!rec)
        return luaL_argerror(L, arg, badvalue(L, s));
    
    return rec->code;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl %edx, %esi
xorl %edx, %edx
callq 0x12cd0
movq %rax, %r15
movl %ebp, %edi
movq %rax, %rsi
callq 0x179b5
testq %rax, %rax
je 0x17a52
movl 0x44(%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x50a38(%rip), %rsi     # 0x68491
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x12d80
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/enums.c
// Function: moonnuklear_enums_push
int enums_push(lua_State *L, uint32_t domain, uint32_t code)
    {
    rec_t *rec = code_search(domain, code);

    if(!rec)
        return unexpected(L);

    lua_pushstring(L, rec->str);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl %esi, %edi
movl %edx, %esi
callq 0x17ac0
testq %rax, %rax
je 0x17aa2
movq 0x48(%rax), %rsi
movq %rbx, %rdi
callq 0x13f90
movl $0x1, %eax
popq %rbx
retq
leaq 0x50676(%rip), %rsi     # 0x6811f
leaq 0x509f4(%rip), %rdx     # 0x684a4
movq %rbx, %rdi
movl $0xca, %ecx
xorl %eax, %eax
popq %rbx
jmp 0x139b0
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/enums.c
// Function: moonnuklear_enums_values
int enums_values(lua_State *L, uint32_t domain)
    {
    int i;
    rec_t *rec;

    lua_newtable(L);
    i = 1;
    rec = code_first(domain, 0);
    while(rec)
        {
        if(rec->domain == domain)
            {
            lua_pushstring(L, rec->str);
            lua_rawseti(L, -2, i++);
            }
        rec = code_next(rec);
        }

    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x127c0
movl %ebx, %edi
callq 0x17911
testq %rax, %rax
je 0x17b7b
movq %rax, %r15
movl $0x1, %ebp
cmpl %ebx, 0x40(%r15)
jne 0x17b3b
movq 0x48(%r15), %rsi
movq %r14, %rdi
callq 0x13f90
movslq %ebp, %rdx
incl %ebp
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12f90
movq 0x8(%r15), %rcx
testq %rcx, %rcx
je 0x17b59
movq %rcx, %rax
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x17b44
movq %rax, %r15
testq %rax, %rax
jne 0x17b17
jmp 0x17b7b
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x17b67
cmpq %r15, (%rax)
je 0x17b4f
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x17b4f
cmpq 0x8(%rax), %r15
movq %rax, %r15
je 0x17b67
jmp 0x17b4f
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/enums.c
// Function: moonnuklear_enums_checklist
uint32_t* enums_checklist(lua_State *L, uint32_t domain, int arg, uint32_t *count, int *err)
    {
    uint32_t* list;
    uint32_t i;

    *count = 0;
    *err = 0;
    if(lua_isnoneornil(L, arg))
        { *err = ERR_NOTPRESENT; return NULL; }
    if(lua_type(L, arg) != LUA_TTABLE)
        { *err = ERR_TABLE; return NULL; }

    *count = luaL_len(L, arg);
    if(*count == 0)
        { *err = ERR_NOTPRESENT; return NULL; }

    list = (uint32_t*)MallocNoErr(L, sizeof(uint32_t) * (*count));
    if(!list)
        { *count = 0; *err = ERR_MEMORY; return NULL; }

    for(i=0; i<*count; i++)
        {
        lua_rawgeti(L, arg, i+1);
        list[i] = enums_test(L, domain, -1, err);
        lua_pop(L, 1);
        if(*err)
            { Free(L, list); *count = 0; return NULL; }
        }
    return list;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movl %edx, %ebp
movl %esi, 0x14(%rsp)
movq %rdi, %r15
xorl %eax, %eax
movq %rcx, 0x8(%rsp)
movl %eax, (%rcx)
movl %eax, (%r8)
movl %edx, %esi
callq 0x13df0
testl %eax, %eax
jle 0x17c6e
movq %r15, %rdi
movl %ebp, %esi
callq 0x13df0
cmpl $0x5, %eax
jne 0x17c77
movq %r15, %rdi
movl %ebp, %esi
callq 0x13e10
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
testl %eax, %eax
je 0x17c6e
movl %eax, %esi
shlq $0x2, %rsi
movq %r15, %rdi
callq 0x12ba0
testq %rax, %rax
je 0x17c93
movq %rax, %r13
xorl %r12d, %r12d
movq 0x8(%rsp), %rax
movl (%rax), %eax
cmpq %rax, %r12
jae 0x17c81
leaq 0x1(%r12), %rbx
movq %r15, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x12950
movq %r15, %rdi
movl 0x14(%rsp), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r14, %rcx
callq 0x13420
movl %eax, (%r13,%r12,4)
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
cmpl $0x0, (%r14)
movq %rbx, %r12
je 0x17c09
movq %r15, %rdi
movq %r13, %rsi
callq 0x130d0
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
jmp 0x17c7e
movl $0x1, (%r14)
jmp 0x17c7e
movl $0xfffffffc, (%r14)     # imm = 0xFFFFFFFC
xorl %r13d, %r13d
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
movl $0xfffffffa, (%r14)     # imm = 0xFFFFFFFA
jmp 0x17c7e
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/flags.c
// Function: ConvertResult
static int ConvertResult(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushconvertresult(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkconvertresult(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %ebp
movl $0x1, %esi
callq 0x13df0
cmpl $0x3, %eax
jne 0x1f6b2
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12f30
movq %rax, %r14
leaq 0x4e77d(%rip), %rsi     # 0x6ddbf
movq %rbx, %rdi
callq 0x13f90
testb $0x1, %r14b
je 0x1f664
leaq 0x4e770(%rip), %rsi     # 0x6ddc7
movq %rbx, %rdi
callq 0x13f90
movl $0x2, %ebp
testb $0x2, %r14b
je 0x1f67b
leaq 0x4e764(%rip), %rsi     # 0x6ddd5
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x4, %r14b
je 0x1f692
leaq 0x4e761(%rip), %rsi     # 0x6dde9
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x8, %r14b
je 0x1f77d
leaq 0x4e759(%rip), %rsi     # 0x6ddfc
movq %rbx, %rdi
callq 0x13f90
incl %ebp
jmp 0x1f77d
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x141b0
xorl %r14d, %r14d
testl %eax, %eax
je 0x1f76d
leaq 0x4e6e9(%rip), %r15     # 0x6ddbf
leaq 0x4e6ea(%rip), %r12     # 0x6ddc7
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x12630
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x12e90
testl %eax, %eax
je 0x1f759
movq %r13, %rdi
movq %r12, %rsi
callq 0x12e90
testl %eax, %eax
je 0x1f749
movq %r13, %rdi
leaq 0x4e6c1(%rip), %rsi     # 0x6ddd5
callq 0x12e90
testl %eax, %eax
je 0x1f74f
movq %r13, %rdi
leaq 0x4e6c2(%rip), %rsi     # 0x6dde9
callq 0x12e90
testl %eax, %eax
je 0x1f755
movq %r13, %rdi
leaq 0x4e6c2(%rip), %rsi     # 0x6ddfc
callq 0x12e90
testl %eax, %eax
jne 0x1f78e
orl $0x8, %r14d
jmp 0x1f759
orl $0x1, %r14d
jmp 0x1f759
orl $0x2, %r14d
jmp 0x1f759
orl $0x4, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x141b0
testl %eax, %eax
jne 0x1f6dd
movl %r14d, %esi
movq %rbx, %rdi
callq 0x12b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x48cfc(%rip), %rsi     # 0x68491
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x12d80
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %r14d
jmp 0x1f76d
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/flags.c
// Function: WidgetStates
static int WidgetStates(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushwidgetstates(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkwidgetstates(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x13df0
cmpl $0x3, %eax
jne 0x1fbb0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12f30
movq %rax, %r14
xorl %ebp, %ebp
testb $0x2, %r14b
je 0x1fb03
leaq 0x4e378(%rip), %rsi     # 0x6de6e
movq %rbx, %rdi
callq 0x13f90
movl $0x1, %ebp
testb $0x4, %r14b
je 0x1fb1a
leaq 0x4e367(%rip), %rsi     # 0x6de77
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x8, %r14b
je 0x1fb31
leaq 0x4e373(%rip), %rsi     # 0x6de9a
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x10, %r14b
je 0x1fb48
leaq 0x49aff(%rip), %rsi     # 0x6963d
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x20, %r14b
je 0x1fb5f
leaq 0x4e32b(%rip), %rsi     # 0x6de80
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x40, %r14b
je 0x1fb76
leaq 0x48b24(%rip), %rsi     # 0x68690
movq %rbx, %rdi
callq 0x13f90
incl %ebp
notl %r14d
testb $0x12, %r14b
jne 0x1fb90
leaq 0x54dad(%rip), %rsi     # 0x74933
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x22, %r14b
jne 0x1fcdf
leaq 0x4a27a(%rip), %rsi     # 0x69e1b
movq %rbx, %rdi
callq 0x13f90
incl %ebp
jmp 0x1fcdf
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x141b0
xorl %r14d, %r14d
testl %eax, %eax
je 0x1fccf
leaq 0x4e29a(%rip), %r15     # 0x6de6e
leaq 0x4e29c(%rip), %r12     # 0x6de77
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x12630
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x12e90
testl %eax, %eax
je 0x1fc89
movq %r13, %rdi
movq %r12, %rsi
callq 0x12e90
testl %eax, %eax
je 0x1fc90
movq %r13, %rdi
leaq 0x4e280(%rip), %rsi     # 0x6de9a
callq 0x12e90
testl %eax, %eax
je 0x1fc97
movq %r13, %rdi
leaq 0x49a10(%rip), %rsi     # 0x6963d
callq 0x12e90
testl %eax, %eax
je 0x1fc9e
movq %r13, %rdi
leaq 0x4e240(%rip), %rsi     # 0x6de80
callq 0x12e90
testl %eax, %eax
je 0x1fca5
movq %r13, %rdi
leaq 0x48a3d(%rip), %rsi     # 0x68690
callq 0x12e90
testl %eax, %eax
je 0x1fcac
movq %r13, %rdi
leaq 0x54ccd(%rip), %rsi     # 0x74933
callq 0x12e90
testl %eax, %eax
je 0x1fcb3
movq %r13, %rdi
leaq 0x4a1a2(%rip), %rsi     # 0x69e1b
callq 0x12e90
movl $0x22, %ecx
testl %eax, %eax
je 0x1fcb8
jmp 0x1fcf0
movl $0x2, %ecx
jmp 0x1fcb8
movl $0x4, %ecx
jmp 0x1fcb8
movl $0x8, %ecx
jmp 0x1fcb8
movl $0x10, %ecx
jmp 0x1fcb8
movl $0x20, %ecx
jmp 0x1fcb8
movl $0x40, %ecx
jmp 0x1fcb8
movl $0x12, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x141b0
testl %eax, %eax
jne 0x1fbdb
movl %r14d, %esi
movq %rbx, %rdi
callq 0x12b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4879a(%rip), %rsi     # 0x68491
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x12d80
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %r14d
jmp 0x1fccf
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/flags.c
// Function: WidgetAlign
static int WidgetAlign(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushwidgetalign(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkwidgetalign(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x13df0
cmpl $0x3, %eax
jne 0x1fddf
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12f30
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x1fd63
leaq 0x4e132(%rip), %rsi     # 0x6de88
movq %rbx, %rdi
callq 0x13f90
movl $0x1, %ebp
testb $0x2, %r14b
je 0x1fd7a
leaq 0x4e123(%rip), %rsi     # 0x6de93
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x4, %r14b
je 0x1fd91
leaq 0x4e11b(%rip), %rsi     # 0x6dea2
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x8, %r14b
je 0x1fda8
leaq 0x4e110(%rip), %rsi     # 0x6deae
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x10, %r14b
je 0x1fdbf
leaq 0x4e103(%rip), %rsi     # 0x6deb8
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x20, %r14b
je 0x1ff2c
leaq 0x4e0f5(%rip), %rsi     # 0x6dec5
movq %rbx, %rdi
callq 0x13f90
incl %ebp
jmp 0x1ff2c
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x141b0
xorl %r14d, %r14d
testl %eax, %eax
je 0x1ff1c
leaq 0x4e085(%rip), %r15     # 0x6de88
leaq 0x4e089(%rip), %r12     # 0x6de93
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x12630
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x12e90
testl %eax, %eax
je 0x1fecf
movq %r13, %rdi
movq %r12, %rsi
callq 0x12e90
testl %eax, %eax
je 0x1fed6
movq %r13, %rdi
leaq 0x4e059(%rip), %rsi     # 0x6dea2
callq 0x12e90
testl %eax, %eax
je 0x1fedd
movq %r13, %rdi
leaq 0x4e04e(%rip), %rsi     # 0x6deae
callq 0x12e90
testl %eax, %eax
je 0x1fee4
movq %r13, %rdi
leaq 0x4e045(%rip), %rsi     # 0x6deb8
callq 0x12e90
testl %eax, %eax
je 0x1feeb
movq %r13, %rdi
leaq 0x4e03f(%rip), %rsi     # 0x6dec5
callq 0x12e90
testl %eax, %eax
je 0x1fef2
movq %r13, %rdi
leaq 0x487f7(%rip), %rsi     # 0x68690
callq 0x12e90
testl %eax, %eax
je 0x1fef9
movq %r13, %rdi
leaq 0x4dfed(%rip), %rsi     # 0x6de99
callq 0x12e90
testl %eax, %eax
je 0x1ff00
movq %r13, %rdi
leaq 0x487f3(%rip), %rsi     # 0x686b2
callq 0x12e90
movl $0x14, %ecx
testl %eax, %eax
je 0x1ff05
jmp 0x1ff3d
movl $0x1, %ecx
jmp 0x1ff05
movl $0x2, %ecx
jmp 0x1ff05
movl $0x4, %ecx
jmp 0x1ff05
movl $0x8, %ecx
jmp 0x1ff05
movl $0x10, %ecx
jmp 0x1ff05
movl $0x20, %ecx
jmp 0x1ff05
movl $0x11, %ecx
jmp 0x1ff05
movl $0x12, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x141b0
testl %eax, %eax
jne 0x1fe0a
movl %r14d, %esi
movq %rbx, %rdi
callq 0x12b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4854d(%rip), %rsi     # 0x68491
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x12d80
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %r14d
jmp 0x1ff1c
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/flags.c
// Function: TextAlign
static int TextAlign(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushtextalign(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checktextalign(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x13df0
cmpl $0x3, %eax
jne 0x2002c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12f30
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x1ffb0
leaq 0x4dee5(%rip), %rsi     # 0x6de88
movq %rbx, %rdi
callq 0x13f90
movl $0x1, %ebp
testb $0x2, %r14b
je 0x1ffc7
leaq 0x4ded6(%rip), %rsi     # 0x6de93
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x4, %r14b
je 0x1ffde
leaq 0x4dece(%rip), %rsi     # 0x6dea2
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x8, %r14b
je 0x1fff5
leaq 0x4dec3(%rip), %rsi     # 0x6deae
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x10, %r14b
je 0x2000c
leaq 0x4deb6(%rip), %rsi     # 0x6deb8
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x20, %r14b
je 0x20179
leaq 0x4dea8(%rip), %rsi     # 0x6dec5
movq %rbx, %rdi
callq 0x13f90
incl %ebp
jmp 0x20179
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x141b0
xorl %r14d, %r14d
testl %eax, %eax
je 0x20169
leaq 0x4de38(%rip), %r15     # 0x6de88
leaq 0x4de3c(%rip), %r12     # 0x6de93
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x12630
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x12e90
testl %eax, %eax
je 0x2011c
movq %r13, %rdi
movq %r12, %rsi
callq 0x12e90
testl %eax, %eax
je 0x20123
movq %r13, %rdi
leaq 0x4de0c(%rip), %rsi     # 0x6dea2
callq 0x12e90
testl %eax, %eax
je 0x2012a
movq %r13, %rdi
leaq 0x4de01(%rip), %rsi     # 0x6deae
callq 0x12e90
testl %eax, %eax
je 0x20131
movq %r13, %rdi
leaq 0x4ddf8(%rip), %rsi     # 0x6deb8
callq 0x12e90
testl %eax, %eax
je 0x20138
movq %r13, %rdi
leaq 0x4ddf2(%rip), %rsi     # 0x6dec5
callq 0x12e90
testl %eax, %eax
je 0x2013f
movq %r13, %rdi
leaq 0x485aa(%rip), %rsi     # 0x68690
callq 0x12e90
testl %eax, %eax
je 0x20146
movq %r13, %rdi
leaq 0x4dda0(%rip), %rsi     # 0x6de99
callq 0x12e90
testl %eax, %eax
je 0x2014d
movq %r13, %rdi
leaq 0x485a6(%rip), %rsi     # 0x686b2
callq 0x12e90
movl $0x14, %ecx
testl %eax, %eax
je 0x20152
jmp 0x2018a
movl $0x1, %ecx
jmp 0x20152
movl $0x2, %ecx
jmp 0x20152
movl $0x4, %ecx
jmp 0x20152
movl $0x8, %ecx
jmp 0x20152
movl $0x10, %ecx
jmp 0x20152
movl $0x20, %ecx
jmp 0x20152
movl $0x11, %ecx
jmp 0x20152
movl $0x12, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x141b0
testl %eax, %eax
jne 0x20057
movl %r14d, %esi
movq %rbx, %rdi
callq 0x12b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x48300(%rip), %rsi     # 0x68491
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x12d80
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %r14d
jmp 0x20169
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/flags.c
// Function: EditEvents
static int EditEvents(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pusheditevents(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkeditevents(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x13df0
cmpl $0x3, %eax
jne 0x2064e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12f30
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x205e9
leaq 0x4983f(%rip), %rsi     # 0x69e1b
movq %rbx, %rdi
callq 0x13f90
movl $0x1, %ebp
testb $0x2, %r14b
je 0x20600
leaq 0x4d881(%rip), %rsi     # 0x6de77
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x4, %r14b
je 0x20617
leaq 0x4d978(%rip), %rsi     # 0x6df85
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x8, %r14b
je 0x2062e
leaq 0x4d95f(%rip), %rsi     # 0x6df83
movq %rbx, %rdi
callq 0x13f90
incl %ebp
testb $0x10, %r14b
je 0x20727
leaq 0x4d950(%rip), %rsi     # 0x6df8f
movq %rbx, %rdi
callq 0x13f90
incl %ebp
jmp 0x20727
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x141b0
xorl %r14d, %r14d
testl %eax, %eax
je 0x20717
leaq 0x497a9(%rip), %r15     # 0x69e1b
leaq 0x4d7fe(%rip), %r12     # 0x6de77
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x12630
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x12e90
testl %eax, %eax
je 0x206e6
movq %r13, %rdi
movq %r12, %rsi
callq 0x12e90
testl %eax, %eax
je 0x206ed
movq %r13, %rdi
leaq 0x4d8d5(%rip), %rsi     # 0x6df85
callq 0x12e90
testl %eax, %eax
je 0x206f4
movq %r13, %rdi
leaq 0x4d8c0(%rip), %rsi     # 0x6df83
callq 0x12e90
testl %eax, %eax
je 0x206fb
movq %r13, %rdi
leaq 0x4d8b9(%rip), %rsi     # 0x6df8f
callq 0x12e90
movl $0x10, %ecx
testl %eax, %eax
je 0x20700
jmp 0x20738
movl $0x1, %ecx
jmp 0x20700
movl $0x2, %ecx
jmp 0x20700
movl $0x4, %ecx
jmp 0x20700
movl $0x8, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x141b0
testl %eax, %eax
jne 0x20679
movl %r14d, %esi
movq %rbx, %rdi
callq 0x12b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x47d52(%rip), %rsi     # 0x68491
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x12d80
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %r14d
jmp 0x20717
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/flags.c
// Function: ChartEvent
static int ChartEvent(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushchartevent(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkchartevent(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x13df0
cmpl $0x3, %eax
jne 0x20cb0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12f30
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x20c90
leaq 0x4d382(%rip), %rsi     # 0x6e005
movq %rbx, %rdi
callq 0x13f90
movl $0x1, %ebp
testb $0x2, %r14b
je 0x20d5d
leaq 0x53caa(%rip), %rsi     # 0x7494b
movq %rbx, %rdi
callq 0x13f90
incl %ebp
jmp 0x20d5d
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x141b0
xorl %r14d, %r14d
testl %eax, %eax
je 0x20d4d
leaq 0x4d331(%rip), %r15     # 0x6e005
leaq 0x53c70(%rip), %r12     # 0x7494b
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x12630
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x12e90
testl %eax, %eax
je 0x20d0f
movq %r13, %rdi
movq %r12, %rsi
callq 0x12e90
movl $0x2, %ecx
testl %eax, %eax
je 0x20d14
jmp 0x20d29
movl $0x1, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x141b0
testl %eax, %eax
jne 0x20cdb
jmp 0x20d4d
leaq 0x47761(%rip), %rsi     # 0x68491
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x12d80
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x12b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/flags.c
// Function: WidgetLayoutStates
static int WidgetLayoutStates(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushwidgetlayoutstates(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkwidgetlayoutstates(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %ebp
movl $0x1, %esi
callq 0x13df0
cmpl $0x3, %eax
jne 0x20e03
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12f30
movq %rax, %r14
leaq 0x4d267(%rip), %rsi     # 0x6e00e
movq %rbx, %rdi
callq 0x13f90
testb $0x1, %r14b
je 0x20dc9
leaq 0x4d254(%rip), %rsi     # 0x6e010
movq %rbx, %rdi
callq 0x13f90
movl $0x2, %ebp
testb $0x2, %r14b
je 0x20de0
leaq 0x4d22b(%rip), %rsi     # 0x6e001
movq %rbx, %rdi
callq 0x13f90
incl %ebp
notl %r14d
testb $0x3, %r14b
jne 0x20eb3
leaq 0x4d222(%rip), %rsi     # 0x6e016
movq %rbx, %rdi
callq 0x13f90
incl %ebp
jmp 0x20eb3
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x141b0
xorl %r14d, %r14d
testl %eax, %eax
je 0x20ea3
leaq 0x4d1e7(%rip), %r15     # 0x6e00e
leaq 0x4d1e2(%rip), %r12     # 0x6e010
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x12630
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x12e90
testl %eax, %eax
je 0x20e93
movq %r13, %rdi
movq %r12, %rsi
callq 0x12e90
testl %eax, %eax
je 0x20e89
movq %r13, %rdi
leaq 0x4d19c(%rip), %rsi     # 0x6e001
callq 0x12e90
testl %eax, %eax
je 0x20e8f
movq %r13, %rdi
leaq 0x4d19e(%rip), %rsi     # 0x6e016
callq 0x12e90
movl $0x3, %r14d
testl %eax, %eax
je 0x20e93
jmp 0x20ec4
orl $0x1, %r14d
jmp 0x20e93
orl $0x2, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x141b0
testl %eax, %eax
jne 0x20e2e
movl %r14d, %esi
movq %rbx, %rdi
callq 0x12b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x475c6(%rip), %rsi     # 0x68491
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x12d80
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %r14d
jmp 0x20ea3
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/flags.c
// Function: StyleHeaderAlign
static int StyleHeaderAlign(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushstyleheaderalign(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkstyleheaderalign(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %ebp
movl $0x1, %esi
callq 0x13df0
cmpl $0x3, %eax
jne 0x20f4e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12f30
movq %rax, %r14
leaq 0x4776d(%rip), %rsi     # 0x68690
movq %rbx, %rdi
callq 0x13f90
testb $0x1, %r14b
je 0x20fee
leaq 0x47776(%rip), %rsi     # 0x686b2
movq %rbx, %rdi
callq 0x13f90
movl $0x2, %ebp
jmp 0x20fee
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x141b0
xorl %r14d, %r14d
testl %eax, %eax
je 0x20fde
leaq 0x47722(%rip), %r15     # 0x68690
leaq 0x4773d(%rip), %r12     # 0x686b2
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x12630
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x12e90
testl %eax, %eax
je 0x20fa8
movq %r13, %rdi
movq %r12, %rsi
callq 0x12e90
movl $0x1, %r14d
testl %eax, %eax
jne 0x20fba
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x141b0
testl %eax, %eax
jne 0x20f75
jmp 0x20fde
leaq 0x474d0(%rip), %rsi     # 0x68491
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x12d80
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %r14d
movl %r14d, %esi
movq %rbx, %rdi
callq 0x12b60
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/font.c
// Function: moonnuklear_pushatlasfont
int pushatlasfont(lua_State *L, ud_t *atlas_ud, nk_font_t *atlas_font, nk_font_config_t *cfg)
/* Pushes the user font embedded in an atlas font, possibly creating the
 * associated ud if it is not yet known by MoonNuklear */
    {
    nk_user_font_t *font = &atlas_font->handle;
    ud_t *ud = moonnuklear_userdata(font);
    if(ud) /* already known */
        { 
        if(cfg) { return unexpected(L); }
        pushfont(L, font); return 1; 
        }
    /* not yet known, create ud */
    ud = newuserdata(L, font, FONT_MT, "font");
    ud->parent_ud = atlas_ud;
    ud->font = atlas_font;
    ud->font_config = cfg;
    ud->destructor = freefont;
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x8(%rdx), %r13
movq %r13, %rdi
callq 0x132d0
testq %rax, %rax
je 0x21051
testq %rbx, %rbx
je 0x21083
leaq 0x470ed(%rip), %rsi     # 0x6811f
leaq 0x4cfe6(%rip), %rdx     # 0x6e01f
movq %r14, %rdi
movl $0x3b, %ecx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x139b0
leaq 0x47059(%rip), %rdx     # 0x680b1
leaq 0x53400(%rip), %rcx     # 0x7445f
movq %r14, %rdi
movq %r13, %rsi
callq 0x13e90
movq %r12, 0x10(%rax)
movq %r15, 0x20(%rax)
movq %rbx, 0x68(%rax)
leaq 0x20(%rip), %rcx        # 0x2109d
movq %rcx, 0x8(%rax)
jmp 0x2108e
movq %r14, %rdi
movq %r13, %rsi
callq 0x13c10
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/font.c
// Function: freefont
static int freefont(lua_State *L, ud_t *ud)
    {
    nk_user_font_t *font = (nk_user_font_t*)ud->handle;
    nk_font_config_t *cfg = ud->font_config;
    int allocated = IsAllocated(ud);
    if(!freeuserdata(L, ud, "font")) return 0;
    if(cfg) freefontconfig(L, cfg);
    if(allocated) Free(L, font);
    return 0;
    }

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x46e0e(%rip), %rcx     # 0x680b1
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x120d0
movq (%r14), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x212e8
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12f30
movq %r14, %rdi
movl %eax, %esi
callq 0x13fb0
testq %rax, %rax
je 0x212fe
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12340
jmp 0x21300
leaq 0x4cd42(%rip), %rdx     # 0x6e031
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12460
jmp 0x21300
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/font.c
// Function: New
static int New(lua_State *L)
/* user_font = user_font(height, width_func, texture_id, query_func) */
    {
    ud_t *ud;
    int ref1, ref2;
    nk_user_font_t *font;
    float height = luaL_checknumber(L, 1);
    int texture_id = luaL_checknumber(L, 3);
    if(!lua_isfunction(L, 2)) return argerrorc(L, 2, ERR_TYPE);
    if(!lua_isfunction(L, 4)) return argerrorc(L, 4, ERR_TYPE);
    lua_pushvalue(L, 2); ref1 = luaL_ref(L, LUA_REGISTRYINDEX);
    lua_pushvalue(L, 4); ref2 = luaL_ref(L, LUA_REGISTRYINDEX);

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x12870
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12870
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13df0
cmpl $0x6, %eax
jne 0x21435
movq %rbx, %rdi
movl $0x4, %esi
callq 0x13df0
cmpl $0x6, %eax
jne 0x21449
xorps %xmm0, %xmm0
cvtsd2ss (%rsp), %xmm0
movss %xmm0, (%rsp)
cvttsd2si 0x8(%rsp), %r12d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12d70
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12780
movl %eax, %ebp
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12d70
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12780
movl %eax, %r14d
movl $0x28, %esi
movq %rbx, %rdi
callq 0x13a00
movq %rax, %r15
leaq 0x46ce8(%rip), %rdx     # 0x680b1
leaq 0x4ccab(%rip), %rcx     # 0x6e07b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13e90
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movq %rcx, 0x20(%rax)
movl %ebp, 0x74(%rax)
movl %r14d, 0x78(%rax)
leaq -0x356(%rip), %rcx      # 0x2109d
movq %rcx, 0x8(%rax)
orb $0x20, 0x70(%rax)
movq %rax, (%r15)
movss (%rsp), %xmm0
movss %xmm0, 0x8(%r15)
leaq 0xb3(%rip), %rax        # 0x214c3
movq %rax, 0x10(%r15)
leaq 0x152(%rip), %rax       # 0x2156d
movq %rax, 0x18(%r15)
movl %r12d, 0x20(%r15)
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x13ac0
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x2145b
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x13ac0
movq %rbx, %rdi
movl $0x4, %esi
movq %rax, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/font.c
// Function: FontFromPtr
static int FontFromPtr(lua_State *L)
    {
    nk_font_t *ptr = (nk_font_t*)checklightuserdata(L, 1);
    nk_user_font_t *font = &ptr->handle;
    ud_t *ud = newuserdata(L, font, FONT_MT, "font (ptr)");
    ud->parent_ud = NULL;
    ud->font = ptr;
    ud->font_config = NULL;
    ud->destructor = freefont;
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x13800
movq %rax, %r14
leaq 0x8(%rax), %rsi
leaq 0x46c23(%rip), %rdx     # 0x680b1
leaq 0x4cbf2(%rip), %rcx     # 0x6e087
movq %rbx, %rdi
callq 0x13e90
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movq %r14, 0x20(%rax)
movq %rcx, 0x68(%rax)
leaq -0x415(%rip), %rcx      # 0x2109d
movq %rcx, 0x8(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/font.c
// Function: WidthCallback
static float WidthCallback(nk_handle handle, float height, const char* text, int len) // nk_text_width_f
    {
#define L moonnuklear_L
    float width;
    ud_t *ud = (ud_t*)(handle.ptr);
    pushvalue(L, ud->ref1);    // function
    lua_pushnumber(L, height); // arg1
    lua_pushlstring(L, text, len); // arg2
    if(lua_pcall(L, 2, 1, 0) != LUA_OK)
        { lua_error(L); return 0; }
    width = luaL_checknumber(L, -1); // retval1
    lua_pop(L, 1);
    return width;
#undef L
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r14
movss %xmm0, 0xc(%rsp)
movq 0x66b12(%rip), %r15     # 0x87ff0
movq (%r15), %rax
movslq 0x74(%rdi), %rdx
movq %rax, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12950
movq (%r15), %rdi
xorps %xmm0, %xmm0
cvtss2sd 0xc(%rsp), %xmm0
callq 0x13180
movq (%r15), %rdi
movslq %ebx, %rdx
movq %r14, %rsi
callq 0x13670
movq (%r15), %rdi
movl $0x2, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x140b0
movq (%r15), %rdi
testl %eax, %eax
je 0x2153c
callq 0x13780
xorps %xmm0, %xmm0
jmp 0x21563
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq (%r15), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movss 0xc(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/image.c
// Function: Image_info
static int Image_info(lua_State *L)
    {
    ud_t *ud;
    nk_rect_t r;
    nk_image_t *image = checkimage(L, 1, &ud);
    if(IsImageId(ud))
        lua_pushlightuserdata(L, image->handle.ptr);
    else
        lua_pushinteger(L, image->handle.id);
    if(!IsSubImage(ud))
        return 1;
    lua_pushinteger(L, image->w);
    lua_pushinteger(L, image->h);
    r.x = image->region[0];
    r.y = image->region[1];
    r.w = image->region[2];
    r.h = image->region[3];
    pushrect(L, &r);
    return 4;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x46aac(%rip), %rcx     # 0x68244
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x120d0
movq %rax, %r14
movq (%r15), %rax
testb $-0x80, 0x70(%rax)
jne 0x217c3
movslq (%r14), %rsi
movq %rbx, %rdi
callq 0x12b60
jmp 0x217ce
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x13450
movq 0x8(%rsp), %rcx
movl $0x1, %eax
testb $0x1, 0x71(%rcx)
je 0x2181e
movzwl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x12b60
movzwl 0xa(%r14), %esi
movq %rbx, %rdi
callq 0x12b60
movq 0xc(%r14), %xmm0
pxor %xmm1, %xmm1
punpcklwd %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3]
cvtdq2ps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x12710
movl $0x4, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq