LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/icysunlight[P]miniftpd/hash.c
// Function: hash_test
void hash_test()
{
    stu_t stu[3] = {
        {"aaa","12345"},
        {"bbb","dadad"},
        {"ccc","xxxxx"},
    };

    hashtable_t* hash = hashtable_init(5,hash_fun);
    int i = 0;
    for ( i = 0 ; i < 3 ; ++i)
    {
        hashtable_add(hash,stu[i].name,strlen(stu[i].name),stu[i].school,strlen(stu[i].name));
    }

    hashtable_del(hash,"aaa",strlen("aaa"));
    hashtable_add(hash,stu[0].name,strlen(stu[0].name),stu[0].school,strlen(stu[0].name));


    char *str = hashtable_search(hash,"aaa",3);
    if  ( NULL == str )
        printf("not fount\n");
    else
        printf("name:\"aaa\",school:%s\n",str);


    hashtable_destroy(&hash);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x149(%rip), %rsi       # 0x6ca1
movl $0x5, %edi
callq 0x6c2b
movq %rax, %rbx
movq %rax, 0x8(%rsp)
movl $0x8, %r12d
leaq 0x5239(%rip), %r13      # 0xbdb0
movq -0x8(%r12,%r13), %r14
movq (%r12,%r13), %r15
movq %r14, %rdi
callq 0x3180
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %r15, %rcx
movl %eax, %r8d
callq 0x6cd0
addq $0x10, %r12
cmpq $0x38, %r12
jne 0x6b77
leaq 0x1fcb(%rip), %r14      # 0x8b77
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq 0x6d8f
leaq 0x1fb8(%rip), %rcx      # 0x8b7b
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %edx
movl $0x3, %r8d
callq 0x6cd0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq 0x6ea0
testq %rax, %rax
je 0x6c07
movq 0x8(%rax), %rsi
testq %rsi, %rsi
je 0x6c07
leaq 0x1f97(%rip), %rdi      # 0x8b95
xorl %eax, %eax
callq 0x31c0
jmp 0x6c13
leaq 0x1fc9(%rip), %rdi      # 0x8bd7
callq 0x30c0
leaq 0x8(%rsp), %rdi
callq 0x6df0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icysunlight[P]miniftpd/hash.c
// Function: hashtable_init
hashtable_t* hashtable_init(int buckets,hash_fun_t hash_fun)
{
    hashtable_t* hash = (hashtable_t*)malloc(sizeof(hashtable_t));

    int size = buckets * sizeof(node_t*);
    hash->pnode = (node_t**)malloc(size);
    hash->buckets = buckets;
    hash->hash_fun = hash_fun;
    memset(hash->pnode,0,size);

    int i = 0;
    while ( i < buckets )
    {
        (hash->pnode[i]) = (node_t*)malloc(sizeof(node_t));
        (hash->pnode[i])->pnext = NULL;
        i++;
    } 

    return hash;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movl %edi, %r15d
movl $0x18, %edi
callq 0x33a0
movq %rax, %rbx
leal (,%r15,8), %eax
movslq %eax, %rsi
movl $0x1, %edi
callq 0x32c0
movq %rax, 0x10(%rbx)
movl %r15d, (%rbx)
movq %r12, 0x8(%rbx)
testl %r15d, %r15d
jle 0x6c92
movq %rax, %r14
movl %r15d, %r15d
xorl %r12d, %r12d
movl $0x20, %edi
callq 0x33a0
movq %rax, (%r14,%r12,8)
movq $0x0, 0x10(%rax)
incq %r12
cmpq %r12, %r15
jne 0x6c74
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icysunlight[P]miniftpd/hash.c
// Function: hash_fun
unsigned int static hash_fun(void* key,int hash_size)
{
    unsigned int hash = 0;
    char* str = key;

    while ( *str ) 
    {
        hash = (*str++) + (hash << 6) + (hash << 16) -hash;
    }

    return (hash & 0x7FFFFFFF) % hash_size;
        
}

// Assembly:
movb (%rdi), %cl
testb %cl, %cl
je 0x6cc7
incq %rdi
xorl %eax, %eax
movsbl %cl, %ecx
imull $0x1003f, %eax, %eax    # imm = 0x1003F
addl %ecx, %eax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x6cac
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
jmp 0x6cc9
xorl %eax, %eax
xorl %edx, %edx
divl %esi
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/icysunlight[P]miniftpd/hash.c
// Function: hashtable_add
int hashtable_add(hashtable_t* hash,void* key,int key_size,void* val,int val_size)
{
     if  ( NULL != hashtable_get_node(hash,key,key_size)) 
     {
         fprintf(stderr,"key exists.");
         return -1;
     }

     node_t* node = hashtable_getbucket(hash,key);
     node_t* toadd = (node_t*)malloc(sizeof(node_t));
     toadd->key = (void*)malloc(key_size);
     toadd->val = (void*)malloc(val_size);
     toadd->pnext = NULL;
     memcpy(toadd->key,key,key_size);
     memcpy(toadd->val,val,val_size);

     toadd->pnext = node->pnext;
     toadd->pprev = node;
     node->pnext = toadd;
     if ( toadd->pnext )
         toadd->pnext->pprev = toadd;
     
     return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %rbx
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %r15
callq 0x6ea0
testq %rax, %rax
jne 0x6d83
movq %r15, %rdi
movq %r14, %rsi
callq 0x6e78
movq %rax, %r12
movl $0x20, %edi
callq 0x33a0
movq %rax, %r15
movslq %r13d, %r13
movq %r13, %rdi
callq 0x33a0
movq %rbx, (%rsp)
movq %rax, %rbx
movq %rax, (%r15)
movslq %ebp, %rbp
movq %rbp, %rdi
callq 0x33a0
movq %r14, %rsi
movq %rax, %r14
movq %rax, 0x8(%r15)
movq %rbx, %rdi
movq %r13, %rdx
callq 0x3350
movq %r14, %rdi
movq (%rsp), %rsi
movq %rbp, %rdx
callq 0x3350
movq 0x10(%r12), %rcx
movq %rcx, 0x10(%r15)
movq %r12, 0x18(%r15)
movq %r15, 0x10(%r12)
xorl %eax, %eax
testq %rcx, %rcx
je 0x6d74
movq %r15, 0x18(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x38be
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x6d74
// File: /workspace/github_c_makefile_star2_O3/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 0x6ea0
testq %rax, %rax
je 0x6dcf
movq %rax, %rbx
movq 0x10(%rax), %rax
movq 0x18(%rbx), %rcx
movq %rax, 0x10(%rcx)
testq %rax, %rax
je 0x6db2
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
callq 0x38da
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x6dcd
// File: /workspace/github_c_makefile_star2_O3/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
cmpl $0x0, (%r14)
jle 0x6e56
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rdi
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x6e46
movq (%r15), %rdi
movq 0x10(%r15), %r13
callq 0x3040
movq 0x8(%r15), %rdi
callq 0x3040
movq %r15, %rdi
callq 0x3040
movq %r13, %r15
testq %r13, %r13
jne 0x6e19
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rdi
callq 0x3040
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x6e08
movq 0x10(%r14), %rdi
callq 0x3040
movq %r14, %rdi
callq 0x3040
movq $0x0, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6e97
movq 0x10(%rbx), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %rax
popq %rbx
retq
callq 0x38f6
xorl %eax, %eax
jmp 0x6e95
// File: /workspace/github_c_makefile_star2_O3/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 0x5430(%rip), %rax      # 0xc318
movq (%rax), %rsi
leaq 0x1cef(%rip), %rdi      # 0x8be1
xorl %eax, %eax
callq 0x31c0
leaq 0x53d0(%rip), %rax      # 0xc2d0
movl (%rax), %esi
leaq 0x1ceb(%rip), %rdi      # 0x8bf4
xorl %eax, %eax
callq 0x31c0
leaq 0x53bd(%rip), %rax      # 0xc2d4
movl (%rax), %esi
leaq 0x1ce4(%rip), %rdi      # 0x8c04
xorl %eax, %eax
callq 0x31c0
leaq 0x53aa(%rip), %rax      # 0xc2d8
movl (%rax), %esi
leaq 0x1cdd(%rip), %rdi      # 0x8c14
xorl %eax, %eax
callq 0x31c0
leaq 0x5397(%rip), %rax      # 0xc2dc
movl (%rax), %esi
leaq 0x1cd5(%rip), %rdi      # 0x8c23
xorl %eax, %eax
callq 0x31c0
leaq 0x53b4(%rip), %rax      # 0xc310
movl (%rax), %esi
leaq 0x1cd1(%rip), %rdi      # 0x8c36
xorl %eax, %eax
callq 0x31c0
leaq 0x536d(%rip), %rax      # 0xc2e0
movl (%rax), %esi
leaq 0x1cce(%rip), %rdi      # 0x8c4a
xorl %eax, %eax
callq 0x31c0
leaq 0x535a(%rip), %rax      # 0xc2e4
movl (%rax), %esi
leaq 0x1cd0(%rip), %rdi      # 0x8c63
xorl %eax, %eax
callq 0x31c0
leaq 0x5347(%rip), %rax      # 0xc2e8
movl (%rax), %esi
leaq 0x1cd5(%rip), %rdi      # 0x8c7f
xorl %eax, %eax
callq 0x31c0
leaq 0x5334(%rip), %rax      # 0xc2ec
movl (%rax), %esi
leaq 0x1cce(%rip), %rdi      # 0x8c8f
xorl %eax, %eax
callq 0x31c0
leaq 0x5321(%rip), %rax      # 0xc2f0
movl (%rax), %esi
leaq 0x1ccb(%rip), %rdi      # 0x8ca3
xorl %eax, %eax
callq 0x31c0
leaq 0x52e2(%rip), %rax      # 0xc2c8
movl (%rax), %esi
leaq 0x1cca(%rip), %rdi      # 0x8cb9
xorl %eax, %eax
callq 0x31c0
leaq 0x52cf(%rip), %rax      # 0xc2cc
movl (%rax), %esi
leaq 0x1cc3(%rip), %rdi      # 0x8cc9
xorl %eax, %eax
callq 0x31c0
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x0, 0x538e(%rip)      # 0xc3b0
leaq 0x52ab(%rip), %r14      # 0xc2d4
movl (%r14), %edi
addl %edi, %edi
leaq 0x2d(%rip), %rbx        # 0x7062
movq %rbx, %rsi
callq 0x6c2b
movq %rax, 0x5374(%rip)      # 0xc3b8
movl (%r14), %edi
addl %edi, %edi
movq %rbx, %rsi
callq 0x6c2b
movq %rax, 0x5368(%rip)      # 0xc3c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x0, 0x533a(%rip)      # 0xc3b0
leaq 0x533b(%rip), %rdi      # 0xc3b8
callq 0x6df0
leaq 0x5337(%rip), %rdi      # 0xc3c0
callq 0x6df0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rsi
movl %edi, (%rsi)
movq 0x5299(%rip), %rdi      # 0xc3c0
movl $0x4, %edx
callq 0x6ddb
movq %rax, %rbx
movq 0x527d(%rip), %rdi      # 0xc3b8
movq %rax, %rsi
movl $0x4, %edx
callq 0x6ddb
movl (%rax), %ecx
cmpl $0x1, %ecx
jne 0x7165
movq 0x5262(%rip), %rdi      # 0xc3b8
movq %rbx, %rsi
movl $0x4, %edx
callq 0x6d8f
jmp 0x7169
decl %ecx
movl %ecx, (%rax)
movq 0x5250(%rip), %rdi      # 0xc3c0
leaq 0xc(%rsp), %rsi
movl $0x4, %edx
callq 0x6d8f
decl 0x522b(%rip)            # 0xc3b0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5141(%rip), %rbx      # 0xc2d8
cmpl $0x0, (%rbx)
je 0x71c4
leaq 0xc(%rsp), %rsi
movl %edi, (%rsi)
movq 0x520e(%rip), %rdi      # 0xc3b8
movl $0x4, %edx
callq 0x6ddb
testq %rax, %rax
je 0x71ed
movl (%rax), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl (%rbx), %ecx
ja 0x71e7
leaq 0x5109(%rip), %rax      # 0xc2d4
movl (%rax), %eax
testl %eax, %eax
sete %cl
cmpl %eax, 0x51d8(%rip)      # 0xc3b0
setbe %al
orb %cl, %al
movzbl %al, %eax
leal -0x2(,%rax,2), %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1ae5(%rip), %rdi      # 0x8cd9
leaq 0x1aea(%rip), %rsi      # 0x8ce5
leaq 0x1aed(%rip), %rcx      # 0x8cef
movl $0x10, %edx
callq 0x3210
// File: /workspace/github_c_makefile_star2_O3/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 0x1645
movq %rsi, %rbx
leaq 0x2c43(%rip), %rsi      # 0x4173
callq 0x10c0
testq %rax, %rax
je 0x164c
leaq 0x2c4d(%rip), %rsi      # 0x4192
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1040
movl (%rbx), %eax
cmpl $0x3e9, %eax            # imm = 0x3E9
jge 0x1653
testl %eax, %eax
movq %rbx, %rsi
jle 0x160d
movl $0x9c48, %r14d          # imm = 0x9C48
movl $0x7d08, %ebx           # imm = 0x7D08
movl $0x3e88, %ecx           # imm = 0x3E88
movl $0x1f48, %edx           # imm = 0x1F48
movl $0x8, %r8d
movl $0x5dc8, %r12d          # imm = 0x5DC8
xorl %r13d, %r13d
movq %rsi, -0x40(%rbp)
movq %r8, -0x48(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
leaq (%rsi,%r12), %rdx
leaq (%rsi,%r8), %rcx
movq -0x30(%rbp), %rax
leaq (%rsi,%rax), %r8
movq -0x38(%rbp), %rax
leaq (%rsi,%rax), %r9
leaq (%rsi,%rbx), %r10
leaq (%rsi,%r14), %r11
movq %r15, %rdi
leaq 0x2be9(%rip), %rsi      # 0x41b4
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x1040
movq -0x48(%rbp), %r8
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rsi
addq $0x10, %rsp
incq %r13
movslq (%rsi), %rax
addq $0x8, %r14
addq $0x8, %rbx
addq $0x8, %rcx
addq $0x8, %rdx
addq $0x8, %r8
addq $0x8, %r12
cmpq %rax, %r13
jl 0x1595
movq %r15, %rdi
movq %rsi, %rbx
callq 0x1060
movl (%rbx), %eax
cmpl $0x2, %eax
jl 0x166d
movq %rbx, %rsi
leal -0x1(%rax), %ecx
xorl %edx, %edx
movsd 0x5dc8(%rsi,%rdx,8), %xmm0
ucomisd 0x5dd0(%rsi,%rdx,8), %xmm0
ja 0x1663
incq %rdx
cmpq %rdx, %rcx
jne 0x1627
jmp 0x166d
callq 0x11e0
jmp 0x1668
callq 0x11b1
jmp 0x1668
movq %rbx, %rdi
callq 0x1150
movq %rbx, %rsi
jmp 0x156d
callq 0x1182
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x16c3
movq %r14, %rdi
movsd %xmm1, -0x28(%rbp)
callq 0x1716
movl %eax, (%r12)
movsd -0x28(%rbp), %xmm0
movq %r14, %rdi
callq 0x1716
movl %eax, (%r15)
movl (%r12), %eax
jmp 0x16e8
movsd %xmm0, -0x28(%rbp)
movapd %xmm1, %xmm0
movq %r14, %rdi
callq 0x1716
movl %eax, (%r15)
movsd -0x28(%rbp), %xmm0
movq %r14, %rdi
callq 0x1716
movl %eax, (%r12)
cmpl $-0x1, %eax
je 0x1711
cmpl $-0x1, (%r15)
je 0x1711
movq %r14, %rdi
movl %ebx, %esi
callq 0x1937
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1bd9
callq 0x120f
// File: /workspace/github_c_makefile_star2_O3/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:
movq $-0x1, 0x13888(%rdi)
movslq (%rdi), %rax
cmpq $0x2, %rax
jl 0x1c49
pushq %rbp
movq %rsp, %rbp
decq %rax
xorl %ecx, %ecx
movsd 0x249a(%rip), %xmm0     # 0x4098
movsd 0x1f48(%rdi,%rcx,8), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1c1c
movsd 0x1f50(%rdi,%rcx,8), %xmm2
ucomisd %xmm0, %xmm2
ja 0x1c40
ucomisd %xmm0, %xmm1
jbe 0x1c36
ucomisd 0x1f50(%rdi,%rcx,8), %xmm0
jbe 0x1c36
leal 0x1(%rcx), %edx
movl %edx, 0x13888(%rdi)
incq %rcx
cmpq %rcx, %rax
jne 0x1bfe
jmp 0x1c48
incl %ecx
movl %ecx, 0x1388c(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/bitmap.c
// Function: moonfreetype_checkbitmap
FT_Bitmap* checkbitmap(lua_State *L, int arg)
    {
    FT_Bitmap *p = testbitmap(L, arg);
    if(p) return p;
    luaL_argerror(L, arg, "not a bitmap");
    return NULL;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0xa04e(%rip), %rdx      # 0x1206e
callq 0x7630
testq %rax, %rax
je 0x8032
movq (%rax), %rax
testq %rax, %rax
jne 0x8045
leaq 0xa00b(%rip), %rdx      # 0x12044
movq %r14, %rdi
movl %ebx, %esi
callq 0x7260
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/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 0x8078
movq %r15, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7180
leaq 0x9fd2(%rip), %rdi      # 0x12051
movq %r14, %rsi
xorl %eax, %eax
callq 0x7270
leaq 0x9fde(%rip), %rdx      # 0x1206e
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_O3/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 %r12
pushq %rbx
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x30(%rsp), %r12
xorl %esi, %esi
xorl %edx, %edx
callq 0x73c0
testl %r15d, %r15d
je 0x811d
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0xa51a(%rip), %rdx      # 0x1260b
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x9f72(%rip), %rdx      # 0x12082
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movl (%r12), %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7530
leaq 0x9f53(%rip), %rdx      # 0x12086
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movl 0x4(%r12), %esi
movq %rbx, %rdi
callq 0x7530
leaq 0xbea2(%rip), %rdx      # 0x13ff6
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movslq 0x8(%r12), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7530
leaq 0x9f13(%rip), %rdx      # 0x1208b
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movzbl 0x1a(%r12), %ebp
movq %rbx, %rdi
movl $0xc, %esi
movl %ebp, %edx
callq 0x7280
leaq 0x9ef0(%rip), %rdx      # 0x12091
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
cmpl $0x2, %ebp
jne 0x81d5
movzwl 0x18(%r12), %esi
movq %rbx, %rdi
callq 0x7530
leaq 0x9ed4(%rip), %rdx      # 0x1209c
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
imulq %r14, %r15
testq %r15, %r15
je 0x8202
movq 0x10(%r12), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7960
leaq 0x9eb1(%rip), %rdx      # 0x120a6
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7370
testl %eax, %eax
je 0x8266
leaq 0x9e6b(%rip), %rdi      # 0x120ad
movq %rbx, %rsi
xorl %eax, %eax
callq 0x7270
testl %ebp, %ebp
je 0x8266
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7550
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/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
movl $0x1, %esi
callq 0x7110
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 0x83aa
leaq 0x9d4f(%rip), %rsi      # 0x120f4
movq %rbx, %rdi
jmp 0x83c6
movq %r14, %rsi
movq %r15, %rdx
callq 0x7410
testl %eax, %eax
je 0x83d8
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7a60
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/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
movl $0x1, %esi
callq 0x7110
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7110
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7770
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 0x8448
leaq 0x9cb1(%rip), %rsi      # 0x120f4
movq %rbx, %rdi
jmp 0x8467
movq %r14, %rsi
movq %r15, %rdx
movl %r12d, %ecx
callq 0x7920
testl %eax, %eax
je 0x8477
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7a60
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x7110
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7770
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7770
movq %rax, %r12
movq %r14, %rdi
callq 0x7230
movq 0x8(%rax), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x7c30
testl %eax, %eax
je 0x84f8
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7a60
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/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 %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7110
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x7830
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x7830
movq 0x20(%r14), %rcx
movq %rcx, 0x20(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl %r15d, %esi
movl %eax, %edx
movl $0x1, %ecx
callq 0x7cd0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x73c0
movl 0x8(%r14), %edx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x7280
leaq 0x9cb5(%rip), %rdx      # 0x1225c
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movzwl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0x7530
leaq 0x9c9d(%rip), %rdx      # 0x12265
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movzwl 0xe(%r14), %esi
movq %rbx, %rdi
callq 0x7530
leaq 0x9c88(%rip), %rdx      # 0x12271
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movzwl 0xc(%r14), %eax
cmpq $0x7, %rax
ja 0x860e
leaq 0x10888(%rip), %rcx     # 0x18e90
movq (%rcx,%rax,8), %rsi
jmp 0x8615
leaq 0x9cb0(%rip), %rsi      # 0x122c5
movq %rbx, %rdi
callq 0x7c90
leaq 0x9c59(%rip), %rdx      # 0x1227d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movzwl 0xc(%r14), %edi
movzwl 0xe(%r14), %esi
callq 0x7910
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7c90
leaq 0x9c39(%rip), %rdx      # 0x1228b
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/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 0x9c37(%rip), %rax      # 0x122c5
cmpl $0x7, %edi
ja 0x86fc
movl %edi, %ecx
leaq 0x9ac0(%rip), %rdx      # 0x1215c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
cmpl $0x6, %esi
jae 0x86fd
movl %esi, %eax
leaq 0x9ac9(%rip), %rcx      # 0x1217c
jmp 0x86f5
decl %esi
cmpl $0x20, %esi
jae 0x8705
movl %esi, %eax
leaq 0x9acf(%rip), %rcx      # 0x12194
jmp 0x86f5
cmpl $0x4, %esi
jae 0x86fd
movl %esi, %eax
leaq 0x9b77(%rip), %rcx      # 0x1224c
jmp 0x86f5
cmpl $0x3, %esi
jae 0x86fd
movl %esi, %eax
leaq 0x9b2f(%rip), %rcx      # 0x12214
jmp 0x86f5
cmpl $0xb, %esi
jae 0x86fd
movl %esi, %eax
leaq 0x9b2b(%rip), %rcx      # 0x12220
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x9c13(%rip), %rax      # 0x12317
retq
leaq 0xa332(%rip), %rax      # 0x12a3e
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x7bf0
cmpl $0x5, %eax
jne 0x878d
leaq 0xbc49(%rip), %rdx      # 0x14376
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d20
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7770
movq %rax, (%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x70b0
leaq 0xbc23(%rip), %rdx      # 0x1437e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d20
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7770
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x70b0
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x9cf0(%rip), %rdx      # 0x12484
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %esi, %esi
xorl %edx, %edx
callq 0x73c0
movq %r15, %rdi
movq %r14, %rsi
callq 0x7530
leaq 0xbbab(%rip), %rdx      # 0x14376
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7530
leaq 0xbb94(%rip), %rdx      # 0x1437e
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x7bf0
cmpl $0x5, %eax
jne 0x88de
leaq 0x9c70(%rip), %rdx      # 0x12493
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d20
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7770
movq %rax, (%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x70b0
leaq 0xbc3e(%rip), %rdx      # 0x1448f
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d20
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7770
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x70b0
leaq 0x9c16(%rip), %rdx      # 0x12496
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d20
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7770
movq %rax, 0x10(%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x70b0
leaq 0x9bea(%rip), %rdx      # 0x12499
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d20
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7770
movq %rax, 0x18(%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x70b0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x9b9f(%rip), %rdx      # 0x12484
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x7260
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x73c0
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x9b7f(%rip), %rdx      # 0x12493
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0xbb5a(%rip), %rdx      # 0x1448f
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x9b40(%rip), %rdx      # 0x12496
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x7530
leaq 0x9b22(%rip), %rdx      # 0x12499
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74e0
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/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 %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7770
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7770
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7770
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7610
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7530
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7770
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7770
movq %r14, %rdi
movq %rax, %rsi
callq 0x7720
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7530
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/computations.c
// Function: Divfix
static int Divfix(lua_State *L)
    {
    FT_Long a = luaL_checkinteger(L, 1);
    FT_Long b = luaL_checkinteger(L, 2);
    lua_pushinteger(L, FT_DivFix(a, b));
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7770
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7770
movq %r14, %rdi
movq %rax, %rsi
callq 0x7940
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7530
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x7730
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7770
movq %r14, %rdi
movq %rax, %rsi
callq 0x7340
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x7b90
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7770
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7770
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7820
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x7b90
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %ebp
leaq 0x20(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x7d50
movq %r14, %rdi
callq 0x78f0
testl %eax, %eax
je 0x8f00
movl %eax, %edi
callq 0x7d00
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x7a60
movl %eax, %ebp
jmp 0x8f1b
movups 0x20(%rsp), %xmm0
movups 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x7bd0
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %ebp
movl $0x1, %esi
xorl %edx, %edx
callq 0x7620
movq %rax, %r14
leaq 0x9a0a(%rip), %rsi      # 0x14923
movq %rax, %rdi
callq 0x7700
testl %eax, %eax
je 0xb038
leaq 0x95d4(%rip), %rsi      # 0x14504
movq %r14, %rdi
callq 0x7700
testl %eax, %eax
je 0xb083
leaq 0x7c28(%rip), %rsi      # 0x12b6f
movq %r14, %rdi
callq 0x7700
testl %eax, %eax
je 0xb03f
leaq 0x7c1f(%rip), %rsi      # 0x12b7d
movq %r14, %rdi
callq 0x7700
testl %eax, %eax
je 0xb046
leaq 0x7c18(%rip), %rsi      # 0x12b8d
movq %r14, %rdi
callq 0x7700
testl %eax, %eax
je 0xb04d
leaq 0x7c10(%rip), %rsi      # 0x12b9c
movq %r14, %rdi
callq 0x7700
testl %eax, %eax
je 0xb054
leaq 0x7c07(%rip), %rsi      # 0x12baa
movq %r14, %rdi
callq 0x7700
testl %eax, %eax
je 0xb05b
leaq 0x7c03(%rip), %rsi      # 0x12bbd
movq %r14, %rdi
callq 0x7700
testl %eax, %eax
je 0xb062
leaq 0x7bfc(%rip), %rsi      # 0x12bcd
movq %r14, %rdi
callq 0x7700
testl %eax, %eax
je 0xb069
leaq 0x7bf1(%rip), %rsi      # 0x12bd9
movq %r14, %rdi
callq 0x7700
testl %eax, %eax
je 0xb070
leaq 0x7261(%rip), %rsi      # 0x1225c
movq %r14, %rdi
callq 0x7700
testl %eax, %eax
je 0xb077
leaq 0x7bd6(%rip), %rsi      # 0x12be4
movq %r14, %rdi
callq 0x7700
testl %eax, %eax
je 0xb07e
leaq 0x7bcf(%rip), %rsi      # 0x12bf0
movq %r14, %rdi
callq 0x7700
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0xb092
movl $0xc, %ebp
jmp 0xb083
movl $0x65, %ebp
jmp 0xb083
movl $0x2, %ebp
jmp 0xb083
movl $0x3, %ebp
jmp 0xb083
movl $0x4, %ebp
jmp 0xb083
movl $0x5, %ebp
jmp 0xb083
movl $0x6, %ebp
jmp 0xb083
movl $0x7, %ebp
jmp 0xb083
movl $0x8, %ebp
jmp 0xb083
movl $0x9, %ebp
jmp 0xb083
movl $0xa, %ebp
jmp 0xb083
movl $0xb, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x78c0
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/face.c
// Function: moonfreetype_checkface
FT_Face* checkface(lua_State *L, int arg)
    {
    FT_Face *p = testface(L, arg);
    if(p) return p;
    luaL_argerror(L, arg, "not a face");
    return NULL;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x6eed(%rip), %rdx      # 0x12000
callq 0x7630
testq %rax, %rax
je 0xb125
movq (%rax), %rax
testq %rax, %rax
jne 0xb138
leaq 0x85f8(%rip), %rdx      # 0x13724
movq %r14, %rdi
movl %ebx, %esi
callq 0x7260
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonfreetype/src/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
movl $0x1, %esi
callq 0x76c0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x7620
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x7830
movq %rax, %r13
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x7830
movq %rax, %rbp
movl $0x8, %esi
movq %rbx, %rdi
callq 0x7c00
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 0x74b0
movl %eax, %ebp
leaq 0x8567(%rip), %rdi      # 0x1372f
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x7270
leaq 0x8f87(%rip), %rdi      # 0x14163
movl %ebp, %esi
xorl %eax, %eax
callq 0x7270
testl %ebp, %ebp
je 0xb216
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
movq (%r15), %rax
movq 0x98(%rax), %rsi
leaq 0x851c(%rip), %rdi      # 0x13743
xorl %eax, %eax
callq 0x7270
leaq 0x6dcb(%rip), %rdx      # 0x12000
movq %rbx, %rdi
movq %r15, %rsi
callq 0x72a0
movq %r15, %rdi
callq 0x7230
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq