LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x7370
testl %eax, %eax
je 0xe9de
leaq 0x5995(%rip), %rdi      # 0x1434f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x7270
testl %ebp, %ebp
je 0xe9de
movq %r15, %rdi
movq %rbx, %rsi
callq 0x78d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/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
movl $0x1, %esi
callq 0x76c0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7770
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7770
movq %rax, %r13
movl $0x28, %esi
movq %rbx, %rdi
callq 0x7c00
movq %rax, %r15
movq (%r14), %rdi
movl %r12d, %esi
movl %r13d, %edx
movq %rax, %rcx
callq 0x7420
testl %eax, %eax
je 0xeac0
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x79e0
movl %ebp, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7a60
leaq 0x58d0(%rip), %rdi      # 0x14397
movq %r15, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x5762(%rip), %rdx      # 0x1423a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x72a0
movq %r15, %rdi
callq 0x7230
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
movl $0x1, 0x18(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x7580
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7580
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 0xeb8d
leaq 0x5823(%rip), %rsi      # 0x143ab
movq %rbx, %rdi
jmp 0xeba9
movq %r14, %rdi
movq %r15, %rsi
callq 0x75d0
testl %eax, %eax
je 0xebbb
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7a60
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/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
movl $0x1, %ebp
movl $0x1, %esi
callq 0x7580
movq %rax, %rdi
callq 0x7690
testl %eax, %eax
je 0xec12
movl %eax, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7810
movl %r14d, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7c90
movl $0x2, %ebp
jmp 0xec1f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7810
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x7580
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7770
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7770
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7300
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x7580
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7770
movq %r14, %rdi
movq %rax, %rsi
callq 0x7930
testl %eax, %eax
je 0xecfc
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7a60
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x7580
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7770
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7770
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7870
testl %eax, %eax
je 0xed63
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x7a60
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/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
movl $0x1, %ebp
movl $0x1, %esi
callq 0x7580
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x7640
testl %eax, %eax
je 0xee0e
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
movl %eax, %ebp
jmp 0xee29
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x76b0
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x7580
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
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 0xee84
leaq 0x5557(%rip), %rsi      # 0x143d6
movq %rbx, %rdi
jmp 0xeea0
movq %r14, %rsi
movq %r15, %rdx
callq 0x7950
testl %eax, %eax
je 0xeeb2
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7a60
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/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
movl $0x1, %ebp
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7330
movq (%r14), %rdi
leaq 0x8(%rsp), %rdx
movl %eax, %esi
callq 0x7190
testl %eax, %eax
je 0xf04a
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
movl %eax, %ebp
jmp 0xf057
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x7ab0
movq (%rax), %rdi
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x18(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x76f0
testl %eax, %eax
je 0xf0aa
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
jmp 0xf0e1
movl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0x7530
movl 0x8(%rsp), %esi
movq %rbx, %rdi
callq 0x7530
movq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
movl $0x4, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7370
testl %eax, %eax
je 0xf1b5
leaq 0x53f7(%rip), %rdi      # 0x14571
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
movq (%r14), %rdi
callq 0x7200
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79e0
testl %ebp, %ebp
je 0xf1b5
movl %ebp, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7a60
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/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
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x7c00
movq %rax, %r15
movq (%r14), %rdi
movq %rax, %rsi
callq 0x71f0
testl %eax, %eax
je 0xf263
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x79e0
movl %ebp, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7a60
leaq 0x5322(%rip), %rdi      # 0x1458c
movq %r15, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x44d7(%rip), %rdx      # 0x13752
movq %rbx, %rdi
movq %r15, %rsi
callq 0x72a0
movq %r15, %rdi
callq 0x7230
movq (%r14), %rcx
movq %rcx, 0x10(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
leaq 0x4473(%rip), %rdx      # 0x13752
movl $0x1, %esi
callq 0x7630
testq %rax, %rax
je 0xf31b
movq (%rax), %rax
testq %rax, %rax
je 0xf31b
movq (%rax), %rdi
callq 0x7430
testl %eax, %eax
je 0xf317
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
jmp 0x7a60
xorl %eax, %eax
popq %rbx
retq
movq %rbx, %rdi
callq 0x7d90
nop
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/stroker.c
// Function: moonfreetype_checkstroker
FT_Stroker* checkstroker(lua_State *L, int arg)
    {
    FT_Stroker *p = teststroker(L, arg);
    if(p) return p;
    luaL_argerror(L, arg, "not a stroker");
    return NULL;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x4f1b(%rip), %rdx      # 0x1424f
callq 0x7630
testq %rax, %rax
je 0xf346
movq (%rax), %rax
testq %rax, %rax
jne 0xf359
leaq 0x527c(%rip), %rdx      # 0x145c9
movq %r14, %rdi
movl %ebx, %esi
callq 0x7260
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/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 0x7370
testl %eax, %eax
je 0xf398
leaq 0x525c(%rip), %rdi      # 0x145d7
movq %rbx, %rsi
xorl %eax, %eax
callq 0x7270
movq (%rbx), %rdi
callq 0x7240
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/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
movl $0x1, %esi
callq 0x76c0
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x7c00
movq %rax, %r15
movq (%r14), %rdi
movq %rax, %rsi
callq 0x77f0
testl %eax, %eax
je 0xf449
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x79e0
movl %ebp, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7a60
leaq 0x51a8(%rip), %rdi      # 0x145f8
movq %r15, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x4dee(%rip), %rdx      # 0x1424f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x72a0
movq %r15, %rdi
callq 0x7230
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x7a40
movq %rax, %r14
movq %rsp, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x7730
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7a30
movq (%r14), %rdi
movzbl %al, %edx
movq %r15, %rsi
callq 0x7060
testl %eax, %eax
je 0xf51a
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
jmp 0xf51c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x7a40
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x7730
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movl $0x3, %esi
movq %r12, %rdx
callq 0x7730
movq (%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x73f0
testl %eax, %eax
je 0xf659
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
jmp 0xf65b
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x7a40
movq %rax, %r14
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x7730
leaq 0x10(%rsp), %r12
movq %rbx, %rdi
movl $0x3, %esi
movq %r12, %rdx
callq 0x7730
movq %rsp, %r13
movq %rbx, %rdi
movl $0x4, %esi
movq %r13, %rdx
callq 0x7730
movq (%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x7d30
testl %eax, %eax
je 0xf6ec
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
jmp 0xf6ee
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x7a40
movq %rax, %r14
movq %rsp, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x7730
movq (%r14), %rdi
movq %r15, %rsi
callq 0x7ba0
testl %eax, %eax
je 0xf74d
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
jmp 0xf74f
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x7a40
movq (%rax), %rdi
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x7470
testl %eax, %eax
je 0xf797
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
jmp 0xf7b4
movl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0x7530
movl 0x8(%rsp), %esi
movq %rbx, %rdi
callq 0x7530
movl $0x2, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x7a40
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7580
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7a30
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 0xf81b
leaq 0x4df6(%rip), %rsi      # 0x1460c
movq %rbx, %rdi
jmp 0xf83b
movq (%r14), %rdi
movzbl %bpl, %edx
movq %r15, %rsi
callq 0x79c0
testl %eax, %eax
je 0xf84a
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7a60
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x7a40
movq %rax, %r14
movl $0x2, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movl $0x2, %edx
callq 0x7b00
movq (%r14), %rdi
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movl %eax, %esi
callq 0x7c50
testl %eax, %eax
je 0xf9ba
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
movl %eax, %ebp
jmp 0xf9d2
movl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0x7530
movl 0x8(%rsp), %esi
movq %rbx, %rdi
callq 0x7530
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0xa42d(%rip), %rax      # 0x1a6e8
testq %rax, %rax
je 0x10332
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ecx, %ecx
movq %rax, %rsi
xorl %edx, %edx
movq 0x20(%rsi), %r13
cmpq %rcx, %r13
jbe 0x102ea
movq %rsi, %rdx
jmp 0x102f0
jae 0x10303
addq $0x8, %rsi
movq (%rsi), %rsi
testq %rsi, %rsi
jne 0x102dc
testq %rdx, %rdx
je 0x10329
movq 0x20(%rdx), %r13
jmp 0x10306
movq %rsi, %rdx
cmpq %r15, 0x38(%rdx)
jne 0x1031e
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq *%rbx
movq 0xa3ca(%rip), %rax      # 0x1a6e8
incq %r13
movq %r13, %rcx
testq %rax, %rax
jne 0x102d7
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xa0c5(%rip), %rax      # 0x1a6f0
testq %rax, %rax
je 0x1065c
movq %rsi, %r14
movq 0xa0be(%rip), %rdi      # 0x1a6f8
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq *%rax
testq %rax, %rax
je 0x1065c
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7510
leaq 0x283f(%rip), %rsi      # 0x12ea2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7a60
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10798
movq $0x0, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7750
movl $0x1, %eax
jmp 0x1079a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7bf0
cmpl $0x3, %eax
jne 0x108aa
movq %r14, %rdi
movl %ebx, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7770
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x7620
cmpq $0x1, (%r15)
jne 0x108c8
movsbq (%rax), %rax
jmp 0x108db
leaq 0x3f38(%rip), %rdx      # 0x14807
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_O3/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 %rbx
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x73c0
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x3356(%rip), %rdx      # 0x13ff6
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x2d2d(%rip), %rdx      # 0x139ee
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x3b92(%rip), %rdx      # 0x14874
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x3b80(%rip), %rdx      # 0x14883
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x3b04(%rip), %rdx      # 0x14828
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x3b4d(%rip), %rdx      # 0x14892
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x3b3b(%rip), %rdx      # 0x148a1
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x3ab5(%rip), %rdx      # 0x1483c
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x73c0
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x3af4(%rip), %rdx      # 0x148b0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x3ad8(%rip), %rdx      # 0x148b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x3abc(%rip), %rdx      # 0x148ba
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x3aa0(%rip), %rdx      # 0x148bf
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/utils.c
// Function: moonfreetype_pushsizemetrics
int pushsizemetrics(lua_State *L, FT_Size size)
    {
    lua_newtable(L);
    lua_pushinteger(L, size->metrics.x_ppem);
    lua_setfield(L, -2, "x_ppem");
    lua_pushinteger(L, size->metrics.y_ppem);
    lua_setfield(L, -2, "y_ppem");
    lua_pushinteger(L, size->metrics.x_scale);
    lua_setfield(L, -2, "x_scale");
    lua_pushinteger(L, size->metrics.y_scale);
    lua_setfield(L, -2, "y_scale");
    lua_pushinteger(L, size->metrics.ascender);
    lua_setfield(L, -2, "ascender");
    lua_pushinteger(L, size->metrics.descender);
    lua_setfield(L, -2, "descender");
    lua_pushinteger(L, size->metrics.height);
    lua_setfield(L, -2, "height");
    lua_pushinteger(L, size->metrics.max_advance);
    lua_setfield(L, -2, "max_advance");
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x73c0
movzwl 0x18(%r14), %esi
movq %rbx, %rdi
callq 0x7530
leaq 0x3a6a(%rip), %rdx      # 0x148c4
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movzwl 0x1a(%r14), %esi
movq %rbx, %rdi
callq 0x7530
leaq 0x3a50(%rip), %rdx      # 0x148cb
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x3a37(%rip), %rdx      # 0x148d2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x3a1f(%rip), %rdx      # 0x148da
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x2ae2(%rip), %rdx      # 0x139bd
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x2acb(%rip), %rdx      # 0x139c6
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x2ad3(%rip), %rdx      # 0x139ee
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x39a7(%rip), %rdx      # 0x148e2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/utils.c
// Function: moonfreetype_pushbitmapsize
int pushbitmapsize(lua_State *L, FT_Bitmap_Size size)
    {
    lua_newtable(L);
    lua_pushinteger(L, size.height);
    lua_setfield(L, -2, "height");
    lua_pushinteger(L, size.width);
    lua_setfield(L, -2, "width");
    lua_pushinteger(L, size.size);
    lua_setfield(L, -2, "size");
    lua_pushinteger(L, size.x_ppem);
    lua_setfield(L, -2, "x_ppem");
    lua_pushinteger(L, size.y_ppem);
    lua_setfield(L, -2, "y_ppem");
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x73c0
movswq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x2a77(%rip), %rdx      # 0x139ee
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movswq 0x12(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x305d(%rip), %rdx      # 0x13ff6
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x35f2(%rip), %rdx      # 0x145ac
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x38e9(%rip), %rdx      # 0x148c4
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x38cf(%rip), %rdx      # 0x148cb
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/variants.c
// Function: Get_char_variant_is_default
static int Get_char_variant_is_default(lua_State *L)
    {
    FT_Face *face = checkface(L, 1);
    FT_ULong charcode = luaL_checkinteger(L, 2);
    FT_ULong selector = luaL_checkinteger(L, 3);
    FT_Int res = FT_Face_GetCharVariantIsDefault(*face, charcode, selector);
    if(res == -1)
        return 0; /* nil -> not a variant */
    lua_pushboolean(L, res);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %ebx
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
callq 0x7770
movq %rax, %r12
movq %r14, %rdi
movl $0x3, %esi
callq 0x7770
movq (%r15), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x7af0
cmpl $-0x1, %eax
je 0x11133
movq %r14, %rdi
movl %eax, %esi
callq 0x7810
jmp 0x11135
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/variants.c
// Function: Get_variant_selectors
static int Get_variant_selectors(lua_State *L)
    {
    size_t i;
    FT_Face *face = checkface(L, 1);
    FT_UInt32 *selector = FT_Face_GetVariantSelectors(*face);
    if(selector == NULL)
        return 0;
    lua_newtable(L);
    i = 0;
    while(selector[i] != 0)
        {
        lua_pushinteger(L, selector[i]);
        i++;
        lua_seti(L, -2, i);
        }
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %ebx
movl $0x1, %esi
callq 0x7ab0
movq (%rax), %rdi
callq 0x7210
testq %rax, %rax
je 0x111ad
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x73c0
movl (%r15), %eax
testl %eax, %eax
je 0x111af
movl $0x1, %r12d
movl %eax, %esi
movq %r14, %rdi
callq 0x7530
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r12, %rdx
callq 0x76a0
movl (%r15,%r12,4), %eax
incq %r12
testl %eax, %eax
jne 0x11186
jmp 0x111af
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/variants.c
// Function: Get_variants_of_char
static int Get_variants_of_char(lua_State *L)
    {
    size_t i;
    FT_Face *face = checkface(L, 1);
    FT_ULong charcode = luaL_checkinteger(L, 2);
    FT_UInt32 *selector = FT_Face_GetVariantsOfChar(*face, charcode);
    if(selector == NULL)
        return 0;
    lua_newtable(L);
    i = 0;
    while(selector[i] != 0)
        {
        lua_pushinteger(L, selector[i]);
        i++;
        lua_seti(L, -2, i);
        }
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %ebx
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
callq 0x7770
movq (%r15), %rdi
movq %rax, %rsi
callq 0x79f0
testq %rax, %rax
je 0x1123a
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x73c0
movl (%r15), %eax
testl %eax, %eax
je 0x1123c
movl $0x1, %r12d
movl %eax, %esi
movq %r14, %rdi
callq 0x7530
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r12, %rdx
callq 0x76a0
movl (%r15,%r12,4), %eax
incq %r12
testl %eax, %eax
jne 0x11213
jmp 0x1123c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/variants.c
// Function: Get_chars_of_variant
static int Get_chars_of_variant(lua_State *L)
    {
    size_t i;
    FT_Face *face = checkface(L, 1);
    FT_ULong selector = luaL_checkinteger(L, 2);
    FT_UInt32 *charcode = FT_Face_GetCharsOfVariant(*face, selector);
    if(charcode == NULL)
        return 0;
    lua_newtable(L);
    i = 0;
    while(charcode[i] != 0)
        {
        lua_pushinteger(L, charcode[i]);
        i++;
        lua_seti(L, -2, i);
        }
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %ebx
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
callq 0x7770
movq (%r15), %rdi
movq %rax, %rsi
callq 0x70a0
testq %rax, %rax
je 0x112c7
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x73c0
movl (%r15), %eax
testl %eax, %eax
je 0x112c9
movl $0x1, %r12d
movl %eax, %esi
movq %r14, %rdi
callq 0x7530
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r12, %rdx
callq 0x76a0
movl (%r15,%r12,4), %eax
incq %r12
testl %eax, %eax
jne 0x112a0
jmp 0x112c9
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O3/videolan[P]bitstream/examples/dvb_gen_si.c
// Function: output_psi_section
static void output_psi_section(uint8_t *section, uint16_t pid, uint8_t *cc) {
    uint16_t section_length = psi_get_length(section) + PSI_HEADER_SIZE;
    uint16_t section_offset = 0;
    do {
        uint8_t ts[TS_SIZE];
        uint8_t ts_offset = 0;
        memset(ts, 0xff, TS_SIZE);

        psi_split_section(ts, &ts_offset, section, &section_offset);

        ts_set_pid(ts, pid);
        ts_set_cc(ts, *cc);
        (*cc)++;
        *cc &= 0xf;

        if (section_offset == section_length)
            psi_split_end(ts, &ts_offset);

        if (write(fileno(stdout), ts, TS_SIZE) < 0)
            perror("write");
    } while (section_offset < section_length);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r14
movzbl 0x1(%rdi), %eax
movzbl 0x2(%rdi), %ecx
andl $0xf, %eax
shll $0x8, %eax
leal (%rcx,%rax), %ebp
addl $0x3, %ebp
movl %esi, 0xc(%rsp)
shrl $0x8, %esi
andb $0x1f, %sil
movl %esi, 0x8(%rsp)
xorl %r12d, %r12d
leaq 0x10(%rsp), %r15
movl $0xbc, %edx
movq %r15, %rbx
movq %r15, %rdi
movl $0xff, %esi
callq 0x1060
movzbl 0x1(%r14), %ecx
movzbl 0x2(%r14), %edx
movw $0x47, 0x10(%rsp)
movb $0x10, 0x13(%rsp)
movb $0x4, %al
testw %r12w, %r12w
jne 0x805b
movb $0x0, 0x14(%rsp)
movb $0x40, 0x11(%rsp)
movb $0x5, %al
andl $0xf, %ecx
shll $0x8, %ecx
subl %r12d, %edx
addl %edx, %ecx
addl $0x3, %ecx
movb $-0x44, %dl
subb %al, %dl
movzbl %dl, %edx
movzwl %cx, %r13d
cmpl %r13d, %edx
cmovbl %edx, %r13d
movzbl %al, %r15d
leaq (%rsp,%r15), %rdi
addq $0x10, %rdi
movzwl %r12w, %esi
addq %r14, %rsi
movq %r13, %rdx
callq 0x1070
addb %r13b, %r15b
addl %r12d, %r13d
movl %r13d, %r12d
movb 0x11(%rsp), %al
movb 0x13(%rsp), %cl
andb $-0x20, %al
addb 0x8(%rsp), %al
movb %al, 0x11(%rsp)
movl 0xc(%rsp), %eax
movb %al, 0x12(%rsp)
movb 0x2fea(%rip), %al       # 0xb0a9
andb $-0x10, %cl
movl %eax, %edx
andb $0xf, %dl
orb %cl, %dl
movb %dl, 0x13(%rsp)
incb %al
andb $0xf, %al
movb %al, 0x2fd2(%rip)       # 0xb0a9
cmpw %bp, %r13w
setne %al
cmpb $-0x44, %r15b
sete %cl
orb %al, %cl
jne 0x8107
movzbl %r15b, %eax
leaq (%rsp,%rax), %rdi
addq $0x10, %rdi
movl $0xbc, %edx
subq %rax, %rdx
movl $0xff, %esi
callq 0x1060
movq 0x2eca(%rip), %rax      # 0xafd8
movq (%rax), %rdi
callq 0x1080
movl $0xbc, %edx
movl %eax, %edi
movq %rbx, %r15
movq %rbx, %rsi
callq 0x1040
testq %rax, %rax
js 0x8139
cmpw %bp, %r12w
jb 0x801c
jmp 0x8147
leaq 0x13b0(%rip), %rdi      # 0x94f0
callq 0x10b0
jmp 0x812d
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/videolan[P]bitstream/examples/dvb_gen_si.c
// Function: build_desc41
static void build_desc41(uint8_t *desc) {
    uint8_t k = 0;
    uint8_t *service_n;

    desc41_init(desc);
    desc_set_length(desc, 255);

    service_n = desc41_get_service(desc, k++);
    desc41n_set_sid(service_n, sid);
    desc41n_set_type(service_n, 1);

    service_n = desc41_get_service(desc, k++);
    desc41n_set_sid(service_n, sid + 100);
    desc41n_set_type(service_n, 2);

    service_n = desc41_get_service(desc, k++);
    desc41n_set_sid(service_n, sid + 200);
    desc41n_set_type(service_n, 1);

    service_n = desc41_get_service(desc, k++);
    desc41n_set_sid(service_n, sid + 300);
    desc41n_set_type(service_n, 2);

    service_n = desc41_get_service(desc, k);
    desc_set_length(desc, service_n - desc - DESC_HEADER_SIZE);
}

// Assembly:
pushq %rbx
movw $0xff41, (%rdi)         # imm = 0xFF41
leaq 0x2(%rdi), %rax
movzwl 0x2f10(%rip), %ecx      # 0xb07a
movb %ch, 0x2(%rdi)
movb %cl, 0x3(%rdi)
movb $0x1, %dl
movb %dl, 0x4(%rdi)
addl $0x64, %ecx
movb %ch, 0x5(%rdi)
movb %cl, 0x6(%rdi)
movb $0x2, 0x7(%rdi)
leaq 0x8(%rdi), %rcx
movzwl 0x2eed(%rip), %ebx      # 0xb07a
addl $0xc8, %ebx
movb %bh, 0x8(%rdi)
movb %bl, 0x9(%rdi)
movb %dl, 0xa(%rdi)
movzbl 0x1(%rdi), %edx
addq %rdi, %rdx
addq $0x2, %rdx
xorl %r8d, %r8d
movq %rcx, %rsi
leaq -0x3(%r8), %r9
cmpq %rdx, %rcx
ja 0x81c3
leaq 0x3(%rsi), %rcx
cmpb $-0x6, %r8b
movq %r9, %r8
jne 0x81aa
movq %rax, %rbx
subq %r9, %rbx
xorl %ecx, %ecx
cmpq %rdx, %rsi
cmovaq %rcx, %rbx
movzwl 0x2ea1(%rip), %edx      # 0xb07a
addl $0x12c, %edx            # imm = 0x12C
movb %dh, (%rbx)
movb %dl, 0x1(%rbx)
movb $0x2, 0x2(%rbx)
movzbl 0x1(%rdi), %edx
cmpq $0x3, %rdx
jb 0x821f
addq %rax, %rdx
leaq 0x8(%rdi), %r9
xorl %ecx, %ecx
movq %r9, %rsi
leaq -0x3(%rcx), %r8
cmpq %rdx, %r9
ja 0x8213
leaq 0x3(%rsi), %r9
cmpb $-0x9, %cl
movq %r8, %rcx
jne 0x81fb
subq %r8, %rax
xorl %ecx, %ecx
cmpq %rdx, %rsi
cmovbeq %rax, %rcx
subl %edi, %ecx
addb $-0x2, %cl
movb %cl, 0x1(%rdi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/videolan[P]bitstream/examples/dvb_gen_si.c
// Function: build_desc55
static void build_desc55(uint8_t *desc) {
    uint8_t k = 0;
    uint8_t *rating_n;

    desc55_init(desc);
    desc_set_length(desc, 255);

    rating_n = desc55_get_rating(desc, k++);
    desc55n_set_country_code(rating_n, (uint8_t *)"USA");
    desc55n_set_rating(rating_n, 0);

    rating_n = desc55_get_rating(desc, k++);
    desc55n_set_country_code(rating_n, (uint8_t *)"CHI");
    desc55n_set_rating(rating_n, 15);

    rating_n = desc55_get_rating(desc, k++);
    desc55n_set_country_code(rating_n, (uint8_t *)"FRA");
    desc55n_set_rating(rating_n, 12);

    rating_n = desc55_get_rating(desc, k++);
    desc55n_set_country_code(rating_n, (uint8_t *)"BUL");
    desc55n_set_rating(rating_n, 24);

    rating_n = desc55_get_rating(desc, k);
    desc_set_length(desc, rating_n - desc - DESC_HEADER_SIZE);
}

// Assembly:
movabsq $0x484300415355ff55, %rax # imm = 0x484300415355FF55
movq %rax, (%rdi)
movb 0x1(%rdi), %al
leaq 0x6(%rdi), %rsi
leaq 0xa(%rdi), %rcx
cmpb $0x8, %al
cmovaeq %rcx, %rsi
xorl %edx, %edx
cmpb $0xc, %al
cmovbq %rdx, %rsi
cmpb $0x8, %al
cmovbq %rdx, %rsi
leaq 0x2(%rdi), %rax
movw $0xf49, 0x8(%rdi)       # imm = 0xF49
movl $0xc415246, (%rsi)      # imm = 0xC415246
movzbl 0x1(%rdi), %esi
addq %rdi, %rsi
addq $0x2, %rsi
movq %rcx, %r8
leaq -0x4(%rdx), %r9
cmpq %rsi, %rcx
ja 0x843a
leaq 0x4(%r8), %rcx
cmpb $-0x8, %dl
movq %r9, %rdx
jne 0x8422
movq %rax, %rcx
subq %r9, %rcx
xorl %edx, %edx
cmpq %rsi, %r8
cmovaq %rdx, %rcx
movl $0x184c5542, (%rcx)     # imm = 0x184C5542
movzbl 0x1(%rdi), %ecx
cmpq $0x4, %rcx
jb 0x8486
addq %rax, %rcx
leaq 0xa(%rdi), %r9
xorl %edx, %edx
movq %r9, %rsi
leaq -0x4(%rdx), %r8
cmpq %rcx, %r9
ja 0x847a
leaq 0x4(%rsi), %r9
cmpb $-0xc, %dl
movq %r8, %rdx
jne 0x8462
subq %r8, %rax
xorl %edx, %edx
cmpq %rcx, %rsi
cmovbeq %rax, %rdx
subl %edi, %edx
addb $-0x2, %dl
movb %dl, 0x1(%rdi)
retq