LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/charmap.c
// Function: moonfreetype_pushcharmap
int pushcharmap(lua_State *L, FT_CharMap map)
    {
    lua_newtable(L);
    pushencoding(L, map->encoding);
    lua_setfield(L, -2, "encoding");
    lua_pushinteger(L, map->platform_id);
    lua_setfield(L, -2, "platform_id");
    lua_pushinteger(L, map->encoding_id);
    lua_setfield(L, -2, "encoding_id");
    lua_pushstring(L, platformstring(map->platform_id));
    lua_setfield(L, -2, "platform_name");
    lua_pushstring(L, encodingstring(map->platform_id, map->encoding_id));
    lua_setfield(L, -2, "encoding_name");
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x73c0
movl 0x8(%r14), %edx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x7280
leaq 0x9cad(%rip), %rdx      # 0x1225c
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movzwl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0x7530
leaq 0x9c95(%rip), %rdx      # 0x12265
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movzwl 0xe(%r14), %esi
movq %rbx, %rdi
callq 0x7530
leaq 0x9c80(%rip), %rdx      # 0x12271
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movzwl 0xc(%r14), %eax
cmpq $0x7, %rax
ja 0x8616
leaq 0x10880(%rip), %rcx     # 0x18e90
movq (%rcx,%rax,8), %rsi
jmp 0x861d
leaq 0x9ca8(%rip), %rsi      # 0x122c5
movq %rbx, %rdi
callq 0x7c90
leaq 0x9c51(%rip), %rdx      # 0x1227d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movzwl 0xc(%r14), %edi
movzwl 0xe(%r14), %esi
callq 0x7910
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7c90
leaq 0x9c31(%rip), %rdx      # 0x1228b
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/charmap.c
// Function: moonfreetype_encodingstring
const char* encodingstring(unsigned int platform_id, unsigned int id)
    {
    switch(platform_id)
        {
        case TT_PLATFORM_APPLE_UNICODE: return encodingstring_apple(id);
        case TT_PLATFORM_MACINTOSH: return encodingstring_macintosh(id);
        case TT_PLATFORM_ISO: return encodingstring_iso(id);
        case TT_PLATFORM_MICROSOFT: return encodingstring_microsoft(id);
        case TT_PLATFORM_CUSTOM: return encodingstring_custom(id);
        case TT_PLATFORM_ADOBE: return encodingstring_adobe(id);
        default:
            return "unknown platform id";
        }
    return NULL; /* unreachable */
    }

// Assembly:
leaq 0x9c2f(%rip), %rax      # 0x122c5
cmpl $0x7, %edi
ja 0x8704
movl %edi, %ecx
leaq 0x9ab8(%rip), %rdx      # 0x1215c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
cmpl $0x6, %esi
jae 0x8705
movl %esi, %eax
leaq 0x9ac1(%rip), %rcx      # 0x1217c
jmp 0x86fd
decl %esi
cmpl $0x20, %esi
jae 0x870d
movl %esi, %eax
leaq 0x9ac7(%rip), %rcx      # 0x12194
jmp 0x86fd
cmpl $0x4, %esi
jae 0x8705
movl %esi, %eax
leaq 0x9b6f(%rip), %rcx      # 0x1224c
jmp 0x86fd
cmpl $0x3, %esi
jae 0x8705
movl %esi, %eax
leaq 0x9b27(%rip), %rcx      # 0x12214
jmp 0x86fd
cmpl $0xb, %esi
jae 0x8705
movl %esi, %eax
leaq 0x9b23(%rip), %rcx      # 0x12220
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x9c0b(%rip), %rax      # 0x12317
retq
leaq 0xa32a(%rip), %rax      # 0x12a3e
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/computations.c
// Function: moonfreetype_checkvector
int checkvector(lua_State *L, int arg, FT_Vector *dst)
    {
    if(!lua_istable(L, arg))
        return luaL_argerror(L, arg, "table expected");
    lua_getfield(L, arg, "x"); dst->x = luaL_checkinteger(L, -1); lua_pop(L, 1);
    lua_getfield(L, arg, "y"); dst->y = luaL_checkinteger(L, -1); lua_pop(L, 1);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x7bf0
cmpl $0x5, %eax
jne 0x8795
leaq 0xbc41(%rip), %rdx      # 0x14376
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d20
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7760
movq %rax, (%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x70b0
leaq 0xbc1b(%rip), %rdx      # 0x1437e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d20
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7760
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x70b0
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x9ce8(%rip), %rdx      # 0x12484
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/computations.c
// Function: moonfreetype_pushvector
int pushvector(lua_State *L, FT_Vector vector)
    {
    lua_newtable(L);
    lua_pushinteger(L, vector.x);
    lua_setfield(L, -2, "x");
    lua_pushinteger(L, vector.y);
    lua_setfield(L, -2, "y");
    return 1;   
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %esi, %esi
xorl %edx, %edx
callq 0x73c0
movq %r15, %rdi
movq %r14, %rsi
callq 0x7530
leaq 0xbba3(%rip), %rdx      # 0x14376
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7530
leaq 0xbb8c(%rip), %rdx      # 0x1437e
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/computations.c
// Function: moonfreetype_checkmatrix
int checkmatrix(lua_State *L, int arg, FT_Matrix *dst)
    {
    if(!lua_istable(L, arg))
        return luaL_argerror(L, arg, "table expected");
    lua_getfield(L, arg, "xx"); dst->xx = luaL_checkinteger(L, -1); lua_pop(L, 1);
    lua_getfield(L, arg, "xy"); dst->xy = luaL_checkinteger(L, -1); lua_pop(L, 1);
    lua_getfield(L, arg, "yx"); dst->yx = luaL_checkinteger(L, -1); lua_pop(L, 1);
    lua_getfield(L, arg, "yy"); dst->yy = luaL_checkinteger(L, -1); lua_pop(L, 1);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x7bf0
cmpl $0x5, %eax
jne 0x88e6
leaq 0x9c68(%rip), %rdx      # 0x12493
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d20
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7760
movq %rax, (%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x70b0
leaq 0xbc36(%rip), %rdx      # 0x1448f
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d20
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7760
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x70b0
leaq 0x9c0e(%rip), %rdx      # 0x12496
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d20
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7760
movq %rax, 0x10(%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x70b0
leaq 0x9be2(%rip), %rdx      # 0x12499
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d20
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7760
movq %rax, 0x18(%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x70b0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x9b97(%rip), %rdx      # 0x12484
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/computations.c
// Function: moonfreetype_pushmatrix
int pushmatrix(lua_State *L, FT_Matrix matrix)
    {
    lua_newtable(L);
    lua_pushinteger(L, matrix.xx);
    lua_setfield(L, -2, "xx");
    lua_pushinteger(L, matrix.xy);
    lua_setfield(L, -2, "xy");
    lua_pushinteger(L, matrix.yx);
    lua_setfield(L, -2, "yx");
    lua_pushinteger(L, matrix.yy);
    lua_setfield(L, -2, "yy");
    return 1;   
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x73c0
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x9b77(%rip), %rdx      # 0x12493
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0xbb52(%rip), %rdx      # 0x1448f
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x9b38(%rip), %rdx      # 0x12496
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x9b1a(%rip), %rdx      # 0x12499
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/computations.c
// Function: Muldiv
static int Muldiv(lua_State *L)
    {
    FT_Long a = luaL_checkinteger(L, 1);
    FT_Long b = luaL_checkinteger(L, 2);
    FT_Long c = luaL_checkinteger(L, 3);
    lua_pushinteger(L, FT_MulDiv(a, b, c));
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7760
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7760
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7760
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7610
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7530
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/computations.c
// Function: Mulfix
static int Mulfix(lua_State *L)
    {
    FT_Long a = luaL_checkinteger(L, 1);
    FT_Long b = luaL_checkinteger(L, 2);
    lua_pushinteger(L, FT_MulFix(a, b));
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7760
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7760
movq %r14, %rdi
movq %rax, %rsi
callq 0x7710
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7530
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/computations.c
// Function: Divfix
static int Divfix(lua_State *L)
    {
    FT_Long a = luaL_checkinteger(L, 1);
    FT_Long b = luaL_checkinteger(L, 2);
    lua_pushinteger(L, FT_DivFix(a, b));
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7760
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7760
movq %r14, %rdi
movq %rax, %rsi
callq 0x7940
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7530
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/computations.c
// Function: Vector_rotate
static int Vector_rotate(lua_State *L)
    {
    FT_Vector vec;
    FT_Angle angle;
    checkvector(L, 1, &vec);
    angle = luaL_checkinteger(L, 2);
    FT_Vector_Rotate(&vec, angle);
    return pushvector(L, vec);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x7720
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7760
movq %r14, %rdi
movq %rax, %rsi
callq 0x7340
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x7b90
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/computations.c
// Function: Vector_polarize
static int Vector_polarize(lua_State *L)
    {
    FT_Vector vec;
    FT_Fixed length;
    FT_Angle angle;
    checkvector(L, 1, &vec);
    FT_Vector_Polarize(&vec, &length, &angle);
    lua_pushinteger(L, length);
    lua_pushinteger(L, angle);
    return 2;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x7720
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7d40
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x7530
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x7530
movl $0x2, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/computations.c
// Function: Vector_from_polar
static int Vector_from_polar(lua_State *L)
    {
    FT_Vector vec;
    FT_Fixed length = luaL_checkinteger(L, 1);
    FT_Angle angle = luaL_checkinteger(L, 2);
    FT_Vector_From_Polar(&vec, length, angle);
    return pushvector(L, vec);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7760
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7760
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7810
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x7b90
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/computations.c
// Function: Vector_transform
static int Vector_transform(lua_State *L)
    {
    FT_Vector vec;
    FT_Matrix mat;
    checkvector(L, 1, &vec);
    checkmatrix(L, 2, &mat);
    FT_Vector_Transform(&vec, &mat);
    return pushvector(L, vec);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x7720
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x7d50
movq %r14, %rdi
movq %r15, %rsi
callq 0x7b50
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x7b90
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/computations.c
// Function: Matrix_multiply
static int Matrix_multiply(lua_State *L)
    {
    FT_Matrix a;
    FT_Matrix b;
    checkmatrix(L, 1, &a);
    checkmatrix(L, 1, &b);
    FT_Matrix_Multiply(&a, &b);
    return pushmatrix(L, b);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x7d50
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x7d50
movq %r14, %rdi
movq %r15, %rsi
callq 0x7030
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x7bd0
movl $0x1, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/computations.c
// Function: Matrix_invert
static int Matrix_invert(lua_State *L)
    {
    FT_Error ec;
    FT_Matrix mat;
    checkmatrix(L, 1, &mat);
    ec = FT_Matrix_Invert(&mat);
    CheckError(L, ec);
    return pushmatrix(L, mat);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movl $0x1, %ebp
leaq 0x20(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x7d50
movq %r14, %rdi
callq 0x78f0
testl %eax, %eax
je 0x8f08
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
movl %eax, %ebp
jmp 0x8f23
movups 0x20(%rsp), %xmm0
movups 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x7bd0
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/enums.c
// Function: Enum
static int Enum(lua_State *L)
/* { strings } = cl.enum('type') lists all the values for a given enum type */
    {
    const char *s = luaL_checkstring(L, 1);
#define CASE(xxx) if(strcmp(s, ""#xxx) == 0) return values##xxx(L)
    CASE(type);
    CASE(orientation);
    CASE(strokerborder);
    CASE(strokerlinejoin);
    CASE(strokerlinecap);
    CASE(glyphbboxmode);
    CASE(truetypeenginetype);
    CASE(sizerequesttype);
    CASE(kerningmode);
    CASE(rendermode);
    CASE(encoding);
    CASE(glyphformat);
    CASE(pixelmode);
#undef CASE
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %ebp
movl $0x1, %esi
xorl %edx, %edx
callq 0x7620
movq %rax, %r14
leaq 0x9a79(%rip), %rsi      # 0x14923
movq %rax, %rdi
callq 0x76f0
testl %eax, %eax
je 0xafc9
leaq 0x9643(%rip), %rsi      # 0x14504
movq %r14, %rdi
callq 0x76f0
testl %eax, %eax
je 0xb014
leaq 0x7c97(%rip), %rsi      # 0x12b6f
movq %r14, %rdi
callq 0x76f0
testl %eax, %eax
je 0xafd0
leaq 0x7c8e(%rip), %rsi      # 0x12b7d
movq %r14, %rdi
callq 0x76f0
testl %eax, %eax
je 0xafd7
leaq 0x7c87(%rip), %rsi      # 0x12b8d
movq %r14, %rdi
callq 0x76f0
testl %eax, %eax
je 0xafde
leaq 0x7c7f(%rip), %rsi      # 0x12b9c
movq %r14, %rdi
callq 0x76f0
testl %eax, %eax
je 0xafe5
leaq 0x7c76(%rip), %rsi      # 0x12baa
movq %r14, %rdi
callq 0x76f0
testl %eax, %eax
je 0xafec
leaq 0x7c72(%rip), %rsi      # 0x12bbd
movq %r14, %rdi
callq 0x76f0
testl %eax, %eax
je 0xaff3
leaq 0x7c6b(%rip), %rsi      # 0x12bcd
movq %r14, %rdi
callq 0x76f0
testl %eax, %eax
je 0xaffa
leaq 0x7c60(%rip), %rsi      # 0x12bd9
movq %r14, %rdi
callq 0x76f0
testl %eax, %eax
je 0xb001
leaq 0x72d0(%rip), %rsi      # 0x1225c
movq %r14, %rdi
callq 0x76f0
testl %eax, %eax
je 0xb008
leaq 0x7c45(%rip), %rsi      # 0x12be4
movq %r14, %rdi
callq 0x76f0
testl %eax, %eax
je 0xb00f
leaq 0x7c3e(%rip), %rsi      # 0x12bf0
movq %r14, %rdi
callq 0x76f0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0xb023
movl $0xc, %ebp
jmp 0xb014
movl $0x65, %ebp
jmp 0xb014
movl $0x2, %ebp
jmp 0xb014
movl $0x3, %ebp
jmp 0xb014
movl $0x4, %ebp
jmp 0xb014
movl $0x5, %ebp
jmp 0xb014
movl $0x6, %ebp
jmp 0xb014
movl $0x7, %ebp
jmp 0xb014
movl $0x8, %ebp
jmp 0xb014
movl $0x9, %ebp
jmp 0xb014
movl $0xa, %ebp
jmp 0xb014
movl $0xb, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x78c0
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/face.c
// Function: moonfreetype_checkface
FT_Face* checkface(lua_State *L, int arg)
    {
    FT_Face *p = testface(L, arg);
    if(p) return p;
    luaL_argerror(L, arg, "not a face");
    return NULL;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x6f5d(%rip), %rdx      # 0x12000
callq 0x7630
testq %rax, %rax
je 0xb0b2
movq (%rax), %rax
jmp 0xb0b4
xorl %eax, %eax
testq %rax, %rax
jne 0xb0cc
leaq 0x8664(%rip), %rdx      # 0x13724
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_O1/stetre[P]moonfreetype/src/face.c
// Function: moonfreetype_newface
int newface(lua_State *L)
/* face = new_face(filepathname [, index=0 [, instance=0]]) */
    {
    FT_Error ec;
    ud_t *ud;
    FT_Library *library = checklibrary(L, 1);
    const char* filepathname = luaL_checkstring(L, 2);
    FT_Long index = luaL_optinteger(L, 3, 0);
    FT_Long instance = luaL_optinteger(L, 3, 0);
    FT_Face *face = (FT_Face*)Malloc(L, sizeof(FT_Face));
    FT_Long face_index = ((instance & 0x00007fff) << 16) | (index & 0x0000ffff);
    

    ec = FT_New_Face(*library, filepathname, face_index, face);
    DBG("created face %p %s\n", (void*)face, filepathname);
    DBG("ec=%d\n", ec);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x76c0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x7620
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x7820
movq %rax, %r13
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x7820
movq %rax, %rbp
movl $0x8, %esi
movq %rbx, %rdi
callq 0x7c00
movq %rax, %r15
shll $0x10, %ebp
andl $0x7fff0000, %ebp       # imm = 0x7FFF0000
movzwl %r13w, %edx
orq %rbp, %rdx
movq (%r14), %rdi
movq %r12, %rsi
movq %rax, %rcx
callq 0x74b0
movl %eax, %ebp
leaq 0x85d3(%rip), %rdi      # 0x1372f
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x7270
leaq 0x8ff3(%rip), %rdi      # 0x14163
movl %ebp, %esi
xorl %eax, %eax
callq 0x7270
testl %ebp, %ebp
je 0xb1aa
movq %rbx, %rdi
movq %r15, %rsi
callq 0x79e0
movl %ebp, %edi
callq 0x7d00
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 0x7a60
movq (%r15), %rax
movq 0x98(%rax), %rsi
leaq 0x8588(%rip), %rdi      # 0x13743
xorl %eax, %eax
callq 0x7270
leaq 0x6e37(%rip), %rdx      # 0x12000
movq %rbx, %rdi
movq %r15, %rsi
callq 0x72a0
movq %r15, %rdi
callq 0x7230
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]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 0x854a(%rip), %rsi      # 0x13752
leaq 0x60(%rip), %rcx        # 0xb26f
movq %r14, %rdx
callq 0x7aa0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7370
testl %eax, %eax
je 0xb268
leaq 0x8537(%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 0xb268
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_O1/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 0xb296
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7900
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7760
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7760
movq %rax, %r12
leaq 0x86f7(%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 0xb381
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_O1/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 0x7760
movq (%r14), %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x7840
testl %eax, %eax
je 0xb3eb
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_O1/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
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 0x7760
movq (%r14), %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x7150
testl %eax, %eax
je 0xb44b
movl %eax, %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_O1/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 0xb494
movq %r14, %rdi
movl %eax, %esi
callq 0x7cc0
jmp 0xb496
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r15
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x7620
movq (%r15), %rdi
movq %rax, %rsi
callq 0x7140
testl %eax, %eax
je 0xb4e4
movq %rbx, %rdi
movl %eax, %esi
callq 0x7cc0
movl $0x1, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb532
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7530
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0x7530
movl $0x2, %eax
jmp 0xb534
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb599
movq %r14, %rdi
movq %rax, %rsi
callq 0x7530
movl 0xc(%rsp), %esi
movq %r14, %rdi
callq 0x7530
jmp 0xb59b
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7330
movq (%r14), %rdi
movl %eax, %esi
callq 0x79b0
testl %eax, %eax
je 0xb5f1
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
// File: /workspace/github_c_makefile_star2_O1/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 0x7760
movq %rax, 0x8(%r15)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x7760
movq %rax, 0x10(%r15)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x7760
movl %eax, 0x18(%r15)
movq %rbx, %rdi
movl $0x6, %esi
callq 0x7760
movl %eax, 0x1c(%r15)
movq (%r14), %rdi
movq %r15, %rsi
callq 0x7780
testl %eax, %eax
je 0xb695
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
jmp 0xb697
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7760
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7760
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
callq 0x7760
movq %rax, %r13
movq %rbx, %rdi
movl $0x5, %esi
callq 0x7760
movq (%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %r13d, %ecx
movl %eax, %r8d
callq 0x7c60
testl %eax, %eax
je 0xb72c
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_O1/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 0xb77b
leaq 0x18(%rsp), %r15
movq %r14, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x7d50
jmp 0xb77e
xorl %r15d, %r15d
movq %r14, %rdi
movl $0x3, %esi
callq 0x7bf0
testl %eax, %eax
jle 0xb7a6
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x7720
jmp 0xb7a9
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_O1/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
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r14
movq %rbx, %rdi
movl $0x9, %esi
movl $0x2, %edx
callq 0x7b00
movq (%r14), %rcx
movq 0x98(%rcx), %rdi
movl %eax, %esi
callq 0x7a80
testl %eax, %eax
je 0xb81b
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
// File: /workspace/github_c_makefile_star2_O1/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 0xb883
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
movl %eax, %ebp
jmp 0xb88e
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_O1/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 0xb8e0
movl $0xa, %esi
movl $0x2, %edx
callq 0x7b00
movq (%r14), %rdi
movl %eax, %esi
callq 0x7650
jmp 0xb901
movl $0x2, %esi
callq 0x7330
movq (%r14), %rdi
cmpl 0x48(%rdi), %eax
jge 0xb92a
movq 0x50(%rdi), %rcx
cltq
movq (%rcx,%rax,8), %rsi
callq 0x7590
testl %eax, %eax
je 0xb920
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 0x8122(%rip), %rdx      # 0x13a53
movq %rbx, %rdi
movl $0x2, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7ab0
movq (%rax), %rdi
callq 0x73d0
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x7530
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb99d
movq %r14, %rdi
movq %rax, %rsi
callq 0x7c90
jmp 0xb99f
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb9d9
movq %r14, %rdi
movq %rax, %rsi
callq 0x7c90
jmp 0xb9db
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xba5e
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
jmp 0xba70
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_O1/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 0x7760
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7760
movq (%r14), %rdi
movq %rsp, %rcx
movq %r15, %rsi
movl %eax, %edx
callq 0x7040
testl %eax, %eax
je 0xbae0
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
movl %eax, %ebp
jmp 0xbaec
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_O1/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 0xbb8b
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_O1/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 %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
xorl %ecx, %ecx
cmpl $0x6f75746c, 0x90(%r14) # imm = 0x6F75746C
jne 0xbbe0
movq 0x8(%rax), %rdx
addq $0xc8, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7160
movl $0x1, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x7ab0
movq (%rax), %rax
movzwl 0x8(%rax), %esi
movq %rbx, %rdi
callq 0x7530
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7530
movl $0x2, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc194
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x73c0
testl %r13d, %r13d
jle 0xc196
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 0xc155
jmp 0xc196
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_O1/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 0xc221
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x73c0
testl %r13d, %r13d
jle 0xc223
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 0xc1eb
jmp 0xc223
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc90c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7760
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0xc879
leaq 0x75e4(%rip), %rsi      # 0x13e50
movq %rbx, %rdi
callq 0x7c90
movl $0x1, %ebp
testb $0x2, %r14b
je 0xc890
leaq 0x75d9(%rip), %rsi      # 0x13e5f
movq %rbx, %rdi
callq 0x7c90
incl %ebp
testb $0x4, %r14b
je 0xc8a7
leaq 0x75d5(%rip), %rsi      # 0x13e72
movq %rbx, %rdi
callq 0x7c90
incl %ebp
testb $0x8, %r14b
je 0xc8be
leaq 0x76dd(%rip), %rsi      # 0x13f91
movq %rbx, %rdi
callq 0x7c90
incl %ebp
testb $0x40, %r14b
je 0xc8d5
leaq 0x75b8(%rip), %rsi      # 0x13e83
movq %rbx, %rdi
callq 0x7c90
incl %ebp
testb %r14b, %r14b
jns 0xc8eb
leaq 0x75ab(%rip), %rsi      # 0x13e8c
movq %rbx, %rdi
callq 0x7c90
incl %ebp
btl $0x9, %r14d
jae 0xca19
leaq 0x7593(%rip), %rsi      # 0x13e90
movq %rbx, %rdi
callq 0x7c90
incl %ebp
jmp 0xca19
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7d70
xorl %r14d, %r14d
testl %eax, %eax
je 0xca09
leaq 0x7520(%rip), %r15      # 0x13e50
leaq 0x7528(%rip), %r12      # 0x13e5f
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x7320
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x76f0
testl %eax, %eax
je 0xc9ca
movq %r13, %rdi
movq %r12, %rsi
callq 0x76f0
testl %eax, %eax
je 0xc9d1
movq %r13, %rdi
leaq 0x7504(%rip), %rsi      # 0x13e72
callq 0x76f0
testl %eax, %eax
je 0xc9d8
movq %r13, %rdi
leaq 0x7610(%rip), %rsi      # 0x13f91
callq 0x76f0
testl %eax, %eax
je 0xc9df
movq %r13, %rdi
leaq 0x74ef(%rip), %rsi      # 0x13e83
callq 0x76f0
testl %eax, %eax
je 0xc9e6
movq %r13, %rdi
leaq 0x74e5(%rip), %rsi      # 0x13e8c
callq 0x76f0
testl %eax, %eax
je 0xc9ed
movq %r13, %rdi
leaq 0x74d6(%rip), %rsi      # 0x13e90
callq 0x76f0
movl $0x200, %ecx            # imm = 0x200
testl %eax, %eax
je 0xc9f2
jmp 0xca2a
movl $0x1, %ecx
jmp 0xc9f2
movl $0x2, %ecx
jmp 0xc9f2
movl $0x4, %ecx
jmp 0xc9f2
movl $0x8, %ecx
jmp 0xc9f2
movl $0x40, %ecx
jmp 0xc9f2
movl $0x80, %ecx
orl %ecx, %r14d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d70
testl %eax, %eax
jne 0xc937
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 0x5b53(%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 0xca09