LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/icysunlight[P]miniftpd/hash.c
// Function: hashtable_del
int hashtable_del(hashtable_t* hash,void* key,int key_size)
{
     node_t* node = hashtable_get_node(hash,key,key_size);
     if ( NULL == node) 
     {
         fprintf(stderr,"key not exists.");
         return -1;
     }
     
     node->pprev->pnext = node->pnext;
     if ( node->pnext )
         node->pnext->pprev = node->pprev;
     free(node->key);
     free(node->val);
     free(node);
     return 0;
}

// Assembly:
pushq %rbx
callq 0x69d1
testq %rax, %rax
je 0x68e2
movq %rax, %rbx
movq 0x10(%rax), %rax
movq 0x18(%rbx), %rcx
movq %rax, 0x10(%rcx)
testq %rax, %rax
je 0x68c5
movq %rcx, 0x18(%rax)
movq (%rbx), %rdi
callq 0x3040
movq 0x8(%rbx), %rdi
callq 0x3040
movq %rbx, %rdi
callq 0x3040
xorl %eax, %eax
popq %rbx
retq
movq 0x470f(%rip), %rax      # 0xaff8
movq (%rax), %rcx
leaq 0x12d4(%rip), %rdi      # 0x7bc7
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
callq 0x3500
pushq $-0x1
popq %rax
jmp 0x68e0
// File: /workspace/github_c_makefile_star2_O2/icysunlight[P]miniftpd/hash.c
// Function: hashtable_destroy
void hashtable_destroy(hashtable_t** phash)
{
    int i = 0;
    hashtable_t* hash = *phash;
    while ( i < hash->buckets )
    {
        node_t* node= (hash->pnode)[i]->pnext;
        while ( NULL != node) 
        {
            node_t* tmp = node;
            node = node->pnext;
            free(tmp->key);
            free(tmp->val);
            free(tmp);
        }
        free(hash->pnode[i]);
        i++;
    } 
    free((hash->pnode));
    free(hash);
    *phash = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
xorl %r12d, %r12d
movslq (%r14), %rax
movq 0x10(%r14), %rdi
cmpq %rax, %r12
jge 0x6977
movq (%rdi,%r12,8), %rax
movq 0x10(%rax), %r15
testq %r15, %r15
je 0x6965
movq (%r15), %rdi
movq 0x10(%r15), %r13
callq 0x3040
movq 0x8(%r15), %rdi
callq 0x3040
movq %r15, %rdi
callq 0x3040
movq %r13, %r15
jmp 0x693e
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rdi
callq 0x3040
incq %r12
jmp 0x692a
callq 0x3040
movq %r14, %rdi
callq 0x3040
andq $0x0, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/icysunlight[P]miniftpd/hash.c
// Function: hashtable_getbucket
node_t* hashtable_getbucket(hashtable_t* hash,void* key)
{
    unsigned int nbucket = hash->hash_fun(key,hash->buckets);
    if ( nbucket > hash->buckets )
    {
        fprintf(stderr,"hash fun error.");
        return NULL;
    }
    return (hash->pnode)[nbucket];

}

// Assembly:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movl (%rdi), %esi
movq %rax, %rdi
callq *0x8(%rbx)
cmpl (%rbx), %eax
ja 0x69b1
movq 0x10(%rbx), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %rax
popq %rbx
retq
movq 0x4640(%rip), %rax      # 0xaff8
movq (%rax), %rcx
leaq 0x11e9(%rip), %rdi      # 0x7bab
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
callq 0x3500
xorl %eax, %eax
jmp 0x69af
// File: /workspace/github_c_makefile_star2_O2/icysunlight[P]miniftpd/test.c
// Function: printconf
int printconf()
{
    printf("listen address:%s\n",tunable_listen_address);
    printf("listen_port:%u\n",tunable_listen_port);
    printf("max_clients:%u\n",tunable_max_clients);
    printf("max_per_ip:%u\n",tunable_max_per_ip);
    printf("accept_timeout:%u\n",tunable_accept_timeout);
    printf("connect_timeout:%u\n",tunable_connect_timeout);
    printf("idle_session_timeout:%u\n",tunable_idle_session_timeout);
    printf("data_connection_timeout:%u\n",tunable_data_connection_timeout);
    printf("local_umask:%o\n",tunable_local_umask);
    printf("upload_max_rate:%u\n",tunable_upload_max_rate);
    printf("download_max_rate:%u\n",tunable_download_max_rate);
    printf("pasv_enable:%d\n",tunable_pasv_enable);
    printf("port_enable:%d\n",tunable_port_enable);
    return 0;
}

// Assembly:
pushq %rax
leaq 0x48fc(%rip), %rax      # 0xb318
movq (%rax), %rsi
leaq 0x11bb(%rip), %rdi      # 0x7be1
xorl %eax, %eax
callq 0x31c0
leaq 0x489c(%rip), %rax      # 0xb2d0
movl (%rax), %esi
leaq 0x11b7(%rip), %rdi      # 0x7bf4
xorl %eax, %eax
callq 0x31c0
leaq 0x4889(%rip), %rax      # 0xb2d4
movl (%rax), %esi
leaq 0x11b0(%rip), %rdi      # 0x7c04
xorl %eax, %eax
callq 0x31c0
leaq 0x4876(%rip), %rax      # 0xb2d8
movl (%rax), %esi
leaq 0x11a9(%rip), %rdi      # 0x7c14
xorl %eax, %eax
callq 0x31c0
leaq 0x4863(%rip), %rax      # 0xb2dc
movl (%rax), %esi
leaq 0x11a1(%rip), %rdi      # 0x7c23
xorl %eax, %eax
callq 0x31c0
leaq 0x4880(%rip), %rax      # 0xb310
movl (%rax), %esi
leaq 0x119d(%rip), %rdi      # 0x7c36
xorl %eax, %eax
callq 0x31c0
leaq 0x4839(%rip), %rax      # 0xb2e0
movl (%rax), %esi
leaq 0x119a(%rip), %rdi      # 0x7c4a
xorl %eax, %eax
callq 0x31c0
leaq 0x4826(%rip), %rax      # 0xb2e4
movl (%rax), %esi
leaq 0x119c(%rip), %rdi      # 0x7c63
xorl %eax, %eax
callq 0x31c0
leaq 0x4813(%rip), %rax      # 0xb2e8
movl (%rax), %esi
leaq 0x11a1(%rip), %rdi      # 0x7c7f
xorl %eax, %eax
callq 0x31c0
leaq 0x4800(%rip), %rax      # 0xb2ec
movl (%rax), %esi
leaq 0x119a(%rip), %rdi      # 0x7c8f
xorl %eax, %eax
callq 0x31c0
leaq 0x47ed(%rip), %rax      # 0xb2f0
movl (%rax), %esi
leaq 0x1197(%rip), %rdi      # 0x7ca3
xorl %eax, %eax
callq 0x31c0
leaq 0x47ae(%rip), %rax      # 0xb2c8
movl (%rax), %esi
leaq 0x1196(%rip), %rdi      # 0x7cb9
xorl %eax, %eax
callq 0x31c0
leaq 0x479b(%rip), %rax      # 0xb2cc
movl (%rax), %esi
leaq 0x118f(%rip), %rdi      # 0x7cc9
xorl %eax, %eax
callq 0x31c0
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/icysunlight[P]miniftpd/clntlmt.c
// Function: clntlmt_init
int clntlmt_init()
{
    clients = 0;
    hash_ip_clients = hashtable_init(2 * tunable_max_clients,hash_fun_limit);
    hash_pid_ip = hashtable_init(2 * tunable_max_clients,hash_fun_limit);
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
andl $0x0, 0x485d(%rip)      # 0xb3b0
leaq 0x477a(%rip), %r14      # 0xb2d4
movl (%r14), %edi
addl %edi, %edi
leaq 0x2d(%rip), %rbx        # 0x6b93
movq %rbx, %rsi
callq 0x673e
movq %rax, 0x4843(%rip)      # 0xb3b8
movl (%r14), %edi
addl %edi, %edi
movq %rbx, %rsi
callq 0x673e
movq %rax, 0x4837(%rip)      # 0xb3c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/icysunlight[P]miniftpd/clntlmt.c
// Function: clntlmt_destroy
int clntlmt_destroy()
{
    clients = 0;
    hashtable_destroy(&hash_ip_clients);
    hashtable_destroy(&hash_pid_ip);
    return 0;
}

// Assembly:
pushq %rax
andl $0x0, 0x480c(%rip)      # 0xb3b0
leaq 0x480d(%rip), %rdi      # 0xb3b8
callq 0x6918
leaq 0x4809(%rip), %rdi      # 0xb3c0
callq 0x6918
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/icysunlight[P]miniftpd/clntlmt.c
// Function: clntlmt_del
void clntlmt_del(pid_t pid)
{
    unsigned int* ip = hashtable_search(hash_pid_ip,&pid,sizeof(pid));
    int* ret = hashtable_search(hash_ip_clients,ip,sizeof(*ip));
    if ( 1 == *ret )
        hashtable_del(hash_ip_clients,ip,sizeof(*ip));
    else 
        *ret = *ret - 1;

    hashtable_del(hash_pid_ip,&pid,sizeof(pid));
    clients--;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x4(%rsp), %rsi
movl %edi, (%rsi)
movq 0x4771(%rip), %rdi      # 0xb3c0
pushq $0x4
popq %rbp
movl %ebp, %edx
callq 0x6903
movq %rax, %rbx
movq 0x4755(%rip), %rdi      # 0xb3b8
movq %rax, %rsi
movl %ebp, %edx
callq 0x6903
movl (%rax), %ecx
cmpl $0x1, %ecx
jne 0x6c88
movq 0x473d(%rip), %rdi      # 0xb3b8
pushq $0x4
popq %rdx
movq %rbx, %rsi
callq 0x68a2
jmp 0x6c8c
decl %ecx
movl %ecx, (%rax)
movq 0x472d(%rip), %rdi      # 0xb3c0
leaq 0x4(%rsp), %rsi
pushq $0x4
popq %rdx
callq 0x68a2
decl 0x470a(%rip)            # 0xb3b0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icysunlight[P]miniftpd/clntlmt.c
// Function: clntlmt_check
int clntlmt_check(unsigned int ip)
{
    if ( tunable_max_per_ip > 0 && clients_ip_get(ip) > tunable_max_per_ip)
    {
        return -1;
    }
    if ( tunable_max_clients > 0 && clients  > tunable_max_clients )
    {
        return -2;
    }
    return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x461f(%rip), %rbx      # 0xb2d8
cmpl $0x0, (%rbx)
je 0x6ce4
leaq 0xc(%rsp), %rsi
movl %edi, (%rsi)
movq 0x46ec(%rip), %rdi      # 0xb3b8
pushq $0x4
popq %rdx
callq 0x6903
testq %rax, %rax
je 0x6d0d
movl (%rax), %eax
cmpl (%rbx), %eax
jbe 0x6ce4
pushq $-0x1
popq %rax
jmp 0x6d07
leaq 0x45e9(%rip), %rax      # 0xb2d4
movl (%rax), %eax
testl %eax, %eax
sete %cl
cmpl %eax, 0x46b8(%rip)      # 0xb3b0
setbe %al
orb %cl, %al
movzbl %al, %eax
leal -0x2(,%rax,2), %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0xfc5(%rip), %rdi       # 0x7cd9
leaq 0xfca(%rip), %rsi       # 0x7ce5
leaq 0xfcd(%rip), %rcx       # 0x7cef
pushq $0x10
popq %rdx
callq 0x3210
// File: /workspace/github_c_makefile_star2_O2/YunyiQian[P]multitel3/./raytrace.c
// Function: model_input
int model_input(char *name,MODEL *m){
	FILE *fp;
	int error;
	int i,im1;

	if ( name==NULL ){
		fprintf(stderr,"No model name\n");
		return -1;
	}else{
		fp = fopen(name,"r");
		if ( fp == NULL ){
			fprintf(stderr,"Error in opening model file\n");
			return -1;
		}
	}

	fscanf(fp,"%d",&m->nlay);
	if ( m->nlay > MAXLAY ){
		fprintf(stderr,"Too many layers in model file\n");
		m->nlay = MAXLAY;
	}

	for (i=0;i<m->nlay;i++){
		fscanf(fp,"%lf%lf%lf%lf%lf%lf",&m->depth[i],&m->vp[i],&m->vs[i],&m->rou[i],&m->qp[i],&m->qs[i]);
	}
	
	fclose(fp);

	for (i=1,im1=0;i<m->nlay;i++,im1++){
		if (m->depth[i] < m->depth[im1]){
			fprintf(stderr,"Depth in model file is not correct\n");
			return -1;
		}
	}

	return m->nlay;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x135b
movq %rsi, %rbx
leaq 0x2f13(%rip), %rsi      # 0x4173
callq 0x10c0
testq %rax, %rax
je 0x1370
leaq 0x2f1d(%rip), %rsi      # 0x4192
movq %rax, -0x38(%rbp)
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1040
movl (%rbx), %eax
cmpl $0x3e9, %eax            # imm = 0x3E9
jge 0x1385
movl $0x9c48, %esi           # imm = 0x9C48
movl $0x7d08, %r12d          # imm = 0x7D08
movl $0x3e88, %r13d          # imm = 0x3E88
movl $0x1f48, %r15d          # imm = 0x1F48
pushq $0x8
popq %r14
movl $0x5dc8, %edx           # imm = 0x5DC8
xorl %r11d, %r11d
cltq
cmpq %rax, %r11
movq -0x38(%rbp), %rdi
jge 0x132a
movq %rdx, -0x30(%rbp)
movq -0x30(%rbp), %rax
leaq (%rbx,%rax), %rdx
leaq (%rbx,%r14), %rcx
leaq (%rbx,%r15), %r8
leaq (%rbx,%r13), %r9
leaq (%rbx,%r12), %r10
movq %r11, -0x40(%rbp)
leaq (%rbx,%rsi), %r11
movq %rsi, -0x48(%rbp)
leaq 0x2ec4(%rip), %rsi      # 0x41b4
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x1040
movq -0x40(%rbp), %r11
movq -0x30(%rbp), %rdx
movq -0x48(%rbp), %rsi
addq $0x10, %rsp
incq %r11
movl (%rbx), %eax
addq $0x8, %rsi
addq $0x8, %r12
addq $0x8, %r13
addq $0x8, %r15
addq $0x8, %r14
addq $0x8, %rdx
jmp 0x12b6
callq 0x1060
movl (%rbx), %eax
movslq %eax, %rcx
movl $0xbba, %edx            # imm = 0xBBA
leaq -0xbb9(%rdx), %rsi
cmpq %rcx, %rsi
jge 0x13d0
movsd -0x8(%rbx,%rdx,8), %xmm0
ucomisd (%rbx,%rdx,8), %xmm0
ja 0x13b1
incq %rdx
jmp 0x1339
movq 0x4c96(%rip), %rax      # 0x5ff8
movq (%rax), %rcx
leaq 0x2df8(%rip), %rdi      # 0x4164
pushq $0xe
jmp 0x13c4
movq 0x4c81(%rip), %rax      # 0x5ff8
movq (%rax), %rcx
leaq 0x2df4(%rip), %rdi      # 0x4175
pushq $0x1c
jmp 0x13c4
movq 0x4c6c(%rip), %rax      # 0x5ff8
movq (%rax), %rcx
leaq 0x2dff(%rip), %rdi      # 0x4195
pushq $0x1e
popq %rsi
pushq $0x1
popq %rdx
callq 0x1120
movl $0x3e8, (%rbx)          # imm = 0x3E8
movl $0x3e8, %eax            # imm = 0x3E8
jmp 0x1293
movq 0x4c40(%rip), %rax      # 0x5ff8
movq (%rax), %rcx
leaq 0x2e05(%rip), %rdi      # 0x41c7
pushq $0x23
popq %rsi
pushq $0x1
popq %rdx
callq 0x1120
pushq $-0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/YunyiQian[P]multitel3/./raytrace.c
// Function: model_init
void model_init(MODEL *m,double sdepth,int *ilay1,double rdepth,int *ilay2,int P){
	int i;
	
	if (sdepth < rdepth){
		*ilay1 = inslay(sdepth,m);
		*ilay2 = inslay(rdepth,m);
	}else{
		*ilay2 = inslay(rdepth,m);
		*ilay1 = inslay(sdepth,m);
	}
	if ( *ilay1 == -1 || *ilay2 == -1 ){
		fprintf(stderr,"Error in creating layer at given depth\n");
		exit (-1);
	}

	mhrv_interp(m,P);
	model_setcmb(m);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
ucomisd %xmm0, %xmm1
jbe 0x1426
movq %r14, %rdi
movsd %xmm1, -0x28(%rbp)
callq 0x1498
movl %eax, (%r12)
movsd -0x28(%rbp), %xmm0
movq %r14, %rdi
callq 0x1498
movl %eax, (%r15)
movl (%r12), %eax
jmp 0x144b
movsd %xmm0, -0x28(%rbp)
movapd %xmm1, %xmm0
movq %r14, %rdi
callq 0x1498
movl %eax, (%r15)
movsd -0x28(%rbp), %xmm0
movq %r14, %rdi
callq 0x1498
movl %eax, (%r12)
cmpl $-0x1, %eax
je 0x1474
cmpl $-0x1, (%r15)
je 0x1474
movq %r14, %rdi
movl %ebx, %esi
callq 0x16d2
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1946
movq 0x4b7d(%rip), %rax      # 0x5ff8
movq (%rax), %rcx
leaq 0x2d66(%rip), %rdi      # 0x41eb
pushq $0x27
popq %rsi
pushq $0x1
popq %rdx
callq 0x1120
pushq $-0x1
popq %rdi
callq 0x1110
// File: /workspace/github_c_makefile_star2_O2/YunyiQian[P]multitel3/./raytrace.c
// Function: model_setcmb
void model_setcmb(MODEL *m){
	int i;

	m->ncmb = -1;
	m->nicb = -1;
	for (i=1;i<m->nlay;i++){
		if (m->vs[i-1] < SMALL && m->vs[i] > SMALL){
			m->nicb = i;
			return;
		}
		if (m->vs[i-1] > SMALL && m->vs[i] < SMALL){
			m->ncmb = i;
		}
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
orq $-0x1, 0x13888(%rdi)
movslq (%rdi), %rcx
leaq 0x1f50(%rdi), %rdx
movabsq $0x1, %rax
movsd 0x272a(%rip), %xmm0     # 0x4098
cmpq %rcx, %rax
jge 0x19a9
movsd -0x8(%rdx), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1988
movsd (%rdx), %xmm2
ucomisd %xmm0, %xmm2
ja 0x19a3
ucomisd %xmm0, %xmm1
jbe 0x199a
ucomisd (%rdx), %xmm0
jbe 0x199a
movl %eax, 0x13888(%rdi)
incq %rax
addq $0x8, %rdx
jmp 0x196e
movl %eax, 0x1388c(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/advance.c
// Function: Get_advance
static int Get_advance(lua_State *L)
    {
    FT_Error ec;
    FT_Fixed advance;
    FT_Face *face = checkface(L, 1);
    FT_UInt glyph_index = checkindex(L, 2);
    FT_Int32 load_flags = checkflags(L, 3); // checkloadflags
    ec = FT_Get_Advance(*face, glyph_index, load_flags, &advance);
    CheckError(L, ec);
    lua_pushinteger(L, advance);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x7ac0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7340
movl %eax, %r15d
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq (%r14), %rdi
movq %rsp, %rcx
movl %r15d, %esi
movl %eax, %edx
callq 0x7470
testl %eax, %eax
je 0x7f09
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a70
movl %eax, %ebp
jmp 0x7f15
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/advance.c
// Function: Get_advances
static int Get_advances(lua_State *L)
    {
    FT_Error ec;
    FT_UInt i;
    FT_Fixed *padvance;
    FT_Face *face = checkface(L, 1);
    FT_UInt start = checkindex(L, 2); /* glyph_index */
    FT_UInt count = checkindex(L, 3);
    FT_Int32 load_flags = checkflags(L, 4); //checkloadflags
    if(count < 1)
        return luaL_argerror(L, 3, "positive number expected");
    padvance = (FT_Fixed*)Malloc(L, sizeof(FT_Fixed)*count);
    ec = FT_Get_Advances(*face, start, count, load_flags, padvance);
    if(ec) Free(L, padvance); /* CheckError() will return, so free the allocated memory */
    CheckError(L, ec);
    for(i=0; i<count; i++)
        lua_pushinteger(L, padvance[i]);
    Free(L, padvance);
    return count;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7ac0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7340
movl %eax, %r15d
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7340
movl %eax, %ebp
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x7780
testl %ebp, %ebp
je 0x7fc9
movq %rax, %r13
movl %ebp, %r12d
leaq (,%r12,8), %rsi
movq %rbx, %rdi
callq 0x7c20
movq %r14, %rcx
movq %rax, %r14
movq (%rcx), %rdi
movl %r15d, %esi
movl %ebp, %edx
movl %r13d, %ecx
movq %rax, %r8
callq 0x70d0
testl %eax, %eax
je 0x7fe9
movl %eax, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79f0
movl %r15d, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7a70
leaq 0x905b(%rip), %rdx      # 0x1102b
pushq $0x3
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7260
xorl %r15d, %r15d
cmpq %r15, %r12
je 0x8002
movq (%r14,%r15,8), %rsi
movq %rbx, %rdi
callq 0x7540
incq %r15
jmp 0x7fec
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79f0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/bitmap.c
// Function: moonfreetype_pushbitmap
int pushbitmap(lua_State *L, FT_Bitmap *bitmap, FT_Library library)
    {
    ud_t *ud = userdata(bitmap);
    if(ud)
        return udata_push(L, bitmap);
    /* create userdata for bitmap  owned by FreeType */
    DBG("created bitmap %p (on push)\n", (void*)bitmap);
    newuserdata(L, (void*)bitmap, BITMAP_MT);
    ud = userdata(bitmap);
    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 0x8097
movq %r15, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7180
leaq 0x8fb3(%rip), %rdi      # 0x11051
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x8fbf(%rip), %rdx      # 0x1106e
movq %r15, %rdi
movq %r14, %rsi
callq 0x72b0
movq %r14, %rdi
callq 0x7230
movq %rbx, 0x8(%rax)
andl $0x0, 0x18(%rax)
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/bitmap.c
// Function: moonfreetype_pushbitmapdata
int pushbitmapdata(lua_State *L, FT_Bitmap bitmap, FT_Int left, FT_Int top, int leftandtop)
/* pushes bitmap contents in a table */
    {
    size_t len; 
    lua_newtable(L);
    if(leftandtop)
        {
        lua_pushinteger(L, left);
        lua_setfield(L, -2, "left");
        lua_pushinteger(L, top);
        lua_setfield(L, -2, "top");
        }
    lua_pushinteger(L, bitmap.rows);
    lua_setfield(L, -2, "rows");
    lua_pushinteger(L, bitmap.width);
    lua_setfield(L, -2, "width");
    lua_pushinteger(L, bitmap.pitch);
    lua_setfield(L, -2, "pitch");
    pushpixelmode(L, bitmap.pixel_mode);
    lua_setfield(L, -2, "pixel_mode");
    if(bitmap.pixel_mode == FT_PIXEL_MODE_GRAY)
        {
        lua_pushinteger(L, bitmap.num_grays); 
        lua_setfield(L, -2, "num_grays");
        }
    len = bitmap.rows * (FT_ULong)bitmap.pitch; /* +/- buffer length */
    if(len)
        {
        len = len > 0 ? len : -len; /* pich may be negative */
        lua_pushlstring(L, (char*)bitmap.buffer, len);
        lua_setfield(L, -2, "buffer");
        }
    /* palette_mode: not used currently 
     * palette:      not used currently 
     */
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x40(%rsp), %r13
xorl %esi, %esi
xorl %edx, %edx
callq 0x73d0
testl %r15d, %r15d
je 0x813a
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0x951d(%rip), %rdx      # 0x1162b
pushq $-0x2
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x74f0
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0x8f53(%rip), %rdx      # 0x11082
movq %rbx, %rdi
movl %r14d, %esi
callq 0x74f0
movl (%r13), %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7540
leaq 0x8f36(%rip), %rdx      # 0x11086
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movl 0x4(%r13), %esi
movq %rbx, %rdi
callq 0x7540
leaq 0xaea6(%rip), %rdx      # 0x13016
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movslq 0x8(%r13), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7540
leaq 0x8efb(%rip), %rdx      # 0x1108b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movzbl 0x1a(%r13), %r12d
pushq $0xc
popq %rsi
movq %rbx, %rdi
movl %r12d, %edx
callq 0x7280
leaq 0x8edd(%rip), %rdx      # 0x11091
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
cmpl $0x2, %r12d
jne 0x81e3
movzwl 0x18(%r13), %esi
movq %rbx, %rdi
callq 0x7540
leaq 0x8ec4(%rip), %rdx      # 0x1109c
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x74f0
imulq %r14, %r15
testq %r15, %r15
je 0x820d
movq 0x10(%r13), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7970
leaq 0x8ea4(%rip), %rdx      # 0x110a6
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x74f0
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/bitmap.c
// Function: moonfreetype_freebitmap
int freebitmap(lua_State *L, FT_Bitmap *bitmap)
    {
    ud_t *ud = userdata(bitmap);
    FT_Library library = ud->library;
    int allocated = ud->allocated;
    if(!freeuserdata(L, bitmap))
        return 0; /* double call */
    DBG("deleting bitmap %p\n", (void*)bitmap);
    if(!allocated)
        return 0;
    FT_Bitmap_Done(library, bitmap);
    Free(L, bitmap);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x7230
movq 0x8(%rax), %r15
movl 0x18(%rax), %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7380
testl %eax, %eax
je 0x8275
leaq 0x8e5c(%rip), %rdi      # 0x110ad
movq %rbx, %rsi
xorl %eax, %eax
callq 0x7270
testl %ebp, %ebp
je 0x8275
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7560
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/bitmap.c
// Function: New_bitmap
static int New_bitmap(lua_State *L)
/* bitmap = new_bitmap(library) 
 */
    {
    ud_t *ud;
    FT_Library *library = checklibrary(L, 1);
    FT_Bitmap *bitmap = (FT_Bitmap*)Malloc(L, sizeof(FT_Bitmap));

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x76d0
movq %rax, %r14
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x7c20
movq %rax, %r12
movq %rax, %rdi
callq 0x75c0
leaq 0x8de4(%rip), %rdi      # 0x110e1
movq %r12, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x8d60(%rip), %rdx      # 0x1106e
movq %r15, %rdi
movq %r12, %rsi
callq 0x72b0
movq %r12, %rdi
callq 0x7230
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
movl $0x1, 0x18(%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/bitmap.c
// Function: Bitmap_copy
static int Bitmap_copy(lua_State *L)
    {
    FT_Error ec;
    ud_t *src_ud, *dst_ud;
    FT_Bitmap *src_bitmap = checkbitmap(L, 1);
    FT_Bitmap *dst_bitmap = checkbitmap(L, 2);
    src_ud = userdata(src_bitmap);
    dst_ud = userdata(dst_bitmap);
    //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, "bitmaps do not belong to the same library");
    ec = FT_Bitmap_Copy(src_ud->library, src_bitmap, dst_bitmap);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7110
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7110
movq %rax, %r15
movq %r14, %rdi
callq 0x7230
movq %rax, %r12
movq %r15, %rdi
callq 0x7230
movq 0x8(%r12), %rdi
cmpq 0x8(%rax), %rdi
je 0x83ab
leaq 0x8d4e(%rip), %rsi      # 0x110f4
movq %rbx, %rdi
jmp 0x83c7
movq %r14, %rsi
movq %r15, %rdx
callq 0x7420
testl %eax, %eax
je 0x83d9
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7a70
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/bitmap.c
// Function: Bitmap_convert
static int Bitmap_convert(lua_State *L)
    {
    FT_Error ec;
    ud_t *src_ud, *dst_ud;
    FT_Bitmap *src_bitmap = checkbitmap(L, 1);
    FT_Bitmap *dst_bitmap = checkbitmap(L, 2);
    FT_Int alignment = luaL_checkinteger(L, 3);
    src_ud = userdata(src_bitmap);
    dst_ud = userdata(dst_bitmap);
    //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, "bitmaps do not belong to the same library");
    ec = FT_Bitmap_Convert(src_ud->library, src_bitmap, dst_bitmap, alignment);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7110
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7110
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq %rax, %r12
movq %r14, %rdi
callq 0x7230
movq %rax, %r13
movq %r15, %rdi
callq 0x7230
movq 0x8(%r13), %rdi
cmpq 0x8(%rax), %rdi
je 0x8443
leaq 0x8cb6(%rip), %rsi      # 0x110f4
movq %rbx, %rdi
jmp 0x8462
movq %r14, %rsi
movq %r15, %rdx
movl %r12d, %ecx
callq 0x7930
testl %eax, %eax
je 0x8472
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7a70
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/bitmap.c
// Function: Bitmap_embolden
static int Bitmap_embolden(lua_State *L)
//@@ GlyphSlot_Own_Bitmap ?
    {
    FT_Error ec;
    FT_Bitmap *bitmap = checkbitmap(L, 1);
    FT_Pos xstrength = luaL_checkinteger(L, 2);
    FT_Pos ystrength = luaL_checkinteger(L, 3);
    ud_t *ud = userdata(bitmap);
    ec = FT_Bitmap_Embolden(ud->library, bitmap, xstrength, ystrength);
    CheckError(L, ec);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7110
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7780
movq %rax, %r12
movq %r14, %rdi
callq 0x7230
movq 0x8(%rax), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x7c50
testl %eax, %eax
je 0x84ed
movl %eax, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7a70
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/bitmap.c
// Function: Data
static int Data(lua_State *L)
/* bitmapdata = bitmap:data([left, top]) 
 * left and top default to 0 */
    {
    FT_Bitmap *bitmap = checkbitmap(L, 1);
    FT_Int left = luaL_optinteger(L, 2, 0);
    FT_Int top = luaL_optinteger(L, 3, 0);
    pushbitmapdata(L, *bitmap, left, top, 1);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x7110
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x7840
movq %rax, %r12
pushq $0x3
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x7840
movq 0x20(%r15), %rcx
movq %rcx, 0x20(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
movl %r12d, %esi
movl %eax, %edx
movl %ebx, %ecx
callq 0x7cf0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/charmap.c
// Function: moonfreetype_pushcharmap
int pushcharmap(lua_State *L, FT_CharMap map)
    {
    lua_newtable(L);
    pushencoding(L, map->encoding);
    lua_setfield(L, -2, "encoding");
    lua_pushinteger(L, map->platform_id);
    lua_setfield(L, -2, "platform_id");
    lua_pushinteger(L, map->encoding_id);
    lua_setfield(L, -2, "encoding_id");
    lua_pushstring(L, platformstring(map->platform_id));
    lua_setfield(L, -2, "platform_name");
    lua_pushstring(L, encodingstring(map->platform_id, map->encoding_id));
    lua_setfield(L, -2, "encoding_name");
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x73d0
movl 0x8(%r14), %edx
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x7280
leaq 0x8ce7(%rip), %rdx      # 0x1127c
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movzwl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0x7540
leaq 0x8ccf(%rip), %rdx      # 0x11285
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movzwl 0xe(%r14), %esi
movq %rbx, %rdi
callq 0x7540
leaq 0x8cbd(%rip), %rdx      # 0x11291
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movzwl 0xc(%r14), %edi
callq 0x7af0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7cb0
leaq 0x8ca3(%rip), %rdx      # 0x1129d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movzwl 0xc(%r14), %edi
movzwl 0xe(%r14), %esi
callq 0x7920
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7cb0
leaq 0x8c86(%rip), %rdx      # 0x112ab
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/charmap.c
// Function: moonfreetype_encodingstring
const char* encodingstring(unsigned int platform_id, unsigned int id)
    {
    switch(platform_id)
        {
        case TT_PLATFORM_APPLE_UNICODE: return encodingstring_apple(id);
        case TT_PLATFORM_MACINTOSH: return encodingstring_macintosh(id);
        case TT_PLATFORM_ISO: return encodingstring_iso(id);
        case TT_PLATFORM_MICROSOFT: return encodingstring_microsoft(id);
        case TT_PLATFORM_CUSTOM: return encodingstring_custom(id);
        case TT_PLATFORM_ADOBE: return encodingstring_adobe(id);
        default:
            return "unknown platform id";
        }
    return NULL; /* unreachable */
    }

// Assembly:
leaq 0x8c89(%rip), %rax      # 0x112e5
cmpl $0x7, %edi
ja 0x86ca
movl %edi, %ecx
leaq 0x8af2(%rip), %rdx      # 0x1115c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
cmpl $0x6, %esi
jae 0x86cb
movl %esi, %eax
leaq 0x8b1b(%rip), %rcx      # 0x1119c
jmp 0x86c3
decl %esi
cmpl $0x20, %esi
jae 0x86d3
movl %esi, %eax
leaq 0x8b21(%rip), %rcx      # 0x111b4
jmp 0x86c3
cmpl $0x4, %esi
jae 0x86cb
movl %esi, %eax
leaq 0x8bc9(%rip), %rcx      # 0x1126c
jmp 0x86c3
cmpl $0x3, %esi
jae 0x86cb
movl %esi, %eax
leaq 0x8b81(%rip), %rcx      # 0x11234
jmp 0x86c3
cmpl $0xb, %esi
jae 0x86cb
movl %esi, %eax
leaq 0x8b7d(%rip), %rcx      # 0x11240
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x8c65(%rip), %rax      # 0x11337
retq
leaq 0x9384(%rip), %rax      # 0x11a5e
retq
nop
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/computations.c
// Function: moonfreetype_checkvector
int checkvector(lua_State *L, int arg, FT_Vector *dst)
    {
    if(!lua_istable(L, arg))
        return luaL_argerror(L, arg, "table expected");
    lua_getfield(L, arg, "x"); dst->x = luaL_checkinteger(L, -1); lua_pop(L, 1);
    lua_getfield(L, arg, "y"); dst->y = luaL_checkinteger(L, -1); lua_pop(L, 1);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x7c10
cmpl $0x5, %eax
jne 0x875f
leaq 0xac99(%rip), %rdx      # 0x13396
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d50
pushq $-0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7780
movq %rax, (%r14)
pushq $-0x2
popq %r12
movq %rbx, %rdi
movl %r12d, %esi
callq 0x70b0
leaq 0xac6f(%rip), %rdx      # 0x1339e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d50
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7780
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x70b0
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8d3e(%rip), %rdx      # 0x114a4
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/computations.c
// Function: moonfreetype_pushvector
int pushvector(lua_State *L, FT_Vector vector)
    {
    lua_newtable(L);
    lua_pushinteger(L, vector.x);
    lua_setfield(L, -2, "x");
    lua_pushinteger(L, vector.y);
    lua_setfield(L, -2, "y");
    return 1;   
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %esi, %esi
xorl %edx, %edx
callq 0x73d0
movq %r15, %rdi
movq %r14, %rsi
callq 0x7540
leaq 0xabf3(%rip), %rdx      # 0x13396
pushq $-0x2
popq %rbp
movq %r15, %rdi
movl %ebp, %esi
callq 0x74f0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7540
leaq 0xabdc(%rip), %rdx      # 0x1339e
movq %r15, %rdi
movl %ebp, %esi
callq 0x74f0
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/computations.c
// Function: moonfreetype_checkmatrix
int checkmatrix(lua_State *L, int arg, FT_Matrix *dst)
    {
    if(!lua_istable(L, arg))
        return luaL_argerror(L, arg, "table expected");
    lua_getfield(L, arg, "xx"); dst->xx = luaL_checkinteger(L, -1); lua_pop(L, 1);
    lua_getfield(L, arg, "xy"); dst->xy = luaL_checkinteger(L, -1); lua_pop(L, 1);
    lua_getfield(L, arg, "yx"); dst->yx = luaL_checkinteger(L, -1); lua_pop(L, 1);
    lua_getfield(L, arg, "yy"); dst->yy = luaL_checkinteger(L, -1); lua_pop(L, 1);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x7c10
cmpl $0x5, %eax
jne 0x88b6
leaq 0x8cb4(%rip), %rdx      # 0x114b3
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d50
pushq $-0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7780
movq %rax, (%r14)
pushq $-0x2
popq %r12
movq %rbx, %rdi
movl %r12d, %esi
callq 0x70b0
leaq 0xac7e(%rip), %rdx      # 0x134af
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d50
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7780
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x70b0
leaq 0x8c5a(%rip), %rdx      # 0x114b6
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d50
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7780
movq %rax, 0x10(%r14)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x70b0
leaq 0x8c32(%rip), %rdx      # 0x114b9
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d50
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7780
movq %rax, 0x18(%r14)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x70b0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8be7(%rip), %rdx      # 0x114a4
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/computations.c
// Function: moonfreetype_pushmatrix
int pushmatrix(lua_State *L, FT_Matrix matrix)
    {
    lua_newtable(L);
    lua_pushinteger(L, matrix.xx);
    lua_setfield(L, -2, "xx");
    lua_pushinteger(L, matrix.xy);
    lua_setfield(L, -2, "xy");
    lua_pushinteger(L, matrix.yx);
    lua_setfield(L, -2, "yx");
    lua_pushinteger(L, matrix.yy);
    lua_setfield(L, -2, "yy");
    return 1;   
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x73d0
movq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0x8bc1(%rip), %rdx      # 0x114b3
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0xab9c(%rip), %rdx      # 0x134af
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0x8b85(%rip), %rdx      # 0x114b6
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
movq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x7540
leaq 0x8b6a(%rip), %rdx      # 0x114b9
movq %rbx, %rdi
movl %ebp, %esi
callq 0x74f0
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/computations.c
// Function: Muldiv
static int Muldiv(lua_State *L)
    {
    FT_Long a = luaL_checkinteger(L, 1);
    FT_Long b = luaL_checkinteger(L, 2);
    FT_Long c = luaL_checkinteger(L, 3);
    lua_pushinteger(L, FT_MulDiv(a, b, c));
    return 1;
    }

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rbp
leaq 0x8(%rsp), %r14
movl %ebp, %esi
movq %r14, %rdx
callq 0x7740
pushq $0x2
popq %rsi
leaq 0x18(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7d80
movq %r14, %rdi
movq %r15, %rsi
callq 0x7b70
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x7bb0
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/computations.c
// Function: Matrix_multiply
static int Matrix_multiply(lua_State *L)
    {
    FT_Matrix a;
    FT_Matrix b;
    checkmatrix(L, 1, &a);
    checkmatrix(L, 1, &b);
    FT_Matrix_Multiply(&a, &b);
    return pushmatrix(L, b);
    }

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

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x7630
movq %rax, %r14
leaq 0x8c4b(%rip), %rsi      # 0x13943
movq %rax, %rdi
callq 0x7710
testl %eax, %eax
je 0xae0e
leaq 0x8815(%rip), %rsi      # 0x13524
movq %r14, %rdi
callq 0x7710
movl %ebp, %esi
testl %eax, %eax
je 0xae39
leaq 0x6e67(%rip), %rsi      # 0x11b8f
movq %r14, %rdi
callq 0x7710
testl %eax, %eax
je 0xae12
leaq 0x6e5e(%rip), %rsi      # 0x11b9d
movq %r14, %rdi
callq 0x7710
testl %eax, %eax
je 0xae16
leaq 0x6e57(%rip), %rsi      # 0x11bad
movq %r14, %rdi
callq 0x7710
testl %eax, %eax
je 0xae1a
leaq 0x6e4f(%rip), %rsi      # 0x11bbc
movq %r14, %rdi
callq 0x7710
testl %eax, %eax
je 0xae1e
leaq 0x6e46(%rip), %rsi      # 0x11bca
movq %r14, %rdi
callq 0x7710
testl %eax, %eax
je 0xae22
leaq 0x6e42(%rip), %rsi      # 0x11bdd
movq %r14, %rdi
callq 0x7710
testl %eax, %eax
je 0xae26
leaq 0x6e3f(%rip), %rsi      # 0x11bed
movq %r14, %rdi
callq 0x7710
testl %eax, %eax
je 0xae2a
leaq 0x6e38(%rip), %rsi      # 0x11bf9
movq %r14, %rdi
callq 0x7710
testl %eax, %eax
je 0xae2e
leaq 0x64a8(%rip), %rsi      # 0x1127c
movq %r14, %rdi
callq 0x7710
testl %eax, %eax
je 0xae32
leaq 0x6e1d(%rip), %rsi      # 0x11c04
movq %r14, %rdi
callq 0x7710
testl %eax, %eax
je 0xae36
leaq 0x6e16(%rip), %rsi      # 0x11c10
movq %r14, %rdi
callq 0x7710
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0xae43
pushq $0xc
jmp 0xae38
pushq $0x65
jmp 0xae38
pushq $0x2
jmp 0xae38
pushq $0x3
jmp 0xae38
pushq $0x4
jmp 0xae38
pushq $0x5
jmp 0xae38
pushq $0x6
jmp 0xae38
pushq $0x7
jmp 0xae38
pushq $0x8
jmp 0xae38
pushq $0x9
jmp 0xae38
pushq $0xa
jmp 0xae38
pushq $0xb
popq %rsi
movq %rbx, %rdi
callq 0x78d0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonfreetype/src/face.c
// Function: moonfreetype_newface
int newface(lua_State *L)
/* face = new_face(filepathname [, index=0 [, instance=0]]) */
    {
    FT_Error ec;
    ud_t *ud;
    FT_Library *library = checklibrary(L, 1);
    const char* filepathname = luaL_checkstring(L, 2);
    FT_Long index = luaL_optinteger(L, 3, 0);
    FT_Long instance = luaL_optinteger(L, 3, 0);
    FT_Face *face = (FT_Face*)Malloc(L, sizeof(FT_Face));
    FT_Long face_index = ((instance & 0x00007fff) << 16) | (index & 0x0000ffff);
    

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x76d0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7630
movq %rax, %r12
pushq $0x3
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x7840
movq %rax, %r13
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x7840
movq %rax, %rbp
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x7c20
movq %rax, %r15
shll $0x10, %ebp
andl $0x7fff0000, %ebp       # imm = 0x7FFF0000
movzwl %r13w, %edx
orq %rbp, %rdx
movq (%r14), %rdi
movq %r12, %rsi
movq %rax, %rcx
callq 0x74c0
movl %eax, %ebp
leaq 0x77f0(%rip), %rdi      # 0x1274f
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x7270
leaq 0x8210(%rip), %rdi      # 0x13183
movl %ebp, %esi
xorl %eax, %eax
callq 0x7270
testl %ebp, %ebp
je 0xafad
movq %rbx, %rdi
movq %r15, %rsi
callq 0x79f0
movl %ebp, %edi
callq 0x7d30
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7a70
movq (%r15), %rax
movq 0x98(%rax), %rsi
leaq 0x77a5(%rip), %rdi      # 0x12763
xorl %eax, %eax
callq 0x7270
leaq 0x6034(%rip), %rdx      # 0x11000
movq %rbx, %rdi
movq %r15, %rsi
callq 0x72b0
movq %r15, %rdi
callq 0x7230
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq