LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/session.c
// Function: ratelim_do
int ratelim_do(session_t* sess,unsigned int maxrate,int nbytes)
{
    if ( 0 == maxrate )
        return 0;
    struct timeval tv;
    if ( -1 == gettimeofday(&tv,NULL) ) 
        return -1;

    double elapsed = (double)(tv.tv_sec - sess->ts_sec) + 0.000001 * (double)(tv.tv_usec - sess->ts_usec);
    if ( elapsed <= 0 )
        elapsed = 0.01;

    double currate = (double)nbytes / elapsed;
    if ( (int)currate < maxrate )
        return 0;
    double timetosleep = ( currate / (double)maxrate - 1 ) * elapsed;


    struct timespec ts;
    ts.tv_sec = (int)timetosleep;
    ts.tv_nsec = (timetosleep - ts.tv_sec) * 1000000000;

    int ret;
    do 
    {
        ret = nanosleep(&ts,&ts);
    } while ( -1 == ret && EINTR == errno); 

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jne 0x4e45
movl $0x0, -0x4(%rbp)
jmp 0x4f7d
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x31f0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x4e69
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4f7d
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0xc38(%rcx), %ecx
subq %rcx, %rax
cvtsi2sd %rax, %xmm1
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0xc3c(%rcx), %ecx
subq %rcx, %rax
cvtsi2sd %rax, %xmm0
movsd 0x42bb(%rip), %xmm2     # 0x9158
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x30(%rbp), %xmm0
jb 0x4ec1
movsd 0x42a4(%rip), %xmm0     # 0x9160
movsd %xmm0, -0x30(%rbp)
cvtsi2sdl -0x18(%rbp), %xmm0
divsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
cvttsd2si -0x38(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x4ee6
movl $0x0, -0x4(%rbp)
jmp 0x4f7d
movsd -0x38(%rbp), %xmm0
movl -0x14(%rbp), %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movsd 0x4271(%rip), %xmm1     # 0x9170
subsd %xmm1, %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
cvttsd2si -0x40(%rbp), %eax
cltq
movq %rax, -0x50(%rbp)
movsd -0x40(%rbp), %xmm0
cvtsi2sdq -0x50(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd 0x4239(%rip), %xmm1     # 0x9168
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x48(%rbp)
leaq -0x50(%rbp), %rsi
movq %rsi, %rdi
callq 0x31c0
movl %eax, -0x54(%rbp)
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl -0x54(%rbp), %ecx
movb %al, -0x55(%rbp)
jne 0x4f6f
callq 0x3050
movq %rax, %rcx
movl $0x4, %eax
cmpl (%rcx), %eax
sete %al
movb %al, -0x55(%rbp)
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0x4f3c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/str.c
// Function: str_split
int str_split(char* str,char *cmd,char* arg,char delim)
{
    char* pos = strchr(str,delim);
    if (NULL == pos)
    {
        strncpy(cmd,str,strlen(str));
        return 1;
    }
    else
    {
        *pos = '\0';
        strncpy(cmd,str,strlen(str));
        strncpy(arg,pos + 1,strlen(pos + 1));
        return 2;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rdi
movsbl -0x21(%rbp), %esi
callq 0x31a0
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x30(%rbp), %rax
jne 0x5074
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3160
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x3070
movl $0x1, -0x4(%rbp)
jmp 0x50dc
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3160
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
callq 0x3070
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
callq 0x3160
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x3070
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/str.c
// Function: str_octal_to_uint
unsigned int str_octal_to_uint(char* str)
{
    unsigned int ret = 0;
    while (*str) 
    {
        if (*str >= '0' && *str <= '7') 
        {
            ret = ret * 8 + *str - '0';
        }
        else
            return 0;
        str++;
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x518e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x5177
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x37, %eax
jg 0x5177
movl -0x14(%rbp), %eax
shll $0x3, %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0x14(%rbp)
jmp 0x5180
movl $0x0, -0x4(%rbp)
jmp 0x5194
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x513f
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/str.c
// Function: is_allspace
int is_allspace(const char* str)
{
    while (*str) {
        if (*str++ != ' ') {
            return 0;
        }
    }    
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x51d3
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x51d1
movl $0x0, -0x4(%rbp)
jmp 0x51da
jmp 0x51a8
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/parseconf.c
// Function: parseconf_load_file
int parseconf_load_file(const char* file)
{
    FILE* pfile = fopen(file,"r");
    if (NULL == pfile)
    {
        fprintf(stderr, "config file open error\n");
        return -1;
    }

    char line[1024];
    while (NULL != fgets(line,1024,pfile))
    {
        if (-1 == parseconf_load_setting(line)) 
        {
            fprintf(stderr, "config file parse error");
        }
    }
    fclose(pfile);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3ec7(%rip), %rsi      # 0x90c1
callq 0x3460
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x522c
movq 0x7de6(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x3f67(%rip), %rsi      # 0x9183
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x528e
jmp 0x522e
leaq -0x420(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x32b0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x527e
leaq -0x420(%rbp), %rdi
callq 0x52a0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x527c
movq 0x7d8d(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x3f26(%rip), %rsi      # 0x919b
movb $0x0, %al
callq 0x3310
jmp 0x522e
movq -0x18(%rbp), %rdi
callq 0x3120
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: ftp_reply
int ftp_reply(session_t* ssinf,int status,const char* text)
{
    char buf[1024] = {0};
    sprintf(buf,"%d %s\r\n",status,text);
    if ( -1 == writen(ssinf->ctrlfd,buf,strlen(buf)))
        ERR_EXIT("written error");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x420(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x3220
leaq -0x420(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
leaq 0x3c5e(%rip), %rsi      # 0x929c
movb $0x0, %al
callq 0x34d0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x42c(%rbp)
leaq -0x420(%rbp), %rax
movq %rax, -0x428(%rbp)
leaq -0x420(%rbp), %rdi
callq 0x3160
movl -0x42c(%rbp), %edi
movq -0x428(%rbp), %rsi
movq %rax, %rdx
callq 0x46a0
movq %rax, %rcx
movq $-0x1, %rax
cmpq %rcx, %rax
jne 0x56a8
jmp 0x5692
leaq 0x3c0b(%rip), %rdi      # 0x92a4
callq 0x3470
movl $0x1, %edi
callq 0x34e0
xorl %eax, %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: get_tcpsocket
int get_tcpsocket(session_t* sess,const char* ip,int nport)
{
    ftpipc_send_cmd(sess->protofd,FTPIPC_GET_DATA_FD);
    
    ftpipc_send_data(sess->protofd,ip,strlen(ip));
    ftpipc_send_data(sess->protofd,&nport,sizeof(int));

    ftpipc_send_data(sess->protofd,sess->port_addr,sizeof(struct sockaddr_in));

    int ret = ftpipc_recv_ret(sess->protofd);
    if ( FTPIPC_RET_OK == ret )
    {
        return ftpipc_recv_fd(sess->protofd);
    }
    else
        return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
movl $0x1, %esi
callq 0x80d0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3160
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
movl %eax, %edx
callq 0x81d0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
leaq -0x1c(%rbp), %rsi
movl $0x4, %edx
callq 0x81d0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x10(%rbp), %rax
movq 0xc18(%rax), %rsi
movl $0x10, %edx
callq 0x81d0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x8180
movl %eax, -0x20(%rbp)
movl $0x1, %eax
cmpl -0x20(%rbp), %eax
jne 0x5828
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x8370
movl %eax, -0x4(%rbp)
jmp 0x582f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: cmd_disconn_start
int cmd_disconn_start()
{
    signal(SIGALRM,signal_cmdalarm);
    if ( 0 != tunable_idle_session_timeout) 
    {
        alarm(tunable_idle_session_timeout);
        //printf("alarm time:%u\n",tunable_idle_session_timeout);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xe, %edi
leaq 0x30(%rip), %rsi        # 0x5e80
callq 0x32f0
xorl %eax, %eax
leaq 0x747a(%rip), %rcx      # 0xd2d8
cmpl (%rcx), %eax
je 0x5e70
leaq 0x746f(%rip), %rax      # 0xd2d8
movl (%rax), %edi
callq 0x3250
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: signal_cmdalarm
void signal_cmdalarm(int sigal)
{
    shutdown(pssinf->ctrlfd,SHUT_RD);
    ftp_reply(pssinf,FTP_IDLE_TIMEOUT,"Time out");
    shutdown(pssinf->ctrlfd,SHUT_WR);
    exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x7816(%rip), %rax      # 0xd6a8
movl 0x8(%rax), %edi
xorl %esi, %esi
callq 0x3140
movq 0x7805(%rip), %rdi      # 0xd6a8
movl $0x1a5, %esi            # imm = 0x1A5
leaq 0x3447(%rip), %rdx      # 0x92f6
callq 0x5600
movq 0x77ed(%rip), %rax      # 0xd6a8
movl 0x8(%rax), %edi
movl $0x1, %esi
callq 0x3140
xorl %edi, %edi
callq 0x34e0
nop
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: data_disconn_start
int data_disconn_start()
{
    b_dataconn = 0;
    signal(SIGALRM,signal_dataalarm);
    if ( 0 != tunable_data_connection_timeout) 
    {
        alarm(tunable_data_connection_timeout);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x77c2(%rip)      # 0xd6a0
movl $0xe, %edi
leaq 0x26(%rip), %rsi        # 0x5f10
callq 0x32f0
xorl %eax, %eax
leaq 0x73e4(%rip), %rcx      # 0xd2dc
cmpl (%rcx), %eax
je 0x5f0a
leaq 0x73d9(%rip), %rax      # 0xd2dc
movl (%rax), %edi
callq 0x3250
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: signal_dataalarm
void signal_dataalarm(int sigal)
{
    if ( 0 == b_dataconn ) 
    {
        clear_transfer(pssinf);
    }
    else 
    {
        b_dataconn = 0;
        alarm(tunable_data_connection_timeout);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
xorl %eax, %eax
cmpl 0x777d(%rip), %eax      # 0xd6a0
jne 0x5f33
movq 0x777c(%rip), %rdi      # 0xd6a8
callq 0x4cc0
jmp 0x5f4b
movl $0x0, 0x7763(%rip)      # 0xd6a0
leaq 0x7398(%rip), %rax      # 0xd2dc
movl (%rax), %edi
callq 0x3250
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: handle_sigurg
void handle_sigurg(int signal)
{        
    memset(pssinf->cmdline,0,sizeof(char) * MAXCMDLINE);
    memset(pssinf->cmd,0,sizeof(char) * MAXCMDLINE);
    memset(pssinf->arg,0,sizeof(char) * MAXCMDLINE);
    
    int ret = readline(pssinf->ctrlfd,pssinf->cmdline,MAXCMDLINE);
    if (-1 == ret )
        ERR_EXIT("read error");
    if (0 == ret)
        exit(EXIT_SUCCESS);

    str_trim_crlf(pssinf->cmdline);
    str_split(pssinf->cmdline,pssinf->cmd,pssinf->arg,' ');
    str_upper(pssinf->cmd);
    printf("[%s]\t[%s]\n",pssinf->cmd,pssinf->arg);

    if ( 0 == strcmp("ABOR",pssinf->cmd) || 0 == strcmp(pssinf->cmd,"\377\364\377\362ABOR"))
    {
        clear_transfer(pssinf);
        pssinf->burg = 1;        
    }
    else 
    {
        ftp_reply(pssinf,FTP_BADCMD,"Unkown command");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x7736(%rip), %rdi      # 0xd6a8
addq $0x18, %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x3220
movq 0x771f(%rip), %rdi      # 0xd6a8
addq $0x418, %rdi            # imm = 0x418
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x3220
movq 0x7705(%rip), %rdi      # 0xd6a8
addq $0x818, %rdi            # imm = 0x818
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x3220
movq 0x76eb(%rip), %rax      # 0xd6a8
movl 0x8(%rax), %edi
movq 0x76e1(%rip), %rsi      # 0xd6a8
addq $0x18, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x4790
movl %eax, -0x8(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x8(%rbp), %eax
jne 0x5ffa
jmp 0x5fe4
leaq 0x3314(%rip), %rdi      # 0x92ff
callq 0x3470
movl $0x1, %edi
callq 0x34e0
xorl %eax, %eax
cmpl -0x8(%rbp), %eax
jne 0x6008
xorl %edi, %edi
callq 0x34e0
movq 0x7699(%rip), %rdi      # 0xd6a8
addq $0x18, %rdi
callq 0x4f90
movq 0x7689(%rip), %rdi      # 0xd6a8
addq $0x18, %rdi
movq 0x767e(%rip), %rsi      # 0xd6a8
addq $0x418, %rsi            # imm = 0x418
movq 0x7670(%rip), %rdx      # 0xd6a8
addq $0x818, %rdx            # imm = 0x818
movl $0x20, %ecx
callq 0x5010
movq 0x7658(%rip), %rdi      # 0xd6a8
addq $0x418, %rdi            # imm = 0x418
callq 0x50f0
movq 0x7645(%rip), %rsi      # 0xd6a8
addq $0x418, %rsi            # imm = 0x418
movq 0x7637(%rip), %rdx      # 0xd6a8
addq $0x818, %rdx            # imm = 0x818
leaq 0x328b(%rip), %rdi      # 0x930a
movb $0x0, %al
callq 0x31b0
movq 0x761b(%rip), %rsi      # 0xd6a8
addq $0x418, %rsi            # imm = 0x418
leaq 0x327e(%rip), %rdi      # 0x9319
callq 0x32e0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x60ca
movq 0x75f9(%rip), %rdi      # 0xd6a8
addq $0x418, %rdi            # imm = 0x418
leaq 0x3258(%rip), %rsi      # 0x9315
callq 0x32e0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x60e9
movq 0x75d7(%rip), %rdi      # 0xd6a8
callq 0x4cc0
movq 0x75cb(%rip), %rax      # 0xd6a8
movl $0x1, 0xc40(%rax)
jmp 0x6101
movq 0x75b8(%rip), %rdi      # 0xd6a8
movl $0x1f4, %esi            # imm = 0x1F4
leaq 0x3222(%rip), %rdx      # 0x931e
callq 0x5600
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: get_datafd
int get_datafd(session_t *sess)
{

    if ( has_port(sess))
    {
        int fd = get_tcpsocket(sess,listenip,20);

        //fd = tcp_clnt("192.168.1.3",0);
        /*
        struct sockaddr_in addr;
        socklen_t socklen;
        if ( -1 == getsockname(fd,(struct sockaddr*)&addr,&socklen))
            ERR_EXIT("getsockname error");
        printf("fd:%d\tip:%s\tport:%d\n",fd,inet_ntoa(addr.sin_addr),ntohs(addr.sin_port)); 
        if ( -1 == connect_timeout(fd,sess->port_addr,tunable_connect_timeout))
        {
            ERR_EXIT("connect_timeout error");
        }
        printf("connect success\n");
        */
        return fd;
    }
    
    if ( has_pasv(sess))
    {
        int fd = accept_timeout(sess->pasv_lsfd,NULL,tunable_accept_timeout);
        return fd; 
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4d80
cmpl $0x0, %eax
je 0x643d
movq -0x10(%rbp), %rdi
leaq 0x7263(%rip), %rax      # 0xd688
movq (%rax), %rsi
movl $0x14, %edx
callq 0x5780
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6479
movq -0x10(%rbp), %rdi
callq 0x4da0
cmpl $0x0, %eax
je 0x6472
movq -0x10(%rbp), %rax
movl 0xc20(%rax), %edi
leaq 0x6e78(%rip), %rax      # 0xd2d4
movl (%rax), %edx
xorl %eax, %eax
movl %eax, %esi
callq 0x4270
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6479
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: do_pass
static void do_pass(session_t* ssinf)
{
    struct spwd* spw = getspnam(username);
    struct passwd* pw = getpwnam(username);
    if (NULL == spw || NULL == pw) 
    {
        ftp_reply(ssinf,530,"Login incorrect");
    }

    char* encriedpw = crypt(ssinf->arg,spw->sp_pwdp);
    if ( 0 == strcmp(encriedpw,spw->sp_pwdp))
    {
        printf("login success\tusername:%s\n",username);    
        ftp_reply(ssinf,230,"Login successful");
        setegid(pw->pw_gid);
        seteuid(pw->pw_uid);
        chdir(pw->pw_dir);
    }
    else
    {
        ftp_reply(ssinf,530,"Login incorrect");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x71ad(%rip), %rdi      # 0xd6b0
callq 0x3440
movq %rax, -0x10(%rbp)
leaq 0x719d(%rip), %rdi      # 0xd6b0
callq 0x3300
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x652c
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x6541
movq -0x8(%rbp), %rdi
movl $0x212, %esi            # imm = 0x212
leaq 0x2f31(%rip), %rdx      # 0x946d
callq 0x5600
movq -0x8(%rbp), %rdi
addq $0x818, %rdi            # imm = 0x818
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3510
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x32e0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x65c7
leaq 0x2f00(%rip), %rdi      # 0x947d
leaq 0x712c(%rip), %rsi      # 0xd6b0
movb $0x0, %al
callq 0x31b0
movq -0x8(%rbp), %rdi
movl $0xe6, %esi
leaq 0x2efd(%rip), %rdx      # 0x9498
callq 0x5600
movq -0x18(%rbp), %rax
movl 0x14(%rax), %edi
callq 0x3520
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x3550
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3170
jmp 0x65dc
movq -0x8(%rbp), %rdi
movl $0x212, %esi            # imm = 0x212
leaq 0x2e96(%rip), %rdx      # 0x946d
callq 0x5600
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: do_port
void do_port(session_t *sess)
{
    clear_transfer(sess);

    int naddr[6];  
    sscanf(sess->arg,"%d,%d,%d,%d,%d,%d",&naddr[0],&naddr[1],&naddr[2],&naddr[3],&naddr[4],&naddr[5]);
    char ip[12] = {0};
    sprintf(ip,"%d.%d.%d.%d",naddr[0],naddr[1],naddr[2],naddr[3]);

    unsigned short nport = naddr[4];
    nport = (nport << 8) + naddr[5];


    //printf("addr:\tip:%s\tport:%d\n",ip,nport); 
    sess->port_addr = (struct sockaddr_in*)malloc(sizeof(struct sockaddr_in));

    sess->port_addr->sin_family = AF_INET;
    sess->port_addr->sin_port = htons(nport);
    sess->port_addr->sin_addr.s_addr = (inet_addr(ip));;


    ftp_reply(sess,FTP_PORTOK,"Port commande successful.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4cc0
movq -0x8(%rbp), %rdi
addq $0x818, %rdi            # imm = 0x818
leaq -0x20(%rbp), %rdx
leaq -0x20(%rbp), %rcx
addq $0x4, %rcx
leaq -0x20(%rbp), %r8
addq $0x8, %r8
leaq -0x20(%rbp), %r9
addq $0xc, %r9
leaq -0x20(%rbp), %r10
addq $0x10, %r10
leaq -0x20(%rbp), %rax
addq $0x14, %rax
leaq 0x2dbf(%rip), %rsi      # 0x94f2
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x33b0
leaq -0x2c(%rbp), %rdi
xorl %esi, %esi
movl $0xc, %edx
callq 0x3220
leaq -0x2c(%rbp), %rdi
movl -0x20(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x14(%rbp), %r9d
leaq 0x2d98(%rip), %rsi      # 0x9504
movb $0x0, %al
callq 0x34d0
movl -0x10(%rbp), %eax
movw %ax, -0x2e(%rbp)
movzwl -0x2e(%rbp), %eax
shll $0x8, %eax
addl -0xc(%rbp), %eax
movw %ax, -0x2e(%rbp)
movl $0x10, %edi
callq 0x33a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xc18(%rax)
movq -0x8(%rbp), %rax
movq 0xc18(%rax), %rax
movw $0x2, (%rax)
movzwl -0x2e(%rbp), %edi
callq 0x3190
movw %ax, %cx
movq -0x8(%rbp), %rax
movq 0xc18(%rax), %rax
movw %cx, 0x2(%rax)
leaq -0x2c(%rbp), %rdi
callq 0x32d0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq 0xc18(%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
movl $0xc8, %esi
leaq 0x2d1c(%rip), %rdx      # 0x9510
callq 0x5600
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: do_pasv
void do_pasv(session_t *sess)
{
    clear_transfer(sess);

    sess->pasv_lsfd = tcp_srv(listenip,0);
    
    struct sockaddr_in srvaddr;
    socklen_t socklen = sizeof(srvaddr);
    if ( -1 == getsockname(sess->pasv_lsfd,(struct sockaddr*)&srvaddr,&socklen))
        ERR_EXIT("getsockname error");
    

    char buf[1024];
    unsigned int port = ntohs(srvaddr.sin_port);
    unsigned int naddr[4];
    sscanf(inet_ntoa(srvaddr.sin_addr),"%u.%u.%u.%d",&naddr[0],&naddr[1],&naddr[2],
            &naddr[3]);

    sprintf(buf,"Entering Passive Mode (%u,%u,%u,%u,%u,%u).",naddr[0],naddr[1],naddr[2],naddr[3],
                port >> 8 , port & 0xFF);

    //printf("port :%u\n",port);
    
    ftp_reply(sess,FTP_PASVOK,buf);


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp            # imm = 0x450
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4cc0
leaq 0x6e69(%rip), %rax      # 0xd688
movq (%rax), %rdi
xorl %esi, %esi
callq 0x3b90
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc20(%rax)
movl $0x10, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0xc20(%rax), %edi
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x34b0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x6876
jmp 0x6860
leaq 0x2cc3(%rip), %rdi      # 0x952a
callq 0x3470
movl $0x1, %edi
callq 0x34e0
movzwl -0x16(%rbp), %edi
callq 0x33f0
movzwl %ax, %eax
movl %eax, -0x424(%rbp)
movl -0x14(%rbp), %edi
callq 0x3110
movq %rax, %rdi
leaq -0x440(%rbp), %rdx
leaq -0x440(%rbp), %rcx
addq $0x4, %rcx
leaq -0x440(%rbp), %r8
addq $0x8, %r8
leaq -0x440(%rbp), %r9
addq $0xc, %r9
leaq 0x2c7a(%rip), %rsi      # 0x953c
movb $0x0, %al
callq 0x33b0
leaq -0x420(%rbp), %rdi
movl -0x440(%rbp), %edx
movl -0x43c(%rbp), %ecx
movl -0x438(%rbp), %r8d
movl -0x434(%rbp), %r9d
movl -0x424(%rbp), %r10d
shrl $0x8, %r10d
movl -0x424(%rbp), %eax
andl $0xff, %eax
leaq 0x2c41(%rip), %rsi      # 0x9548
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x34d0
movq -0x8(%rbp), %rdi
leaq -0x420(%rbp), %rdx
movl $0xe3, %esi
callq 0x5600
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: do_type
void do_type(session_t *sess)
{
    //printf("%s\n",sess->arg);
    if ( 0 == strcmp("A",sess->arg))
    {
        //sess->bASCII = 1;
        //ftp_reply(sess,FTP_TYPEOK,"Switching to ASCII mode.");
        ftp_reply(sess,504,"ASCII mode unimplement");
    }
    else if ( 0 == strcmp("I",sess->arg))
    {
        sess->bASCII = 0;
        ftp_reply(sess,FTP_TYPEOK,"Switching to Binary mode.");
    }
    else
    {
        ftp_reply(sess,FTP_BADCMD,"Unrecognised TYPE command.");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
addq $0x818, %rsi            # imm = 0x818
leaq 0x2c15(%rip), %rdi      # 0x9573
callq 0x32e0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x6982
movq -0x8(%rbp), %rdi
movl $0x1f8, %esi            # imm = 0x1F8
leaq 0x2bfa(%rip), %rdx      # 0x9575
callq 0x5600
jmp 0x69da
movq -0x8(%rbp), %rsi
addq $0x818, %rsi            # imm = 0x818
leaq 0x2bf8(%rip), %rdi      # 0x958c
callq 0x32e0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x69c3
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdi
movl $0xc8, %esi
leaq 0x2bd2(%rip), %rdx      # 0x958e
callq 0x5600
jmp 0x69d8
movq -0x8(%rbp), %rdi
movl $0x1f4, %esi            # imm = 0x1F4
leaq 0x2bd5(%rip), %rdx      # 0x95a8
callq 0x5600
jmp 0x69da
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: do_list
void do_list(session_t *sess)
{
    int data_fd = get_datafd(sess);
    if ( -1 == data_fd )
    {
        ftp_reply(sess,FTP_BADSENDCONN,"Use port or pasv first");
        return;
    }

    char buf[1024];
    getcwd(buf,1024); 
    ftp_reply(sess,FTP_DATACONN,"Here comes the dictionary listing.");
    transfer_list(data_fd,buf);
    close(data_fd);
    ftp_reply(sess,FTP_TRANSFEROK,"Directory send OK.");
    clear_transfer(sess);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6400
movl %eax, -0xc(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0xc(%rbp), %eax
jne 0x702c
movq -0x8(%rbp), %rdi
movl $0x1a9, %esi            # imm = 0x1A9
leaq 0x259e(%rip), %rdx      # 0x95c3
callq 0x5600
jmp 0x7087
leaq -0x410(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x3240
movq -0x8(%rbp), %rdi
movl $0x96, %esi
leaq 0x265c(%rip), %rdx      # 0x96a9
callq 0x5600
movl -0xc(%rbp), %edi
leaq -0x410(%rbp), %rsi
callq 0x5a60
movl -0xc(%rbp), %edi
callq 0x3260
movq -0x8(%rbp), %rdi
movl $0xe2, %esi
leaq 0x2653(%rip), %rdx      # 0x96cc
callq 0x5600
movq -0x8(%rbp), %rdi
callq 0x4cc0
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: do_mkd
void do_mkd(session_t *sess)
{
    if ( -1 == mkdir(sess->arg,0777) )
    {
        ftp_reply(sess,FTP_FILEFAIL,"Create dictionary operation filed");
    }
    else 
    {
        char buf[1024] = {0};
        sprintf(buf,"\"%s\" created.",sess->arg);
        ftp_reply(sess,FTP_MKDIROK,buf);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x818, %rdi            # imm = 0x818
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x3090
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x71f6
movq -0x8(%rbp), %rdi
movl $0x226, %esi            # imm = 0x226
leaq 0x2530(%rip), %rdx      # 0x971f
callq 0x5600
jmp 0x723e
leaq -0x410(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x3220
leaq -0x410(%rbp), %rdi
movq -0x8(%rbp), %rdx
addq $0x818, %rdx            # imm = 0x818
leaq 0x251f(%rip), %rsi      # 0x9741
movb $0x0, %al
callq 0x34d0
movq -0x8(%rbp), %rdi
leaq -0x410(%rbp), %rdx
movl $0x101, %esi            # imm = 0x101
callq 0x5600
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: do_rnfr
void do_rnfr(session_t *sess)
{
    if ( NULL == sess->rn_filepath ) 
        sess->rn_filepath = (char*)malloc(strlen(sess->arg));
    else 
    {
        free(sess->rn_filepath);
        sess->rn_filepath = (char*)malloc(strlen(sess->arg) + 2);
    }

    strcpy(sess->rn_filepath,sess->arg);

    ftp_reply(sess,FTP_RESTOK,"Ready for RNTO.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq 0xc28(%rcx), %rax
jne 0x7353
movq -0x8(%rbp), %rdi
addq $0x818, %rdi            # imm = 0x818
callq 0x3160
movq %rax, %rdi
callq 0x33a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xc28(%rax)
jmp 0x738d
movq -0x8(%rbp), %rax
movq 0xc28(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rdi
addq $0x818, %rdi            # imm = 0x818
callq 0x3160
movq %rax, %rdi
addq $0x2, %rdi
callq 0x33a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xc28(%rax)
movq -0x8(%rbp), %rax
movq 0xc28(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x818, %rsi            # imm = 0x818
callq 0x3080
movq -0x8(%rbp), %rdi
movl $0x15e, %esi            # imm = 0x15E
leaq 0x2413(%rip), %rdx      # 0x97cb
callq 0x5600
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: do_rnto
void do_rnto(session_t *sess)
{
    if ( NULL == sess->rn_filepath) 
    {
        ftp_reply(sess,FTP_NEEDRNFR,"RNFR required first.");
        return;
    }

    if ( -1 == rename(sess->rn_filepath,sess->arg))
    {
        printf("oripath:%s\t,detpath:%s\n",sess->rn_filepath,sess->arg);
        ftp_reply(sess,FTP_FILEFAIL,"Rename failed.");
    }
    else
        ftp_reply(sess,FTP_RENAMEOK,"Rename successful.");

    free(sess->rn_filepath);
    sess->rn_filepath = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq 0xc28(%rcx), %rax
jne 0x7405
movq -0x8(%rbp), %rdi
movl $0x1f7, %esi            # imm = 0x1F7
leaq 0x23e0(%rip), %rdx      # 0x97db
callq 0x5600
jmp 0x749a
movq -0x8(%rbp), %rax
movq 0xc28(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x818, %rsi            # imm = 0x818
callq 0x3480
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x7466
movq -0x8(%rbp), %rax
movq 0xc28(%rax), %rsi
movq -0x8(%rbp), %rdx
addq $0x818, %rdx            # imm = 0x818
leaq 0x23a8(%rip), %rdi      # 0x97f0
movb $0x0, %al
callq 0x31b0
movq -0x8(%rbp), %rdi
movl $0x226, %esi            # imm = 0x226
leaq 0x23a9(%rip), %rdx      # 0x9808
callq 0x5600
jmp 0x747b
movq -0x8(%rbp), %rdi
movl $0xfa, %esi
leaq 0x23a1(%rip), %rdx      # 0x9817
callq 0x5600
movq -0x8(%rbp), %rax
movq 0xc28(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0xc28(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: do_site
void do_site(session_t *sess)
{
    char cmd[128] = {0};
    char arg[128] = {0};
    if ( 0 == strcmp("",sess->arg ))
    {
        ftp_reply(sess,FTP_BADCMD,"Unkown SITE commond.");
        return;
    }
    str_split(sess->arg,cmd,arg,' ');
    str_upper(cmd);

    if ( 0 == strcmp(cmd,"HELP") )
        do_site_help(sess,arg);
    else if ( 0 == strcmp(cmd,"UMASK") )
        do_site_umask(sess,arg);
    else if ( 0 == strcmp(cmd,"CHMOD") )
        do_site_chmod(sess,arg);
    else
        ftp_reply(sess,FTP_BADCMD,"Unkown SITE commond.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x3220
leaq -0x110(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x3220
movq -0x8(%rbp), %rsi
addq $0x818, %rsi            # imm = 0x818
leaq 0x24b2(%rip), %rdi      # 0x9999
callq 0x32e0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x750e
movq -0x8(%rbp), %rdi
movl $0x1f4, %esi            # imm = 0x1F4
leaq 0x2326(%rip), %rdx      # 0x982a
callq 0x5600
jmp 0x75dd
movq -0x8(%rbp), %rdi
addq $0x818, %rdi            # imm = 0x818
leaq -0x90(%rbp), %rsi
leaq -0x110(%rbp), %rdx
movl $0x20, %ecx
callq 0x5010
leaq -0x90(%rbp), %rdi
callq 0x50f0
leaq -0x90(%rbp), %rdi
leaq 0x230c(%rip), %rsi      # 0x9857
callq 0x32e0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x756a
movq -0x8(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x7b10
jmp 0x75dd
leaq -0x90(%rbp), %rdi
leaq 0x22c7(%rip), %rsi      # 0x983f
callq 0x32e0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x7597
movq -0x8(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x7b40
jmp 0x75db
leaq -0x90(%rbp), %rdi
leaq 0x22a0(%rip), %rsi      # 0x9845
callq 0x32e0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x75c4
movq -0x8(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x7c20
jmp 0x75d9
movq -0x8(%rbp), %rdi
movl $0x1f4, %esi            # imm = 0x1F4
leaq 0x2256(%rip), %rdx      # 0x982a
callq 0x5600
jmp 0x75db
jmp 0x75dd
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: do_feat
void do_feat(session_t *sess)
{
    ftp_lreply(sess,FTP_FEAT,"Features");
    writen(sess->ctrlfd," EPRT\r\n",strlen(" EPRT\r\n"));
    writen(sess->ctrlfd," EPSV\r\n",strlen(" EPSV\r\n"));
    writen(sess->ctrlfd," MDTM\r\n",strlen(" MDTM\r\n"));
    writen(sess->ctrlfd," PASV\r\n",strlen(" PASV\r\n"));
    writen(sess->ctrlfd," REST STREAM\r\n",strlen(" REST STREAM\r\n"));
    writen(sess->ctrlfd," SIZE\r\n",strlen(" SIZE\r\n"));
    writen(sess->ctrlfd," TVFS\r\n",strlen(" PASV\r\n"));
    writen(sess->ctrlfd," UTF8\r\n",strlen(" UTF8\r\n"));
    ftp_reply(sess,FTP_FEAT,"End");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0xd3, %esi
leaq 0x22a8(%rip), %rdx      # 0x98e4
callq 0x56c0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
leaq 0x229e(%rip), %rsi      # 0x98ed
movl $0x7, %edx
callq 0x46a0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
leaq 0x228e(%rip), %rsi      # 0x98f5
movl $0x7, %edx
callq 0x46a0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
leaq 0x227e(%rip), %rsi      # 0x98fd
movl $0x7, %edx
callq 0x46a0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
leaq 0x226e(%rip), %rsi      # 0x9905
movl $0x7, %edx
callq 0x46a0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
leaq 0x225e(%rip), %rsi      # 0x990d
movl $0xe, %edx
callq 0x46a0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
leaq 0x2255(%rip), %rsi      # 0x991c
movl $0x7, %edx
callq 0x46a0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
leaq 0x2245(%rip), %rsi      # 0x9924
movl $0x7, %edx
callq 0x46a0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
leaq 0x2235(%rip), %rsi      # 0x992c
movl $0x7, %edx
callq 0x46a0
movq -0x8(%rbp), %rdi
movl $0xd3, %esi
leaq 0x2223(%rip), %rdx      # 0x9934
callq 0x5600
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: do_size
void do_size(session_t *sess)
{
    struct stat statbuf;
    if ( -1 == stat(sess->arg,&statbuf) )
    {
        ftp_reply(sess,FTP_FILEFAIL,"Could not get file size.");
        return;
    }

    if ( !S_ISREG(statbuf.st_mode) )
    {
        ftp_reply(sess,FTP_FILEFAIL,"Could not get file size.");
        return;
    }

    char sizebuf[128] = {0};
    sprintf(sizebuf,"%d",(int)statbuf.st_size);
    ftp_reply(sess,FTP_SIZEOK,sizebuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x818, %rdi            # imm = 0x818
leaq -0x98(%rbp), %rsi
callq 0x3340
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x7768
movq -0x8(%rbp), %rdi
movl $0x226, %esi            # imm = 0x226
leaq 0x21d7(%rip), %rdx      # 0x9938
callq 0x5600
jmp 0x77d1
movl -0x80(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
je 0x778e
movq -0x8(%rbp), %rdi
movl $0x226, %esi            # imm = 0x226
leaq 0x21b1(%rip), %rdx      # 0x9938
callq 0x5600
jmp 0x77d1
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x3220
leaq -0x120(%rbp), %rdi
movq -0x68(%rbp), %rax
movl %eax, %edx
leaq 0x1b2b(%rip), %rsi      # 0x92e0
movb $0x0, %al
callq 0x34d0
movq -0x8(%rbp), %rdi
leaq -0x120(%rbp), %rdx
movl $0xd5, %esi
callq 0x5600
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: do_help
void do_help(session_t *sess)
{
    ftp_lreply(sess,FTP_HELP,"The following commands are recognized.");
    writen(sess->ctrlfd," ABOR ACCT ALLO APPE CDUP CWD  DELE EPRT EPSV FEAT HELP LIST MDTM MKD\r\n",
            strlen(" ABOR ACCT ALLO APPE CDUP CWD  DELE EPRT EPSV FEAT HELP LIST MDTM MKD\r\n"));
    writen(sess->ctrlfd," MODE NLST NOOP OPTS PASS PASV PORT PWD  QUIT REIN REST RETR RMD  RNFR\r\n",
            strlen(" MODE NLST NOOP OPTS PASS PASV PORT PWD  QUIT REIN REST RETR RMD  RNFR\r\n"));
    writen(sess->ctrlfd," RNTO SITE SIZE SMNT STAT STOR STOU STRU SYST TYPE USER XCUP XCWD XMKD\r\n",
            strlen(" RNTO SITE SIZE SMNT STAT STOR STOU STRU SYST TYPE USER XCUP XCWD XMKD\r\n"));
    writen(sess->ctrlfd," XPWD XRMD\r\n",strlen(" XPWD XRMD\r\n"));
    ftp_reply(sess,FTP_HELP,"HELP OK");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0xd6, %esi
leaq 0x1f6f(%rip), %rdx      # 0x99fb
callq 0x56c0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
leaq 0x1f83(%rip), %rsi      # 0x9a22
movl $0x47, %edx
callq 0x46a0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
leaq 0x1fb3(%rip), %rsi      # 0x9a6a
movl $0x48, %edx
callq 0x46a0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
leaq 0x1fe4(%rip), %rsi      # 0x9ab3
movl $0x48, %edx
callq 0x46a0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
leaq 0x2015(%rip), %rsi      # 0x9afc
movl $0xc, %edx
callq 0x46a0
movq -0x8(%rbp), %rdi
movl $0xd6, %esi
leaq 0x2008(%rip), %rdx      # 0x9b09
callq 0x5600
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: do_site_umask
void do_site_umask(session_t* sess,char* cmdline)
{
    char str[128] = {0};
    if ( 0 == strlen(cmdline) )
    {
        sprintf(str,"Your current UMASK is 0%o",tunable_local_umask);
        ftp_reply(sess,FTP_UMASKOK,str);
    }
    else
    {
        unsigned int maskval = str_octal_to_uint(cmdline);
        printf("%u\n",maskval);
        umask(maskval); 
        sprintf(str,"UMASK set to %o",maskval);
        ftp_reply(sess,FTP_UMASKOK,str);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x3220
movq -0x10(%rbp), %rdi
callq 0x3160
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x7bae
leaq -0x90(%rbp), %rdi
leaq 0x5759(%rip), %rax      # 0xd2e0
movl (%rax), %edx
leaq 0x1ccc(%rip), %rsi      # 0x985c
movb $0x0, %al
callq 0x34d0
movq -0x8(%rbp), %rdi
leaq -0x90(%rbp), %rdx
movl $0xc8, %esi
callq 0x5600
jmp 0x7c0c
movq -0x10(%rbp), %rdi
callq 0x5130
movl %eax, -0x94(%rbp)
movl -0x94(%rbp), %esi
leaq 0x20ec(%rip), %rdi      # 0x9cb6
movb $0x0, %al
callq 0x31b0
movl -0x94(%rbp), %edi
callq 0x3330
leaq -0x90(%rbp), %rdi
movl -0x94(%rbp), %edx
leaq 0x1c86(%rip), %rsi      # 0x9876
movb $0x0, %al
callq 0x34d0
movq -0x8(%rbp), %rdi
leaq -0x90(%rbp), %rdx
movl $0xc8, %esi
callq 0x5600
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpproto.c
// Function: do_site_chmod
void do_site_chmod(session_t* sess,char* arg)
{
    char perm[128] = {0};
    char file[128] = {0};
    
    if ( 2 != str_split(arg,perm,file,' ') )
    {
        ftp_reply(sess,FTP_BADCMD,"SITE CHMOD needs 2 arguments.");
        return;
    }

    unsigned int mode = str_octal_to_uint(perm);
    if ( -1 == chmod(file,mode) )
        ftp_reply(sess,FTP_CHMODFAIL,"SITE CHMODE command failed");
    else
        ftp_reply(sess,FTP_CHMODOK,"SITE CHMODE command ok");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x3220
leaq -0x110(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x3220
movq -0x10(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x110(%rbp), %rdx
movl $0x20, %ecx
callq 0x5010
movl %eax, %ecx
movl $0x2, %eax
cmpl %ecx, %eax
je 0x7c97
movq -0x8(%rbp), %rdi
movl $0x1f4, %esi            # imm = 0x1F4
leaq 0x1bf6(%rip), %rdx      # 0x9886
callq 0x5600
jmp 0x7cf2
leaq -0x90(%rbp), %rdi
callq 0x5130
movl %eax, -0x114(%rbp)
leaq -0x110(%rbp), %rdi
movl -0x114(%rbp), %esi
callq 0x3400
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x7cdd
movq -0x8(%rbp), %rdi
movl $0x226, %esi            # imm = 0x226
leaq 0x1bce(%rip), %rdx      # 0x98a4
callq 0x5600
jmp 0x7cf2
movq -0x8(%rbp), %rdi
movl $0xc8, %esi
leaq 0x1bd2(%rip), %rdx      # 0x98bf
callq 0x5600
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpnobody.c
// Function: handle_pri
int handle_pri(session_t* ssinf)
{

    set_minprivilage();
    int cmd;
    while (1)
    {
        cmd = ftpipc_recv_cmd(ssinf->nobodyfd);
        if ( 0 == cmd)
            exit(EXIT_SUCCESS);
        if ( -1 == cmd )
            exit(EXIT_FAILURE);
        switch (cmd)
        {
        case FTPIPC_GET_DATA_FD:
            do_getdatafd(ssinf);
            break;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x7d90
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x8100
movl %eax, -0xc(%rbp)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jne 0x7d5d
xorl %edi, %edi
callq 0x34e0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0xc(%rbp), %eax
jne 0x7d71
movl $0x1, %edi
callq 0x34e0
movl -0xc(%rbp), %eax
subl $0x1, %eax
jne 0x7d84
jmp 0x7d7b
movq -0x8(%rbp), %rdi
callq 0x7e80
jmp 0x7d41
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpnobody.c
// Function: set_minprivilage
void set_minprivilage(void)
{
    struct passwd* pwd = getpwnam("nobody");
    if ( NULL == pwd )
        ERR_EXIT("getpwnam error");
    if ( -1 == setegid(pwd->pw_gid))
        ERR_EXIT("setegid error"); 
    if ( -1 == seteuid(pwd->pw_uid))
        ERR_EXIT("seteuid error"); 

    struct __user_cap_header_struct cap_header;
    cap_header.version = _LINUX_CAPABILITY_VERSION_1;
    cap_header.pid = 0;
    struct __user_cap_data_struct cap_data;
    cap_data.effective = cap_data.permitted = 1 << CAP_NET_BIND_SERVICE;
    cap_data.inheritable = 0;
    if ( -1 == capset(&cap_header,&cap_data))
        ERR_EXIT("capset error");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x1d88(%rip), %rdi      # 0x9b27
callq 0x3300
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
jne 0x7dc8
jmp 0x7db2
leaq 0x1d75(%rip), %rdi      # 0x9b2e
callq 0x3470
movl $0x1, %edi
callq 0x34e0
movq -0x8(%rbp), %rax
movl 0x14(%rax), %edi
callq 0x3520
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x7df7
jmp 0x7de1
leaq 0x1d55(%rip), %rdi      # 0x9b3d
callq 0x3470
movl $0x1, %edi
callq 0x34e0
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x3550
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x7e26
jmp 0x7e10
leaq 0x1d34(%rip), %rdi      # 0x9b4b
callq 0x3470
movl $0x1, %edi
callq 0x34e0
movl $0x19980330, -0x10(%rbp) # imm = 0x19980330
movl $0x0, -0xc(%rbp)
movl $0x400, -0x18(%rbp)     # imm = 0x400
movl $0x400, -0x1c(%rbp)     # imm = 0x400
movl $0x0, -0x14(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x7d00
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x7e79
jmp 0x7e63
leaq 0x1cef(%rip), %rdi      # 0x9b59
callq 0x3470
movl $0x1, %edi
callq 0x34e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpnobody.c
// Function: do_getdatafd
void do_getdatafd(session_t* ssinf)
{
    char ip[128] = {0};
    int port;
    if ( -1 == ftpipc_recv_data(ssinf->nobodyfd,ip,128))
        return;
    if ( -1 == ftpipc_recv_data(ssinf->nobodyfd,&port,sizeof(int)))
       return;
    //printf("nobody recv data:oip:%s\t,%u\n",ip,port);


    struct sockaddr_in addr;
    if ( -1 == ftpipc_recv_data(ssinf->nobodyfd,&addr,sizeof(addr)))
        return;
    //printf("ip:%s\tport:%d\n",inet_ntoa(addr.sin_addr),ntohs(addr.sin_port)); 



    int fd = tcp_clnt(ip,port);
    if ( -1 == connect_timeout(fd,&addr,tunable_connect_timeout))
    {
        ERR_EXIT("connect_timeout error");
    }
    //printf("connect success\n");
     

    if ( -1 == fd )
        ftpipc_send_ret(ssinf->nobodyfd,FTPIPC_RET_BAD);
    
    ftpipc_send_ret(ssinf->nobodyfd,FTPIPC_RET_OK);
    ftpipc_send_fd(ssinf->nobodyfd,fd); 

    close(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x3220
movq -0x8(%rbp), %rax
movl (%rax), %edi
leaq -0x90(%rbp), %rsi
movl $0x80, %edx
callq 0x8280
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x7ec9
jmp 0x7fb9
movq -0x8(%rbp), %rax
movl (%rax), %edi
leaq -0x94(%rbp), %rsi
movl $0x4, %edx
callq 0x8280
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x7ef0
jmp 0x7fb9
movq -0x8(%rbp), %rax
movl (%rax), %edi
leaq -0xa4(%rbp), %rsi
movl $0x10, %edx
callq 0x8280
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x7f17
jmp 0x7fb9
leaq -0x90(%rbp), %rdi
movl -0x94(%rbp), %eax
movzwl %ax, %esi
callq 0x3d00
movl %eax, -0xa8(%rbp)
movl -0xa8(%rbp), %edi
leaq 0x5751(%rip), %rax      # 0xd690
movl (%rax), %edx
leaq -0xa4(%rbp), %rsi
callq 0x43f0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x7f70
jmp 0x7f5a
leaq 0x1bb0(%rip), %rdi      # 0x9b11
callq 0x3470
movl $0x1, %edi
callq 0x34e0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0xa8(%rbp), %eax
jne 0x7f8d
movq -0x8(%rbp), %rax
movl (%rax), %edi
movl $0x2, %esi
callq 0x8150
movq -0x8(%rbp), %rax
movl (%rax), %edi
movl $0x1, %esi
callq 0x8150
movq -0x8(%rbp), %rax
movl (%rax), %edi
movl -0xa8(%rbp), %esi
callq 0x8340
movl -0xa8(%rbp), %edi
callq 0x3260
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpipc.c
// Function: ftpipc_init
int ftpipc_init(session_t* ssinf)
{
    int fd[2];
    if (-1 == socketpair(AF_UNIX,SOCK_STREAM,0,fd))
        ERR_EXIT("socketpair error");

    ssinf->protofd = fd[0];
    ssinf->nobodyfd = fd[1];

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rcx
movl $0x1, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x3360
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x8011
jmp 0x7ffb
leaq 0x1b64(%rip), %rdi      # 0x9b66
callq 0x3470
movl $0x1, %edi
callq 0x34e0
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icysunlight[P]miniftpd/ftpipc.c
// Function: ftpipc_close
void ftpipc_close(session_t* ssinf)
{
    if ( ssinf->protofd != -1 )
        close(ssinf->protofd);
    if ( ssinf->nobodyfd != -1 )
        close(ssinf->nobodyfd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x4(%rax)
je 0x8052
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x3260
movq -0x8(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x8066
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x3260
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)