LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpipc.c
// Function: ftpipc_recv_cmd
int ftpipc_recv_cmd(int fd)
{
    char cmd;
    int ret;
    ret = readn(fd,&cmd,sizeof(cmd));
    if ( sizeof(cmd) == ret ) 
        return cmd;
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
callq 0x4600
movl %eax, -0x10(%rbp)
movslq -0x10(%rbp), %rcx
movl $0x1, %eax
cmpq %rcx, %rax
jne 0x8136
movsbl -0x9(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x813c
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpipc.c
// Function: ftpipc_send_int
int ftpipc_send_int(int fd,int val)
{
    int bufsize = sizeof(int);
    if ( bufsize != writen(fd,&val,bufsize) )
        return -1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x4, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %edi
movslq -0x10(%rbp), %rdx
leaq -0xc(%rbp), %rsi
callq 0x46a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
je 0x8262
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8269
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpipc.c
// Function: ftpipc_recv_data
int ftpipc_recv_data(int fd,void* str,int maxsize)
{
    int bufsize = ftpipc_recv_int(fd);
    if ( bufsize > maxsize )
        return -1;

    if ( bufsize != readn(fd,str,bufsize) )
        return -1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x8(%rbp), %edi
callq 0x82f0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x82ae
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x82e2
movslq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x4600
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0x82db
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x82e2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0x30(%rbp), %rdi
leaq 0x4a0a(%rip), %rsi      # 0xcdb0
movl $0x30, %edx
callq 0x3350
movl $0x5, %edi
leaq 0x224(%rip), %rsi       # 0x85e0
callq 0x8520
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x3c(%rbp)
cmpl $0x3, -0x3c(%rbp)
jge 0x8468
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movslq -0x3c(%rbp), %rcx
leaq -0x30(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movslq -0x3c(%rbp), %rcx
leaq -0x30(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x3160
movl %eax, -0x54(%rbp)
movslq -0x3c(%rbp), %rcx
leaq -0x30(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movslq -0x3c(%rbp), %rcx
leaq -0x30(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x3160
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movl -0x54(%rbp), %edx
movq -0x50(%rbp), %rcx
movl %eax, %r8d
callq 0x8640
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x83d3
movq -0x38(%rbp), %rdi
leaq 0x1704(%rip), %rsi      # 0x9b77
movl $0x3, %edx
callq 0x8770
movq -0x38(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3160
movl %eax, -0x74(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3160
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movl -0x74(%rbp), %edx
movq -0x70(%rbp), %rcx
movl %eax, %r8d
callq 0x8640
movq -0x38(%rbp), %rdi
leaq 0x16a5(%rip), %rsi      # 0x9b77
movl $0x3, %edx
callq 0x8830
movq %rax, -0x48(%rbp)
xorl %eax, %eax
cmpq -0x48(%rbp), %rax
jne 0x84f8
leaq 0x16a6(%rip), %rdi      # 0x9b95
movb $0x0, %al
callq 0x31b0
jmp 0x850a
movq -0x48(%rbp), %rsi
leaq 0x169d(%rip), %rdi      # 0x9ba0
movb $0x0, %al
callq 0x31b0
leaq -0x38(%rbp), %rdi
callq 0x8880
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x33a0
movq %rax, -0x18(%rbp)
movslq -0x4(%rbp), %rax
shlq $0x3, %rax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rdi
callq 0x33a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x1c(%rbp), %rdx
xorl %esi, %esi
callq 0x3220
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x85d3
movl $0x20, %edi
callq 0x33a0
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq $0x0, 0x10(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x858b
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x862d
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %eax
movl -0x10(%rbp), %ecx
shll $0x6, %ecx
addl %ecx, %eax
movl -0x10(%rbp), %ecx
shll $0x10, %ecx
addl %ecx, %eax
subl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x85fa
movl -0x10(%rbp), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
divl -0xc(%rbp)
movl %edx, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x89d0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x8699
movq 0x497c(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x1540(%rip), %rsi      # 0x9bc6
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x875e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8950
movq %rax, -0x38(%rbp)
movl $0x20, %edi
callq 0x33a0
movq %rax, -0x40(%rbp)
movslq -0x1c(%rbp), %rdi
callq 0x33a0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movslq -0x2c(%rbp), %rdi
callq 0x33a0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x3350
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
movslq -0x2c(%rbp), %rdx
callq 0x3350
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x8757
movq -0x40(%rbp), %rcx
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x89d0
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x87c0
movq 0x4852(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x1422(%rip), %rsi      # 0x9bd2
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x881c
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x87f3
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3030
movq -0x28(%rbp), %rdi
callq 0x3030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/hash.c
// Function: hashtable_search
void* hashtable_search(hashtable_t* hash,void* key,int key_size)
{
    node_t* node = hashtable_get_node(hash,key,key_size);
    if ( NULL != node) 
    {
        return node->val;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x89d0
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
je 0x886d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x8875
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x8924
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x8901
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3030
movq -0x28(%rbp), %rdi
callq 0x3030
jmp 0x88c1
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x889e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3030
movq -0x18(%rbp), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl (%rcx), %esi
callq *%rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jbe 0x89a4
movq 0x466f(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x1223(%rip), %rsi      # 0x9bb6
movb $0x0, %al
callq 0x3310
movq $0x0, -0x8(%rbp)
jmp 0x89b7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/hash.c
// Function: hashtable_get_node
node_t* hashtable_get_node(hashtable_t* hash,void* key,int key_size)
{
    node_t* node = hashtable_getbucket(hash,key)->pnext;
    while ( NULL != node )
    {
        if ( 0 == memcmp(key,node->key,key_size) )
        {
            return node;
        }
        node = node->pnext;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8950
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
je 0x8a34
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x32a0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x8a26
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8a3c
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x89f8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
leaq 0x4c3d(%rip), %rax      # 0xd698
movq (%rax), %rsi
leaq 0x117d(%rip), %rdi      # 0x9be2
movb $0x0, %al
callq 0x31b0
leaq 0x4855(%rip), %rax      # 0xd2c8
movl (%rax), %esi
leaq 0x1179(%rip), %rdi      # 0x9bf5
movb $0x0, %al
callq 0x31b0
leaq 0x4842(%rip), %rax      # 0xd2cc
movl (%rax), %esi
leaq 0x1172(%rip), %rdi      # 0x9c05
movb $0x0, %al
callq 0x31b0
leaq 0x482f(%rip), %rax      # 0xd2d0
movl (%rax), %esi
leaq 0x116b(%rip), %rdi      # 0x9c15
movb $0x0, %al
callq 0x31b0
leaq 0x481c(%rip), %rax      # 0xd2d4
movl (%rax), %esi
leaq 0x1163(%rip), %rdi      # 0x9c24
movb $0x0, %al
callq 0x31b0
leaq 0x4bc1(%rip), %rax      # 0xd690
movl (%rax), %esi
leaq 0x115f(%rip), %rdi      # 0x9c37
movb $0x0, %al
callq 0x31b0
leaq 0x47f2(%rip), %rax      # 0xd2d8
movl (%rax), %esi
leaq 0x115c(%rip), %rdi      # 0x9c4b
movb $0x0, %al
callq 0x31b0
leaq 0x47df(%rip), %rax      # 0xd2dc
movl (%rax), %esi
leaq 0x115e(%rip), %rdi      # 0x9c64
movb $0x0, %al
callq 0x31b0
leaq 0x47cc(%rip), %rax      # 0xd2e0
movl (%rax), %esi
leaq 0x1163(%rip), %rdi      # 0x9c80
movb $0x0, %al
callq 0x31b0
leaq 0x47b9(%rip), %rax      # 0xd2e4
movl (%rax), %esi
leaq 0x115c(%rip), %rdi      # 0x9c90
movb $0x0, %al
callq 0x31b0
leaq 0x47a6(%rip), %rax      # 0xd2e8
movl (%rax), %esi
leaq 0x1159(%rip), %rdi      # 0x9ca4
movb $0x0, %al
callq 0x31b0
leaq 0x4767(%rip), %rax      # 0xd2c0
movl (%rax), %esi
leaq 0x1158(%rip), %rdi      # 0x9cba
movb $0x0, %al
callq 0x31b0
leaq 0x4754(%rip), %rax      # 0xd2c4
movl (%rax), %esi
leaq 0x1151(%rip), %rdi      # 0x9cca
movb $0x0, %al
callq 0x31b0
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movl $0x0, 0x4b92(%rip)      # 0xd730
leaq 0x4727(%rip), %rax      # 0xd2cc
movl (%rax), %edi
shll %edi
leaq 0x30(%rip), %rsi        # 0x8be0
callq 0x8520
movq %rax, 0x4b7c(%rip)      # 0xd738
leaq 0x4709(%rip), %rax      # 0xd2cc
movl (%rax), %edi
shll %edi
leaq 0x12(%rip), %rsi        # 0x8be0
callq 0x8520
movq %rax, 0x4b66(%rip)      # 0xd740
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movl $0x0, 0x4b12(%rip)      # 0xd730
leaq 0x4b13(%rip), %rdi      # 0xd738
callq 0x8880
leaq 0x4b0f(%rip), %rdi      # 0xd740
callq 0x8880
xorl %eax, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/clntlmt.c
// Function: client_add
static int client_add(unsigned int ip)
{
    int* ret = hashtable_search(hash_ip_clients,&ip,sizeof(ip));
    if ( NULL != ret ) 
    {
        *ret = *ret + 1;
        return *ret;
    }
    else 
    {
        int val = 1;
        hashtable_add(hash_ip_clients,&ip,sizeof(ip),&val,sizeof(ret));
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq 0x4a96(%rip), %rdi      # 0xd738
leaq -0x8(%rbp), %rsi
movl $0x4, %edx
callq 0x8830
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x8cd6
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x8d03
movl $0x1, -0x14(%rbp)
movq 0x4a54(%rip), %rdi      # 0xd738
leaq -0x8(%rbp), %rsi
movl $0x4, %edx
leaq -0x14(%rbp), %rcx
movl $0x8, %r8d
callq 0x8640
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x4a1e(%rip), %rdi      # 0xd740
leaq -0x4(%rbp), %rsi
movl $0x4, %edx
callq 0x8830
movq %rax, -0x10(%rbp)
movq 0x49fd(%rip), %rdi      # 0xd738
movq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x8830
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movl $0x1, %eax
cmpl (%rcx), %eax
jne 0x8d71
movq 0x49d7(%rip), %rdi      # 0xd738
movq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x8770
jmp 0x8d80
movq -0x18(%rbp), %rax
movl (%rax), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq 0x49b9(%rip), %rdi      # 0xd740
leaq -0x4(%rbp), %rsi
movl $0x4, %edx
callq 0x8770
movl 0x4995(%rip), %eax      # 0xd730
addl $-0x1, %eax
movl %eax, 0x498c(%rip)      # 0xd730
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq 0x450e(%rip), %rax      # 0xd2d0
cmpl $0x0, (%rax)
jbe 0x8de3
movl -0x8(%rbp), %edi
callq 0x8e20
leaq 0x44fa(%rip), %rcx      # 0xd2d0
cmpl (%rcx), %eax
jbe 0x8de3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8e10
leaq 0x44e2(%rip), %rax      # 0xd2cc
cmpl $0x0, (%rax)
jbe 0x8e09
movl 0x493b(%rip), %eax      # 0xd730
leaq 0x44d0(%rip), %rcx      # 0xd2cc
cmpl (%rcx), %eax
jbe 0x8e09
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x8e10
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movsd -0x10(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x14bf
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rdi
callq 0x1540
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rdi
callq 0x1540
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
jmp 0x14eb
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rdi
callq 0x1540
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rdi
callq 0x1540
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x14fd
movq -0x28(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x151f
movq 0x5af4(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x3c8d(%rip), %rsi      # 0x519b
movb $0x0, %al
callq 0x10b0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1120
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x19e0
movq -0x8(%rbp), %rdi
callq 0x1e60
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x13888(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x1388c(%rax) # imm = 0xFFFFFFFF
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x1f44
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd 0x3171(%rip), %xmm0     # 0x5020
ucomisd 0x1f48(%rax,%rcx,8), %xmm0
jbe 0x1ee8
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsd 0x1f48(%rax,%rcx,8), %xmm0
movsd 0x314d(%rip), %xmm1     # 0x5020
ucomisd %xmm1, %xmm0
jbe 0x1ee8
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1388c(%rax)
jmp 0x1f46
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd 0x1f48(%rax,%rcx,8), %xmm0
movsd 0x311a(%rip), %xmm1     # 0x5020
ucomisd %xmm1, %xmm0
jbe 0x1f34
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsd 0x3104(%rip), %xmm0     # 0x5020
ucomisd 0x1f48(%rax,%rcx,8), %xmm0
jbe 0x1f34
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x13888(%rax)
jmp 0x1f36
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1e8b
jmp 0x1f46
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x7ac0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x7340
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movl $0x3, %esi
callq 0x7770
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
leaq 0x18(%rsp), %rcx
callq 0x7470
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x7f3e
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl 0x24(%rsp), %edi
callq 0x7d30
movq (%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x7a70
movl %eax, 0x34(%rsp)
jmp 0x7f57
jmp 0x7f40
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x7540
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x7ac0
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x7340
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x7340
movl %eax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x4, %esi
callq 0x7770
movl %eax, 0x14(%rsp)
cmpl $0x1, 0x18(%rsp)
jae 0x7fdc
movq 0x38(%rsp), %rdi
movl $0x3, %esi
leaq 0x1105d(%rip), %rdx     # 0x1902b
callq 0x7260
movl %eax, 0x44(%rsp)
jmp 0x80ad
movq 0x38(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
shlq $0x3, %rsi
callq 0x7c20
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
movl 0x14(%rsp), %ecx
movq 0x28(%rsp), %r8
callq 0x70d0
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x802d
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x79f0
jmp 0x802f
cmpl $0x0, 0x34(%rsp)
je 0x805e
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %edi
callq 0x7d30
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x7a70
movl %eax, 0x44(%rsp)
jmp 0x80ad
jmp 0x8060
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x18(%rsp), %eax
jae 0x8096
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x30(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x7540
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x8068
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x79f0
movl 0x18(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x8120
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x80f4
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x8112
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
leaq 0x10f40(%rip), %rdx     # 0x19044
callq 0x7260
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x7230
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x81bd
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x7180
movl %eax, 0x24(%rsp)
jmp 0x8214
movq 0x10(%rsp), %rsi
leaq 0x10e88(%rip), %rdi     # 0x19051
movb $0x0, %al
callq 0x7270
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x10e8d(%rip), %rdx     # 0x1906e
callq 0x72b0
movq 0x10(%rsp), %rdi
callq 0x7230
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movl $0x0, 0x18(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x7230
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7380
cmpl $0x0, %eax
jne 0x8455
movl $0x0, 0x34(%rsp)
jmp 0x849f
movq 0x20(%rsp), %rsi
leaq 0x10c4c(%rip), %rdi     # 0x190ad
movb $0x0, %al
callq 0x7270
cmpl $0x0, 0xc(%rsp)
jne 0x8479
movl $0x0, 0x34(%rsp)
jmp 0x849f
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7560
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x79f0
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x76d0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x28, %esi
callq 0x7c20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x75c0
movq 0x8(%rsp), %rsi
leaq 0x10b9a(%rip), %rdi     # 0x190e1
movb $0x0, %al
callq 0x7270
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x10b0f(%rip), %rdx     # 0x1906e
callq 0x72b0
movq 0x8(%rsp), %rdi
callq 0x7230
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movl $0x1, 0x18(%rax)
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x7110
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x7110
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7230
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rdi
callq 0x7230
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
je 0x866c
movq 0x38(%rsp), %rdi
leaq 0x10a95(%rip), %rsi     # 0x190f4
movb $0x0, %al
callq 0x7a70
movl %eax, 0x44(%rsp)
jmp 0x86c1
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x7420
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x86b7
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %edi
callq 0x7d30
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x7a70
movl %eax, 0x44(%rsp)
jmp 0x86c1
jmp 0x86b9
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x7110
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x7110
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x7770
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7230
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rdi
callq 0x7230
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
je 0x875f
movq 0x38(%rsp), %rdi
leaq 0x109a2(%rip), %rsi     # 0x190f4
movb $0x0, %al
callq 0x7a70
movl %eax, 0x44(%rsp)
jmp 0x87b6
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
callq 0x7930
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x87ac
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movl 0x34(%rsp), %edi
callq 0x7d30
movq (%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x7a70
movl %eax, 0x44(%rsp)
jmp 0x87b6
jmp 0x87ae
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x7110
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x7770
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x7770
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7230
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x7c50
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x8864
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %edi
callq 0x7d30
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x7a70
movl %eax, 0x44(%rsp)
jmp 0x886e
jmp 0x8866
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0x7110
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x7830
movl %eax, 0x34(%rsp)
movq 0x40(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x7830
movl %eax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rcx
movl 0x34(%rsp), %esi
movl 0x30(%rsp), %edx
movq 0x20(%rcx), %r8
movq %rsp, %rax
movq %r8, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %ecx
callq 0x7cf0
movl $0x1, %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x73d0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x8(%rax), %edx
movl $0xa, %esi
callq 0x7280
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x10920(%rip), %rdx     # 0x19274
callq 0x74f0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movzwl 0xc(%rax), %eax
movl %eax, %esi
callq 0x7540
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x108fe(%rip), %rdx     # 0x1927d
callq 0x74f0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movzwl 0xe(%rax), %eax
movl %eax, %esi
callq 0x7540
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x108df(%rip), %rdx     # 0x19289
callq 0x74f0
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movzwl 0xc(%rax), %edi
callq 0x7af0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x7cb0
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x108b0(%rip), %rdx     # 0x19295
callq 0x74f0
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movzwl 0xc(%rax), %edi
movq 0x18(%rsp), %rax
movzwl 0xe(%rax), %esi
callq 0x7920
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x7cb0
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x1087a(%rip), %rdx     # 0x192a3
callq 0x74f0
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/charmap.c
// Function: moonfreetype_platformstring
const char* platformstring(unsigned int id)
    {
    switch(id)
        {
        case TT_PLATFORM_APPLE_UNICODE: return "apple unicode";
        case TT_PLATFORM_MACINTOSH: return "macintosh";
        case TT_PLATFORM_ISO: return "iso"; /* deprecated */
        case TT_PLATFORM_MICROSOFT: return "microsoft";
        case TT_PLATFORM_CUSTOM: return "custom";
        case TT_PLATFORM_ADOBE: return "adobe";
        default:
            return "unknown platform id";
        }
    return NULL; /* unreachable */
    }

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x7, %rax
ja 0x8abc
movq -0x18(%rsp), %rax
leaq 0x106fd(%rip), %rcx     # 0x1915c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10842(%rip), %rax     # 0x192b1
movq %rax, -0x8(%rsp)
jmp 0x8ac8
leaq 0x10842(%rip), %rax     # 0x192bf
movq %rax, -0x8(%rsp)
jmp 0x8ac8
leaq 0x1083e(%rip), %rax     # 0x192c9
movq %rax, -0x8(%rsp)
jmp 0x8ac8
leaq 0x10834(%rip), %rax     # 0x192cd
movq %rax, -0x8(%rsp)
jmp 0x8ac8
leaq 0x10f67(%rip), %rax     # 0x19a0e
movq %rax, -0x8(%rsp)
jmp 0x8ac8
leaq 0x10822(%rip), %rax     # 0x192d7
movq %rax, -0x8(%rsp)
jmp 0x8ac8
leaq 0x1081a(%rip), %rax     # 0x192dd
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0xc(%rsp)
movl %esi, 0x8(%rsp)
movl 0xc(%rsp), %eax
movq %rax, (%rsp)
subq $0x7, %rax
ja 0x8b5e
movq (%rsp), %rax
leaq 0x10687(%rip), %rcx     # 0x1917c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%rsp), %edi
callq 0x8b80
movq %rax, 0x10(%rsp)
jmp 0x8b6a
movl 0x8(%rsp), %edi
callq 0x8c10
movq %rax, 0x10(%rsp)
jmp 0x8b6a
movl 0x8(%rsp), %edi
callq 0x8e60
movq %rax, 0x10(%rsp)
jmp 0x8b6a
movl 0x8(%rsp), %edi
callq 0x8ed0
movq %rax, 0x10(%rsp)
jmp 0x8b6a
movl 0x8(%rsp), %edi
callq 0x8f80
movq %rax, 0x10(%rsp)
jmp 0x8b6a
movl 0x8(%rsp), %edi
callq 0x8f90
movq %rax, 0x10(%rsp)
jmp 0x8b6a
leaq 0x10778(%rip), %rax     # 0x192dd
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/charmap.c
// Function: encodingstring_apple
static const char* encodingstring_apple(unsigned int id)
    {
    switch(id)
        {
        case TT_APPLE_ID_DEFAULT: return "default";
        case TT_APPLE_ID_UNICODE_1_1: return "unicode 1 1";
        case TT_APPLE_ID_ISO_10646: return "iso 10646";
        case TT_APPLE_ID_UNICODE_2_0: return "unicode 2 0";
        case TT_APPLE_ID_UNICODE_32: return "unicode 32";
        case TT_APPLE_ID_VARIANT_SELECTOR: return "variant selector";
        default:
            return "unknown encoding id";
        }
    return NULL; /* unreachable */
    }

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x5, %rax
ja 0x8bfc
movq -0x18(%rsp), %rax
leaq 0x105fd(%rip), %rcx     # 0x1919c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x12e71(%rip), %rax     # 0x1ba20
movq %rax, -0x8(%rsp)
jmp 0x8c08
leaq 0x10734(%rip), %rax     # 0x192f1
movq %rax, -0x8(%rsp)
jmp 0x8c08
leaq 0x10732(%rip), %rax     # 0x192fd
movq %rax, -0x8(%rsp)
jmp 0x8c08
leaq 0x1072e(%rip), %rax     # 0x19307
movq %rax, -0x8(%rsp)
jmp 0x8c08
leaq 0x1072c(%rip), %rax     # 0x19313
movq %rax, -0x8(%rsp)
jmp 0x8c08
leaq 0x10729(%rip), %rax     # 0x1931e
movq %rax, -0x8(%rsp)
jmp 0x8c08
leaq 0x1072c(%rip), %rax     # 0x1932f
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonfreetype/src/charmap.c
// Function: encodingstring_iso
static const char* encodingstring_iso(unsigned int id)
    {
    switch(id)
        {
        case TT_ISO_ID_7BIT_ASCII: return "7bit ascii";
        case TT_ISO_ID_10646: return "10646";
        case TT_ISO_ID_8859_1: return "8859 1";
        default:
            return "unknown encoding id";
        }
    return NULL; /* unreachable */
    }

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x10(%rsp)
testl %eax, %eax
je 0x8e88
jmp 0x8e72
movl -0x10(%rsp), %eax
subl $0x1, %eax
je 0x8e96
jmp 0x8e7d
movl -0x10(%rsp), %eax
subl $0x2, %eax
je 0x8ea4
jmp 0x8eb2
leaq 0x105c0(%rip), %rax     # 0x1944f
movq %rax, -0x8(%rsp)
jmp 0x8ebe
leaq 0x10464(%rip), %rax     # 0x19301
movq %rax, -0x8(%rsp)
jmp 0x8ebe
leaq 0x105af(%rip), %rax     # 0x1945a
movq %rax, -0x8(%rsp)
jmp 0x8ebe
leaq 0x10476(%rip), %rax     # 0x1932f
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)