LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x7ac0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl 0x38(%rax), %eax
movl %eax, 0x30(%rsp)
cmpl $0x0, 0x30(%rsp)
jne 0xff00
movl $0x0, 0x44(%rsp)
jmp 0xff92
movq 0x38(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x73d0
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0xff8a
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rax
movslq 0x34(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x79a0
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x76b0
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0xff16
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x7ac0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl 0x48(%rax), %eax
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jne 0xffdd
movl $0x0, 0x24(%rsp)
jmp 0x1004a
movq 0x18(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x73d0
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x10042
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x50(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x7990
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x76b0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xfff3
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x7c10
cmpl $0x3, %eax
jne 0x107a8
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x7770
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x10960
movl %eax, 0x24(%rsp)
jmp 0x107d6
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x10ac0
movq 0x8(%rsp), %rdi
movslq %eax, %rsi
callq 0x7540
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x7c10
cmpl $0x3, %eax
jne 0x10828
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x7770
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x10c80
movl %eax, 0x24(%rsp)
jmp 0x10856
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x10da0
movq 0x8(%rsp), %rdi
movslq %eax, %rsi
callq 0x7540
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x7c10
cmpl $0x3, %eax
jne 0x108a8
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x7770
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x10f40
movl %eax, 0x24(%rsp)
jmp 0x108d6
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x110c0
movq 0x8(%rsp), %rdi
movslq %eax, %rsi
callq 0x7540
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/flags.c
// Function: LoadFlags
static int LoadFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushloadflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkloadflags(L, 1));
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x7c10
cmpl $0x3, %eax
jne 0x10928
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x7770
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x112d0
movl %eax, 0x24(%rsp)
jmp 0x10956
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x11740
movq 0x8(%rsp), %rdi
movslq %eax, %rsi
callq 0x7540
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/flags.c
// Function: pushsubglyphflags
static int pushsubglyphflags(lua_State *L, FT_Int32 flags)
    {
    int n = 0;

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
        CASE(FT_SUBGLYPH_FLAG_ARGS_ARE_WORDS, "args are words");
        CASE(FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES, "args are xy values");
        CASE(FT_SUBGLYPH_FLAG_ROUND_XY_TO_GRID, "round xy to grid");
        CASE(FT_SUBGLYPH_FLAG_SCALE, "scale");
        CASE(FT_SUBGLYPH_FLAG_XY_SCALE, "xy scale");
        CASE(FT_SUBGLYPH_FLAG_2X2, "2x2");
        CASE(FT_SUBGLYPH_FLAG_USE_MY_METRICS, "use my metrics");
#undef CASE

    return n;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1099d
movq 0x10(%rsp), %rdi
leaq 0xa4dd(%rip), %rsi      # 0x1ae6a
callq 0x7cb0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x1099f
jmp 0x109a1
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x109c9
movq 0x10(%rsp), %rdi
leaq 0xa4c0(%rip), %rsi      # 0x1ae79
callq 0x7cb0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x109cb
jmp 0x109cd
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x109f5
movq 0x10(%rsp), %rdi
leaq 0xa4a7(%rip), %rsi      # 0x1ae8c
callq 0x7cb0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x109f7
jmp 0x109f9
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x10a21
movq 0x10(%rsp), %rdi
leaq 0xa59a(%rip), %rsi      # 0x1afab
callq 0x7cb0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x10a23
jmp 0x10a25
movl 0xc(%rsp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x10a4d
movq 0x10(%rsp), %rdi
leaq 0xa460(%rip), %rsi      # 0x1ae9d
callq 0x7cb0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x10a4f
jmp 0x10a51
movl 0xc(%rsp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x10a7b
movq 0x10(%rsp), %rdi
leaq 0xa43b(%rip), %rsi      # 0x1aea6
callq 0x7cb0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x10a7d
jmp 0x10a7f
movl 0xc(%rsp), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x10aa9
movq 0x10(%rsp), %rdi
leaq 0xa411(%rip), %rsi      # 0x1aeaa
callq 0x7cb0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x10aab
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/flags.c
// Function: checksubglyphflags
static FT_Int32 checksubglyphflags(lua_State *L, int arg) 
    {
    const char *s;
    FT_Int32 flags = 0;
    
    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
        CASE(FT_SUBGLYPH_FLAG_ARGS_ARE_WORDS, "args are words");
        CASE(FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES, "args are xy values");
        CASE(FT_SUBGLYPH_FLAG_ROUND_XY_TO_GRID, "round xy to grid");
        CASE(FT_SUBGLYPH_FLAG_SCALE, "scale");
        CASE(FT_SUBGLYPH_FLAG_XY_SCALE, "xy scale");
        CASE(FT_SUBGLYPH_FLAG_2X2, "2x2");
        CASE(FT_SUBGLYPH_FLAG_USE_MY_METRICS, "use my metrics");
#undef CASE
        return (FT_Int32)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }

    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x7da0
cmpl $0x0, %eax
je 0x10c6f
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x7330
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0xa352(%rip), %rsi      # 0x1ae6a
callq 0x7700
cmpl $0x0, %eax
jne 0x10b34
jmp 0x10b24
movl 0x14(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x10c6a
movq 0x18(%rsp), %rdi
leaq 0xa339(%rip), %rsi      # 0x1ae79
callq 0x7700
cmpl $0x0, %eax
jne 0x10b5c
jmp 0x10b4c
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x10c6a
movq 0x18(%rsp), %rdi
leaq 0xa324(%rip), %rsi      # 0x1ae8c
callq 0x7700
cmpl $0x0, %eax
jne 0x10b84
jmp 0x10b74
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x10c6a
movq 0x18(%rsp), %rdi
leaq 0xa41b(%rip), %rsi      # 0x1afab
callq 0x7700
cmpl $0x0, %eax
jne 0x10bac
jmp 0x10b9c
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x10c6a
movq 0x18(%rsp), %rdi
leaq 0xa2e5(%rip), %rsi      # 0x1ae9d
callq 0x7700
cmpl $0x0, %eax
jne 0x10bd4
jmp 0x10bc4
movl 0x14(%rsp), %eax
orl $0x40, %eax
movl %eax, 0x14(%rsp)
jmp 0x10c6a
movq 0x18(%rsp), %rdi
leaq 0xa2c6(%rip), %rsi      # 0x1aea6
callq 0x7700
cmpl $0x0, %eax
jne 0x10bfb
jmp 0x10bec
movl 0x14(%rsp), %eax
orl $0x80, %eax
movl %eax, 0x14(%rsp)
jmp 0x10c6a
movq 0x18(%rsp), %rdi
leaq 0xa2a3(%rip), %rsi      # 0x1aeaa
callq 0x7700
cmpl $0x0, %eax
jne 0x10c22
jmp 0x10c13
movl 0x14(%rsp), %eax
orl $0x200, %eax            # imm = 0x200
movl %eax, 0x14(%rsp)
jmp 0x10c6a
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x8950(%rip), %rsi      # 0x1959c
movb $0x0, %al
callq 0x7690
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rax, %rdx
callq 0x7260
movl %eax, 0x34(%rsp)
jmp 0x10c77
jmp 0x10ad5
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/flags.c
// Function: pushfstypeflags
static int pushfstypeflags(lua_State *L, FT_Int32 flags)
    {
    int n = 0;

    if(flags==FT_FSTYPE_INSTALLABLE_EMBEDDING) 
        { lua_pushstring(L, "installable embedding"); return 1; }

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
//  CASE(FT_FSTYPE_INSTALLABLE_EMBEDDING, "installable embedding");  zero
    CASE(FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING, "restricted license embedding");
    CASE(FT_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING, "preview and print embedding");
    CASE(FT_FSTYPE_EDITABLE_EMBEDDING, "editable embedding");
    CASE(FT_FSTYPE_NO_SUBSETTING, "no subsetting");
    CASE(FT_FSTYPE_BITMAP_EMBEDDING_ONLY, "bitmap embedding only");
#undef CASE

    return n;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl $0x0, (%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x10cb9
movq 0x8(%rsp), %rdi
leaq 0xa212(%rip), %rsi      # 0x1aeb9
callq 0x7cb0
movl $0x1, 0x14(%rsp)
jmp 0x10d96
jmp 0x10cbb
movl 0x4(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x10ce1
movq 0x8(%rsp), %rdi
leaq 0xa1fc(%rip), %rsi      # 0x1aecf
callq 0x7cb0
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x10ce3
jmp 0x10ce5
movl 0x4(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x10d0b
movq 0x8(%rsp), %rdi
leaq 0xa1ef(%rip), %rsi      # 0x1aeec
callq 0x7cb0
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x10d0d
jmp 0x10d0f
movl 0x4(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x10d35
movq 0x8(%rsp), %rdi
leaq 0xa1e1(%rip), %rsi      # 0x1af08
callq 0x7cb0
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x10d37
jmp 0x10d39
movl 0x4(%rsp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x10d61
movq 0x8(%rsp), %rdi
leaq 0xa1c8(%rip), %rsi      # 0x1af1b
callq 0x7cb0
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x10d63
jmp 0x10d65
movl 0x4(%rsp), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x10d8d
movq 0x8(%rsp), %rdi
leaq 0xa1aa(%rip), %rsi      # 0x1af29
callq 0x7cb0
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x10d8f
movl (%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/flags.c
// Function: checkfstypeflags
static FT_Int32 checkfstypeflags(lua_State *L, int arg) 
    {
    const char *s;
    FT_Int32 flags = 0;
    
    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
    CASE(FT_FSTYPE_INSTALLABLE_EMBEDDING, "installable embedding");
    CASE(FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING, "restricted license embedding");
    CASE(FT_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING, "preview and print embedding");
    CASE(FT_FSTYPE_EDITABLE_EMBEDDING, "editable embedding");
    CASE(FT_FSTYPE_NO_SUBSETTING, "no subsetting");
    CASE(FT_FSTYPE_BITMAP_EMBEDDING_ONLY, "bitmap embedding only");
#undef CASE
        return (FT_Int32)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }

    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x7da0
cmpl $0x0, %eax
je 0x10f27
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x7330
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0xa0c1(%rip), %rsi      # 0x1aeb9
callq 0x7700
cmpl $0x0, %eax
jne 0x10e14
jmp 0x10e04
movl 0x14(%rsp), %eax
orl $0x0, %eax
movl %eax, 0x14(%rsp)
jmp 0x10f22
movq 0x18(%rsp), %rdi
leaq 0xa0af(%rip), %rsi      # 0x1aecf
callq 0x7700
cmpl $0x0, %eax
jne 0x10e3c
jmp 0x10e2c
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x10f22
movq 0x18(%rsp), %rdi
leaq 0xa0a4(%rip), %rsi      # 0x1aeec
callq 0x7700
cmpl $0x0, %eax
jne 0x10e64
jmp 0x10e54
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x10f22
movq 0x18(%rsp), %rdi
leaq 0xa098(%rip), %rsi      # 0x1af08
callq 0x7700
cmpl $0x0, %eax
jne 0x10e8c
jmp 0x10e7c
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0x10f22
movq 0x18(%rsp), %rdi
leaq 0xa083(%rip), %rsi      # 0x1af1b
callq 0x7700
cmpl $0x0, %eax
jne 0x10eb3
jmp 0x10ea4
movl 0x14(%rsp), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, 0x14(%rsp)
jmp 0x10f22
movq 0x18(%rsp), %rdi
leaq 0xa06a(%rip), %rsi      # 0x1af29
callq 0x7700
cmpl $0x0, %eax
jne 0x10eda
jmp 0x10ecb
movl 0x14(%rsp), %eax
orl $0x200, %eax            # imm = 0x200
movl %eax, 0x14(%rsp)
jmp 0x10f22
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x8698(%rip), %rsi      # 0x1959c
movb $0x0, %al
callq 0x7690
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rax, %rdx
callq 0x7260
movl %eax, 0x34(%rsp)
jmp 0x10f2f
jmp 0x10db5
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/flags.c
// Function: pushoutlineflags
static int pushoutlineflags(lua_State *L, FT_Int32 flags)
    {
    int n = 0;

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
//      CASE(FT_OUTLINE_NONE, "none"); zero
        CASE(FT_OUTLINE_OWNER, "owner");
        CASE(FT_OUTLINE_EVEN_ODD_FILL, "even odd fill");
        CASE(FT_OUTLINE_REVERSE_FILL, "reverse fill");
        CASE(FT_OUTLINE_IGNORE_DROPOUTS, "ignore dropouts");
        CASE(FT_OUTLINE_SMART_DROPOUTS, "smart dropouts");
        CASE(FT_OUTLINE_INCLUDE_STUBS, "include stubs");
        CASE(FT_OUTLINE_HIGH_PRECISION, "high precision");
        CASE(FT_OUTLINE_SINGLE_PASS, "single pass");
#undef CASE

    return n;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x10f7d
movq 0x10(%rsp), %rdi
leaq 0x9fd2(%rip), %rsi      # 0x1af3f
callq 0x7cb0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x10f7f
jmp 0x10f81
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x10fa9
movq 0x10(%rsp), %rdi
leaq 0x9fac(%rip), %rsi      # 0x1af45
callq 0x7cb0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x10fab
jmp 0x10fad
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x10fd5
movq 0x10(%rsp), %rdi
leaq 0x9f8e(%rip), %rsi      # 0x1af53
callq 0x7cb0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x10fd7
jmp 0x10fd9
movl 0xc(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x11001
movq 0x10(%rsp), %rdi
leaq 0x9f6f(%rip), %rsi      # 0x1af60
callq 0x7cb0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x11003
jmp 0x11005
movl 0xc(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x1102d
movq 0x10(%rsp), %rdi
leaq 0x9f53(%rip), %rsi      # 0x1af70
callq 0x7cb0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x1102f
jmp 0x11031
movl 0xc(%rsp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x11059
movq 0x10(%rsp), %rdi
leaq 0x9f36(%rip), %rsi      # 0x1af7f
callq 0x7cb0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x1105b
jmp 0x1105d
movl 0xc(%rsp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x11087
movq 0x10(%rsp), %rdi
leaq 0x9f16(%rip), %rsi      # 0x1af8d
callq 0x7cb0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x11089
jmp 0x1108b
movl 0xc(%rsp), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x110b5
movq 0x10(%rsp), %rdi
leaq 0x9ef7(%rip), %rsi      # 0x1af9c
callq 0x7cb0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x110b7
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x7380
cmpl $0x0, %eax
jne 0x11bea
movl $0x0, 0x14(%rsp)
jmp 0x11c1e
movq (%rsp), %rsi
leaq 0x94bb(%rip), %rdi      # 0x1b0b0
movb $0x0, %al
callq 0x7270
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x7610
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x79f0
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x7ac0
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x8, %esi
callq 0x7c20
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7230
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x98(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x78a0
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x11d3c
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x79f0
cmpl $0x0, 0x34(%rsp)
je 0x11d30
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %edi
callq 0x7d30
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x7a70
movl %eax, 0x44(%rsp)
jmp 0x11d8a
jmp 0x11d32
movl $0x0, 0x44(%rsp)
jmp 0x11d8a
movq 0x10(%rsp), %rsi
leaq 0x9398(%rip), %rdi      # 0x1b0e0
movb $0x0, %al
callq 0x7270
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x9363(%rip), %rdx      # 0x1b0c3
callq 0x72b0
movq 0x10(%rsp), %rdi
callq 0x7230
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x12660
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x8, %esi
callq 0x7c20
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7230
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x7290
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x11ea5
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x79f0
cmpl $0x0, 0x34(%rsp)
je 0x11e99
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %edi
callq 0x7d30
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x7a70
movl %eax, 0x44(%rsp)
jmp 0x11ef3
jmp 0x11e9b
movl $0x0, 0x44(%rsp)
jmp 0x11ef3
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x920d(%rip), %rdx      # 0x1b0c3
callq 0x72b0
movq 0x10(%rsp), %rdi
callq 0x7230
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rsi
leaq 0x9225(%rip), %rdi      # 0x1b109
movb $0x0, %al
callq 0x7270
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movl $0x1, %esi
callq 0x12660
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
movl $0x5, %esi
movl $0x2, %edx
callq 0x7b20
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movl 0x24(%rsp), %esi
leaq 0x30(%rsp), %rdx
callq 0x7670
movq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x76c0
movl $0x1, %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
callq 0x12660
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movl $0x9, %esi
movl $0x2, %edx
callq 0x7b20
movl %eax, 0x14(%rsp)
movq 0x48(%rsp), %rdi
movl $0x3, %esi
callq 0x7c10
cmpl $0x0, %eax
jle 0x12000
movq 0x48(%rsp), %rdi
movl $0x3, %esi
leaq 0x30(%rsp), %rdx
callq 0x7730
leaq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x7710
movb %al, 0x27(%rsp)
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
movq 0x28(%rsp), %rcx
movzbl 0x27(%rsp), %edi
leaq 0x9132(%rip), %r8       # 0x1b164
leaq 0x9126(%rip), %rax      # 0x1b15f
cmpl $0x0, %edi
cmovneq %rax, %r8
leaq 0x90e7(%rip), %rdi      # 0x1b12e
movb $0x0, %al
callq 0x7270
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x28(%rsp), %rdx
movzbl 0x27(%rsp), %ecx
callq 0x77b0
movl %eax, 0x44(%rsp)
movq 0x18(%rsp), %rsi
movl 0x44(%rsp), %edx
leaq 0x90f0(%rip), %rdi      # 0x1b16a
movb $0x0, %al
callq 0x7270
cmpl $0x0, 0x44(%rsp)
je 0x120b0
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x44(%rsp), %edi
callq 0x7d30
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x7a70
movl %eax, 0x54(%rsp)
jmp 0x120ba
jmp 0x120b2
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
callq 0x12660
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movl $0x2, %esi
leaq 0x20(%rsp), %rdx
callq 0x7d80
movq 0x48(%rsp), %rdi
movl $0x3, %esi
leaq 0x10(%rsp), %rdx
callq 0x7730
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x78b0
movl %eax, 0x44(%rsp)
cmpl $0x0, 0x44(%rsp)
je 0x1215d
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movl 0x44(%rsp), %edi
callq 0x7d30
movq (%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x7a70
movl %eax, 0x54(%rsp)
jmp 0x12167
jmp 0x1215f
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x12660
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x7a50
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0x7710
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movzbl 0x17(%rsp), %edx
callq 0x7cc0
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x12203
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x10(%rsp), %edi
callq 0x7d30
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x7a70
movl %eax, 0x34(%rsp)
jmp 0x1220d
jmp 0x12205
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x12660
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x7a50
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0x7710
movb %al, 0x17(%rsp)
movq 0x28(%rsp), %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0x7710
movb %al, 0x16(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movb 0x17(%rsp), %al
movzbl %al, %edx
movzbl 0x16(%rsp), %ecx
callq 0x7530
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x122d2
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x10(%rsp), %edi
callq 0x7d30
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x7a70
movl %eax, 0x34(%rsp)
jmp 0x122dc
jmp 0x122d4
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x12660
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpl $0x62697473, 0x10(%rax) # imm = 0x62697473
je 0x123da
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x8db5(%rip), %rdx      # 0x1b184
callq 0x7260
movl %eax, 0x24(%rsp)
jmp 0x1240a
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x30, %rsi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
callq 0x78c0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x12660
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
cmpl $0x62697473, 0x10(%rax) # imm = 0x62697473
je 0x1246a
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x8d25(%rip), %rdx      # 0x1b184
callq 0x7260
movl %eax, 0x44(%rsp)
jmp 0x124c0
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rcx
addq $0x30, %rcx
movq 0x30(%rsp), %rax
movl 0x28(%rax), %esi
movq 0x30(%rsp), %rax
movl 0x2c(%rax), %edx
movq 0x20(%rcx), %r8
movq %rsp, %rax
movq %r8, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %ecx
callq 0x7cf0
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x12660
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpl $0x6f75746c, 0x10(%rax) # imm = 0x6F75746C
je 0x1251a
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x8c92(%rip), %rdx      # 0x1b1a1
callq 0x7260
movl %eax, 0x24(%rsp)
jmp 0x1254a
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x28, %rsi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
callq 0x7160
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x12660
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
cmpl $0x6f75746c, 0x10(%rax) # imm = 0x6F75746C
je 0x125aa
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x8c02(%rip), %rdx      # 0x1b1a1
callq 0x7260
movl %eax, 0x44(%rsp)
jmp 0x125eb
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rcx
addq $0x28, %rcx
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x7360
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/glyph.c
// Function: checkglyph
static FT_Glyph* checkglyph(lua_State *L, int arg)
    {
    FT_Glyph *p = testglyph(L, arg);
    if(p) return p;
    luaL_argerror(L, arg, "not a glyph");
    return NULL;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x12600
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x12694
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x126b2
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
leaq 0x8a7e(%rip), %rdx      # 0x1b122
callq 0x7260
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/library.c
// Function: moonfreetype_checklibrary
FT_Library* checklibrary(lua_State *L, int arg)
    {
    FT_Library *p = testlibrary(L, arg);
    if(p) return p;
    luaL_argerror(L, arg, "not a library");
    return NULL;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x72a0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x12754
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x12772
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
leaq 0x8ac0(%rip), %rdx      # 0x1b224
callq 0x7260
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/library.c
// Function: Delete
static int Delete(lua_State *L)
    {
    FT_Error ec;
    FT_Library *library = testlibrary(L, 1);
    if(!library) return 0; /* already deleted */
    /* delete all contained objects */
    udata_scan(L, BITMAP_MT, *library, Freebitmap);
    udata_scan(L, OUTLINE_MT, *library, Freeoutline);
    udata_scan(L, STROKER_MT, *library, Freestroker);
    udata_scan(L, GLYPH_MT, *library, Freeglyph);
    udata_scan(L, FACE_MT, *library, Freeface);

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x72a0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x127f2
movl $0x0, 0x24(%rsp)
jmp 0x1291a
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
leaq 0x6868(%rip), %rsi      # 0x1906e
leaq 0x1e3(%rip), %rcx       # 0x129f0
callq 0x7ab0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
leaq 0x8a2e(%rip), %rsi      # 0x1b254
leaq 0x213(%rip), %rcx       # 0x12a40
callq 0x7ab0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
leaq 0x8a23(%rip), %rsi      # 0x1b269
leaq 0x243(%rip), %rcx       # 0x12a90
callq 0x7ab0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
leaq 0x885d(%rip), %rsi      # 0x1b0c3
leaq 0x273(%rip), %rcx       # 0x12ae0
callq 0x7ab0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
leaq 0x677a(%rip), %rsi      # 0x19000
leaq 0x2a3(%rip), %rcx       # 0x12b30
callq 0x7ab0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x7380
cmpl $0x0, %eax
jne 0x128b0
movl $0x0, 0x24(%rsp)
jmp 0x1291a
movq 0x8(%rsp), %rsi
leaq 0x89c2(%rip), %rdi      # 0x1b27e
movb $0x0, %al
callq 0x7270
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x73c0
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x79f0
cmpl $0x0, 0x14(%rsp)
je 0x12910
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl 0x14(%rsp), %edi
callq 0x7d30
movq (%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x7a70
movl %eax, 0x24(%rsp)
jmp 0x1291a
jmp 0x12912
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/library.c
// Function: LibraryVersion
static int LibraryVersion(lua_State *L) 
    {
    int major, minor, patch;
    FT_Library* library = checklibrary(L, 1);
    FT_Library_Version(*library, &major, &minor, &patch);
    lua_pushinteger(L, major);
    lua_pushinteger(L, minor);
    lua_pushinteger(L, patch);
    return 3;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x76d0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0x1c(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x14(%rsp), %rcx
callq 0x76e0
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x7540
movq 0x20(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0x7540
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x7540
movl $0x3, %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/library.c
// Function: Get_truetype_engine_type
static int Get_truetype_engine_type(lua_State *L) //@@DOC (o cassare?)
    {
    FT_Library* library = checklibrary(L, 1);
    FT_TrueTypeEngineType type = FT_Get_TrueType_Engine_Type(*library);
    pushtruetypeenginetype(L, type);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x76d0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x7bd0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %edx
movl $0x6, %esi
callq 0x7280
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/library.c
// Function: Freebitmap
static int Freebitmap(lua_State *L, const void *bitmap, const void *library)
    {
    ud_t *ud = userdata(bitmap);
    if(ud->library == (FT_Library)library)
        freebitmap(L, (FT_Bitmap*)bitmap);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7230
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x10(%rsp), %rax
jne 0x12a31
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x77e0
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/library.c
// Function: Freeoutline
static int Freeoutline(lua_State *L, const void *outline, const void *library)
    {
    ud_t *ud = userdata(outline);
    if(ud->library == (FT_Library)library)
        freeoutline(L, (FT_Outline*)outline);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7230
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x10(%rsp), %rax
jne 0x12a81
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x70f0
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/library.c
// Function: Freestroker
static int Freestroker(lua_State *L, const void *stroker, const void *library)
    {
    ud_t *ud = userdata(stroker);
    if(ud->library == (FT_Library)library)
        freestroker(L, (FT_Stroker*)stroker);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7230
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x10(%rsp), %rax
jne 0x12ad1
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x7b30
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/library.c
// Function: Freeglyph
static int Freeglyph(lua_State *L, const void *glyph, const void *library)
    {
    ud_t *ud = userdata(glyph);
    if(ud->library == (FT_Library)library)
        freeglyph(L, (FT_Glyph*)glyph);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7230
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x10(%rsp), %rax
jne 0x12b21
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x70e0
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/library.c
// Function: Freeface
static int Freeface(lua_State *L, const void *face, const void *library)
    {
    ud_t *ud = userdata(face);
    if(ud->library == (FT_Library)library)
        freeface(L, (FT_Face*)face);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7230
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x10(%rsp), %rax
jne 0x12b71
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x71d0
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/library.c
// Function: InitFreeType
static int InitFreeType(lua_State *L)
    {
    FT_Error ec;
    FT_Library *library = (FT_Library*)Malloc(L, sizeof(FT_Library));

    ec = FT_Init_FreeType(library);

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x8, %esi
callq 0x7c20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x74d0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x12bfa
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x79f0
cmpl $0x0, 0x14(%rsp)
je 0x12bee
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl 0x14(%rsp), %edi
callq 0x7d30
movq (%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x7a70
movl %eax, 0x24(%rsp)
jmp 0x12c2b
jmp 0x12bf0
movl $0x0, 0x24(%rsp)
jmp 0x12c2b
movq 0x8(%rsp), %rsi
leaq 0x86b9(%rip), %rdi      # 0x1b2bf
movb $0x0, %al
callq 0x7270
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x64a3(%rip), %rdx      # 0x190c1
callq 0x72b0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/main.c
// Function: luaopen_moonfreetype
int luaopen_moonfreetype(lua_State *L)
/* Lua calls this function to load the module */
    {
    moonfreetype_L = L;
    
    moonfreetype_utils_init(L);
    lua_newtable(L); /* the freetype table */
    moonfreetype_open_enums(L);
    moonfreetype_open_flags(L);
    AddVersions(L);
    AddConstants(L);
    
    atexit(AtExit);

    /* add functions: */
    luaL_setfuncs(L, Functions, 0);
    moonfreetype_open_computations(L);
    moonfreetype_open_library(L);
    moonfreetype_open_face(L);
    moonfreetype_open_glyph(L);
    moonfreetype_open_size(L);
    moonfreetype_open_advance(L);
    moonfreetype_open_pfr(L);
    moonfreetype_open_variants(L);
    moonfreetype_open_bitmap(L);
    moonfreetype_open_outline(L);
    moonfreetype_open_stroker(L);

    return 1;
    }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rcx
movq 0xe380(%rip), %rax      # 0x20fd0
movq %rcx, (%rax)
movq (%rsp), %rdi
callq 0x7d00
movq (%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x73d0
movq (%rsp), %rdi
callq 0x7740
movq (%rsp), %rdi
callq 0x7390
movq (%rsp), %rdi
callq 0x12d20
movq (%rsp), %rdi
callq 0x12da0
leaq 0x79c(%rip), %rdi       # 0x13430
callq 0x18300
movq (%rsp), %rdi
leaq 0x863c(%rip), %rsi      # 0x1b2e0
xorl %edx, %edx
callq 0x7250
movq (%rsp), %rdi
callq 0x72c0
movq (%rsp), %rdi
callq 0x7c00
movq (%rsp), %rdi
callq 0x7be0
movq (%rsp), %rdi
callq 0x7b80
movq (%rsp), %rdi
callq 0x7320
movq (%rsp), %rdi
callq 0x74a0
movq (%rsp), %rdi
callq 0x7a30
movq (%rsp), %rdi
callq 0x7b60
movq (%rsp), %rdi
callq 0x7120
movq (%rsp), %rdi
callq 0x72d0
movq (%rsp), %rdi
callq 0x7090
movl $0x1, %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/main.c
// Function: AddVersions
static void AddVersions(lua_State *L)
    {
    lua_pushstring(L, "_VERSION");
    lua_pushstring(L, "MoonFreeType " MOONFREETYPE_VERSION);
    lua_settable(L, -3);

    lua_pushstring(L, "_FREETYPE_VERSION");
    lua_pushfstring(L, "FreeType %d.%d.%d", FREETYPE_MAJOR, FREETYPE_MINOR, FREETYPE_PATCH);
    lua_settable(L, -3);
    }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
leaq 0x85da(%rip), %rsi      # 0x1b30a
callq 0x7cb0
movq (%rsp), %rdi
leaq 0x85b0(%rip), %rsi      # 0x1b2f0
callq 0x7cb0
movq (%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x7800
movq (%rsp), %rdi
leaq 0x85a3(%rip), %rsi      # 0x1b301
callq 0x7cb0
movq (%rsp), %rdi
leaq 0x85a5(%rip), %rsi      # 0x1b313
movl $0x2, %edx
movl $0xb, %ecx
movl $0x1, %r8d
movb $0x0, %al
callq 0x7690
movq (%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x7800
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/outline.c
// Function: moonfreetype_checkoutline
FT_Outline* checkoutline(lua_State *L, int arg)
    {
    FT_Outline *p = testoutline(L, arg);
    if(p) return p;
    luaL_argerror(L, arg, "not a outline");
    return NULL;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x134b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x13484
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x134a2
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
leaq 0x7e91(%rip), %rdx      # 0x1b325
callq 0x7260
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)