LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/flags.c
// Function: FsTypeFlags
static int FsTypeFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushfstypeflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkfstypeflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7bf0
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
cmpl $0x3, %eax
jne 0xcb12
callq 0x7760
movq %rax, %r14
testl %r14d, %r14d
je 0xcbf1
xorl %ebp, %ebp
testb $0x2, %r14b
je 0xcaab
leaq 0x7417(%rip), %rsi      # 0x13eb5
movq %rbx, %rdi
callq 0x7c90
movl $0x1, %ebp
testb $0x4, %r14b
je 0xcac2
leaq 0x741a(%rip), %rsi      # 0x13ed2
movq %rbx, %rdi
callq 0x7c90
incl %ebp
testb $0x8, %r14b
je 0xcad9
leaq 0x741f(%rip), %rsi      # 0x13eee
movq %rbx, %rdi
callq 0x7c90
incl %ebp
btl $0x8, %r14d
jae 0xcaf1
leaq 0x741a(%rip), %rsi      # 0x13f01
movq %rbx, %rdi
callq 0x7c90
incl %ebp
btl $0x9, %r14d
jae 0xcc00
leaq 0x740c(%rip), %rsi      # 0x13f0f
movq %rbx, %rdi
callq 0x7c90
incl %ebp
jmp 0xcc00
callq 0x7d70
xorl %r14d, %r14d
testl %eax, %eax
je 0xcbdf
leaq 0x7376(%rip), %r15      # 0x13e9f
leaq 0x7385(%rip), %r12      # 0x13eb5
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x7320
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x76f0
testl %eax, %eax
je 0xcbcb
movq %r13, %rdi
movq %r12, %rsi
callq 0x76f0
testl %eax, %eax
je 0xcbb2
movq %r13, %rdi
leaq 0x736b(%rip), %rsi      # 0x13ed2
callq 0x76f0
testl %eax, %eax
je 0xcbb8
movq %r13, %rdi
leaq 0x7374(%rip), %rsi      # 0x13eee
callq 0x76f0
testl %eax, %eax
je 0xcbbe
movq %r13, %rdi
leaq 0x7374(%rip), %rsi      # 0x13f01
callq 0x76f0
testl %eax, %eax
je 0xcbc4
movq %r13, %rdi
leaq 0x736f(%rip), %rsi      # 0x13f0f
callq 0x76f0
testl %eax, %eax
jne 0xcc11
orl $0x200, %r14d           # imm = 0x200
jmp 0xcbcb
orl $0x2, %r14d
jmp 0xcbcb
orl $0x4, %r14d
jmp 0xcbcb
orl $0x8, %r14d
jmp 0xcbcb
orl $0x100, %r14d           # imm = 0x100
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d70
testl %eax, %eax
jne 0xcb30
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0x7530
movl $0x1, %ebp
jmp 0xcc00
leaq 0x72a7(%rip), %rsi      # 0x13e9f
movq %rbx, %rdi
callq 0x7c90
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x596c(%rip), %rsi      # 0x12584
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x7680
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x7260
movl %eax, %r14d
jmp 0xcbdf
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/flags.c
// Function: OutlineFlags
static int OutlineFlags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushoutlineflags(L, luaL_checkinteger(L, 1));
    lua_pushinteger(L, checkoutlineflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7bf0
cmpl $0x3, %eax
jne 0xcd30
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7760
movq %rax, %r14
xorl %ebp, %ebp
testb $0x1, %r14b
je 0xcc84
leaq 0x72ae(%rip), %rsi      # 0x13f25
movq %rbx, %rdi
callq 0x7c90
movl $0x1, %ebp
testb $0x2, %r14b
je 0xcc9b
leaq 0x729a(%rip), %rsi      # 0x13f2b
movq %rbx, %rdi
callq 0x7c90
incl %ebp
testb $0x4, %r14b
je 0xccb2
leaq 0x7291(%rip), %rsi      # 0x13f39
movq %rbx, %rdi
callq 0x7c90
incl %ebp
testb $0x8, %r14b
je 0xccc9
leaq 0x7287(%rip), %rsi      # 0x13f46
movq %rbx, %rdi
callq 0x7c90
incl %ebp
testb $0x10, %r14b
je 0xcce0
leaq 0x7280(%rip), %rsi      # 0x13f56
movq %rbx, %rdi
callq 0x7c90
incl %ebp
testb $0x20, %r14b
je 0xccf7
leaq 0x7278(%rip), %rsi      # 0x13f65
movq %rbx, %rdi
callq 0x7c90
incl %ebp
btl $0x8, %r14d
jae 0xcd0f
leaq 0x726e(%rip), %rsi      # 0x13f73
movq %rbx, %rdi
callq 0x7c90
incl %ebp
btl $0x9, %r14d
jae 0xce71
leaq 0x7261(%rip), %rsi      # 0x13f82
movq %rbx, %rdi
callq 0x7c90
incl %ebp
jmp 0xce71
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7d70
xorl %r14d, %r14d
testl %eax, %eax
je 0xce61
leaq 0x58d2(%rip), %r15      # 0x12626
leaq 0x71ca(%rip), %r12      # 0x13f25
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x7320
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x76f0
testl %eax, %eax
je 0xce4d
movq %r13, %rdi
movq %r12, %rsi
callq 0x76f0
testl %eax, %eax
je 0xce22
movq %r13, %rdi
leaq 0x7191(%rip), %rsi      # 0x13f2b
callq 0x76f0
testl %eax, %eax
je 0xce28
movq %r13, %rdi
leaq 0x7188(%rip), %rsi      # 0x13f39
callq 0x76f0
testl %eax, %eax
je 0xce2e
movq %r13, %rdi
leaq 0x7182(%rip), %rsi      # 0x13f46
callq 0x76f0
testl %eax, %eax
je 0xce34
movq %r13, %rdi
leaq 0x717f(%rip), %rsi      # 0x13f56
callq 0x76f0
testl %eax, %eax
je 0xce3a
movq %r13, %rdi
leaq 0x717b(%rip), %rsi      # 0x13f65
callq 0x76f0
testl %eax, %eax
je 0xce40
movq %r13, %rdi
leaq 0x7176(%rip), %rsi      # 0x13f73
callq 0x76f0
testl %eax, %eax
je 0xce46
movq %r13, %rdi
leaq 0x7172(%rip), %rsi      # 0x13f82
callq 0x76f0
testl %eax, %eax
jne 0xce82
orl $0x200, %r14d           # imm = 0x200
jmp 0xce4d
orl $0x1, %r14d
jmp 0xce4d
orl $0x2, %r14d
jmp 0xce4d
orl $0x4, %r14d
jmp 0xce4d
orl $0x8, %r14d
jmp 0xce4d
orl $0x10, %r14d
jmp 0xce4d
orl $0x20, %r14d
jmp 0xce4d
orl $0x100, %r14d           # imm = 0x100
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d70
testl %eax, %eax
jne 0xcd5b
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0x7530
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x56fb(%rip), %rsi      # 0x12584
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x7680
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x7260
movl %eax, %r14d
jmp 0xce61
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/glyph.c
// Function: moonfreetype_freeglyph
int freeglyph(lua_State *L, FT_Glyph *glyph)
    {
    if(!freeuserdata(L, glyph))
        return 0; /* double call */
    DBG("deleting glyph %p\n", (void*)glyph);
    FT_Done_Glyph(*glyph);
    Free(L, glyph);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x7370
testl %eax, %eax
je 0xd497
leaq 0x6c1c(%rip), %rdi      # 0x14096
movq %rbx, %rsi
xorl %eax, %eax
callq 0x7270
movq (%rbx), %rdi
callq 0x7600
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_O1/stetre[P]moonfreetype/src/glyph.c
// Function: Get_glyph
static int Get_glyph(lua_State *L)
/* glyph = get_glyph(face) 
 * extracts the glyph image from the current face->glyph slot
 */
    {
    FT_Error ec;
    FT_Library library;
    ud_t *ud;
    FT_Face *face = checkface(L, 1);
    FT_Glyph *glyph = (FT_Glyph*)Malloc(L, sizeof(FT_Glyph));

    ud = userdata(face);
    library = ud->library;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r15
movl $0x8, %esi
movq %rbx, %rdi
callq 0x7c00
movq %rax, %r14
movq %r15, %rdi
callq 0x7230
movq 0x8(%rax), %r12
movq (%r15), %rax
movq 0x98(%rax), %rdi
movq %r14, %rsi
callq 0x7890
testl %eax, %eax
je 0xd55a
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79e0
movl %ebp, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7a60
leaq 0x6b65(%rip), %rdi      # 0x140c6
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x6b37(%rip), %rdx      # 0x140a9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72a0
movq %r14, %rdi
callq 0x7230
movq %r12, 0x8(%rax)
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/glyph.c
// Function: Glyph_copy
static int Glyph_copy(lua_State *L)
    {
    FT_Error ec;
    FT_Library library;
    ud_t *ud;
    FT_Glyph *oldglyph = checkglyph(L, 1);
    FT_Glyph *glyph = (FT_Glyph*)Malloc(L, sizeof(FT_Glyph));

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0xdab2
movq %rax, %r15
movl $0x8, %esi
movq %rbx, %rdi
callq 0x7c00
movq %rax, %r14
movq %r15, %rdi
callq 0x7230
movq 0x8(%rax), %r12
movq (%r15), %rdi
movq %r14, %rsi
callq 0x7290
testl %eax, %eax
je 0xd630
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79e0
movl %ebp, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7a60
leaq 0x6a72(%rip), %rdx      # 0x140a9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72a0
movq %r14, %rdi
callq 0x7230
movq %r12, 0x8(%rax)
leaq 0x6a9a(%rip), %rdi      # 0x140ef
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/glyph.c
// Function: Glyph_get_cbox
static int Glyph_get_cbox(lua_State *L) 
    {
    FT_BBox acbox;
    FT_Glyph *glyph = checkglyph(L, 1);
    FT_UInt bbox_mode = checkglyphbboxmode(L, 2);
    FT_Glyph_Get_CBox(*glyph, bbox_mode, &acbox);
    pushbbox(L, acbox);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0xdab2
movq %rax, %r14
movq %rbx, %rdi
movl $0x5, %esi
movl $0x2, %edx
callq 0x7b00
movq (%r14), %rdi
leaq 0x28(%rsp), %r14
movl %eax, %esi
movq %r14, %rdx
callq 0x7660
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x76b0
movl $0x1, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/glyph.c
// Function: Glyph_to_bitmap
static int Glyph_to_bitmap(lua_State *L)
    {
    FT_Error ec;
    FT_Vector vec, *origin=0;
    FT_Bool destroy;
    FT_Glyph *glyph = checkglyph(L, 1);
    FT_Render_Mode render_mode = checkrendermode(L, 2);
    if(!lua_isnoneornil(L, 3))
        {
        checkvector(L, 3, &vec);
        origin = &vec;
        }
    destroy = optboolean(L, 4, 1); /* defaults to true */
    DBG("glyph_to_bitmap %p mode=%d origin=%p destroy=%s\n", 
            (void*)glyph,  render_mode, (void*)origin, destroy ? "true":"false");
    ec = FT_Glyph_To_Bitmap(glyph, render_mode, origin, destroy);
    DBG("glyph_to_bitmap %p ec=%d\n", (void*)glyph,  ec);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0xdab2
movq %rax, %r14
movq %rbx, %rdi
movl $0x9, %esi
movl $0x2, %edx
callq 0x7b00
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7bf0
xorl %r15d, %r15d
testl %eax, %eax
jle 0xd722
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movl $0x3, %esi
movq %r12, %rdx
callq 0x7720
jmp 0xd725
xorl %r12d, %r12d
movq %rbx, %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x7700
movl %eax, %r13d
andl $0xff, %r13d
leaq 0x6a02(%rip), %rax      # 0x1414a
leaq 0x69f6(%rip), %r8       # 0x14145
cmoveq %rax, %r8
leaq 0x69ba(%rip), %rdi      # 0x14114
movq %r14, %rsi
movl %ebp, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x7270
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
movl %r13d, %ecx
callq 0x77a0
movl %eax, %ebp
leaq 0x69ce(%rip), %rdi      # 0x14150
movq %r14, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x7270
testl %ebp, %ebp
je 0xd7a9
movl %ebp, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
movl %eax, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/glyph.c
// Function: Glyph_transform
static int Glyph_transform(lua_State *L)
    {
    FT_Error ec;
    FT_Matrix matrix;
    FT_Vector delta;
    FT_Glyph *glyph = checkglyph(L, 1);
    checkmatrix(L, 2, &matrix);
    checkvector(L, 3, &delta);
    ec = FT_Glyph_Transform(*glyph, &matrix, &delta);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
callq 0xdab2
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x7d50
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movl $0x3, %esi
movq %r12, %rdx
callq 0x7720
movq (%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x78a0
testl %eax, %eax
je 0xd823
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
jmp 0xd825
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/glyph.c
// Function: Glyph_stroke
static int Glyph_stroke(lua_State *L) //@@
    {
    FT_Glyph *glyph = checkglyph(L, 1);
    FT_Stroker *stroker = checkstroker(L, 2);
    FT_Bool destroy = optboolean(L, 3, 1);
    FT_Error ec = FT_Glyph_Stroke(glyph, *stroker, destroy);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xdab2
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7a40
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0x7700
movq (%r15), %rsi
movzbl %al, %edx
movq %r14, %rdi
callq 0x7ca0
testl %eax, %eax
je 0xd88e
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x7a60
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/glyph.c
// Function: Glyph_strokeborder
static int Glyph_strokeborder(lua_State *L) //@@
    {
    FT_Glyph *glyph = checkglyph(L, 1);
    FT_Stroker *stroker = checkstroker(L, 2);
    FT_Bool inside = optboolean(L, 3, 1);
    FT_Bool destroy = optboolean(L, 3, 1);
    FT_Error ec = FT_Glyph_StrokeBorder(glyph, *stroker, inside, destroy);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xdab2
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7a40
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0x7700
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0x7700
movq (%r15), %rsi
movl $0xff, %ecx
andl %ecx, %ebp
andl %eax, %ecx
movq %r14, %rdi
movl %ebp, %edx
callq 0x7520
testl %eax, %eax
je 0xd916
movl %eax, %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
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/glyph.c
// Function: Bitmap
static int Bitmap(lua_State *L)
/* bitmap = glyph:bitmap() */
    {
    FT_BitmapGlyphRec *rec;
    FT_Glyph *glyph = checkglyph(L, 1);
    if((*glyph)->format != FT_GLYPH_FORMAT_BITMAP)
        return luaL_argerror(L, 1, "glyph format is not 'bitmap'");
    rec = (FT_BitmapGlyphRec*)(*glyph);
    pushbitmap(L, &(rec->bitmap), rec->root.library);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xdab2
movq (%rax), %rsi
cmpl $0x62697473, 0x10(%rsi) # imm = 0x62697473
jne 0xd994
movq (%rsi), %rdx
addq $0x30, %rsi
movq %rbx, %rdi
callq 0x78b0
movl $0x1, %eax
popq %rbx
retq
leaq 0x67cf(%rip), %rdx      # 0x1416a
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/glyph.c
// Function: Bitmapdata
static int Bitmapdata(lua_State *L)
/* bitmapdata = glyph:bitmapdata() */
    {
    FT_BitmapGlyphRec *rec;
    FT_Glyph *glyph = checkglyph(L, 1);
    if((*glyph)->format != FT_GLYPH_FORMAT_BITMAP)
        return luaL_argerror(L, 1, "glyph format is not 'bitmap'");
    rec = (FT_BitmapGlyphRec*)(*glyph);
    pushbitmapdata(L, rec->bitmap, rec->left, rec->top, 1);
    return 1;
    }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0xdab2
movq (%rax), %rax
cmpl $0x62697473, 0x10(%rax) # imm = 0x62697473
jne 0xd9fa
movl 0x28(%rax), %esi
movl 0x2c(%rax), %edx
movq 0x50(%rax), %rcx
movq %rcx, 0x20(%rsp)
movups 0x30(%rax), %xmm0
movups 0x40(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x7cd0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
retq
leaq 0x6769(%rip), %rdx      # 0x1416a
movq %rbx, %rdi
movl $0x1, %esi
addq $0x30, %rsp
popq %rbx
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/glyph.c
// Function: Outline
static int Outline(lua_State *L)
/* outline = glyph:outline() */
    {
    FT_OutlineGlyphRec *rec;
    FT_Glyph *glyph = checkglyph(L, 1);
    if((*glyph)->format != FT_GLYPH_FORMAT_OUTLINE)
        return luaL_argerror(L, 1, "glyph format is not 'outline'");
    rec = (FT_OutlineGlyphRec*)(*glyph);
    pushoutline(L, &(rec->outline), rec->root.library);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xdab2
movq (%rax), %rsi
cmpl $0x6f75746c, 0x10(%rsi) # imm = 0x6F75746C
jne 0xda3e
movq (%rsi), %rdx
addq $0x28, %rsi
movq %rbx, %rdi
callq 0x7160
movl $0x1, %eax
popq %rbx
retq
leaq 0x6742(%rip), %rdx      # 0x14187
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/glyph.c
// Function: Outlinedata
static int Outlinedata(lua_State *L)
    {
    FT_OutlineGlyphRec *rec;
    FT_Glyph *glyph = checkglyph(L, 1);
    if((*glyph)->format != FT_GLYPH_FORMAT_OUTLINE)
        return luaL_argerror(L, 1, "glyph format is not 'outline'");
    rec = (FT_OutlineGlyphRec *)(*glyph);
    pushoutlinedata(L, rec->outline);
    return 1;
    }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0xdab2
movq (%rax), %rax
cmpl $0x6f75746c, 0x10(%rax) # imm = 0x6F75746C
jne 0xda99
movq 0x48(%rax), %rcx
movq %rcx, 0x20(%rsp)
movups 0x28(%rax), %xmm0
movups 0x38(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x7350
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
retq
leaq 0x66e7(%rip), %rdx      # 0x14187
movq %rbx, %rdi
movl $0x1, %esi
addq $0x30, %rsp
popq %rbx
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/glyph.c
// Function: checkglyph
static FT_Glyph* checkglyph(lua_State *L, int arg)
    {
    FT_Glyph *p = testglyph(L, arg);
    if(p) return p;
    luaL_argerror(L, arg, "not a glyph");
    return NULL;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x65ec(%rip), %rdx      # 0x140a9
movl $0x1, %esi
callq 0x7630
testq %rax, %rax
je 0xdad1
movq (%rax), %rax
jmp 0xdad3
xorl %eax, %eax
testq %rax, %rax
jne 0xdaee
leaq 0x6629(%rip), %rdx      # 0x14108
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7260
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/library.c
// Function: moonfreetype_checklibrary
FT_Library* checklibrary(lua_State *L, int arg)
    {
    FT_Library *p = testlibrary(L, arg);
    if(p) return p;
    luaL_argerror(L, arg, "not a library");
    return NULL;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x45a6(%rip), %rdx      # 0x120c1
callq 0x7630
testq %rax, %rax
je 0xdb2a
movq (%rax), %rax
jmp 0xdb2c
xorl %eax, %eax
testq %rax, %rax
jne 0xdb44
leaq 0x66d2(%rip), %rdx      # 0x1420a
movq %r14, %rdi
movl %ebx, %esi
callq 0x7260
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/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
leaq 0x4537(%rip), %rdx      # 0x120c1
movl $0x1, %esi
callq 0x7630
testq %rax, %rax
je 0xdb9e
movq (%rax), %r14
jmp 0xdba1
xorl %r14d, %r14d
testq %r14, %r14
je 0xdc78
movq (%r14), %rdx
leaq 0x44ba(%rip), %rsi      # 0x1206e
leaq 0x15b(%rip), %rcx       # 0xdd16
movq %rbx, %rdi
callq 0x7aa0
movq (%r14), %rdx
leaq 0x666d(%rip), %rsi      # 0x1423a
leaq 0x171(%rip), %rcx       # 0xdd45
movq %rbx, %rdi
callq 0x7aa0
movq (%r14), %rdx
leaq 0x6669(%rip), %rsi      # 0x1424f
leaq 0x187(%rip), %rcx       # 0xdd74
movq %rbx, %rdi
callq 0x7aa0
movq (%r14), %rdx
leaq 0x64aa(%rip), %rsi      # 0x140a9
leaq 0x19d(%rip), %rcx       # 0xdda3
movq %rbx, %rdi
callq 0x7aa0
movq (%r14), %rdx
leaq 0x43e8(%rip), %rsi      # 0x12000
leaq 0x1b3(%rip), %rcx       # 0xddd2
movq %rbx, %rdi
callq 0x7aa0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7370
testl %eax, %eax
je 0xdc78
leaq 0x6627(%rip), %rdi      # 0x14264
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
movq (%r14), %rdi
callq 0x73b0
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79e0
testl %ebp, %ebp
je 0xdc78
movl %ebp, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7a60
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/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
movl $0x1, %esi
callq 0x76c0
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 0x76d0
movslq (%r14), %rsi
movq %rbx, %rdi
callq 0x7530
movslq (%r15), %rsi
movq %rbx, %rdi
callq 0x7530
movslq (%r12), %rsi
movq %rbx, %rdi
callq 0x7530
movl $0x3, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x76c0
movq (%rax), %rdi
callq 0x7bb0
movq %rbx, %rdi
movl $0x6, %esi
movl %eax, %edx
callq 0x7280
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xdd3d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x77d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xdd6c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x70f0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xdd9b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7b10
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xddca
movq %r14, %rdi
movq %rbx, %rsi
callq 0x70e0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xddf9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x71d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x8, %esi
callq 0x7c00
movq %rax, %r14
movq %rax, %rdi
callq 0x74c0
testl %eax, %eax
je 0xde46
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79e0
movl %ebp, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7a60
leaq 0x6458(%rip), %rdi      # 0x142a5
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x4263(%rip), %rdx      # 0x120c1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72a0
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/outline.c
// Function: moonfreetype_checkoutline
FT_Outline* checkoutline(lua_State *L, int arg)
    {
    FT_Outline *p = testoutline(L, arg);
    if(p) return p;
    luaL_argerror(L, arg, "not a outline");
    return NULL;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x5cca(%rip), %rdx      # 0x1423a
callq 0x7630
testq %rax, %rax
je 0xe57f
movq (%rax), %rax
jmp 0xe581
xorl %eax, %eax
testq %rax, %rax
jne 0xe599
leaq 0x5d78(%rip), %rdx      # 0x14305
movq %r14, %rdi
movl %ebx, %esi
callq 0x7260
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/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 0xe5cc
movq %r15, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7180
leaq 0x5d40(%rip), %rdi      # 0x14313
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x5c56(%rip), %rdx      # 0x1423a
movq %r15, %rdi
movq %r14, %rsi
callq 0x72a0
movq %r14, %rdi
callq 0x7230
movq %rbx, 0x8(%rax)
movl $0x0, 0x18(%rax)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe922
leaq 0x5a51(%rip), %rdi      # 0x1434f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x7270
testl %ebp, %ebp
je 0xe922
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_O1/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 0x7760
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7760
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 0xea04
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 0x598c(%rip), %rdi      # 0x14397
movq %r15, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x581e(%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_O1/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 0xead5
leaq 0x58db(%rip), %rsi      # 0x143ab
movq %rbx, %rdi
jmp 0xeaf1
movq %r14, %rdi
movq %r15, %rsi
callq 0x75d0
testl %eax, %eax
je 0xeb03
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7a60
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/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 0xeb5a
movl %eax, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7800
movl %r14d, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7c90
movl $0x2, %ebp
jmp 0xeb67
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7800
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7760
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7760
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_O1/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
movl $0x1, %esi
callq 0x7580
movq %rax, %r14
movq %rsp, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x7d50
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_O1/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 0x7760
movq %r14, %rdi
movq %rax, %rsi
callq 0x7930
testl %eax, %eax
je 0xec44
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7a60
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/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 0x7760
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7760
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7860
testl %eax, %eax
je 0xecab
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x7a60
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7580
leaq 0x28(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x7d60
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x76b0
movl $0x1, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xed56
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
movl %eax, %ebp
jmp 0xed71
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_O1/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 0xedcc
leaq 0x560f(%rip), %rsi      # 0x143d6
movq %rbx, %rdi
jmp 0xede8
movq %r14, %rsi
movq %r15, %rdx
callq 0x7950
testl %eax, %eax
je 0xedfa
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7a60
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/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 %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7580
movq %rax, %rdi
callq 0x79a0
movq %rbx, %rdi
movl $0x1, %esi
movl %eax, %edx
callq 0x7280
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7580
movq %rax, %rdi
callq 0x7540
movq %rbx, %rdi
movl $0x2, %esi
movl %eax, %edx
callq 0x7280
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/outline.c
// Function: Outline_getoutsideborder
static int Outline_getoutsideborder(lua_State *L)
    {
    FT_Outline *outline = checkoutline(L, 1);
    FT_StrokerBorder border = FT_Outline_GetOutsideBorder(outline);
    pushstrokerborder(L, border);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7580
movq %rax, %rdi
callq 0x7b70
movq %rbx, %rdi
movl $0x2, %esi
movl %eax, %edx
callq 0x7280
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xef92
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
movl %eax, %ebp
jmp 0xef9f
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_O1/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 0x76e0
testl %eax, %eax
je 0xeff2
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
jmp 0xf029
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_O1/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
movl $0x1, %esi
callq 0x7ab0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7330
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7330
movq (%r14), %rdi
movq %rsp, %rcx
movl %ebp, %esi
movl %eax, %edx
callq 0x7c80
testl %eax, %eax
je 0xf08c
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
jmp 0xf09d
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x7b90
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xf0fd
leaq 0x54af(%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 0xf0fd
movl %ebp, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7a60
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonfreetype/src/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 0xf1ab
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 0x53da(%rip), %rdi      # 0x1458c
movq %r15, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x458f(%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_O1/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 0x4527(%rip), %rdx      # 0x13752
movl $0x1, %esi
callq 0x7630
testq %rax, %rax
je 0xf23f
movq (%rax), %rax
jmp 0xf241
xorl %eax, %eax
testq %rax, %rax
je 0xf26b
movq (%rax), %rdi
callq 0x7430
testl %eax, %eax
je 0xf267
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_O1/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 0x4fcb(%rip), %rdx      # 0x1424f
callq 0x7630
testq %rax, %rax
je 0xf293
movq (%rax), %rax
jmp 0xf295
xorl %eax, %eax
testq %rax, %rax
jne 0xf2ad
leaq 0x5328(%rip), %rdx      # 0x145c9
movq %r14, %rdi
movl %ebx, %esi
callq 0x7260
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq