LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: moonfreetype_freeface
int freeface(lua_State *L, FT_Face *face)
    {
    FT_Error ec;
    /* delete all contained objects */
    udata_scan(L, SIZE_MT, face, Freesize);
    if(!freeuserdata(L, face))
        return 0; /* double call */
    DBG("deleting face %p\n", (void*)face);
    ec = FT_Done_Face(*face);
    Free(L, face);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x84de(%rip), %rsi      # 0x13752
leaq 0x60(%rip), %rcx        # 0xb2db
movq %r14, %rdx
callq 0x7aa0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7370
testl %eax, %eax
je 0xb2d4
leaq 0x84cb(%rip), %rdi      # 0x13764
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
movq (%r14), %rdi
callq 0x7390
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79e0
testl %ebp, %ebp
je 0xb2d4
movl %ebp, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7a60
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: Freesize
static int Freesize(lua_State *L, const void *size, const void *face)
    {
    ud_t *ud = userdata(size);
    if(ud->face == (FT_Face)face)
        freesize(L, (FT_Size*)size);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x7230
cmpq %r15, 0x10(%rax)
jne 0xb302
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7900
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: Set_pixel_sizes
static int Set_pixel_sizes(lua_State *L)
    {
    FT_Error ec;
    FT_Face *face = checkface(L, 1);
    FT_UInt width = luaL_checkinteger(L, 2);
    FT_UInt height = luaL_checkinteger(L, 3);
    DBG("set_pixel_sizes %p, %d ,%d\n",(void*)face, width, height);
    ec = FT_Set_Pixel_Sizes(*face, width, height);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7770
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7770
movq %rax, %r12
leaq 0x868f(%rip), %rdi      # 0x13a37
movq %r14, %rsi
movl %r15d, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x7270
movq (%r14), %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x71e0
testl %eax, %eax
je 0xb3e9
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7a60
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: Load_char
static int Load_char(lua_State *L)
/* glyph = load_char(charcode [, load_flags = "default"]) */
    {
    FT_Error ec;
    FT_Int32 load_flags;
    FT_Face *face = checkface(L, 1);
    FT_ULong char_code = checkcharcode(L, 2);
    load_flags = checkflags(L, 3); //checkloadflags
    ec = FT_Load_Char(*face, char_code, load_flags);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7a90
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7770
movq (%r14), %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x7850
testl %eax, %eax
je 0xb453
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x7a60
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: Get_char_index
static int Get_char_index(lua_State *L)
/* glyph_index = get_char_index(char_code) 
 * returns nil if character undefined */
    {
    FT_Face *face = checkface(L, 1);
    FT_ULong char_code = checkcharcode(L, 2);
    FT_UInt glyph_index = FT_Get_Char_Index(*face, char_code);
    if(!glyph_index)    
        return 0;
    pushindex(L, glyph_index);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x1, %ebx
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
callq 0x7a90
movq (%r15), %rdi
movq %rax, %rsi
callq 0x7a00
testl %eax, %eax
je 0xb4fc
movq %r14, %rdi
movl %eax, %esi
callq 0x7cc0
jmp 0xb4fe
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: Get_first_char
static int Get_first_char(lua_State *L)
    {
    FT_ULong char_code;
    FT_UInt glyph_index;
    FT_Face *face = checkface(L, 1);
    char_code = FT_Get_First_Char(*face, &glyph_index);
    if(glyph_index==0)
        return 0;
    lua_pushinteger(L, char_code);
    lua_pushinteger(L, glyph_index);
    return 2;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7ab0
movq (%rax), %rdi
leaq 0x4(%rsp), %r14
movq %r14, %rsi
callq 0x7560
cmpl $0x0, (%r14)
je 0xb59a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7530
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0x7530
movl $0x2, %eax
jmp 0xb59c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: Get_next_char
static int Get_next_char(lua_State *L)
    {
    FT_UInt glyph_index;
    FT_Face *face = checkface(L, 1);
    FT_ULong char_code = checkcharcode(L, 2);
    char_code = FT_Get_Next_Char(*face, char_code, &glyph_index);
    if(glyph_index==0)
        return 0;
    lua_pushinteger(L, char_code);
    lua_pushinteger(L, glyph_index);
    return 2;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r15
movl $0x2, %ebx
movq %r14, %rdi
movl $0x2, %esi
callq 0x7a90
movq (%r15), %rdi
leaq 0xc(%rsp), %r15
movq %rax, %rsi
movq %r15, %rdx
callq 0x7ae0
cmpl $0x0, (%r15)
je 0xb601
movq %r14, %rdi
movq %rax, %rsi
callq 0x7530
movl 0xc(%rsp), %esi
movq %r14, %rdi
callq 0x7530
jmp 0xb603
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: Request_size
static int Request_size(lua_State *L)
    {
    FT_Error ec;
    FT_Size_RequestRec rec;
    FT_Face *face = checkface(L, 1);
    rec.type = (FT_Size_Request_Type)checksizerequesttype(L, 2);
    rec.width = luaL_checkinteger(L, 3);
    rec.height = luaL_checkinteger(L, 4);
    rec.horiResolution = luaL_checkinteger(L, 5);
    rec.vertResolution = luaL_checkinteger(L, 6);
    ec = FT_Request_Size(*face, &rec);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r14
movq %rbx, %rdi
movl $0x7, %esi
movl $0x2, %edx
callq 0x7b00
movq %rsp, %r15
movl %eax, (%r15)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7770
movq %rax, 0x8(%r15)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x7770
movq %rax, 0x10(%r15)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x7770
movl %eax, 0x18(%r15)
movq %rbx, %rdi
movl $0x6, %esi
callq 0x7770
movl %eax, 0x1c(%r15)
movq (%r14), %rdi
movq %r15, %rsi
callq 0x7790
testl %eax, %eax
je 0xb6fd
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
jmp 0xb6ff
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: Set_char_size
static int Set_char_size(lua_State *L)
    {
    FT_Error ec;
    FT_Face *face = checkface(L, 1);
    FT_F26Dot6 char_width = luaL_checkinteger(L, 2);
    FT_F26Dot6 char_height = luaL_checkinteger(L, 3);
    FT_UInt horz_resolution = luaL_checkinteger(L, 4);
    FT_UInt vert_resolution = luaL_checkinteger(L, 5);
    ec = FT_Set_Char_Size(*face, char_width, char_height, horz_resolution, vert_resolution );
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7770
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7770
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
callq 0x7770
movq %rax, %r13
movq %rbx, %rdi
movl $0x5, %esi
callq 0x7770
movq (%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %r13d, %ecx
movl %eax, %r8d
callq 0x7c60
testl %eax, %eax
je 0xb794
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7a60
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: Set_transform
static int Set_transform(lua_State *L)
    {
    FT_Face *face = checkface(L, 1);
    FT_Matrix *matrix = NULL;
    FT_Vector *delta = NULL;
    FT_Matrix mat;
    FT_Vector vec;
    if(!lua_isnoneornil(L, 2))
        {
        checkmatrix(L, 2, &mat);
        matrix = &mat;
        }
    if(!lua_isnoneornil(L, 3))
        {
        checkvector(L, 2, &vec);
        delta = &vec;
        }
    FT_Set_Transform(*face, matrix, delta);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
movl $0x1, %esi
callq 0x7ab0
movq %rax, %rbx
movq %r14, %rdi
movl $0x2, %esi
callq 0x7bf0
testl %eax, %eax
jle 0xb7e3
leaq 0x18(%rsp), %r15
movq %r14, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x7d50
jmp 0xb7e6
xorl %r15d, %r15d
movq %r14, %rdi
movl $0x3, %esi
callq 0x7bf0
testl %eax, %eax
jle 0xb80e
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x7730
jmp 0xb811
xorl %r12d, %r12d
movq (%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7b30
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: Get_glyph_name
static int Get_glyph_name(lua_State *L)
    {
    FT_Error ec;
    char name[MAXNAMELEN];
    FT_Face *face = checkface(L, 1);
    FT_UInt glyph_index = checkindex(L, 2);
    name[0]='\0';
    ec = FT_Get_Glyph_Name(*face, glyph_index, name, MAXNAMELEN);
    CheckError(L, ec);
    lua_pushstring(L, name);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movl $0x1, %ebp
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7330
movq %rsp, %rdx
movb $0x0, (%rdx)
movq (%r14), %rdi
movl %eax, %esi
movl $0x80, %ecx
callq 0x7100
testl %eax, %eax
je 0xb8eb
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
movl %eax, %ebp
jmp 0xb8f6
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7c90
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: Select_charmap
static int Select_charmap(lua_State *L)
/* select_charmap(encoding | index) 
 * index = index in charmaps (1-based) */
    {
    FT_Encoding encoding;
    FT_Int charmap_index;
    FT_Error ec;
    FT_Face *face = checkface(L, 1);
    int t = lua_type(L, 2);
    if(t == LUA_TSTRING)
        {
        encoding = (FT_Encoding)checkencoding(L, 2);
        ec = FT_Select_Charmap(*face, encoding);
        }
    else
        {
        charmap_index = checkindex(L, 2);
        if(charmap_index >= (*face)->num_charmaps)
            return luaL_argerror(L, 2, "out of range");
        ec = FT_Set_Charmap(*face, (*face)->charmaps[charmap_index]);
        }
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7bf0
movq %rbx, %rdi
cmpl $0x4, %eax
jne 0xb948
movl $0xa, %esi
movl $0x2, %edx
callq 0x7b00
movq (%r14), %rdi
movl %eax, %esi
callq 0x7650
jmp 0xb969
movl $0x2, %esi
callq 0x7330
movq (%r14), %rdi
cmpl 0x48(%rdi), %eax
jge 0xb992
movq 0x50(%rdi), %rcx
cltq
movq (%rcx,%rax,8), %rsi
callq 0x7590
testl %eax, %eax
je 0xb988
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7a60
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x80ba(%rip), %rdx      # 0x13a53
movq %rbx, %rdi
movl $0x2, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: Get_font_format
static int Get_font_format(lua_State *L)
    {
    FT_Face *face = checkface(L, 1);
    const char *fmt = FT_Get_Font_Format(*face);
    if(!fmt)
        return 0;
    lua_pushstring(L, fmt);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %ebx
movl $0x1, %esi
callq 0x7ab0
movq (%rax), %rdi
callq 0x7480
testq %rax, %rax
je 0xba05
movq %r14, %rdi
movq %rax, %rsi
callq 0x7c90
jmp 0xba07
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: Get_postscript_name
static int Get_postscript_name (lua_State *L)
    {
    FT_Face *face = checkface(L, 1);
    const char *name = FT_Get_Postscript_Name(*face);
    if(!name) return 0;
    lua_pushstring(L, name);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %ebx
movl $0x1, %esi
callq 0x7ab0
movq (%rax), %rdi
callq 0x71c0
testq %rax, %rax
je 0xba41
movq %r14, %rdi
movq %rax, %rsi
callq 0x7c90
jmp 0xba43
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: Get_kerning
static int Get_kerning(lua_State *L)
    {
    FT_Error ec;
    FT_Vector vec;
    FT_Face *face = checkface(L, 1);
    FT_UInt left_glyph = checkindex(L, 2); /* glyph_index */
    FT_UInt right_glyph = checkindex(L, 3); /* glyph_index */
    FT_UInt kern_mode = checkkerningmode(L, 4);
    ec = FT_Get_Kerning(*face, left_glyph, right_glyph, kern_mode, &vec);
    CheckError(L, ec);
    return pushvector(L, vec);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7330
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7330
movl %eax, %r15d
movq %rbx, %rdi
movl $0x8, %esi
movl $0x4, %edx
callq 0x7b00
movq (%r14), %rdi
leaq 0x8(%rsp), %r8
movl %ebp, %esi
movl %r15d, %edx
movl %eax, %ecx
callq 0x71b0
testl %eax, %eax
je 0xbac6
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
jmp 0xbad8
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x7b90
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: Get_track_kerning
static int Get_track_kerning(lua_State *L)
    {
    FT_Error ec;
    FT_Fixed kerning;
    FT_Face *face = checkface(L, 1);
    FT_Fixed point_size = luaL_checkinteger(L, 2);
    FT_Int degree = luaL_checkinteger(L, 3);
    ec = FT_Get_Track_Kerning(*face, point_size, degree, &kerning);
    CheckError(L, ec);
    lua_pushinteger(L, kerning);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %ebp
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7770
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7770
movq (%r14), %rdi
movq %rsp, %rcx
movq %r15, %rsi
movl %eax, %edx
callq 0x7040
testl %eax, %eax
je 0xbb48
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
movl %eax, %ebp
jmp 0xbb54
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: Glyph_bitmap
static int Glyph_bitmap(lua_State *L)
/* bitmap, left, top = glyph_bitmap() */
    {
    FT_Face *face = checkface(L, 1);
    FT_GlyphSlot glyph = (*face)->glyph;
    ud_t *ud = userdata(face);
    FT_Library library = ud->library;
    if(glyph->format != FT_GLYPH_FORMAT_BITMAP)
        return 0;
    pushbitmap(L, &(glyph->bitmap), library);
    lua_pushinteger(L, glyph->bitmap_left);
    lua_pushinteger(L, glyph->bitmap_top);
    return 3;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7ab0
movq (%rax), %rcx
movq 0x98(%rcx), %r14
movq %rax, %rdi
callq 0x7230
movq %rax, %rcx
xorl %eax, %eax
cmpl $0x62697473, 0x90(%r14) # imm = 0x62697473
jne 0xbbf3
movq 0x8(%rcx), %rdx
leaq 0x98(%r14), %rsi
movq %rbx, %rdi
callq 0x78b0
movslq 0xc0(%r14), %rsi
movq %rbx, %rdi
callq 0x7530
movslq 0xc4(%r14), %rsi
movq %rbx, %rdi
callq 0x7530
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: Available_sizes
static int Available_sizes(lua_State *L) 
/* available_sizes = available_sizes () */
    {
    FT_Int i, n;
    FT_Face *face = checkface(L, 1);
    n = (*face)->num_fixed_sizes;
    if(n == 0)
        return 0;
    lua_newtable(L);
    for(i=0; i<n; i++)
        {
        pushbitmapsize(L, (*face)->available_sizes[i]);
        lua_seti(L, -2, i+1);
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl $0x1, %ebx
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r15
movq (%rax), %rax
movl 0x38(%rax), %r13d
testq %r13, %r13
je 0xc1fc
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x73c0
testl %r13d, %r13d
jle 0xc1fe
shlq $0x5, %r13
movl $0x1, %r12d
xorl %ebp, %ebp
movq (%r15), %rax
movq 0x40(%rax), %rax
movups (%rax,%rbp), %xmm0
movups 0x10(%rax,%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x7990
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r12, %rdx
callq 0x76a0
addq $0x20, %rbp
incq %r12
cmpq %rbp, %r13
jne 0xc1bd
jmp 0xc1fe
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: Charmaps
static int Charmaps(lua_State *L) 
    {
    FT_Int i, n;
    FT_Face *face = checkface(L, 1);
    n = (*face)->num_charmaps;
    if(n == 0)
        return 0;
    lua_newtable(L);
    for(i=0; i<n; i++)
        {
        pushcharmap(L, (*face)->charmaps[i]);
        lua_seti(L, -2, i+1);
        }
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movl $0x1, %ebx
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r15
movq (%rax), %rax
movl 0x48(%rax), %r13d
testq %r13, %r13
je 0xc289
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x73c0
testl %r13d, %r13d
jle 0xc28b
negq %r13
movl $0x1, %r12d
movq (%r15), %rax
movq 0x50(%rax), %rax
movq -0x8(%rax,%r12,8), %rsi
movq %r14, %rdi
callq 0x7980
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r12, %rdx
callq 0x76a0
leaq (%r12,%r13), %rax
incq %rax
incq %r12
cmpq $0x1, %rax
jne 0xc253
jmp 0xc28b
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/flags.c
// Function: SubglyphFlags
static int SubglyphFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushsubglyphflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checksubglyphflags(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 0x7bf0
cmpl $0x3, %eax
jne 0xc974
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7770
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0xc8e1
leaq 0x757c(%rip), %rsi      # 0x13e50
movq %rbx, %rdi
callq 0x7c90
movl $0x1, %ebp
testb $0x2, %r14b
je 0xc8f8
leaq 0x7571(%rip), %rsi      # 0x13e5f
movq %rbx, %rdi
callq 0x7c90
incl %ebp
testb $0x4, %r14b
je 0xc90f
leaq 0x756d(%rip), %rsi      # 0x13e72
movq %rbx, %rdi
callq 0x7c90
incl %ebp
testb $0x8, %r14b
je 0xc926
leaq 0x7675(%rip), %rsi      # 0x13f91
movq %rbx, %rdi
callq 0x7c90
incl %ebp
testb $0x40, %r14b
je 0xc93d
leaq 0x7550(%rip), %rsi      # 0x13e83
movq %rbx, %rdi
callq 0x7c90
incl %ebp
testb %r14b, %r14b
jns 0xc953
leaq 0x7543(%rip), %rsi      # 0x13e8c
movq %rbx, %rdi
callq 0x7c90
incl %ebp
btl $0x9, %r14d
jae 0xca81
leaq 0x752b(%rip), %rsi      # 0x13e90
movq %rbx, %rdi
callq 0x7c90
incl %ebp
jmp 0xca81
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7d70
xorl %r14d, %r14d
testl %eax, %eax
je 0xca71
leaq 0x74b8(%rip), %r15      # 0x13e50
leaq 0x74c0(%rip), %r12      # 0x13e5f
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x7320
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x7700
testl %eax, %eax
je 0xca32
movq %r13, %rdi
movq %r12, %rsi
callq 0x7700
testl %eax, %eax
je 0xca39
movq %r13, %rdi
leaq 0x749c(%rip), %rsi      # 0x13e72
callq 0x7700
testl %eax, %eax
je 0xca40
movq %r13, %rdi
leaq 0x75a8(%rip), %rsi      # 0x13f91
callq 0x7700
testl %eax, %eax
je 0xca47
movq %r13, %rdi
leaq 0x7487(%rip), %rsi      # 0x13e83
callq 0x7700
testl %eax, %eax
je 0xca4e
movq %r13, %rdi
leaq 0x747d(%rip), %rsi      # 0x13e8c
callq 0x7700
testl %eax, %eax
je 0xca55
movq %r13, %rdi
leaq 0x746e(%rip), %rsi      # 0x13e90
callq 0x7700
movl $0x200, %ecx            # imm = 0x200
testl %eax, %eax
je 0xca5a
jmp 0xca92
movl $0x1, %ecx
jmp 0xca5a
movl $0x2, %ecx
jmp 0xca5a
movl $0x4, %ecx
jmp 0xca5a
movl $0x8, %ecx
jmp 0xca5a
movl $0x40, %ecx
jmp 0xca5a
movl $0x80, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d70
testl %eax, %eax
jne 0xc99f
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0x7530
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5aeb(%rip), %rsi      # 0x12584
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x7680
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x7260
movl %eax, %r14d
jmp 0xca71
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/flags.c
// Function: FsTypeFlags
static int FsTypeFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushfstypeflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkfstypeflags(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 0x7bf0
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
cmpl $0x3, %eax
jne 0xcb7a
callq 0x7770
movq %rax, %r14
testl %r14d, %r14d
je 0xcc59
xorl %ebp, %ebp
testb $0x2, %r14b
je 0xcb13
leaq 0x73af(%rip), %rsi      # 0x13eb5
movq %rbx, %rdi
callq 0x7c90
movl $0x1, %ebp
testb $0x4, %r14b
je 0xcb2a
leaq 0x73b2(%rip), %rsi      # 0x13ed2
movq %rbx, %rdi
callq 0x7c90
incl %ebp
testb $0x8, %r14b
je 0xcb41
leaq 0x73b7(%rip), %rsi      # 0x13eee
movq %rbx, %rdi
callq 0x7c90
incl %ebp
btl $0x8, %r14d
jae 0xcb59
leaq 0x73b2(%rip), %rsi      # 0x13f01
movq %rbx, %rdi
callq 0x7c90
incl %ebp
btl $0x9, %r14d
jae 0xcc68
leaq 0x73a4(%rip), %rsi      # 0x13f0f
movq %rbx, %rdi
callq 0x7c90
incl %ebp
jmp 0xcc68
callq 0x7d70
xorl %r14d, %r14d
testl %eax, %eax
je 0xcc47
leaq 0x730e(%rip), %r15      # 0x13e9f
leaq 0x731d(%rip), %r12      # 0x13eb5
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x7320
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x7700
testl %eax, %eax
je 0xcc33
movq %r13, %rdi
movq %r12, %rsi
callq 0x7700
testl %eax, %eax
je 0xcc1a
movq %r13, %rdi
leaq 0x7303(%rip), %rsi      # 0x13ed2
callq 0x7700
testl %eax, %eax
je 0xcc20
movq %r13, %rdi
leaq 0x730c(%rip), %rsi      # 0x13eee
callq 0x7700
testl %eax, %eax
je 0xcc26
movq %r13, %rdi
leaq 0x730c(%rip), %rsi      # 0x13f01
callq 0x7700
testl %eax, %eax
je 0xcc2c
movq %r13, %rdi
leaq 0x7307(%rip), %rsi      # 0x13f0f
callq 0x7700
testl %eax, %eax
jne 0xcc79
orl $0x200, %r14d           # imm = 0x200
jmp 0xcc33
orl $0x2, %r14d
jmp 0xcc33
orl $0x4, %r14d
jmp 0xcc33
orl $0x8, %r14d
jmp 0xcc33
orl $0x100, %r14d           # imm = 0x100
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d70
testl %eax, %eax
jne 0xcb98
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0x7530
movl $0x1, %ebp
jmp 0xcc68
leaq 0x723f(%rip), %rsi      # 0x13e9f
movq %rbx, %rdi
callq 0x7c90
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5904(%rip), %rsi      # 0x12584
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x7680
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x7260
movl %eax, %r14d
jmp 0xcc47
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/flags.c
// Function: OutlineFlags
static int OutlineFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushoutlineflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkoutlineflags(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 0x7bf0
cmpl $0x3, %eax
jne 0xcd98
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7770
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0xccec
leaq 0x7246(%rip), %rsi      # 0x13f25
movq %rbx, %rdi
callq 0x7c90
movl $0x1, %ebp
testb $0x2, %r14b
je 0xcd03
leaq 0x7232(%rip), %rsi      # 0x13f2b
movq %rbx, %rdi
callq 0x7c90
incl %ebp
testb $0x4, %r14b
je 0xcd1a
leaq 0x7229(%rip), %rsi      # 0x13f39
movq %rbx, %rdi
callq 0x7c90
incl %ebp
testb $0x8, %r14b
je 0xcd31
leaq 0x721f(%rip), %rsi      # 0x13f46
movq %rbx, %rdi
callq 0x7c90
incl %ebp
testb $0x10, %r14b
je 0xcd48
leaq 0x7218(%rip), %rsi      # 0x13f56
movq %rbx, %rdi
callq 0x7c90
incl %ebp
testb $0x20, %r14b
je 0xcd5f
leaq 0x7210(%rip), %rsi      # 0x13f65
movq %rbx, %rdi
callq 0x7c90
incl %ebp
btl $0x8, %r14d
jae 0xcd77
leaq 0x7206(%rip), %rsi      # 0x13f73
movq %rbx, %rdi
callq 0x7c90
incl %ebp
btl $0x9, %r14d
jae 0xced9
leaq 0x71f9(%rip), %rsi      # 0x13f82
movq %rbx, %rdi
callq 0x7c90
incl %ebp
jmp 0xced9
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7d70
xorl %r14d, %r14d
testl %eax, %eax
je 0xcec9
leaq 0x586a(%rip), %r15      # 0x12626
leaq 0x7162(%rip), %r12      # 0x13f25
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x7320
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x7700
testl %eax, %eax
je 0xceb5
movq %r13, %rdi
movq %r12, %rsi
callq 0x7700
testl %eax, %eax
je 0xce8a
movq %r13, %rdi
leaq 0x7129(%rip), %rsi      # 0x13f2b
callq 0x7700
testl %eax, %eax
je 0xce90
movq %r13, %rdi
leaq 0x7120(%rip), %rsi      # 0x13f39
callq 0x7700
testl %eax, %eax
je 0xce96
movq %r13, %rdi
leaq 0x711a(%rip), %rsi      # 0x13f46
callq 0x7700
testl %eax, %eax
je 0xce9c
movq %r13, %rdi
leaq 0x7117(%rip), %rsi      # 0x13f56
callq 0x7700
testl %eax, %eax
je 0xcea2
movq %r13, %rdi
leaq 0x7113(%rip), %rsi      # 0x13f65
callq 0x7700
testl %eax, %eax
je 0xcea8
movq %r13, %rdi
leaq 0x710e(%rip), %rsi      # 0x13f73
callq 0x7700
testl %eax, %eax
je 0xceae
movq %r13, %rdi
leaq 0x710a(%rip), %rsi      # 0x13f82
callq 0x7700
testl %eax, %eax
jne 0xceea
orl $0x200, %r14d           # imm = 0x200
jmp 0xceb5
orl $0x1, %r14d
jmp 0xceb5
orl $0x2, %r14d
jmp 0xceb5
orl $0x4, %r14d
jmp 0xceb5
orl $0x8, %r14d
jmp 0xceb5
orl $0x10, %r14d
jmp 0xceb5
orl $0x20, %r14d
jmp 0xceb5
orl $0x100, %r14d           # imm = 0x100
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d70
testl %eax, %eax
jne 0xcdc3
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0x7530
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5693(%rip), %rsi      # 0x12584
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x7680
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x7260
movl %eax, %r14d
jmp 0xcec9
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/glyph.c
// Function: moonfreetype_freeglyph
int freeglyph(lua_State *L, FT_Glyph *glyph)
    {
    if(!freeuserdata(L, glyph))
        return 0; /* double call */
    DBG("deleting glyph %p\n", (void*)glyph);
    FT_Done_Glyph(*glyph);
    Free(L, glyph);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x7370
testl %eax, %eax
je 0xd4ff
leaq 0x6bb4(%rip), %rdi      # 0x14096
movq %rbx, %rsi
xorl %eax, %eax
callq 0x7270
movq (%rbx), %rdi
callq 0x7600
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/glyph.c
// Function: Get_glyph
static int Get_glyph(lua_State *L)
/* glyph = get_glyph(face) 
 * extracts the glyph image from the current face->glyph slot
 */
    {
    FT_Error ec;
    FT_Library library;
    ud_t *ud;
    FT_Face *face = checkface(L, 1);
    FT_Glyph *glyph = (FT_Glyph*)Malloc(L, sizeof(FT_Glyph));

    ud = userdata(face);
    library = ud->library;

    ec = FT_Get_Glyph((*face)->glyph, glyph);
    if(ec)
        {
        Free(L, glyph);
        CheckError(L, ec); /* raises an error */
        return 0;
        }
    DBG("created glyph %p\n", (void*)glyph);
    newuserdata(L, (void*)glyph, GLYPH_MT);
    ud = userdata(glyph);
    ud->library = library;
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r15
movl $0x8, %esi
movq %rbx, %rdi
callq 0x7c00
movq %rax, %r14
movq %r15, %rdi
callq 0x7230
movq 0x8(%rax), %r12
movq (%r15), %rax
movq 0x98(%rax), %rdi
movq %r14, %rsi
callq 0x7890
testl %eax, %eax
je 0xd5c2
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79e0
movl %ebp, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7a60
leaq 0x6afd(%rip), %rdi      # 0x140c6
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x6acf(%rip), %rdx      # 0x140a9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72a0
movq %r14, %rdi
callq 0x7230
movq %r12, 0x8(%rax)
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/glyph.c
// Function: Glyph_copy
static int Glyph_copy(lua_State *L)
    {
    FT_Error ec;
    FT_Library library;
    ud_t *ud;
    FT_Glyph *oldglyph = checkglyph(L, 1);
    FT_Glyph *glyph = (FT_Glyph*)Malloc(L, sizeof(FT_Glyph));

    ud = userdata(oldglyph);
    library = ud->library;
    ec = FT_Glyph_Copy(*oldglyph, glyph);
    if(ec)
        {
        Free(L, glyph);
        CheckError(L, ec); /* raises an error */
        return 0;
        }
    newuserdata(L, (void*)glyph, GLYPH_MT);
    ud = userdata(glyph);
    ud->library = library;
    DBG("created glyph %p (copy)\n", (void*)glyph);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0xdb16
movq %rax, %r15
movl $0x8, %esi
movq %rbx, %rdi
callq 0x7c00
movq %rax, %r14
movq %r15, %rdi
callq 0x7230
movq 0x8(%rax), %r12
movq (%r15), %rdi
movq %r14, %rsi
callq 0x7290
testl %eax, %eax
je 0xd694
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79e0
movl %ebp, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7a60
leaq 0x6a0e(%rip), %rdx      # 0x140a9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72a0
movq %r14, %rdi
callq 0x7230
movq %r12, 0x8(%rax)
leaq 0x6a36(%rip), %rdi      # 0x140ef
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/glyph.c
// Function: Glyph_to_bitmap
static int Glyph_to_bitmap(lua_State *L)
    {
    FT_Error ec;
    FT_Vector vec, *origin=0;
    FT_Bool destroy;
    FT_Glyph *glyph = checkglyph(L, 1);
    FT_Render_Mode render_mode = checkrendermode(L, 2);
    if(!lua_isnoneornil(L, 3))
        {
        checkvector(L, 3, &vec);
        origin = &vec;
        }
    destroy = optboolean(L, 4, 1); /* defaults to true */
    DBG("glyph_to_bitmap %p mode=%d origin=%p destroy=%s\n", 
            (void*)glyph,  render_mode, (void*)origin, destroy ? "true":"false");
    ec = FT_Glyph_To_Bitmap(glyph, render_mode, origin, destroy);
    DBG("glyph_to_bitmap %p ec=%d\n", (void*)glyph,  ec);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0xdb16
movq %rax, %r14
movq %rbx, %rdi
movl $0x9, %esi
movl $0x2, %edx
callq 0x7b00
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7bf0
xorl %r15d, %r15d
testl %eax, %eax
jle 0xd786
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movl $0x3, %esi
movq %r12, %rdx
callq 0x7730
jmp 0xd789
xorl %r12d, %r12d
movq %rbx, %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x7710
movl %eax, %r13d
andl $0xff, %r13d
leaq 0x699e(%rip), %rax      # 0x1414a
leaq 0x6992(%rip), %r8       # 0x14145
cmoveq %rax, %r8
leaq 0x6956(%rip), %rdi      # 0x14114
movq %r14, %rsi
movl %ebp, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x7270
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
movl %r13d, %ecx
callq 0x77b0
movl %eax, %ebp
leaq 0x696a(%rip), %rdi      # 0x14150
movq %r14, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x7270
testl %ebp, %ebp
je 0xd80d
movl %ebp, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
movl %eax, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/glyph.c
// Function: Glyph_transform
static int Glyph_transform(lua_State *L)
    {
    FT_Error ec;
    FT_Matrix matrix;
    FT_Vector delta;
    FT_Glyph *glyph = checkglyph(L, 1);
    checkmatrix(L, 2, &matrix);
    checkvector(L, 3, &delta);
    ec = FT_Glyph_Transform(*glyph, &matrix, &delta);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
callq 0xdb16
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x7d50
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movl $0x3, %esi
movq %r12, %rdx
callq 0x7730
movq (%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x78a0
testl %eax, %eax
je 0xd887
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
jmp 0xd889
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/glyph.c
// Function: Glyph_stroke
static int Glyph_stroke(lua_State *L) //@@
    {
    FT_Glyph *glyph = checkglyph(L, 1);
    FT_Stroker *stroker = checkstroker(L, 2);
    FT_Bool destroy = optboolean(L, 3, 1);
    FT_Error ec = FT_Glyph_Stroke(glyph, *stroker, destroy);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xdb16
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7a40
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0x7710
movq (%r15), %rsi
movzbl %al, %edx
movq %r14, %rdi
callq 0x7ca0
testl %eax, %eax
je 0xd8f2
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x7a60
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/glyph.c
// Function: Glyph_strokeborder
static int Glyph_strokeborder(lua_State *L) //@@
    {
    FT_Glyph *glyph = checkglyph(L, 1);
    FT_Stroker *stroker = checkstroker(L, 2);
    FT_Bool inside = optboolean(L, 3, 1);
    FT_Bool destroy = optboolean(L, 3, 1);
    FT_Error ec = FT_Glyph_StrokeBorder(glyph, *stroker, inside, destroy);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xdb16
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7a40
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0x7710
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0x7710
movq (%r15), %rsi
movl $0xff, %ecx
andl %ecx, %ebp
andl %eax, %ecx
movq %r14, %rdi
movl %ebp, %edx
callq 0x7520
testl %eax, %eax
je 0xd97a
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7a60
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/glyph.c
// Function: Bitmap
static int Bitmap(lua_State *L)
/* bitmap = glyph:bitmap() */
    {
    FT_BitmapGlyphRec *rec;
    FT_Glyph *glyph = checkglyph(L, 1);
    if((*glyph)->format != FT_GLYPH_FORMAT_BITMAP)
        return luaL_argerror(L, 1, "glyph format is not 'bitmap'");
    rec = (FT_BitmapGlyphRec*)(*glyph);
    pushbitmap(L, &(rec->bitmap), rec->root.library);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xdb16
movq (%rax), %rsi
cmpl $0x62697473, 0x10(%rsi) # imm = 0x62697473
jne 0xd9f8
movq (%rsi), %rdx
addq $0x30, %rsi
movq %rbx, %rdi
callq 0x78b0
movl $0x1, %eax
popq %rbx
retq
leaq 0x676b(%rip), %rdx      # 0x1416a
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/glyph.c
// Function: Bitmapdata
static int Bitmapdata(lua_State *L)
/* bitmapdata = glyph:bitmapdata() */
    {
    FT_BitmapGlyphRec *rec;
    FT_Glyph *glyph = checkglyph(L, 1);
    if((*glyph)->format != FT_GLYPH_FORMAT_BITMAP)
        return luaL_argerror(L, 1, "glyph format is not 'bitmap'");
    rec = (FT_BitmapGlyphRec*)(*glyph);
    pushbitmapdata(L, rec->bitmap, rec->left, rec->top, 1);
    return 1;
    }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0xdb16
movq (%rax), %rax
cmpl $0x62697473, 0x10(%rax) # imm = 0x62697473
jne 0xda5e
movl 0x28(%rax), %esi
movl 0x2c(%rax), %edx
movq 0x50(%rax), %rcx
movq %rcx, 0x20(%rsp)
movups 0x30(%rax), %xmm0
movups 0x40(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x7cd0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
retq
leaq 0x6705(%rip), %rdx      # 0x1416a
movq %rbx, %rdi
movl $0x1, %esi
addq $0x30, %rsp
popq %rbx
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/glyph.c
// Function: Outline
static int Outline(lua_State *L)
/* outline = glyph:outline() */
    {
    FT_OutlineGlyphRec *rec;
    FT_Glyph *glyph = checkglyph(L, 1);
    if((*glyph)->format != FT_GLYPH_FORMAT_OUTLINE)
        return luaL_argerror(L, 1, "glyph format is not 'outline'");
    rec = (FT_OutlineGlyphRec*)(*glyph);
    pushoutline(L, &(rec->outline), rec->root.library);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xdb16
movq (%rax), %rsi
cmpl $0x6f75746c, 0x10(%rsi) # imm = 0x6F75746C
jne 0xdaa2
movq (%rsi), %rdx
addq $0x28, %rsi
movq %rbx, %rdi
callq 0x7160
movl $0x1, %eax
popq %rbx
retq
leaq 0x66de(%rip), %rdx      # 0x14187
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/glyph.c
// Function: Outlinedata
static int Outlinedata(lua_State *L)
    {
    FT_OutlineGlyphRec *rec;
    FT_Glyph *glyph = checkglyph(L, 1);
    if((*glyph)->format != FT_GLYPH_FORMAT_OUTLINE)
        return luaL_argerror(L, 1, "glyph format is not 'outline'");
    rec = (FT_OutlineGlyphRec *)(*glyph);
    pushoutlinedata(L, rec->outline);
    return 1;
    }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0xdb16
movq (%rax), %rax
cmpl $0x6f75746c, 0x10(%rax) # imm = 0x6F75746C
jne 0xdafd
movq 0x48(%rax), %rcx
movq %rcx, 0x20(%rsp)
movups 0x28(%rax), %xmm0
movups 0x38(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x7350
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
retq
leaq 0x6683(%rip), %rdx      # 0x14187
movq %rbx, %rdi
movl $0x1, %esi
addq $0x30, %rsp
popq %rbx
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/glyph.c
// Function: checkglyph
static FT_Glyph* checkglyph(lua_State *L, int arg)
    {
    FT_Glyph *p = testglyph(L, arg);
    if(p) return p;
    luaL_argerror(L, arg, "not a glyph");
    return NULL;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x6588(%rip), %rdx      # 0x140a9
movl $0x1, %esi
callq 0x7630
testq %rax, %rax
je 0xdb38
movq (%rax), %rax
testq %rax, %rax
jne 0xdb4e
leaq 0x65c9(%rip), %rdx      # 0x14108
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7260
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/library.c
// Function: moonfreetype_checklibrary
FT_Library* checklibrary(lua_State *L, int arg)
    {
    FT_Library *p = testlibrary(L, arg);
    if(p) return p;
    luaL_argerror(L, arg, "not a library");
    return NULL;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x4546(%rip), %rdx      # 0x120c1
callq 0x7630
testq %rax, %rax
je 0xdb8d
movq (%rax), %rax
testq %rax, %rax
jne 0xdba0
leaq 0x6676(%rip), %rdx      # 0x1420a
movq %r14, %rdi
movl %ebx, %esi
callq 0x7260
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/library.c
// Function: Delete
static int Delete(lua_State *L)
    {
    FT_Error ec;
    FT_Library *library = testlibrary(L, 1);
    if(!library) return 0; /* already deleted */
    /* delete all contained objects */
    udata_scan(L, BITMAP_MT, *library, Freebitmap);
    udata_scan(L, OUTLINE_MT, *library, Freeoutline);
    udata_scan(L, STROKER_MT, *library, Freestroker);
    udata_scan(L, GLYPH_MT, *library, Freeglyph);
    udata_scan(L, FACE_MT, *library, Freeface);

    if(!freeuserdata(L, library))
        return 0; /* double call */
    DBG("deleting library %p\n", (void*)library);
    ec = FT_Done_FreeType(*library);
    Free(L, library);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x44db(%rip), %rdx      # 0x120c1
movl $0x1, %esi
callq 0x7630
testq %rax, %rax
je 0xdcd3
movq (%rax), %r14
testq %r14, %r14
je 0xdcd3
movq (%r14), %rdx
leaq 0x445f(%rip), %rsi      # 0x1206e
leaq 0x15b(%rip), %rcx       # 0xdd71
movq %rbx, %rdi
callq 0x7aa0
movq (%r14), %rdx
leaq 0x6612(%rip), %rsi      # 0x1423a
leaq 0x171(%rip), %rcx       # 0xdda0
movq %rbx, %rdi
callq 0x7aa0
movq (%r14), %rdx
leaq 0x660e(%rip), %rsi      # 0x1424f
leaq 0x187(%rip), %rcx       # 0xddcf
movq %rbx, %rdi
callq 0x7aa0
movq (%r14), %rdx
leaq 0x644f(%rip), %rsi      # 0x140a9
leaq 0x19d(%rip), %rcx       # 0xddfe
movq %rbx, %rdi
callq 0x7aa0
movq (%r14), %rdx
leaq 0x438d(%rip), %rsi      # 0x12000
leaq 0x1b3(%rip), %rcx       # 0xde2d
movq %rbx, %rdi
callq 0x7aa0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7370
testl %eax, %eax
je 0xdcd3
leaq 0x65cc(%rip), %rdi      # 0x14264
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
movq (%r14), %rdi
callq 0x73b0
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79e0
testl %ebp, %ebp
je 0xdcd3
movl %ebp, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7a60
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/library.c
// Function: Freebitmap
static int Freebitmap(lua_State *L, const void *bitmap, const void *library)
    {
    ud_t *ud = userdata(bitmap);
    if(ud->library == (FT_Library)library)
        freebitmap(L, (FT_Bitmap*)bitmap);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x7230
cmpq %r15, 0x8(%rax)
jne 0xdd98
movq %r14, %rdi
movq %rbx, %rsi
callq 0x77e0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/library.c
// Function: Freeoutline
static int Freeoutline(lua_State *L, const void *outline, const void *library)
    {
    ud_t *ud = userdata(outline);
    if(ud->library == (FT_Library)library)
        freeoutline(L, (FT_Outline*)outline);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x7230
cmpq %r15, 0x8(%rax)
jne 0xddc7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x70f0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/library.c
// Function: Freestroker
static int Freestroker(lua_State *L, const void *stroker, const void *library)
    {
    ud_t *ud = userdata(stroker);
    if(ud->library == (FT_Library)library)
        freestroker(L, (FT_Stroker*)stroker);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x7230
cmpq %r15, 0x8(%rax)
jne 0xddf6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7b10
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/library.c
// Function: Freeface
static int Freeface(lua_State *L, const void *face, const void *library)
    {
    ud_t *ud = userdata(face);
    if(ud->library == (FT_Library)library)
        freeface(L, (FT_Face*)face);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x7230
cmpq %r15, 0x8(%rax)
jne 0xde54
movq %r14, %rdi
movq %rbx, %rsi
callq 0x71d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/library.c
// Function: InitFreeType
static int InitFreeType(lua_State *L)
    {
    FT_Error ec;
    FT_Library *library = (FT_Library*)Malloc(L, sizeof(FT_Library));

    ec = FT_Init_FreeType(library);

    if(ec)
        {
        Free(L, library);
        CheckError(L, ec); /* raises an error */
        return 0;
        }
    
    DBG("created library %p\n", (void*)library);
    newuserdata(L, (void*)library, LIBRARY_MT);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x8, %esi
callq 0x7c00
movq %rax, %r14
movq %rax, %rdi
callq 0x74c0
testl %eax, %eax
je 0xdea1
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79e0
movl %ebp, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7a60
leaq 0x63fd(%rip), %rdi      # 0x142a5
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x4208(%rip), %rdx      # 0x120c1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72a0
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/outline.c
// Function: moonfreetype_checkoutline
FT_Outline* checkoutline(lua_State *L, int arg)
    {
    FT_Outline *p = testoutline(L, arg);
    if(p) return p;
    luaL_argerror(L, arg, "not a outline");
    return NULL;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x5c6e(%rip), %rdx      # 0x1423a
callq 0x7630
testq %rax, %rax
je 0xe5de
movq (%rax), %rax
testq %rax, %rax
jne 0xe5f1
leaq 0x5d20(%rip), %rdx      # 0x14305
movq %r14, %rdi
movl %ebx, %esi
callq 0x7260
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/outline.c
// Function: moonfreetype_pushoutline
int pushoutline(lua_State *L, FT_Outline *outline, FT_Library library)
    {
    ud_t *ud = userdata(outline);
    if(ud)
        return udata_push(L, outline);
    /* create userdata for outline  owned by FreeType */
    DBG("created outline %p (on push)\n", (void*)outline);
    newuserdata(L, (void*)outline, OUTLINE_MT);
    ud = userdata(outline);
    ud->library = library;
    ud->allocated = 0;
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x7230
testq %rax, %rax
je 0xe624
movq %r15, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7180
leaq 0x5ce8(%rip), %rdi      # 0x14313
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x5bfe(%rip), %rdx      # 0x1423a
movq %r15, %rdi
movq %r14, %rsi
callq 0x72a0
movq %r14, %rdi
callq 0x7230
movq %rbx, 0x8(%rax)
movl $0x0, 0x18(%rax)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq