LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x7769(%rip), %rsi      # 0x12772
leaq 0x60(%rip), %rcx        # 0xb070
movq %r14, %rdx
callq 0x7ab0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7380
testl %eax, %eax
je 0xb069
leaq 0x7756(%rip), %rdi      # 0x12784
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
movq (%r14), %rdi
callq 0x73a0
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79f0
testl %ebp, %ebp
je 0xb069
movl %ebp, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7a70
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb097
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7910
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x7ac0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq %rax, %r12
leaq 0x792e(%rip), %rdi      # 0x12a57
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 0xb16a
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7a70
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x7ac0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7aa0
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq (%r14), %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x7860
testl %eax, %eax
je 0xb1ce
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x7a70
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/face.c
// Function: Load_glyph
static int Load_glyph(lua_State *L)
/* glyph = load_glyph(glyph_index [, load_flags = "default"]) */
    {
    FT_Error ec;
    FT_Int32 load_flags;
    FT_Face *face = checkface(L, 1);
    FT_UInt glyph_index = checkindex(L, 2);
    load_flags = checkflags(L, 3); //checkloadflags
    ec = FT_Load_Glyph(*face, glyph_index, load_flags);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7ac0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7340
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq (%r14), %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x7150
testl %eax, %eax
je 0xb228
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7a70
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x7ac0
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x7aa0
movq (%r15), %rdi
movq %rax, %rsi
callq 0x7a10
testl %eax, %eax
je 0xb26a
movq %r14, %rdi
movl %eax, %esi
callq 0x7ce0
jmp 0xb26c
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/face.c
// Function: Get_name_index
static int Get_name_index(lua_State *L)
/* glyph_index = get_name_index(name) 
 * returns nil if character undefined */
    {
    FT_Face *face = checkface(L, 1);
    FT_String *name = (FT_String*)luaL_checkstring(L, 2);
    FT_UInt glyph_index = FT_Get_Name_Index(*face, name);
    if(!glyph_index)    
        return 0;
    pushindex(L, glyph_index);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x7ac0
movq %rax, %r12
xorl %r15d, %r15d
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x7630
movq (%r12), %rdi
movq %rax, %rsi
callq 0x7140
testl %eax, %eax
je 0xb2b9
movq %r14, %rdi
movl %eax, %esi
callq 0x7ce0
movl %ebx, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x7ac0
movq (%rax), %rdi
leaq 0x4(%rsp), %r14
movq %r14, %rsi
callq 0x7570
cmpl $0x0, (%r14)
je 0xb309
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7540
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0x7540
pushq $0x2
popq %rax
jmp 0xb30b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x7ac0
movq %rax, %r15
pushq $0x2
popq %rbx
movq %r14, %rdi
movl %ebx, %esi
callq 0x7aa0
movq (%r15), %rdi
leaq 0xc(%rsp), %r15
movq %rax, %rsi
movq %r15, %rdx
callq 0x7b00
cmpl $0x0, (%r15)
je 0xb369
movq %r14, %rdi
movq %rax, %rsi
callq 0x7540
movl 0xc(%rsp), %esi
movq %r14, %rdi
callq 0x7540
jmp 0xb36b
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/face.c
// Function: Select_size
static int Select_size(lua_State *L)
    {
    FT_Error ec;
    FT_Face *face = checkface(L, 1);
    FT_Int index = checkindex(L, 2);
    ec = FT_Select_Size(*face, index);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7ac0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7340
movq (%r14), %rdi
movl %eax, %esi
callq 0x79c0
testl %eax, %eax
je 0xb3bd
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7a70
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x7ac0
movq %rax, %r14
pushq $0x7
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x7b20
movq %rsp, %r15
movl %eax, (%r15)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq %rax, 0x8(%r15)
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq %rax, 0x10(%r15)
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x7780
movl %eax, 0x18(%r15)
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x7780
movl %eax, 0x1c(%r15)
movq (%r14), %rdi
movq %r15, %rsi
callq 0x77a0
testl %eax, %eax
je 0xb453
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a70
jmp 0xb455
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x7ac0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq %rax, %r12
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq %rax, %r13
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq (%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %r13d, %ecx
movl %eax, %r8d
callq 0x7c80
testl %eax, %eax
je 0xb4e0
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7a70
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x7ac0
movq %rax, %rbx
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x7c10
testl %eax, %eax
jle 0xb529
pushq $0x2
popq %rsi
leaq 0x18(%rsp), %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x7d80
jmp 0xb52c
xorl %r15d, %r15d
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x7c10
testl %eax, %eax
jle 0xb550
pushq $0x2
popq %rsi
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0x7740
jmp 0xb553
xorl %r12d, %r12d
movq (%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7b50
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/face.c
// Function: Render_glyph
static int Render_glyph(lua_State *L)
/* render_glyph(face, render_mode)  (acts on face->glyph) */
    {
    FT_Error ec;
    FT_Face *face = checkface(L, 1);
    FT_Render_Mode render_mode = checkrendermode(L, 2);
    ec = FT_Render_Glyph((*face)->glyph, render_mode); 
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7ac0
movq %rax, %r14
pushq $0x9
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x7b20
movq (%r14), %rcx
movq 0x98(%rcx), %rdi
movl %eax, %esi
callq 0x7a90
testl %eax, %eax
je 0xb5bf
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7a70
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x7ac0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7340
movq %rsp, %rdx
movb $0x0, (%rdx)
movq (%r14), %rdi
movl %eax, %esi
movl $0x80, %ecx
callq 0x7100
testl %eax, %eax
je 0xb620
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a70
movl %eax, %ebp
jmp 0xb62b
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7cb0
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x7ac0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7c10
cmpl $0x4, %eax
jne 0xb675
pushq $0xa
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x7b20
movq (%r14), %rdi
movl %eax, %esi
callq 0x7660
jmp 0xb697
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7340
movq (%r14), %rdi
cmpl 0x48(%rdi), %eax
jge 0xb6c0
movq 0x50(%rdi), %rcx
cltq
movq (%rcx,%rax,8), %rsi
callq 0x75a0
testl %eax, %eax
je 0xb6b6
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7a70
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x73ac(%rip), %rdx      # 0x12a73
pushq $0x2
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/face.c
// Function: Get_fstype_flags
static int Get_fstype_flags(lua_State *L)
    {
    FT_Face *face = checkface(L, 1);
    FT_UShort flags = FT_Get_FSType_Flags(*face);
    pushflags(L, flags);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x7ac0
movq (%rax), %rdi
callq 0x73e0
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x7540
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x7ac0
movq (%rax), %rdi
callq 0x7490
testq %rax, %rax
je 0xb730
movq %r14, %rdi
movq %rax, %rsi
callq 0x7cb0
jmp 0xb732
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x7ac0
movq (%rax), %rdi
callq 0x71c0
testq %rax, %rax
je 0xb767
movq %r14, %rdi
movq %rax, %rsi
callq 0x7cb0
jmp 0xb769
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x7ac0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7340
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7340
movl %eax, %r15d
pushq $0x8
popq %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x7b20
movq (%r14), %rdi
leaq 0x8(%rsp), %r8
movl %ebp, %esi
movl %r15d, %edx
movl %eax, %ecx
callq 0x71b0
testl %eax, %eax
je 0xb7e2
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a70
jmp 0xb7f4
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x7bb0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x7ac0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq (%r14), %rdi
movq %rsp, %rcx
movq %r15, %rsi
movl %eax, %edx
callq 0x7040
testl %eax, %eax
je 0xb85b
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a70
movl %eax, %ebp
jmp 0xb867
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x7ac0
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 0xb906
movq 0x8(%rcx), %rdx
leaq 0x98(%r14), %rsi
movq %rbx, %rdi
callq 0x78c0
movslq 0xc0(%r14), %rsi
movq %rbx, %rdi
callq 0x7540
movslq 0xc4(%r14), %rsi
movq %rbx, %rdi
callq 0x7540
pushq $0x3
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/face.c
// Function: Glyph_outline
static int Glyph_outline(lua_State *L)
/* outline = glyph_outline() */
    {
    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_OUTLINE)
        return 0;
    pushoutline(L, &(glyph->outline), library);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x7ac0
movq (%rax), %rcx
movq 0x98(%rcx), %r15
movq %rax, %rdi
callq 0x7230
xorl %ecx, %ecx
cmpl $0x6f75746c, 0x90(%r15) # imm = 0x6F75746C
jne 0xb959
movq 0x8(%rax), %rdx
addq $0xc8, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7160
movl %ebx, %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/face.c
// Function: Face_index
static int Face_index(lua_State *L) 
/* index, instance = face_index() */
    {
    FT_Face *face = checkface(L, 1);
    FT_Long index = (*face)->face_index & 0x0000ffff;
    lua_pushinteger(L, index & 0x0000ffff);
    lua_pushinteger(L, (index & 0x7fff0000) >> 16);
    return 2;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7ac0
movq (%rax), %rax
movzwl 0x8(%rax), %esi
movq %rbx, %rdi
callq 0x7540
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7540
pushq $0x2
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x7ac0
movq %rax, %r15
movq (%rax), %rax
movl 0x38(%rax), %r13d
testl %r13d, %r13d
je 0xbf6a
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x73d0
testl %r13d, %r13d
cmovlel %ebx, %r13d
shlq $0x5, %r13
pushq $0x1
popq %r12
pushq $-0x2
popq %rbp
cmpq %rbx, %r13
je 0xbf65
movq (%r15), %rax
movq 0x40(%rax), %rax
movups (%rax,%rbx), %xmm0
movups 0x10(%rax,%rbx), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x79a0
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x76b0
addq $0x20, %rbx
incq %r12
jmp 0xbf29
pushq $0x1
popq %rax
jmp 0xbf6c
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x7ac0
movq %rax, %r15
movq (%rax), %rax
movl 0x48(%rax), %ebp
testl %ebp, %ebp
je 0xbfef
xorl %r13d, %r13d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x73d0
testl %ebp, %ebp
cmovgl %ebp, %r13d
negq %r13
pushq $0x1
popq %r12
pushq $-0x2
popq %rbp
leaq (%r12,%r13), %rax
cmpq $0x1, %rax
je 0xbff1
movq (%r15), %rax
movq 0x50(%rax), %rax
movq -0x8(%rax,%r12,8), %rsi
movq %r14, %rdi
callq 0x7990
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x76b0
incq %r12
jmp 0xbfbf
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]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
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x7c10
cmpl $0x3, %eax
jne 0xc665
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7780
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0xc5d2
leaq 0x68a9(%rip), %rsi      # 0x12e70
movq %rbx, %rdi
callq 0x7cb0
movl %r15d, %ebp
testb $0x2, %r14b
je 0xc5e9
leaq 0x68a0(%rip), %rsi      # 0x12e7f
movq %rbx, %rdi
callq 0x7cb0
incl %ebp
testb $0x4, %r14b
je 0xc600
leaq 0x689c(%rip), %rsi      # 0x12e92
movq %rbx, %rdi
callq 0x7cb0
incl %ebp
testb $0x8, %r14b
je 0xc617
leaq 0x69a4(%rip), %rsi      # 0x12fb1
movq %rbx, %rdi
callq 0x7cb0
incl %ebp
testb $0x40, %r14b
je 0xc62e
leaq 0x687f(%rip), %rsi      # 0x12ea3
movq %rbx, %rdi
callq 0x7cb0
incl %ebp
testb %r14b, %r14b
jns 0xc644
leaq 0x6872(%rip), %rsi      # 0x12eac
movq %rbx, %rdi
callq 0x7cb0
incl %ebp
btl $0x9, %r14d
jae 0xc772
leaq 0x685a(%rip), %rsi      # 0x12eb0
movq %rbx, %rdi
callq 0x7cb0
incl %ebp
jmp 0xc772
xorl %r14d, %r14d
leaq 0x6801(%rip), %r12      # 0x12e70
movl %ebp, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7da0
testl %eax, %eax
je 0xc764
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x7330
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x7710
movl %ebp, %ecx
testl %eax, %eax
je 0xc734
movq %r13, %rdi
leaq 0x67cb(%rip), %rsi      # 0x12e7f
callq 0x7710
pushq $0x2
popq %rcx
testl %eax, %eax
je 0xc734
movq %r13, %rdi
leaq 0x67c8(%rip), %rsi      # 0x12e92
callq 0x7710
pushq $0x4
popq %rcx
testl %eax, %eax
je 0xc734
movq %r13, %rdi
leaq 0x68d1(%rip), %rsi      # 0x12fb1
callq 0x7710
pushq $0x8
popq %rcx
testl %eax, %eax
je 0xc734
movq %r13, %rdi
leaq 0x67ad(%rip), %rsi      # 0x12ea3
callq 0x7710
pushq $0x40
popq %rcx
testl %eax, %eax
je 0xc734
movq %r13, %rdi
leaq 0x67a0(%rip), %rsi      # 0x12eac
callq 0x7710
testl %eax, %eax
je 0xc72f
movq %r13, %rdi
leaq 0x6791(%rip), %rsi      # 0x12eb0
callq 0x7710
movl $0x200, %ecx            # imm = 0x200
testl %eax, %eax
je 0xc734
jmp 0xc73f
movl $0x80, %ecx
orl %ecx, %r14d
incl %r15d
jmp 0xc672
leaq 0x4e5e(%rip), %rsi      # 0x115a4
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x7690
movq %rbx, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x7260
movl %eax, %r14d
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0x7540
pushq $0x1
popq %rbp
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_O2/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
pushq $0x1
popq %r12
movl %r12d, %esi
callq 0x7c10
cmpl $0x3, %eax
jne 0xc842
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7780
movq %rax, %r14
testl %r14d, %r14d
je 0xc927
xorl %ebp, %ebp
testb $0x2, %r14b
je 0xc7db
leaq 0x6705(%rip), %rsi      # 0x12ed5
movq %rbx, %rdi
callq 0x7cb0
movl %r15d, %ebp
testb $0x4, %r14b
je 0xc7f2
leaq 0x670a(%rip), %rsi      # 0x12ef2
movq %rbx, %rdi
callq 0x7cb0
incl %ebp
testb $0x8, %r14b
je 0xc809
leaq 0x670f(%rip), %rsi      # 0x12f0e
movq %rbx, %rdi
callq 0x7cb0
incl %ebp
btl $0x8, %r14d
jae 0xc821
leaq 0x670a(%rip), %rsi      # 0x12f21
movq %rbx, %rdi
callq 0x7cb0
incl %ebp
btl $0x9, %r14d
jae 0xc96c
leaq 0x66fc(%rip), %rsi      # 0x12f2f
movq %rbx, %rdi
callq 0x7cb0
incl %ebp
jmp 0xc96c
xorl %r14d, %r14d
leaq 0x6673(%rip), %r15      # 0x12ebf
movq %rbx, %rdi
movl %r12d, %esi
callq 0x7da0
testl %eax, %eax
je 0xc95e
leal 0x1(%r12), %ebp
movq %rbx, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x7330
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x7710
movl %ebp, %r12d
testl %eax, %eax
je 0xc84c
movq %r13, %rdi
leaq 0x6645(%rip), %rsi      # 0x12ed5
callq 0x7710
testl %eax, %eax
je 0xc8f4
movq %r13, %rdi
leaq 0x664f(%rip), %rsi      # 0x12ef2
callq 0x7710
testl %eax, %eax
je 0xc900
movq %r13, %rdi
leaq 0x6658(%rip), %rsi      # 0x12f0e
callq 0x7710
testl %eax, %eax
je 0xc90c
movq %r13, %rdi
leaq 0x6658(%rip), %rsi      # 0x12f21
callq 0x7710
testl %eax, %eax
je 0xc918
movq %r13, %rdi
leaq 0x6653(%rip), %rsi      # 0x12f2f
callq 0x7710
testl %eax, %eax
jne 0xc938
orl $0x200, %r14d           # imm = 0x200
movl %ebp, %r12d
jmp 0xc84c
orl $0x2, %r14d
movl %ebp, %r12d
jmp 0xc84c
orl $0x4, %r14d
movl %ebp, %r12d
jmp 0xc84c
orl $0x8, %r14d
movl %ebp, %r12d
jmp 0xc84c
orl $0x100, %r14d           # imm = 0x100
movl %ebp, %r12d
jmp 0xc84c
leaq 0x6591(%rip), %rsi      # 0x12ebf
movq %rbx, %rdi
callq 0x7cb0
jmp 0xc969
leaq 0x4c65(%rip), %rsi      # 0x115a4
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x7690
decl %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x7260
movl %eax, %r14d
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0x7540
pushq $0x1
popq %rbp
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_O2/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
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x7c10
cmpl $0x3, %eax
jne 0xca76
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7780
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0xc9ca
leaq 0x6586(%rip), %rsi      # 0x12f45
movq %rbx, %rdi
callq 0x7cb0
movl %r15d, %ebp
testb $0x2, %r14b
je 0xc9e1
leaq 0x6574(%rip), %rsi      # 0x12f4b
movq %rbx, %rdi
callq 0x7cb0
incl %ebp
testb $0x4, %r14b
je 0xc9f8
leaq 0x656b(%rip), %rsi      # 0x12f59
movq %rbx, %rdi
callq 0x7cb0
incl %ebp
testb $0x8, %r14b
je 0xca0f
leaq 0x6561(%rip), %rsi      # 0x12f66
movq %rbx, %rdi
callq 0x7cb0
incl %ebp
testb $0x10, %r14b
je 0xca26
leaq 0x655a(%rip), %rsi      # 0x12f76
movq %rbx, %rdi
callq 0x7cb0
incl %ebp
testb $0x20, %r14b
je 0xca3d
leaq 0x6552(%rip), %rsi      # 0x12f85
movq %rbx, %rdi
callq 0x7cb0
incl %ebp
btl $0x8, %r14d
jae 0xca55
leaq 0x6548(%rip), %rsi      # 0x12f93
movq %rbx, %rdi
callq 0x7cb0
incl %ebp
btl $0x9, %r14d
jae 0xcbc4
leaq 0x653b(%rip), %rsi      # 0x12fa2
movq %rbx, %rdi
callq 0x7cb0
incl %ebp
jmp 0xcbc4
xorl %r14d, %r14d
leaq 0x4bc6(%rip), %r15      # 0x11646
leaq 0x64be(%rip), %r12      # 0x12f45
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7da0
testl %eax, %eax
je 0xcbb6
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x7330
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x7710
testl %eax, %eax
je 0xcb8b
movq %r13, %rdi
movq %r12, %rsi
callq 0x7710
testl %eax, %eax
je 0xcb60
movq %r13, %rdi
leaq 0x6473(%rip), %rsi      # 0x12f4b
callq 0x7710
testl %eax, %eax
je 0xcb66
movq %r13, %rdi
leaq 0x646a(%rip), %rsi      # 0x12f59
callq 0x7710
testl %eax, %eax
je 0xcb6c
movq %r13, %rdi
leaq 0x6464(%rip), %rsi      # 0x12f66
callq 0x7710
testl %eax, %eax
je 0xcb72
movq %r13, %rdi
leaq 0x6461(%rip), %rsi      # 0x12f76
callq 0x7710
testl %eax, %eax
je 0xcb78
movq %r13, %rdi
leaq 0x645d(%rip), %rsi      # 0x12f85
callq 0x7710
testl %eax, %eax
je 0xcb7e
movq %r13, %rdi
leaq 0x6458(%rip), %rsi      # 0x12f93
callq 0x7710
testl %eax, %eax
je 0xcb84
movq %r13, %rdi
leaq 0x6454(%rip), %rsi      # 0x12fa2
callq 0x7710
testl %eax, %eax
jne 0xcb92
orl $0x200, %r14d           # imm = 0x200
jmp 0xcb8b
orl $0x1, %r14d
jmp 0xcb8b
orl $0x2, %r14d
jmp 0xcb8b
orl $0x4, %r14d
jmp 0xcb8b
orl $0x8, %r14d
jmp 0xcb8b
orl $0x10, %r14d
jmp 0xcb8b
orl $0x20, %r14d
jmp 0xcb8b
orl $0x100, %r14d           # imm = 0x100
incl %ebp
jmp 0xca87
leaq 0x4a0b(%rip), %rsi      # 0x115a4
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x7690
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x7260
movl %eax, %r14d
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0x7540
pushq $0x1
popq %rbp
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_O2/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 0x7380
testl %eax, %eax
je 0xd1ab
leaq 0x5f28(%rip), %rdi      # 0x130b6
movq %rbx, %rsi
xorl %eax, %eax
callq 0x7270
movq (%rbx), %rdi
callq 0x7610
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x7ac0
movq %rax, %r15
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x7c20
movq %rax, %r14
movq %r15, %rdi
callq 0x7230
movq 0x8(%rax), %r12
movq (%r15), %rax
movq 0x98(%rax), %rdi
movq %r14, %rsi
callq 0x78a0
testl %eax, %eax
je 0xd26a
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79f0
movl %ebp, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7a70
leaq 0x5e75(%rip), %rdi      # 0x130e6
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x5e47(%rip), %rdx      # 0x130c9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72b0
movq %r14, %rdi
callq 0x7230
movq %r12, 0x8(%rax)
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd79f
movq %rax, %r15
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x7c20
movq %rax, %r14
movq %r15, %rdi
callq 0x7230
movq 0x8(%rax), %r12
movq (%r15), %rdi
movq %r14, %rsi
callq 0x7290
testl %eax, %eax
je 0xd327
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79f0
movl %ebp, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7a70
leaq 0x5d9b(%rip), %rdx      # 0x130c9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72b0
movq %r14, %rdi
callq 0x7230
movq %r12, 0x8(%rax)
leaq 0x5dc3(%rip), %rdi      # 0x1310f
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/glyph.c
// Function: Glyph_get_cbox
static int Glyph_get_cbox(lua_State *L) 
    {
    FT_BBox acbox;
    FT_Glyph *glyph = checkglyph(L, 1);
    FT_UInt bbox_mode = checkglyphbboxmode(L, 2);
    FT_Glyph_Get_CBox(*glyph, bbox_mode, &acbox);
    pushbbox(L, acbox);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0xd79f
movq %rax, %r14
pushq $0x5
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x7b20
movq (%r14), %rdi
leaq 0x28(%rsp), %r14
movl %eax, %esi
movq %r14, %rdx
callq 0x7670
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x76c0
pushq $0x1
popq %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd79f
movq %rax, %r14
pushq $0x9
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x7b20
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7c10
xorl %r15d, %r15d
testl %eax, %eax
jle 0xd409
pushq $0x3
popq %rsi
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x7740
jmp 0xd40c
xorl %r12d, %r12d
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x7720
movl %eax, %r13d
andl $0xff, %r13d
leaq 0x5d3f(%rip), %rax      # 0x1316a
leaq 0x5d33(%rip), %r8       # 0x13165
cmoveq %rax, %r8
leaq 0x5cf7(%rip), %rdi      # 0x13134
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 0x77c0
movl %eax, %ebp
leaq 0x5d0b(%rip), %rdi      # 0x13170
movq %r14, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x7270
testl %ebp, %ebp
je 0xd48c
movl %ebp, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a70
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_O2/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 0xd79f
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x18(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7d80
pushq $0x3
popq %rsi
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x7740
movq (%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x78b0
testl %eax, %eax
je 0xd502
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a70
jmp 0xd504
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd79f
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7a50
movq %rax, %r15
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x7720
movq (%r15), %rsi
movzbl %al, %edx
movq %r14, %rdi
callq 0x7cc0
testl %eax, %eax
je 0xd567
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x7a70
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xd79f
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7a50
movq %rax, %r15
pushq $0x3
popq %rbp
pushq $0x1
popq %r12
movq %rbx, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x7720
movl %eax, %r13d
movq %rbx, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x7720
movq (%r15), %rsi
movl $0xff, %ecx
andl %ecx, %r13d
andl %eax, %ecx
movq %r14, %rdi
movl %r13d, %edx
callq 0x7530
testl %eax, %eax
je 0xd5f5
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7a70
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]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 0xd79f
movq (%rax), %rsi
cmpl $0x62697473, 0x10(%rsi) # imm = 0x62697473
jne 0xd66f
movq (%rsi), %rdx
addq $0x30, %rsi
movq %rbx, %rdi
callq 0x78c0
pushq $0x1
popq %rax
popq %rbx
retq
leaq 0x5b14(%rip), %rdx      # 0x1318a
pushq $0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0xd79f
movq (%rax), %rax
cmpl $0x62697473, 0x10(%rax) # imm = 0x62697473
jne 0xd6d2
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)
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %ecx
callq 0x7cf0
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5ab1(%rip), %rdx      # 0x1318a
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %rbp
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O2/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 0xd79f
movq (%rax), %rsi
cmpl $0x6f75746c, 0x10(%rsi) # imm = 0x6F75746C
jne 0xd713
movq (%rsi), %rdx
addq $0x28, %rsi
movq %rbx, %rdi
callq 0x7160
pushq $0x1
popq %rax
popq %rbx
retq
leaq 0x5a8d(%rip), %rdx      # 0x131a7
pushq $0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O2/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 0xd79f
movq (%rax), %rax
cmpl $0x6f75746c, 0x10(%rax) # imm = 0x6F75746C
jne 0xd76a
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 0x7360
pushq $0x1
popq %rax
addq $0x30, %rsp
popq %rbx
retq
leaq 0x5a36(%rip), %rdx      # 0x131a7
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
jmp 0x7260