LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/library.c
// Function: Delete
static int Delete(lua_State *L)
    {
    FT_Error ec;
    FT_Library *library = testlibrary(L, 1);
    if(!library) return 0; /* already deleted */
    /* delete all contained objects */
    udata_scan(L, BITMAP_MT, *library, Freebitmap);
    udata_scan(L, OUTLINE_MT, *library, Freeoutline);
    udata_scan(L, STROKER_MT, *library, Freestroker);
    udata_scan(L, GLYPH_MT, *library, Freeglyph);
    udata_scan(L, FACE_MT, *library, Freeface);

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x72a0
testq %rax, %rax
je 0xd935
movq %rax, %r14
movq (%rax), %rdx
leaq 0x37fd(%rip), %rsi      # 0x1106e
leaq 0x159(%rip), %rcx       # 0xd9d1
movq %rbx, %rdi
callq 0x7ab0
movq (%r14), %rdx
leaq 0x59d0(%rip), %rsi      # 0x1325a
leaq 0x16f(%rip), %rcx       # 0xda00
movq %rbx, %rdi
callq 0x7ab0
movq (%r14), %rdx
leaq 0x59cc(%rip), %rsi      # 0x1326f
leaq 0x185(%rip), %rcx       # 0xda2f
movq %rbx, %rdi
callq 0x7ab0
movq (%r14), %rdx
leaq 0x580d(%rip), %rsi      # 0x130c9
leaq 0x19b(%rip), %rcx       # 0xda5e
movq %rbx, %rdi
callq 0x7ab0
movq (%r14), %rdx
leaq 0x372b(%rip), %rsi      # 0x11000
leaq 0x1b1(%rip), %rcx       # 0xda8d
movq %rbx, %rdi
callq 0x7ab0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7380
testl %eax, %eax
je 0xd935
leaq 0x598a(%rip), %rdi      # 0x13284
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
movq (%r14), %rdi
callq 0x73c0
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79f0
testl %ebp, %ebp
je 0xd935
movl %ebp, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7a70
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x76d0
movq (%rax), %rdi
leaq 0x14(%rsp), %r14
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x76f0
movslq (%r14), %rsi
movq %rbx, %rdi
callq 0x7540
movslq (%r15), %rsi
movq %rbx, %rdi
callq 0x7540
movslq (%r12), %rsi
movq %rbx, %rdi
callq 0x7540
pushq $0x3
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x76d0
movq (%rax), %rdi
callq 0x7bd0
pushq $0x6
popq %rsi
movq %rbx, %rdi
movl %eax, %edx
callq 0x7280
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/library.c
// Function: Freebitmap
static int Freebitmap(lua_State *L, const void *bitmap, const void *library)
    {
    ud_t *ud = userdata(bitmap);
    if(ud->library == (FT_Library)library)
        freebitmap(L, (FT_Bitmap*)bitmap);
    return 0;
    }

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

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

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

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

    ec = FT_Init_FreeType(library);

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x8
popq %rsi
callq 0x7c20
movq %rax, %r14
movq %rax, %rdi
callq 0x74d0
testl %eax, %eax
je 0xdaff
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79f0
movl %ebp, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7a70
leaq 0x57bf(%rip), %rdi      # 0x132c5
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x35aa(%rip), %rdx      # 0x110c1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72b0
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/outline.c
// Function: moonfreetype_pushoutline
int pushoutline(lua_State *L, FT_Outline *outline, FT_Library library)
    {
    ud_t *ud = userdata(outline);
    if(ud)
        return udata_push(L, outline);
    /* create userdata for outline  owned by FreeType */
    DBG("created outline %p (on push)\n", (void*)outline);
    newuserdata(L, (void*)outline, OUTLINE_MT);
    ud = userdata(outline);
    ud->library = library;
    ud->allocated = 0;
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x7230
testq %rax, %rax
je 0xe22f
movq %r15, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7180
leaq 0x50fd(%rip), %rdi      # 0x13333
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x5013(%rip), %rdx      # 0x1325a
movq %r15, %rdi
movq %r14, %rsi
callq 0x72b0
movq %r14, %rdi
callq 0x7230
movq %rbx, 0x8(%rax)
andl $0x0, 0x18(%rax)
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/outline.c
// Function: moonfreetype_freeoutline
int freeoutline(lua_State *L, FT_Outline *outline)
    {
    ud_t *ud = userdata(outline);
    FT_Library library = ud->library;
    int allocated = ud->allocated;
    if(!freeuserdata(L, outline))
        return 0; /* double call */
    DBG("deleting outline %p\n", (void*)outline);
    if(!allocated)
        return 0;
    FT_Outline_Done(library, outline);
    Free(L, outline);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x7230
movq 0x8(%rax), %r15
movl 0x18(%rax), %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7380
testl %eax, %eax
je 0xe52b
leaq 0x4e68(%rip), %rdi      # 0x1336f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x7270
testl %ebp, %ebp
je 0xe52b
movq %r15, %rdi
movq %rbx, %rsi
callq 0x78e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/outline.c
// Function: Outline_new
static int Outline_new(lua_State *L)
/* outline = outline_new(library, num_points, num_contours) 
 */
    {
    FT_Error ec;
    ud_t *ud;
    FT_Library *library = checklibrary(L, 1);
    FT_UInt num_points = luaL_checkinteger(L, 2);
    FT_Int num_contours = luaL_checkinteger(L, 3);
    FT_Outline *outline = (FT_Outline*)Malloc(L, sizeof(FT_Outline));

    ec = FT_Outline_New(*library, num_points, num_contours, outline);
    if(ec)
        {
        Free(L, outline);
        CheckError(L, ec); /* raises an error */
        return 0;
        }

    DBG("created outline %p\n", (void*)outline);
    newuserdata(L, (void*)outline, OUTLINE_MT);
    ud = userdata(outline);
    ud->library = *library;
    ud->allocated = 1;
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x76d0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq %rax, %r13
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x7c20
movq %rax, %r15
movq (%r14), %rdi
movl %r12d, %esi
movl %r13d, %edx
movq %rax, %rcx
callq 0x7430
testl %eax, %eax
je 0xe605
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x79f0
movl %ebp, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7a70
leaq 0x4dab(%rip), %rdi      # 0x133b7
movq %r15, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x4c3d(%rip), %rdx      # 0x1325a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x72b0
movq %r15, %rdi
callq 0x7230
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
movl $0x1, 0x18(%rax)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/outline.c
// Function: Outline_copy
static int Outline_copy(lua_State *L)
    {
    FT_Error ec;
    ud_t *src_ud, *dst_ud;
    FT_Outline *src_outline = checkoutline(L, 1);
    FT_Outline *dst_outline = checkoutline(L, 2);
    src_ud = userdata(src_outline);
    dst_ud = userdata(dst_outline);
    //DBG("libraries: src %p dst %p\n", (void*)(src_ud->library), (void*)(dst_ud->library));
    if(src_ud->library != dst_ud->library)
        return luaL_error(L, "outlines do not belong to the same library");
    ec = FT_Outline_Copy(src_outline, dst_outline);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7590
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7590
movq %rax, %r15
movq %r14, %rdi
callq 0x7230
movq %rax, %r12
movq %r15, %rdi
callq 0x7230
movq 0x8(%r12), %rcx
cmpq 0x8(%rax), %rcx
je 0xe6be
leaq 0x4d12(%rip), %rsi      # 0x133cb
movq %rbx, %rdi
jmp 0xe6da
movq %r14, %rdi
movq %r15, %rsi
callq 0x75e0
testl %eax, %eax
je 0xe6ec
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7a70
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/outline.c
// Function: Outline_check
static int Outline_check(lua_State *L) 
    {
    FT_Outline *outline = checkoutline(L, 1);
    FT_Error ec = FT_Outline_Check(outline);
    if(ec)
        { 
        lua_pushboolean(L, 0);
        lua_pushstring(L, fterrorstring(ec));
        return 2;
        }
    lua_pushboolean(L, 1);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x7590
movq %rax, %rdi
callq 0x76a0
testl %eax, %eax
je 0xe73c
movl %eax, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7820
movl %r14d, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7cb0
pushq $0x2
popq %rbp
jmp 0xe746
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7820
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/outline.c
// Function: Outline_translate
static int Outline_translate(lua_State *L) 
    {
    FT_Outline *outline = checkoutline(L, 1);
    FT_Pos xofs = luaL_checkinteger(L, 2);
    FT_Pos yofs = luaL_checkinteger(L, 3);
    FT_Outline_Translate(outline, xofs, yofs);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7590
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7310
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/outline.c
// Function: Outline_transform
static int Outline_transform(lua_State *L) 
    {
    FT_Matrix matrix;
    FT_Outline *outline = checkoutline(L, 1);
    checkmatrix(L, 2, &matrix);
    FT_Outline_Transform(outline, &matrix);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7590
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7d80
movq %r14, %rdi
movq %r15, %rsi
callq 0x7070
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/outline.c
// Function: Outline_embolden
static int Outline_embolden(lua_State *L)
    {
    FT_Error ec;
    FT_Outline *outline = checkoutline(L, 1);
    FT_Pos strength = luaL_checkinteger(L, 2);
    ec = FT_Outline_Embolden(outline, strength);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7590
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq %r14, %rdi
movq %rax, %rsi
callq 0x7940
testl %eax, %eax
je 0xe815
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7a70
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/outline.c
// Function: Outline_emboldenxy
static int Outline_emboldenxy(lua_State *L)
    {
    FT_Outline *outline = checkoutline(L, 1);
    FT_Pos xstrength = luaL_checkinteger(L, 2);
    FT_Pos ystrength = luaL_checkinteger(L, 3);
    FT_Error ec = FT_Outline_EmboldenXY(outline, xstrength, ystrength);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7590
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7880
testl %eax, %eax
je 0xe876
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x7a70
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/outline.c
// Function: Outline_get_cbox
static int Outline_get_cbox(lua_State *L)
    {
    FT_BBox box;
    FT_Outline *outline = checkoutline(L, 1);
    FT_Outline_Get_CBox(outline, &box);
    pushbbox(L, box);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x7590
leaq 0x20(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x7d90
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x76c0
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/outline.c
// Function: Outline_get_bbox
static int Outline_get_bbox(lua_State *L)
    {
    FT_Error ec;
    FT_BBox box;
    FT_Outline *outline = checkoutline(L, 1);
    ec = FT_Outline_Get_BBox(outline, &box);
    CheckError(L, ec);
    pushbbox(L, box);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x7590
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x7650
testl %eax, %eax
je 0xe919
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a70
movl %eax, %ebp
jmp 0xe934
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x76c0
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/outline.c
// Function: Outline_get_bitmap
static int Outline_get_bitmap(lua_State *L)
    {
    FT_Error ec;
    FT_Outline *outline = checkoutline(L, 1);
    FT_Bitmap *bitmap = checkbitmap(L, 2);
    ud_t *ud_o = userdata(outline);
    ud_t *ud_b = userdata(bitmap);
    if(ud_o->library != ud_b->library)
        return luaL_error(L, "outline and bitmap do not belong to the same library");
    ec = FT_Outline_Get_Bitmap(ud_o->library, outline, bitmap);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7590
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7110
movq %rax, %r15
movq %r14, %rdi
callq 0x7230
movq %rax, %r12
movq %r15, %rdi
callq 0x7230
movq 0x8(%r12), %rdi
cmpq 0x8(%rax), %rdi
je 0xe98b
leaq 0x4a70(%rip), %rsi      # 0x133f6
movq %rbx, %rdi
jmp 0xe9a7
movq %r14, %rsi
movq %r15, %rdx
callq 0x7960
testl %eax, %eax
je 0xe9b9
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7a70
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/outline.c
// Function: Outline_get_orientation
static int Outline_get_orientation(lua_State *L)
    {
    FT_Outline *outline = checkoutline(L, 1);
    FT_Orientation orientation = FT_Outline_Get_Orientation(outline);
    pushorientation(L, orientation);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x7590
movq %rax, %rdi
callq 0x79b0
movq %rbx, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x7280
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/outline.c
// Function: Outline_getinsideborder
static int Outline_getinsideborder(lua_State *L)
    {
    FT_Outline *outline = checkoutline(L, 1);
    FT_StrokerBorder border = FT_Outline_GetInsideBorder(outline);
    pushstrokerborder(L, border);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x7590
movq %rax, %rdi
callq 0x7550
pushq $0x2
popq %rsi
movq %rbx, %rdi
movl %eax, %edx
callq 0x7280
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/pfr.c
// Function: Get_pfr_advance
static int Get_pfr_advance(lua_State *L) 
    {
    FT_Error ec;
    FT_Pos advance;
    FT_Face *face = checkface(L, 1);
    FT_UInt glyph_index = checkindex(L, 2);
    ec = FT_Get_PFR_Advance(*face, glyph_index, &advance);
    CheckError(L, ec);
    lua_pushinteger(L, advance);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x7ac0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7340
movq (%r14), %rdi
leaq 0x8(%rsp), %rdx
movl %eax, %esi
callq 0x7190
testl %eax, %eax
je 0xeb4b
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a70
movl %eax, %ebp
jmp 0xeb58
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/pfr.c
// Function: Get_pfr_metrics
static int Get_pfr_metrics(lua_State *L) 
    {
    FT_Error ec;
    FT_UInt outline_res, metrics_res;
    FT_Fixed x_scale, y_scale;
    FT_Face *face = checkface(L, 1);
    ec = FT_Get_PFR_Metrics(*face, &outline_res, &metrics_res, &x_scale, &y_scale);
    CheckError(L, ec);
    lua_pushinteger(L, outline_res);
    lua_pushinteger(L, metrics_res);
    lua_pushinteger(L, x_scale);
    lua_pushinteger(L, y_scale);
    return 4;
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7ac0
movq (%rax), %rdi
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x18(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x7700
testl %eax, %eax
je 0xeba9
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a70
jmp 0xebde
movl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0x7540
movl 0x8(%rsp), %esi
movq %rbx, %rdi
callq 0x7540
movq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
pushq $0x4
popq %rax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/pfr.c
// Function: Get_pfr_kerning
static int Get_pfr_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 */
    ec = FT_Get_PFR_Kerning(*face, left_glyph, right_glyph, &vec);
    CheckError(L, ec);
    return pushvector(L, vec);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7ac0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7340
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7340
movq (%r14), %rdi
movq %rsp, %rcx
movl %ebp, %esi
movl %eax, %edx
callq 0x7ca0
testl %eax, %eax
je 0xec3b
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a70
jmp 0xec4c
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x7bb0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/size.c
// Function: moonfreetype_freesize
int freesize(lua_State *L, FT_Size *size)
    {
    FT_Error ec;
    if(!freeuserdata(L, size))
        return 0; /* double call */
    DBG("deleting size %p\n", (void*)size);
    ec = FT_Done_Size(*size);
    Free(L, size);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x7380
testl %eax, %eax
je 0xecad
leaq 0x491f(%rip), %rdi      # 0x13591
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
movq (%r14), %rdi
callq 0x7200
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79f0
testl %ebp, %ebp
je 0xecad
movl %ebp, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7a70
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/size.c
// Function: New_size
static int New_size(lua_State *L)
    {
    FT_Error ec;
    ud_t *ud;
    FT_Face *face = checkface(L, 1);
    FT_Size *size = (FT_Size*)Malloc(L, sizeof(FT_Size));

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7ac0
movq %rax, %r14
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x7c20
movq %rax, %r15
movq (%r14), %rdi
movq %rax, %rsi
callq 0x71f0
testl %eax, %eax
je 0xed57
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x79f0
movl %ebp, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7a70
leaq 0x484e(%rip), %rdi      # 0x135ac
movq %r15, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x3a03(%rip), %rdx      # 0x12772
movq %rbx, %rdi
movq %r15, %rsi
callq 0x72b0
movq %r15, %rdi
callq 0x7230
movq (%r14), %rcx
movq %rcx, 0x10(%rax)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/size.c
// Function: Activate_size
static int Activate_size(lua_State *L)
    {
    FT_Size *size = checksize(L, 1);
    FT_Error ec = FT_Activate_Size(*size);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xee0c
movq %rax, %r14
testq %rax, %rax
jne 0xeddb
leaq 0x47f6(%rip), %rdx      # 0x135c6
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x7260
movq (%r14), %rdi
callq 0x7440
testl %eax, %eax
je 0xee02
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7a70
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/stroker.c
// Function: moonfreetype_freestroker
int freestroker(lua_State *L, FT_Stroker *stroker)
    {
    if(!freeuserdata(L, stroker))
        return 0; /* double call */
    DBG("deleting stroker %p\n", (void*)stroker);
    FT_Stroker_Done(*stroker);
    Free(L, stroker);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x7380
testl %eax, %eax
je 0xeeaf
leaq 0x4765(%rip), %rdi      # 0x135f7
movq %rbx, %rsi
xorl %eax, %eax
callq 0x7270
movq (%rbx), %rdi
callq 0x7240
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/stroker.c
// Function: Stroker_new
static int Stroker_new(lua_State *L)
/* stroker = stroker_new(face) 
 */
    {
    FT_Error ec;
    ud_t *ud;
    FT_Library *library = checklibrary(L, 1);
    FT_Stroker *stroker = (FT_Stroker*)Malloc(L, sizeof(FT_Stroker));

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x76d0
movq %rax, %r14
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x7c20
movq %rax, %r15
movq (%r14), %rdi
movq %rax, %rsi
callq 0x7800
testl %eax, %eax
je 0xef5c
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x79f0
movl %ebp, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7a70
leaq 0x46b5(%rip), %rdi      # 0x13618
movq %r15, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x42fb(%rip), %rdx      # 0x1326f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x72b0
movq %r15, %rdi
callq 0x7230
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/stroker.c
// Function: Stroker_beginsubpath
static int Stroker_beginsubpath(lua_State *L)
    {
    FT_Error ec;
    FT_Vector to;
    FT_Bool open;
    FT_Stroker *stroker = checkstroker(L, 1);
    checkvector(L, 2, &to);
    open = checkboolean(L, 3);
    ec = FT_Stroker_BeginSubPath(*stroker, &to, open);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7a50
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7740
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7a40
movq (%r14), %rdi
movzbl %al, %edx
movq %r15, %rsi
callq 0x7060
testl %eax, %eax
je 0xf017
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a70
jmp 0xf019
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/stroker.c
// Function: Stroker_set
static int Stroker_set(lua_State *L) 
    {
    FT_Stroker *stroker = checkstroker(L, 1);
    FT_Fixed radius = luaL_checkinteger(L, 2);
    FT_Stroker_LineCap line_cap = checkstrokerlinecap(L, 3);
    FT_Stroker_LineJoin line_join = checkstrokerlinejoin(L, 4);
    FT_Fixed miter_limit = luaL_checkinteger(L, 5);
    FT_Stroker_Set(*stroker, radius, line_cap, line_join, miter_limit); 
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7a50
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq %rax, %r15
pushq $0x4
popq %rbp
pushq $0x3
popq %r12
movq %rbx, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x7b20
movl %eax, %r13d
movq %rbx, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x7b20
movl %eax, %ebp
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq (%r14), %rdi
movq %r15, %rsi
movl %r13d, %edx
movl %ebp, %ecx
movq %rax, %r8
callq 0x75f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/stroker.c
// Function: Stroker_conicto
static int Stroker_conicto(lua_State *L) 
    {
    FT_Error ec;
    FT_Vector control, to;
    FT_Stroker *stroker = checkstroker(L, 1);
    checkvector(L, 2, &control);
    checkvector(L, 3, &to);
    ec = FT_Stroker_ConicTo(*stroker, &control, &to);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7a50
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x18(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7740
pushq $0x3
popq %rsi
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x7740
movq (%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7400
testl %eax, %eax
je 0xf14c
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a70
jmp 0xf14e
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/stroker.c
// Function: Stroker_cubicto
static int Stroker_cubicto(lua_State *L) 
    {
    FT_Error ec;
    FT_Vector control1, control2, to;
    FT_Stroker *stroker = checkstroker(L, 1);
    checkvector(L, 2, &control1);
    checkvector(L, 3, &control2);
    checkvector(L, 4, &to);
    ec = FT_Stroker_CubicTo(*stroker, &control1, &control2, &to);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7a50
movq %rax, %r14
pushq $0x2
popq %rsi
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7740
pushq $0x3
popq %rsi
leaq 0x10(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x7740
pushq $0x4
popq %rsi
movq %rsp, %r13
movq %rbx, %rdi
movq %r13, %rdx
callq 0x7740
movq (%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x7d60
testl %eax, %eax
je 0xf1d7
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a70
jmp 0xf1d9
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/stroker.c
// Function: Stroker_lineto
static int Stroker_lineto(lua_State *L)
    {
    FT_Error ec;
    FT_Vector to;
    FT_Stroker *stroker = checkstroker(L, 1);
    checkvector(L, 2, &to);
    ec = FT_Stroker_LineTo(*stroker, &to);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7a50
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7740
movq (%r14), %rdi
movq %r15, %rsi
callq 0x7bc0
testl %eax, %eax
je 0xf234
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a70
jmp 0xf236
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/stroker.c
// Function: Stroker_getcounts
static int Stroker_getcounts(lua_State *L)
    {
    FT_Error ec;
    FT_UInt num_points, num_contours;
    FT_Stroker *stroker = checkstroker(L, 1);
    ec = FT_Stroker_GetCounts(*stroker, &num_points, &num_contours);
    CheckError(L, ec);
    lua_pushinteger(L, num_points);
    lua_pushinteger(L, num_contours);
    return 2;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7a50
movq (%rax), %rdi
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x7480
testl %eax, %eax
je 0xf27c
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a70
jmp 0xf297
movl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0x7540
movl 0x8(%rsp), %esi
movq %rbx, %rdi
callq 0x7540
pushq $0x2
popq %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/stroker.c
// Function: Stroker_parseoutline
static int Stroker_parseoutline(lua_State *L)
    {
    ud_t *ud1, *ud2;
    FT_Error ec;
    FT_Stroker *stroker = checkstroker(L, 1);
    FT_Outline *outline = checkoutline(L, 2);
    FT_Bool opened = checkboolean(L, 3);
    ud1 = userdata(stroker);
    ud2 = userdata(outline);
    if(ud1->library != ud2->library)
        return luaL_error(L, "stroker and outline do not belong to the same library");
    ec = FT_Stroker_ParseOutline(*stroker, outline, opened);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7a50
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7590
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7a40
movl %eax, %ebp
movq %r14, %rdi
callq 0x7230
movq %rax, %r12
movq %r15, %rdi
callq 0x7230
movq 0x8(%r12), %rcx
cmpq 0x8(%rax), %rcx
je 0xf2f8
leaq 0x4339(%rip), %rsi      # 0x1362c
movq %rbx, %rdi
jmp 0xf318
movq (%r14), %rdi
movzbl %bpl, %edx
movq %r15, %rsi
callq 0x79d0
testl %eax, %eax
je 0xf327
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7a70
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/stroker.c
// Function: Stroker_export
static int Stroker_export(lua_State *L) 
    {
    ud_t *ud1, *ud2;
    FT_Stroker *stroker = checkstroker(L, 1);
    FT_Outline *outline = checkoutline(L, 2);
    ud1 = userdata(stroker);
    ud2 = userdata(outline);
    if(ud1->library != ud2->library)
        return luaL_error(L, "stroker and outline do not belong to the same library");
    FT_Stroker_Export(*stroker, outline);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7a50
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7590
movq %rax, %r15
movq %r14, %rdi
callq 0x7230
movq %rax, %r12
movq %r15, %rdi
callq 0x7230
movq 0x8(%r12), %rcx
cmpq 0x8(%rax), %rcx
je 0xf390
leaq 0x42b1(%rip), %rsi      # 0x1362c
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7a70
movq (%r14), %rdi
movq %r15, %rsi
callq 0x70c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/stroker.c
// Function: Stroker_exportborder
static int Stroker_exportborder(lua_State *L)
    {
    ud_t *ud1, *ud2;
    FT_Stroker *stroker = checkstroker(L, 1);
    FT_StrokerBorder border = checkstrokerborder(L, 2);
    FT_Outline *outline = checkoutline(L, 3);
    ud1 = userdata(stroker);
    ud2 = userdata(outline);
    if(ud1->library != ud2->library)
        return luaL_error(L, "stroker and outline do not belong to the same library");
    FT_Stroker_ExportBorder(*stroker, border, outline);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7a50
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl %edx, %esi
callq 0x7b20
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7590
movq %rax, %r15
movq %r14, %rdi
callq 0x7230
movq %rax, %r12
movq %r15, %rdi
callq 0x7230
movq 0x8(%r12), %rcx
cmpq 0x8(%rax), %rcx
je 0xf413
leaq 0x422b(%rip), %rsi      # 0x1362c
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7a70
movq (%r14), %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x74e0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/stroker.c
// Function: Stroker_getbordercounts
static int Stroker_getbordercounts(lua_State *L)
    {
    FT_Error ec;
    FT_UInt num_points, num_contours;
    FT_Stroker *stroker = checkstroker(L, 1);
    FT_StrokerBorder border = checkstrokerborder(L, 2);
    ec = FT_Stroker_GetBorderCounts(*stroker, border, &num_points, &num_contours);
    CheckError(L, ec);
    lua_pushinteger(L, num_points);
    lua_pushinteger(L, num_contours);
    return 2;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7a50
movq %rax, %r14
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
movl %ebp, %edx
callq 0x7b20
movq (%r14), %rdi
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movl %eax, %esi
callq 0x7c70
testl %eax, %eax
je 0xf480
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a70
movl %eax, %ebp
jmp 0xf498
movl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0x7540
movl 0x8(%rsp), %esi
movq %rbx, %rdi
callq 0x7540
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/udata.c
// Function: moonfreetype_udata_scan
void udata_scan(lua_State *L, const char *mt,  
            void *info, int (*func)(lua_State *L, const void *ptr, const void *info))
/* scans the udata database, and calls the func callback for every 'mt' object found
 * (the object may be deleted in the callback) */
    {
    uintptr_t id = 0;
    udata_t *udata;
    while((udata = udata_first(id)))
        {
        id = udata->id + 1;
//printf("udata_scan %p\n", udata->id);
        if(mt == udata->mt)
            func(L, (const void*)(udata->id), info);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movq %r13, %rdi
callq 0xfd20
testq %rax, %rax
je 0xfd85
movq 0x20(%rax), %rsi
leaq 0x1(%rsi), %r13
cmpq %r15, 0x38(%rax)
jne 0xfd60
movq %r12, %rdi
movq %r14, %rdx
callq *%rbx
jmp 0xfd60
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/utils.c
// Function: moonfreetype_Malloc
void *Malloc(lua_State *L, size_t size)
    {
    void *ptr = Malloc_(size);
    if(ptr==NULL)
        { luaL_error(L, errstring(ERR_MEMORY)); return NULL; }
    memset(ptr, 0, size);
    //DBG("Malloc %p\n", ptr);
    return ptr;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x100a0
movq %rax, %rbx
testq %rax, %rax
je 0x10086
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x7520
leaq 0x1e35(%rip), %rsi      # 0x11ec2
movq %r14, %rdi
xorl %eax, %eax
callq 0x7a70
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/utils.c
// Function: moonfreetype_freeuserdata
int freeuserdata(lua_State *L, void *ptr)
    {
    ud_t *ud = userdata(ptr);
    if(!ud)
        return 0; /* already deleted */
    ud->obj = NULL;
    udata_free(L, ptr);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x7230
testq %rax, %rax
je 0x101c0
andq $0x0, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7760
pushq $0x1
popq %rax
jmp 0x101c2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/utils.c
// Function: moonfreetype_checkcharcode
FT_ULong checkcharcode(lua_State *L, int arg)
/* a charcode may be given as an integer code, or as a character (e.g. 'X') */
    {
    const char *c;
    size_t len;
    FT_ULong char_code;
    if(lua_type(L, arg) == LUA_TNUMBER)
        char_code = luaL_checkinteger(L, arg);
    else
        {
        c = luaL_checklstring(L, arg, &len);
        if(len != 1)
            return luaL_argerror(L, arg, "invalid length, must be 1");
        char_code = c[0];
        }
    return char_code;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x7c10
cmpl $0x3, %eax
jne 0x102d2
movq %r14, %rdi
movl %ebx, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7780
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x7630
cmpq $0x1, (%r15)
jne 0x102f0
movsbq (%rax), %rax
jmp 0x10303
leaq 0x3530(%rip), %rdx      # 0x13827
movq %r14, %rdi
movl %ebx, %esi
callq 0x7260
cltq
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/utils.c
// Function: moonfreetype_pushglyphmetrics
int pushglyphmetrics(lua_State *L, FT_Glyph_Metrics metrics)
    {
    lua_newtable(L);
    lua_pushinteger(L, metrics.width);
    lua_setfield(L, -2, "width");
    lua_pushinteger(L, metrics.height);
    lua_setfield(L, -2, "height");
    lua_pushinteger(L, metrics.horiBearingX);
    lua_setfield(L, -2, "hori_bearing_x");
    lua_pushinteger(L, metrics.horiBearingY);
    lua_setfield(L, -2, "hori_bearing_y");
    lua_pushinteger(L, metrics.horiAdvance);
    lua_setfield(L, -2, "hori_advance");
    lua_pushinteger(L, metrics.vertBearingX);
    lua_setfield(L, -2, "vert_bearing_x");
    lua_pushinteger(L, metrics.vertBearingY);
    lua_setfield(L, -2, "vert_bearing_y");
    lua_pushinteger(L, metrics.vertAdvance);
    lua_setfield(L, -2, "vert_advance");
    return 1;   
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x73d0
movq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0x2989(%rip), %rdx      # 0x13016
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0x2360(%rip), %rdx      # 0x12a0e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0x31c8(%rip), %rdx      # 0x13894
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0x31b9(%rip), %rdx      # 0x138a3
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0x3140(%rip), %rdx      # 0x13848
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0x318c(%rip), %rdx      # 0x138b2
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0x317d(%rip), %rdx      # 0x138c1
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movq 0x58(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0x30fa(%rip), %rdx      # 0x1385c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/utils.c
// Function: moonfreetype_pushbbox
int pushbbox(lua_State *L, FT_BBox bbox)
    {
    lua_newtable(L);
    lua_pushinteger(L, bbox.xMin);
    lua_setfield(L, -2, "xmin");
    lua_pushinteger(L, bbox.xMax);
    lua_setfield(L, -2, "xmax");
    lua_pushinteger(L, bbox.yMin);
    lua_setfield(L, -2, "ymin");
    lua_pushinteger(L, bbox.yMax);
    lua_setfield(L, -2, "ymax");
    return 1;   
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x73d0
movq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0x3137(%rip), %rdx      # 0x138d0
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0x311b(%rip), %rdx      # 0x138d5
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0x3102(%rip), %rdx      # 0x138da
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0x30e9(%rip), %rdx      # 0x138df
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq