LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/VeeeectorPan[P]MyNetdisk/SourceFile/bind_sfd.c
// Function: bind_sfd
int bind_sfd(char** arg,int sfd)
{
    struct sockaddr_in server_addr;
    server_addr.sin_addr.s_addr = inet_addr(arg[0]);
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(atoi(arg[1]));
    int ret = bind(sfd,(struct sockaddr*)&server_addr,sizeof(server_addr));
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x21e0
leaq -0x28(%rbp), %r15
movl %eax, 0x4(%r15)
movw $0x2, (%r15)
movq 0x8(%r14), %rdi
callq 0x2300
rolw $0x8, %ax
movw %ax, 0x2(%r15)
pushq $0x10
popq %rdx
movl %ebx, %edi
movq %r15, %rsi
callq 0x2050
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/VeeeectorPan[P]MyNetdisk/SourceFile/client_get.c
// Function: client_get
int client_get(int client_fd)
{
    MYSQL* connect;
    connect_mysql(&connect);
    int file_id;
    int ret = recv(client_fd,&file_id,sizeof(int),0);
    DISCON_CHECK(ret,0,client_fd);
    int file_name_len;
    ret = recv(client_fd,&file_name_len,sizeof(int),0);
    DISCON_CHECK(ret,0,client_fd);
    int path_len;
    ret = recv(client_fd,&path_len,sizeof(int),0);
    DISCON_CHECK(ret,0,client_fd);
    char file_name[128] = {0};
    ret = recv_client_all(client_fd,file_name,file_name_len);
    DISCON_CHECK(ret,-1,client_fd);
    char path[4096] = {0};
    ret = recv_client_all(client_fd,path,path_len);
    DISCON_CHECK(ret,-1,client_fd);
    printf("%s\n%s\n",file_name,path);
    send_file_to_client(client_fd,file_id,file_name,path,connect);
    close(client_fd);
    mysql_close(connect);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10a0, %rsp           # imm = 0x10A0
movl %edi, %ebx
leaq -0x38(%rbp), %rdi
callq 0x3434
leaq -0x2c(%rbp), %rsi
pushq $0x4
popq %rdx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x20a0
testl %eax, %eax
je 0x2788
leaq -0x28(%rbp), %rsi
pushq $0x4
popq %rdx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x20a0
testl %eax, %eax
je 0x2788
leaq -0x24(%rbp), %rsi
pushq $0x4
popq %rdx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x20a0
testl %eax, %eax
je 0x2788
xorps %xmm0, %xmm0
leaq -0xc0(%rbp), %rsi
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl -0x28(%rbp), %edx
movl %ebx, %edi
callq 0x45cc
cmpl $-0x1, %eax
je 0x2788
leaq -0x10c0(%rbp), %r15
xorl %r14d, %r14d
movl $0x1000, %edx           # imm = 0x1000
movq %r15, %rdi
xorl %esi, %esi
callq 0x2130
movl -0x24(%rbp), %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x45cc
cmpl $-0x1, %eax
je 0x2788
leaq 0x293c(%rip), %rdi      # 0x5083
leaq -0xc0(%rbp), %r15
leaq -0x10c0(%rbp), %r12
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2040
movl -0x2c(%rbp), %esi
movq -0x38(%rbp), %r8
movl %ebx, %edi
movq %r15, %rdx
movq %r12, %rcx
callq 0x48f4
movl %ebx, %edi
callq 0x2380
movq -0x38(%rbp), %rdi
callq 0x2260
jmp 0x2793
movl %ebx, %edi
callq 0x2380
pushq $-0x1
popq %r14
movl %r14d, %eax
addq $0x10a0, %rsp           # imm = 0x10A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/VeeeectorPan[P]MyNetdisk/SourceFile/compute_file_md5_2.c
// Function: compute_file_md5_2
int compute_file_md5_2(int fd,char* md5_str,int size)
{
    int i;
	int ret;
	unsigned char data[READ_DATA_SIZE];
	unsigned char md5_value[MD5_SIZE];
	MD5_CTX md5;


	// init md5
	MD5Init(&md5);

    int total = 0;
    while(total < size)
	{
        if(size - total > 4096)
		    ret = read(fd, data, 4096);
        else
            ret = read(fd,data,size - total);
		if (-1 == ret)
		{
			perror("read");
			close(fd);
			return -1;
		}
		MD5Update(&md5, data, ret);
        total += ret;
	}


	MD5Final(&md5, md5_value);

	// convert md5 value to md5 string
	for(i = 0; i < MD5_SIZE; i++)
	{
		snprintf(md5_str + i*2, 2+1, "%02x", md5_value[i]);
	}

	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1078, %rsp           # imm = 0x1078
movl %edx, -0x30(%rbp)
movq %rsi, %rbx
movl %edi, -0x2c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x3b54
xorl %r14d, %r14d
movl $0x1000, %r15d          # imm = 0x1000
leaq -0x10a0(%rbp), %r13
movl -0x30(%rbp), %eax
subl %r14d, %eax
jle 0x33be
cmpl %r15d, %eax
cmovgel %r15d, %eax
movslq %eax, %rdx
movl -0x2c(%rbp), %edi
movq %r13, %rsi
callq 0x22a0
movq %rax, %r12
cmpl $-0x1, %r12d
je 0x3404
leaq -0x98(%rbp), %rdi
movq %r13, %rsi
movl %r12d, %edx
callq 0x3b72
addl %r12d, %r14d
jmp 0x3381
leaq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x438a
xorl %r14d, %r14d
leaq 0x201b(%rip), %r15      # 0x53f3
pushq $0x3
popq %r12
xorl %r13d, %r13d
cmpq $0x10, %r13
je 0x341c
movzbl -0x40(%rbp,%r13), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2310
incq %r13
addq $0x2, %rbx
jmp 0x33df
leaq 0x1fe3(%rip), %rdi      # 0x53ee
callq 0x2190
movl -0x2c(%rbp), %edi
callq 0x2380
pushq $-0x1
popq %r14
movl %r14d, %eax
addq $0x1078, %rsp           # imm = 0x1078
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/VeeeectorPan[P]MyNetdisk/SourceFile/factory_init.c
// Function: factory_init
int factory_init(factory_t *p_fact,int pthread_num,int que_capacity,int epoll_fd)
{
    if(pthread_num < 1 || que_capacity < 1)
    {
        puts("pthread_num or que_capacity error!\n");
        return -1;
    }
    que_init(&p_fact->que,que_capacity);
    pthread_cond_init(&p_fact->cond,NULL);
    pthread_mutex_init(&p_fact->mutex,NULL);
    p_fact->epoll_fd = epoll_fd;
    p_fact->pthread_num = pthread_num;
    p_fact->pthId_arr = (pthread_t*)malloc(sizeof(pthread_t) * pthread_num);
    p_fact->pthread_func = thread_func;
    p_fact->start_flag = 0;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r12d
testl %esi, %esi
setg %al
testl %edx, %edx
setg %cl
testb %cl, %al
jne 0x34d6
leaq 0x1f91(%rip), %rdi      # 0x545c
callq 0x22f0
pushq $-0x1
popq %r14
jmp 0x3526
movl %esi, %r15d
movq %rdi, %rbx
addq $0x20, %rdi
movl %edx, %esi
callq 0x44e0
leaq 0x60(%rbx), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x2230
leaq 0x38(%rbx), %rdi
xorl %esi, %esi
callq 0x22c0
movl %r12d, 0x8(%rbx)
movl %r15d, 0x4(%rbx)
movl %r15d, %edi
shlq $0x3, %rdi
callq 0x2250
movq %rax, 0x10(%rbx)
leaq 0x13(%rip), %rax        # 0x3532
movq %rax, 0x18(%rbx)
andl $0x0, (%rbx)
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/VeeeectorPan[P]MyNetdisk/SourceFile/factory_start.c
// Function: factory_start
int factory_start(factory_t* p_fact)
{
    if(p_fact->start_flag == 0)
    {
        for(int i = 0; i < p_fact->pthread_num; ++i)
        {
            pthread_create(p_fact->pthId_arr + i,NULL,p_fact->pthread_func,p_fact);
        }
        p_fact->start_flag = 1;
    }
    return 0;
}

// Assembly:
cmpl $0x0, (%rdi)
jne 0x36cb
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jge 0x36bb
movq 0x10(%rbx), %rdi
addq %r14, %rdi
movq 0x18(%rbx), %rdx
xorl %esi, %esi
movq %rbx, %rcx
callq 0x2330
incq %r15
addq $0x8, %r14
jmp 0x3694
movl $0x1, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/VeeeectorPan[P]MyNetdisk/SourceFile/get_crypt_passwd.c
// Function: get_crypt_passwd
const char* get_crypt_passwd(const char* crybuf)
{
    int i; 
    int num = 0;
    for(i = 0; num != 3; ++i)
    {
        if(crybuf[i] == '$')
            ++num;
    }
    return crybuf + i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
xorl %ecx, %ecx
xorl %edx, %edx
cmpl $0x3, %edx
je 0x36f1
xorl %esi, %esi
cmpb $0x24, (%rax,%rcx)
sete %sil
incq %rcx
addl %esi, %edx
jmp 0x36db
movl %ecx, %ecx
addq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/VeeeectorPan[P]MyNetdisk/SourceFile/get_file_id.c
// Function: get_file_id
int get_file_id(char* mysql_oper,int user_id,MYSQL* connect)
{
    sprintf(mysql_oper,"select file_id from File where user_id=%d;",user_id);
    int queryResult = mysql_query(connect,mysql_oper);
    if(queryResult)
    {
        printf("%s\n",mysql_error(connect));
        return -1;
    }
    MYSQL_ROW row;
    MYSQL_RES* res;
    res = mysql_use_result(connect);
    row = mysql_fetch_row(res);
    int ret = atoi(row[0]);
    mysql_free_result(res);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %edx
movq %rdi, %r14
leaq 0x1d98(%rip), %rsi      # 0x54a6
xorl %eax, %eax
callq 0x2060
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2140
movq %rbx, %rdi
testl %eax, %eax
je 0x3739
callq 0x20b0
movq %rax, %rdi
callq 0x22f0
pushq $-0x1
popq %rax
jmp 0x375f
callq 0x2340
movq %rax, %rbx
movq %rax, %rdi
callq 0x2200
movq (%rax), %rdi
callq 0x2300
movl %eax, %r14d
movq %rbx, %rdi
callq 0x21f0
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/VeeeectorPan[P]MyNetdisk/SourceFile/get_salt.c
// Function: get_salt
void get_salt(char* str)
{
    srand(time(NULL));
    for(int i = 0; i < 16; ++i)
    {
        switch(rand()%3)
        {
        case 0:
            str[i] = rand()%26 + 'a';
            break;
        case 1:
            str[i] = rand()%26 + 'A';
            break;
        case 2:
            str[i] = rand()%10 + '0';
            break;
        }   
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x21b0
movl %eax, %edi
callq 0x21d0
pushq $0x3
popq %r15
cmpq $0x10, %r14
je 0x37cc
callq 0x2080
cltd
idivl %r15d
cmpl $0x2, %edx
ja 0x37c7
movl %edx, %r13d
shll $0x3, %edx
movl $0x304161, %r12d        # imm = 0x304161
movl %edx, %ecx
shrl %cl, %r12d
callq 0x2080
cltd
leaq 0x1d18(%rip), %rcx      # 0x54d4
idivl (%rcx,%r13,4)
addb %r12b, %dl
movb %dl, (%rbx,%r14)
incq %r14
jmp 0x378a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/VeeeectorPan[P]MyNetdisk/SourceFile/get_user_id.c
// Function: get_user_id
int get_user_id(char* mysql_oper,const char* user_name,MYSQL* connect)
{
    sprintf(mysql_oper,"select user_id from User where user_name='%s'",user_name);
    int queryResult = mysql_query(connect,mysql_oper);
    if(queryResult)
    {
        printf("%s\n",mysql_error(connect));
        return -1;
    }
    MYSQL_ROW row;
    MYSQL_RES* res;
    res = mysql_use_result(connect);
    row = mysql_fetch_row(res);
    int ret = atoi(row[0]);
    mysql_free_result(res);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x1ced(%rip), %rsi      # 0x54e0
xorl %eax, %eax
callq 0x2060
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2140
movq %rbx, %rdi
testl %eax, %eax
je 0x381e
callq 0x20b0
movq %rax, %rdi
callq 0x22f0
pushq $-0x1
popq %rax
jmp 0x3844
callq 0x2340
movq %rax, %rbx
movq %rax, %rdi
callq 0x2200
movq (%rax), %rdi
callq 0x2300
movl %eax, %r14d
movq %rbx, %rdi
callq 0x21f0
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/VeeeectorPan[P]MyNetdisk/SourceFile/is_match.c
// Function: is_match
int is_match(const char* user_name,const char* user_passwd,MYSQL* connect)
{
    char sha512[256] = {0};
    strcpy(sha512,"$6$");
    char mysql_oper[256];
    sprintf(mysql_oper,"select salt,cryptpasswd from User where user_name='%s'",user_name);
    int queryResult = mysql_query(connect,mysql_oper);
    if(queryResult)
    {
        printf("%s\n",mysql_error(connect));
        return -1;
    }
    MYSQL_ROW row;
    MYSQL_RES* res;
    res = mysql_use_result(connect);
    row = mysql_fetch_row(res);
    sprintf(sha512 + 3,"%s",row[0]);
    void* crypt_add = NULL;
    int crypt_size = 0;
    crypt_ra(user_passwd,sha512,&crypt_add,&crypt_size);
    int len = strlen(sha512) + 1;
    sha512[len - 1] = '$';
    sprintf(sha512 + len,"%s",row[1]);
    mysql_free_result(res);
    int ret = strcmp(sha512,(const char*)crypt_add);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x140(%rbp), %r12
movl $0x100, %edx            # imm = 0x100
movq %r12, %rdi
xorl %esi, %esi
callq 0x2130
movl $0x243624, (%r12)       # imm = 0x243624
leaq 0x1c48(%rip), %rsi      # 0x550e
leaq -0x240(%rbp), %r12
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2060
movq %r14, %rdi
movq %r12, %rsi
callq 0x2140
movq %r14, %rdi
testl %eax, %eax
je 0x3901
callq 0x20b0
movq %rax, %rdi
callq 0x22f0
pushq $-0x1
popq %rax
jmp 0x3985
callq 0x2340
movq %rax, %r14
movq %rax, %rdi
callq 0x2200
movq %rax, %r12
leaq -0x13d(%rbp), %rdi
movq (%rax), %rsi
callq 0x21c0
leaq -0x38(%rbp), %r15
andq $0x0, (%r15)
leaq -0x2c(%rbp), %rcx
andl $0x0, (%rcx)
leaq -0x140(%rbp), %r13
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x2240
movq %r13, %rdi
callq 0x20c0
cltq
movb $0x24, -0x140(%rbp,%rax)
incl %eax
cltq
leaq (%rax,%rbp), %rdi
addq $-0x140, %rdi           # imm = 0xFEC0
movq 0x8(%r12), %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x21f0
movq (%r15), %rsi
movq %r13, %rdi
callq 0x2290
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/VeeeectorPan[P]MyNetdisk/SourceFile/query.c
// Function: query
MYSQL_RES* query(char* mysql_oper,MYSQL* connect)
{
    int queryResult = mysql_query(connect,mysql_oper);
    if(queryResult)
    {
        printf("%s\n",mysql_error(connect));
        return NULL;
    }
    MYSQL_RES* res;
    res = mysql_use_result(connect);
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rsi
movq %rbx, %rdi
callq 0x2140
movq %rbx, %rdi
testl %eax, %eax
je 0x4499
callq 0x20b0
movq %rax, %rdi
callq 0x22f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2340
// File: /workspace/github_c_makefile_star2_O2/VeeeectorPan[P]MyNetdisk/SourceFile/query2.c
// Function: query2
MYSQL_RES* query2(char* mysql_oper,MYSQL* connect)
{
    int queryResult = mysql_query(connect,mysql_oper);
    if(queryResult)
    {
        printf("%s\n",mysql_error(connect));
        return NULL;
    }
    return mysql_store_result(connect);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rsi
movq %rbx, %rdi
callq 0x2140
movq %rbx, %rdi
testl %eax, %eax
je 0x44d5
callq 0x20b0
movq %rax, %rdi
callq 0x22f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2120
// File: /workspace/github_c_makefile_star2_O2/VeeeectorPan[P]MyNetdisk/SourceFile/queue.c
// Function: que_push
int que_push(que_t* p_queue,int client_fd,int ctl_no)
{
    if(p_queue->que_size == p_queue->que_capacity)
        return -1;
    struct Queue_node* new_node = (struct Queue_node*)malloc(sizeof(struct Queue_node));
    memset(new_node,0,sizeof(struct Queue_node));
    new_node->client_fd = client_fd;
    new_node->ctl_no = ctl_no;
    if(p_queue->que_size == 0)
    {
        p_queue->head = new_node;
        p_queue->tail = new_node;
    }
    else
    {
        p_queue->tail->next = new_node;
        p_queue->tail = new_node;
    }
    p_queue->que_size++;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x4(%rdi), %r12d
cmpl (%rdi), %r12d
jne 0x450c
pushq $-0x1
popq %rax
jmp 0x4547
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x2150
movl %r15d, (%rax)
movl %r14d, 0x4(%rax)
testl %r12d, %r12d
je 0x4536
movq 0x10(%rbx), %rcx
movq %rax, 0x8(%rcx)
jmp 0x453a
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
incl %r12d
movl %r12d, 0x4(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/VeeeectorPan[P]MyNetdisk/SourceFile/queue.c
// Function: que_pop
int que_pop(que_t* p_queue,struct Queue_node** pop_node)
{
    if(p_queue->que_size == 0)
        return -1;
    *pop_node = p_queue->head;
    p_queue->head = p_queue->head->next;
    p_queue->que_size--;
    return 0;
}

// Assembly:
movl 0x4(%rdi), %eax
testl %eax, %eax
je 0x4573
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rcx
movq %rcx, (%rsi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rdi)
decl %eax
movl %eax, 0x4(%rdi)
xorl %eax, %eax
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O2/VeeeectorPan[P]MyNetdisk/SourceFile/queue.c
// Function: que_free
void que_free(que_t* p_queue)
{
    if(p_queue->que_size == 0)
        return;
    for(int i = 0;i < p_queue->que_size; ++i)
    {
        struct Queue_node* node = p_queue->head;
        p_queue->head = p_queue->head->next;
        free(node);
    }
    p_queue->head = p_queue->tail = NULL;
    p_queue->que_size = 0;
}

// Assembly:
movl 0x4(%rdi), %eax
testl %eax, %eax
je 0x45c8
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rdi), %r14
xorl %r15d, %r15d
cmpl %eax, %r15d
jge 0x45b2
movq 0x8(%rbx), %rdi
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rbx)
callq 0x2220
incl %r15d
movl 0x4(%rbx), %eax
jmp 0x4594
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andl $0x0, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/VeeeectorPan[P]MyNetdisk/SourceFile/recv_n_bytes.c
// Function: recv_n_bytes
int recv_n_bytes(int fd,void* buf,int len)
{
    int total = 0;
    int ret;
    while(total < len)
    {
        ret = recv(fd,(char*)buf + total,len - total,MSG_WAITALL);
        if(ret == 0)
        {
            printf("server disconnected!\n");
            return -1;
        }
        total += ret;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movl %edi, %r12d
xorl %ebx, %ebx
xorl %r13d, %r13d
movl %r14d, %eax
subl %r13d, %eax
jle 0x4674
movslq %r13d, %rsi
addq %r15, %rsi
movslq %eax, %rdx
movl %r12d, %edi
movl $0x100, %ecx            # imm = 0x100
callq 0x20a0
addl %eax, %r13d
testl %eax, %eax
jne 0x4640
leaq 0xf14(%rip), %rdi       # 0x5580
callq 0x22f0
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/VeeeectorPan[P]MyNetdisk/SourceFile/recv_user_file.c
// Function: recv_user_file
int recv_user_file(int client_fd,int file_fd,off_t file_size)
{
    int total = 0;
    int pipefd[2];
    int ret = pipe(pipefd);
    ERROR_CHECK(ret,-1,"pipe");
    while(total < file_size)
    {
        ret = splice(client_fd,NULL,pipefd[1],NULL,4096,SPLICE_F_MOVE|SPLICE_F_MORE);
        ERROR_CHECK(ret,-1,"splice");
        ret = splice(pipefd[0],NULL,file_fd,NULL,ret,SPLICE_F_MOVE|SPLICE_F_MORE);
        ERROR_CHECK(ret,-1,"splice");
        total += ret;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movl %edi, %r15d
leaq -0x30(%rbp), %rdi
callq 0x2270
cmpl $-0x1, %eax
je 0x4710
pushq $0x5
popq %r12
xorl %r13d, %r13d
movslq %r13d, %rax
cmpq %rbx, %rax
jge 0x46ff
movl -0x2c(%rbp), %edx
movl $0x1000, %r8d           # imm = 0x1000
movl %r15d, %edi
xorl %esi, %esi
xorl %ecx, %ecx
movl %r12d, %r9d
callq 0x20e0
cmpl $-0x1, %eax
je 0x46f6
movl -0x30(%rbp), %edi
movslq %eax, %r8
xorl %esi, %esi
movl %r14d, %edx
xorl %ecx, %ecx
movl %r12d, %r9d
callq 0x20e0
addl %eax, %r13d
cmpl $-0x1, %eax
jne 0x46b4
leaq 0xe9d(%rip), %rdi       # 0x559a
jmp 0x4717
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe7e(%rip), %rdi       # 0x5595
callq 0x2190
pushq $-0x1
popq %rax
jmp 0x4701
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/VeeeectorPan[P]MyNetdisk/SourceFile/update_user_table.c
// Function: update_user_table
int update_user_table(char* mysql_oper,int user_id,int file_id,MYSQL* connect)
{
    sprintf(mysql_oper,"update User set dir_id=%d where user_id=%d;",file_id,user_id);
    int queryResult = mysql_query(connect,mysql_oper);
    if(queryResult)
    {
        printf("%s\n",mysql_error(connect));
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %esi, %ecx
movq %rdi, %r15
leaq 0xa5b(%rip), %rsi       # 0x562c
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x2060
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2140
testl %eax, %eax
je 0x4bfe
movq %rbx, %rdi
callq 0x20b0
movq %rax, %rdi
callq 0x22f0
pushq $-0x1
popq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/VeeeectorPan[P]MyNetdisk/SourceFile/user_name_avaialbe.c
// Function: user_name_avaiable
int user_name_avaiable(const char* user_name,MYSQL* connect)
{
    char buf[128];
    sprintf(buf,"select * from User where user_name='%s'",user_name);
    unsigned int queryRet = mysql_query(connect,buf);
    if(queryRet)
    {
        printf("Mysql query error: %s\n",mysql_error(connect));
        return -1;
    }
    MYSQL_RES* res;
    res = mysql_store_result(connect);
    return (mysql_num_rows(res) == 0)? 1: 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq %rdi, %rdx
leaq 0xa31(%rip), %rsi       # 0x5658
leaq -0x90(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2060
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2140
movq %rbx, %rdi
testl %eax, %eax
je 0x4c65
callq 0x20b0
leaq 0x4bf(%rip), %rdi       # 0x5115
movq %rax, %rsi
xorl %eax, %eax
callq 0x2040
pushq $-0x1
popq %rax
jmp 0x4c7d
callq 0x2120
movq %rax, %rdi
callq 0x21a0
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
sete %al
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dwelch67[P]lc3/vsim.c
// Function: fetch_mem
unsigned short fetch_mem ( unsigned short add )
{
    unsigned short data;
    fetch_mem_count++;
    data=mem[add];
    printf("fetch_mem[0x%04X]=>0x%04X\n",add,data);
    return(data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %esi
incl 0x3ea6(%rip)            # 0x5090
movl %edi, %eax
leaq 0x3ead(%rip), %rcx      # 0x50a0
movzwl (%rcx,%rax,2), %eax
movzwl %ax, %ebx
leaq 0x1e43(%rip), %rdi      # 0x3044
movl %ebx, %edx
xorl %eax, %eax
callq 0x1060
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dwelch67[P]lc3/vsim.c
// Function: read_mem
unsigned short read_mem ( unsigned short add )
{
    unsigned short data;
    read_mem_count++;
    data=mem[add];
    printf("read_mem[0x%04X]=>0x%04X\n",add,data);
    return(data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %esi
incl 0x23e7f(%rip)           # 0x250a0
movl %edi, %eax
leaq 0x3e76(%rip), %rcx      # 0x50a0
movzwl (%rcx,%rax,2), %eax
movzwl %ax, %ebx
leaq 0x1e27(%rip), %rdi      # 0x305f
movl %ebx, %edx
xorl %eax, %eax
callq 0x1060
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/USArmyResearchLab[P]ARL_OpenSHMEM/test/hello.c
// Function: main
int main(int argc, char* argv[])
{
	int err = 0;
	int major, minor;
	char name[SHMEM_MAX_NAME_LEN];

	// Starts/Initializes SHMEM/OpenSHMEM
	// Some implementations use the deprecated start_pes(0)
	shmem_init();

	// Fetch the number or processes
	// Some implementations use the deprecated num_pes()
	int n_pes = shmem_n_pes();

	// Assign my process ID to me
	int me = shmem_my_pe();

	// Query 
	shmem_info_get_name(name);
	shmem_info_get_version(&major, &minor);

	if (me == 0) {
		printf("# API   : %s (%d.%d)\n", name, major, minor);
		printf("# HEADER: %s (%d.%d)\n", SHMEM_VENDOR_STRING,
			SHMEM_MAJOR_VERSION, SHMEM_MINOR_VERSION);
	}

	// Global barrier
	shmem_barrier_all();

	// Comparing shmem.h header values and API values
	if (strncmp(name, SHMEM_VENDOR_STRING, SHMEM_MAX_NAME_LEN)) {
		printf("# %d: ERROR: vendor name mismatch\n", me);
		err++;
	}
	if (major != SHMEM_MAJOR_VERSION) {
		printf("# %d: ERROR: major version mismatch\n", me);
		err++;
	}
	if (minor != SHMEM_MINOR_VERSION) {
		printf("# %d: ERROR: minor version mismatch\n", me);
		err++;
	}

	printf("Hello, World from %d of %d\n", me, n_pes);

	return(err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
callq 0x1498
leaq 0x3dcf(%rip), %rax      # 0x5144
movl (%rax), %ebx
leaq 0x3dc2(%rip), %rax      # 0x5140
movl (%rax), %r14d
leaq -0x60(%rbp), %rdi
callq 0x1468
leaq -0x20(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x1488
testl %r14d, %r14d
jne 0x13cf
movl -0x20(%rbp), %edx
movl -0x1c(%rbp), %ecx
leaq 0x1c5b(%rip), %rdi      # 0x3004
leaq -0x60(%rbp), %rsi
xorl %eax, %eax
callq 0x10e0
leaq 0x1c5f(%rip), %rdi      # 0x301a
leaq 0x1c6e(%rip), %rsi      # 0x3030
pushq $0x1
popq %rdx
pushq $0x4
popq %rcx
xorl %eax, %eax
callq 0x10e0
callq 0x145c
leaq 0x1c55(%rip), %rsi      # 0x3030
leaq -0x60(%rbp), %rdi
pushq $0x33
popq %rdx
callq 0x11b0
testl %eax, %eax
je 0x1402
leaq 0x1c71(%rip), %rdi      # 0x3063
movl %r14d, %esi
xorl %eax, %eax
callq 0x10e0
pushq $0x1
popq %r15
jmp 0x1405
xorl %r15d, %r15d
cmpl $0x1, -0x20(%rbp)
je 0x141f
leaq 0x1c74(%rip), %rdi      # 0x3086
movl %r14d, %esi
xorl %eax, %eax
callq 0x10e0
incl %r15d
cmpl $0x4, -0x1c(%rbp)
je 0x1439
leaq 0x1c7f(%rip), %rdi      # 0x30ab
movl %r14d, %esi
xorl %eax, %eax
callq 0x10e0
incl %r15d
leaq 0x1c90(%rip), %rdi      # 0x30d0
movl %r14d, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10e0
movl %r15d, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/deoxysneq256128v13/ref/deoxys.c
// Function: set_nonce_in_tweak
static void set_nonce_in_tweak(uint8_t *tweak, const uint8_t *nonce) {
    tweak[0] = (tweak[0] & 0xf0)     ^ (nonce[0] >> 4);
    tweak[1] = (nonce[0] & 0xf) << 4 ^ (nonce[1] >> 4);
    tweak[2] = (nonce[1] & 0xf) << 4 ^ (nonce[2] >> 4);
    tweak[3] = (nonce[2] & 0xf) << 4 ^ (nonce[3] >> 4);
    tweak[4] = (nonce[3] & 0xf) << 4 ^ (nonce[4] >> 4);
    tweak[5] = (nonce[4] & 0xf) << 4 ^ (nonce[5] >> 4);
    tweak[6] = (nonce[5] & 0xf) << 4 ^ (nonce[6] >> 4);
    tweak[7] = (nonce[6] & 0xf) << 4 ^ (nonce[7] >> 4);
    tweak[8] = (nonce[7] & 0xf) << 4;
}

// Assembly:
movb (%rdi), %al
andb $-0x10, %al
movb (%rsi), %cl
shrb $0x4, %cl
orb %al, %cl
movb %cl, (%rdi)
movb (%rsi), %al
movb 0x1(%rsi), %cl
shrb $0x4, %cl
shlb $0x4, %al
orb %cl, %al
movb %al, 0x1(%rdi)
movb 0x1(%rsi), %al
movb 0x2(%rsi), %cl
shrb $0x4, %cl
shlb $0x4, %al
orb %cl, %al
movb %al, 0x2(%rdi)
movb 0x2(%rsi), %al
movb 0x3(%rsi), %cl
shrb $0x4, %cl
shlb $0x4, %al
orb %cl, %al
movb %al, 0x3(%rdi)
movb 0x3(%rsi), %al
movb 0x4(%rsi), %cl
shrb $0x4, %cl
shlb $0x4, %al
orb %cl, %al
movb %al, 0x4(%rdi)
movb 0x4(%rsi), %al
movb 0x5(%rsi), %cl
shrb $0x4, %cl
shlb $0x4, %al
orb %cl, %al
movb %al, 0x5(%rdi)
movb 0x5(%rsi), %al
movb 0x6(%rsi), %cl
shrb $0x4, %cl
shlb $0x4, %al
orb %cl, %al
movb %al, 0x6(%rdi)
movb 0x6(%rsi), %al
movb 0x7(%rsi), %cl
shrb $0x4, %cl
shlb $0x4, %al
orb %cl, %al
movb %al, 0x7(%rdi)
movb 0x7(%rsi), %al
shlb $0x4, %al
movb %al, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/vdedios[P]minishell/srcs/main.c
// Function: main
int				main(int argc, char **argv, char **envp)
{
	t_shell shell;
	char	*line;
	char	*tmp;
	char	curr_pwd[1024];

	line = NULL;
	shell.stat_loc = 0;
	shell.instructions = NULL;
	shell.env = ft_strdup_matrix(envp);
	getcwd(curr_pwd, 1024);
	tmp = ft_strjoin("PWD=", curr_pwd);
	ft_export(&shell, tmp);
	free(tmp);
	handle_shlvl(&shell);
	tmp = ft_strdup("_=/bin/bash");
	ft_export(&shell, tmp);
	free(tmp);
	if (argc == 3 && ft_strcmp(argv[1], "-c"))
		exec_argument(ft_strdup(argv[2]), &shell);
	else
		read_input(line, &shell);
	return (shell.stat_loc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x448, %rsp            # imm = 0x448
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
andl $0x0, 0x28(%r14)
movl %edi, %ebp
andq $0x0, (%r14)
movq %rdx, %rdi
callq 0x4591
movq %rax, 0x20(%r14)
leaq 0x40(%rsp), %r15
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdi
callq 0x1090
leaq 0x3de1(%rip), %rdi      # 0x50c6
movq %r15, %rsi
callq 0x4d88
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x252f
movq %r15, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x4930
leaq 0x3cf2(%rip), %rdi      # 0x5004
callq 0x4d48
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x252f
movq %r15, %rdi
callq 0x1030
cmpl $0x3, %ebp
jne 0x13b8
movq 0x8(%rbx), %rdi
leaq 0x3ccf(%rip), %rsi      # 0x5010
callq 0x4f6c
testq %rax, %rax
je 0x13b8
movq 0x10(%rbx), %rdi
callq 0x4d48
movq %rax, %r14
movq %rax, %rdi
callq 0x324c
movq %rax, %rbx
movq %r14, %rdi
callq 0x1030
testq %rbx, %rbx
je 0x137e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x16e3
jmp 0x1386
movl $0x2, 0x30(%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x44f6
movq (%rbx), %rdi
callq 0x44d8
movq (%rbx), %rdi
callq 0x1030
movl 0x28(%rbx), %eax
addq $0x448, %rsp            # imm = 0x448
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %rax
andq $0x0, (%rax)
pushq $0x1
popq %rbp
movl %ebp, %edi
callq 0x1080
movl %eax, %r14d
leaq 0x3069(%rip), %r15      # 0x443c
pushq $0x3
popq %rdi
movq %r15, %rsi
callq 0x1110
pushq $0x2
popq %r12
leaq 0x3f2e(%rip), %r13      # 0x5317
movl %r12d, %edi
movq %r15, %rsi
callq 0x1110
movl %r14d, %edi
movl %ebp, %esi
callq 0x1070
movq %r13, %rdi
movl %ebp, %esi
callq 0x4bec
movq %rsp, %rdi
callq 0x4393
testl %eax, %eax
je 0x144b
movq (%rsp), %rdi
callq 0x324c
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x1030
testq %rbx, %rbx
je 0x1441
movq %rbx, (%rsp)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x16e3
jmp 0x13e9
movl $0x2, 0x30(%rsp)
jmp 0x13e9
leaq 0x3bc1(%rip), %rdi      # 0x5013
pushq $0x1
popq %rsi
callq 0x4ba4
leaq 0x8(%rsp), %rdi
callq 0x44f6
movq (%rsp), %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O2/vdedios[P]minishell/srcs/shell/shell.c
// Function: get_path
char			*get_path(t_shell *shell)
{
	char *value;
	char *tmp;
	char *path;
	char **paths;

	value = get_env(shell, "PATH");
	if (!value || ft_strlen(value) == 0)
	{
		free(value);
		path = search_binary_in_pwd(shell);
	}
	else
	{
		tmp = append_pwd(value);
		paths = ft_split(tmp, ':');
		path = search_binary(shell, paths);
		free(value);
		free(tmp);
		clean_matrix(paths);
		free(paths);
	}
	return (path);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3b92(%rip), %rsi      # 0x5018
callq 0x1cdc
movq %rax, %r14
testq %rax, %rax
je 0x14f6
movq %r14, %rdi
callq 0x4f18
testq %rax, %rax
je 0x14f6
movq %r14, %rdi
callq 0x186f
movq %rax, %r15
pushq $0x3a
popq %rsi
movq %rax, %rdi
callq 0x4c14
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x40b4
movq %rax, %rbx
movq %r14, %rdi
callq 0x1030
movq %r15, %rdi
callq 0x1030
movq %r12, %rdi
callq 0x44d8
movq %r12, %rdi
callq 0x1030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4000
// File: /workspace/github_c_makefile_star2_O2/vdedios[P]minishell/srcs/shell/shell.c
// Function: run_command
int				run_command(t_shell *shell)
{
	pid_t	pid;
	char	*path;
	char	*tmp;

	shell->is_binary = 0;
	path = get_path(shell);
	if (path)
	{
		if ((pid = fork()) == 0 && check_permissions(shell, path))
		{
			execve(path, shell->args, shell->env);
			exit(shell->stat_loc);
		}
		signal(SIGINT, signal_handler_waiting);
		waitpid(pid, &shell->stat_loc, 0);
		if (WIFEXITED(shell->stat_loc))
			shell->stat_loc = WEXITSTATUS(shell->stat_loc);
		if (shell->stat_loc == -1)
			ft_putstr_fd("\n", 1);
		tmp = update_last_arg(shell->args);
		ft_export(shell, tmp);
		free(tmp);
	}
	free(path);
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x30(%rdi)
callq 0x1474
movq %rax, %r14
testq %rax, %rax
je 0x15a7
callq 0x1190
movl %eax, %ebp
testl %eax, %eax
jne 0x1546
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4888
testl %eax, %eax
jne 0x15bd
leaq 0x2f25(%rip), %rsi      # 0x4472
pushq $0x2
popq %rdi
callq 0x1110
leaq 0x28(%rbx), %r15
movl %ebp, %edi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1150
movl 0x28(%rbx), %eax
testb $0x7f, %al
je 0x1582
cmpl $-0x1, %eax
jne 0x1588
leaq 0x3aa5(%rip), %rdi      # 0x501d
pushq $0x1
popq %rsi
callq 0x4bec
jmp 0x1588
movzbl %ah, %eax
movl %eax, (%r15)
movq 0x18(%rbx), %rdi
callq 0x185c
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x252f
movq %r15, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
movq %r14, %rdi
callq 0x10f0
movl 0x28(%rbx), %edi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O2/vdedios[P]minishell/srcs/shell/shell.c
// Function: check_builtin
int				check_builtin(t_shell *shell)
{
	int		ret;
	char	*tmp;

	ret = 0;
	if (ft_strcmp(shell->args[0], "exit"))
		ft_exit(shell);
	else if (ft_strcmp(shell->args[0], "echo"))
		ret = ft_echo(shell->args + 1);
	else if (ft_strcmp(shell->args[0], "cd"))
		ret = ft_cd(shell);
	else if (ft_strcmp(*shell->args, "pwd"))
		ret = ft_pwd(shell);
	else if (ft_strcmp(*shell->args, "export"))
		ret = exec_export(shell);
	else if (ft_strcmp(*shell->args, "unset"))
		ret = ft_unset(shell);
	else
		return (exec_env(shell));
	tmp = update_last_arg(shell->args);
	ft_export(shell, tmp);
	free(tmp);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq (%rax), %rdi
leaq 0x3a29(%rip), %rsi      # 0x5013
callq 0x4f6c
testq %rax, %rax
je 0x1603
movq %rbx, %rdi
callq 0x2904
xorl %ebp, %ebp
jmp 0x16b1
movq 0x18(%rbx), %rax
movq (%rax), %rdi
leaq 0x3a0e(%rip), %rsi      # 0x501f
callq 0x4f6c
movq 0x18(%rbx), %rdi
testq %rax, %rax
je 0x162d
addq $0x8, %rdi
callq 0x2218
jmp 0x16af
movq (%rdi), %rdi
leaq 0x39ed(%rip), %rsi      # 0x5024
callq 0x4f6c
testq %rax, %rax
je 0x164b
movq %rbx, %rdi
callq 0x1df0
jmp 0x16af
movq 0x18(%rbx), %rax
movq (%rax), %rdi
leaq 0x39ce(%rip), %rsi      # 0x5027
callq 0x4f6c
testq %rax, %rax
je 0x166d
movq %rbx, %rdi
callq 0x22a8
jmp 0x16af
movq 0x18(%rbx), %rax
movq (%rax), %rdi
leaq 0x39b0(%rip), %rsi      # 0x502b
callq 0x4f6c
testq %rax, %rax
je 0x168f
movq %rbx, %rdi
callq 0x1974
jmp 0x16af
movq 0x18(%rbx), %rax
movq (%rax), %rdi
leaq 0x3995(%rip), %rsi      # 0x5032
callq 0x4f6c
testq %rax, %rax
je 0x16d7
movq %rbx, %rdi
callq 0x2304
movl %eax, %ebp
movq 0x18(%rbx), %rdi
callq 0x185c
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x252f
movq %r14, %rdi
callq 0x1030
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1993
// File: /workspace/github_c_makefile_star2_O2/vdedios[P]minishell/srcs/shell/shell.c
// Function: minishell
void			minishell(char *line, t_shell *shell)
{
	size_t	it;
	size_t	jt;

	it = 0;
	line = safe_allocate(line, inject_spaces);
	if (validate_input(shell, line))
	{
		shell->instructions = ft_split_non_escaped(line, ';');
		while (shell->instructions[it])
		{
			jt = 0;
			shell->stat_loc = 0;
			while (is_space(shell->instructions[it][jt]))
				jt++;
			shell->commands = ft_split_non_escaped(&shell->instructions[it][jt],
					'|');
			handle_commands(shell);
			shell->previous_stat = shell->stat_loc;
			free(shell->commands);
			it++;
		}
	}
	free(line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x4d9(%rip), %rsi       # 0x1bd1
callq 0x1940
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3988
testl %eax, %eax
je 0x181f
pushq $0x3b
popq %rsi
movq %r14, %rdi
callq 0x3730
movq %rax, (%rbx)
xorl %r12d, %r12d
pushq $-0x1
popq %r13
pushq $0x7c
popq %rbp
cmpq $0x0, (%rax,%r12,8)
je 0x181f
andl $0x0, 0x28(%rbx)
movq %r13, %r15
movq (%rbx), %rax
movq (%rax,%r12,8), %rax
movsbl 0x1(%rax,%r15), %edi
callq 0x34be
incq %r15
testw %ax, %ax
jne 0x173d
movq (%rbx), %rax
addq (%rax,%r12,8), %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0x3730
movq %rax, 0x10(%rbx)
cmpq $0x0, 0x8(%rax)
je 0x1780
movq %rbx, %rdi
callq 0x46b4
jmp 0x1805
movq (%rax), %rsi
testq %rsi, %rsi
je 0x1805
movq %rbx, %rdi
callq 0x2f6d
movq %rax, %r15
movq %rax, %rdi
callq 0x31ec
movq %rax, 0x18(%rbx)
movq (%rax), %rdi
callq 0x4d48
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x3c60
cmpl $-0x1, %eax
je 0x17d6
movq 0x18(%rbx), %rax
cmpq $0x0, (%rax)
je 0x17d6
movq %rbx, %rdi
callq 0x15d5
testl %eax, %eax
jne 0x17d6
movq %rbx, %rdi
callq 0x1511
movq 0x18(%rbx), %rdi
callq 0x44d8
movq 0x18(%rbx), %rdi
callq 0x1030
movq %r15, %rdi
callq 0x1030
movq 0x10(%rbx), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
callq 0x1030
movl 0x28(%rbx), %eax
movl %eax, 0x2c(%rbx)
movq 0x10(%rbx), %rdi
callq 0x1030
incq %r12
movq (%rbx), %rax
jmp 0x172b
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/vdedios[P]minishell/srcs/shell/shell_utils.c
// Function: append_pwd
char	*append_pwd(char *value)
{
	char	cwd[1024];
	char	*aux;

	aux = value;
	if (getcwd(cwd, sizeof(cwd)))
	{
		if (value[0] == ':')
			return (ft_strjoin(cwd, value));
		if (value[ft_strlen(value) - 1] == ':')
			return (ft_strjoin(value, cwd));
		while (*aux)
		{
			if (!(aux = ft_strchr(aux, ':')))
				break ;
			if (*(aux + 1) == ':')
				return (ft_strjoin(value, cwd));
			aux++;
		}
	}
	return (ft_strdup(value));
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x1090
testq %rax, %rax
je 0x18db
cmpb $0x3a, (%rbx)
jne 0x189a
movq %rsp, %rdi
movq %rbx, %rsi
jmp 0x18d4
movq %rbx, %rdi
callq 0x4f18
cmpb $0x3a, -0x1(%rbx,%rax)
je 0x18ce
movb (%rbx), %al
pushq $0x3a
popq %rbp
movq %rbx, %rdi
testb %al, %al
je 0x18db
movl %ebp, %esi
callq 0x4d28
testq %rax, %rax
je 0x18db
movq %rax, %rdi
incq %rdi
movb 0x1(%rax), %al
cmpb $0x3a, %al
jne 0x18b1
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4d88
jmp 0x18e3
movq %rbx, %rdi
callq 0x4d48
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/vdedios[P]minishell/srcs/shell/shell_utils.c
// Function: to_lower
char	*to_lower(char *input)
{
	size_t	it;
	char	*output;
	char	*tmp;

	tmp = ft_strdup(input);
	output = calloc(1, ft_strlen(tmp));
	it = -1;
	while (tmp[++it])
	{
		output[it] = ft_tolower(tmp[it]);
	}
	free(tmp);
	output[it] = '\0';
	return (output);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x4d48
movq %rax, %rbx
movq %rax, %rdi
callq 0x4f18
pushq $0x1
popq %rdi
movq %rax, %rsi
callq 0x1100
movq %rax, %r14
xorl %r15d, %r15d
movsbl (%rbx,%r15), %edi
testl %edi, %edi
je 0x192a
callq 0x4f28
movb %al, (%r14,%r15)
incq %r15
jmp 0x1913
movq %rbx, %rdi
callq 0x1030
movb $0x0, (%r14,%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/vdedios[P]minishell/srcs/shell/shell_utils.c
// Function: safe_allocate
char	*safe_allocate(char *line, char *(*f)(char *))
{
	char	*tmp;
	char	*aux;

	tmp = f(line);
	free(line);
	aux = ft_strdup(tmp);
	free(tmp);
	return (aux);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq *%rsi
movq %rax, %r14
movq %rbx, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x4d48
movq %rax, %rbx
movq %r14, %rdi
callq 0x1030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/vdedios[P]minishell/srcs/shell/shell_utils_2.c
// Function: exec_env
int		exec_env(t_shell *shell)
{
	char	*lower;
	char	*path;
	char	*tmp;

	lower = to_lower(shell->args[0]);
	if (ft_strcmp(lower, "env"))
	{
		path = get_path(shell);
		tmp = ft_strjoin("_=", path);
		free(path);
		ft_export(shell, tmp);
		free(tmp);
		free(lower);
		return (ft_env(shell, shell->env));
	}
	free(lower);
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq (%rax), %rdi
callq 0x18ed
movq %rax, %r14
leaq 0x36a3(%rip), %rsi      # 0x5057
movq %rax, %rdi
callq 0x4f6c
testq %rax, %rax
je 0x1a18
movq %rbx, %rdi
callq 0x1474
movq %rax, %r15
leaq 0x3665(%rip), %rdi      # 0x5038
movq %rax, %rsi
callq 0x4d88
movq %rax, %r12
movq %r15, %rdi
callq 0x1030
movq %rbx, %rdi
movq %r12, %rsi
callq 0x252f
movq %r12, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq 0x20(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1d49
movq %r14, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/vdedios[P]minishell/srcs/shell/shell_utils_2.c
// Function: get_var_key
char	*get_var_key(char *line, int it)
{
	int		i;
	int		k;
	char	*key;

	i = it;
	k = 0;
	while (i >= 0 && line[i] != '{')
		i--;
	if (!(key = malloc((it - i) * sizeof(char))))
		return (NULL);
	i++;
	while (i < it)
		key[k++] = line[i++];
	key[k] = '\0';
	return (key);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
cmpl $-0x1, %esi
pushq $-0x1
popq %r14
cmovll %esi, %r14d
movl %esi, %eax
testl %eax, %eax
js 0x1a57
movl %eax, %ecx
cmpb $0x7b, (%rbx,%rcx)
je 0x1a54
decl %eax
jmp 0x1a44
movl %eax, %r14d
movl %ebp, %eax
subl %r14d, %eax
movslq %eax, %rdi
callq 0x1140
testq %rax, %rax
je 0x1a8c
movslq %r14d, %rcx
movslq %ebp, %rdx
incq %rcx
movq %rax, %rsi
cmpq %rdx, %rcx
jge 0x1a89
movb (%rbx,%rcx), %dil
movb %dil, (%rsi)
incq %rsi
incq %rcx
jmp 0x1a75
movb $0x0, (%rsi)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/vdedios[P]minishell/srcs/shell/shell_utils_3.c
// Function: add_space
char	*add_space(char *line, char *output, size_t *it, char redir)
{
	if (line[*it] == redir)
	{
		ft_strlcat(output, line, ft_strlen(output) + *it + 1);
		if (line[*it - 1] != ' ' && line[*it - 1] != redir)
			ft_strlcat(output, " ", ft_strlen(output) + 2);
		ft_strlcat(output, line + *it, ft_strlen(output) + 2);
		if (line[*it + 1] != ' ' && line[*it + 1] != redir)
			ft_strlcat(output, " ", ft_strlen(output) + 2);
		line = line + *it + 1;
		*it = -1;
	}
	return (line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdi, %rbx
movq (%rdx), %rax
cmpb %bpl, (%rdi,%rax)
jne 0x1b77
movq %rdx, %r14
movq %rsi, %r15
movq %rsi, %rdi
callq 0x4f18
movq (%r14), %rcx
leaq (%rax,%rcx), %rdx
incq %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4e54
movq (%r14), %r12
movb -0x1(%rbx,%r12), %al
cmpb $0x20, %al
sete %cl
cmpb %bpl, %al
sete %al
orb %cl, %al
jne 0x1b1e
movq %r15, %rdi
callq 0x4f18
leaq 0x2(%rax), %rdx
leaq 0x365a(%rip), %rsi      # 0x516d
movq %r15, %rdi
callq 0x4e54
movq (%r14), %r12
addq %rbx, %r12
movq %r15, %rdi
callq 0x4f18
leaq 0x2(%rax), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x4e54
movq (%r14), %rax
movb 0x1(%rbx,%rax), %cl
cmpb $0x20, %cl
sete %dl
cmpb %bpl, %cl
sete %cl
orb %dl, %cl
jne 0x1b6d
movq %r15, %rdi
callq 0x4f18
leaq 0x2(%rax), %rdx
leaq 0x360b(%rip), %rsi      # 0x516d
movq %r15, %rdi
callq 0x4e54
movq (%r14), %rax
addq %rax, %rbx
incq %rbx
orq $-0x1, (%r14)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/vdedios[P]minishell/srcs/shell/shell_utils_3.c
// Function: additional_spaces
size_t	additional_spaces(char *line)
{
	size_t	cont;
	size_t	it;

	it = -1;
	cont = 0;
	while (line[++it])
	{
		if (line[it] == '>' && line[it - 1] != ' ' && line[it - 1] != '>')
			cont++;
		if (line[it] == '>' && line[it + 1] != ' ')
			cont++;
		if (line[it] == '<' && line[it - 1] != ' ' && line[it - 1] != '<')
			cont++;
		if (line[it] == '<' && line[it + 1] != ' ')
			cont++;
	}
	return (cont);
}

// Assembly:
pushq $-0x1
popq %rcx
xorl %eax, %eax
movzbl 0x1(%rdi,%rcx), %edx
testl %edx, %edx
je 0x1bd0
incq %rcx
cmpl $0x3c, %edx
je 0x1baf
cmpl $0x3e, %edx
jne 0x1b88
movzbl -0x1(%rdi,%rcx), %edx
cmpl $0x20, %edx
je 0x1bc1
cmpl $0x3e, %edx
je 0x1bc1
jmp 0x1bbe
movzbl -0x1(%rdi,%rcx), %edx
cmpl $0x20, %edx
je 0x1bc1
cmpl $0x3c, %edx
je 0x1bc1
incq %rax
xorl %edx, %edx
cmpb $0x20, 0x1(%rdi,%rcx)
setne %dl
addq %rdx, %rax
jmp 0x1b88
retq
// File: /workspace/github_c_makefile_star2_O2/vdedios[P]minishell/srcs/shell/shell_utils_3.c
// Function: inject_spaces
char	*inject_spaces(char *line)
{
	size_t	it;
	size_t	cont;
	char	*output;

	it = -1;
	cont = additional_spaces(line);
	output = calloc(1, ft_strlen(line) + cont + 1);
	while (*line == ' ')
		line++;
	while (line[++it])
	{
		line = add_space(line, output, &it, '>');
		line = add_space(line, output, &it, '<');
	}
	ft_strlcat(output, line, line - output);
	return (output);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
callq 0x1b83
movq %rax, %rbx
movq %r14, %rdi
callq 0x4f18
leaq (%rbx,%rax), %rsi
incq %rsi
pushq $0x1
popq %rdi
callq 0x1100
movq %rax, %rbx
decq %r14
cmpb $0x20, 0x1(%r14)
leaq 0x1(%r14), %r14
je 0x1c05
pushq $-0x1
popq %rax
leaq 0x8(%rsp), %r15
pushq $0x3e
popq %rbp
pushq $0x3c
popq %r12
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpb $0x0, 0x1(%r14,%rax)
je 0x1c5b
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x1aac
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl %r12d, %ecx
callq 0x1aac
movq %rax, %r14
movq 0x8(%rsp), %rax
jmp 0x1c1f
movq %r14, %rdx
subq %rbx, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e54
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/vdedios[P]minishell/srcs/builtin/ft_env.c
// Function: delete_environment
void			delete_environment(t_shell *shell, char *key, char **env)
{
	size_t	it;
	size_t	len;

	(void)shell;
	len = ft_strlen(key);
	it = 0;
	while (env[it])
	{
		if (ft_strncmp(key, env[it], len) == 0)
			break ;
		it++;
	}
	if (env[it])
	{
		free(env[it]);
		env[it] = NULL;
		it++;
		while (env[it])
		{
			env[it - 1] = env[it];
			it++;
		}
		env[it - 1] = NULL;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
callq 0x4f18
movq %rax, %r15
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x1cd6
movq %r14, %rdi
movq %r15, %rdx
callq 0x4f38
testl %eax, %eax
je 0x1caf
addq $0x8, %rbx
jmp 0x1c92
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1cd6
callq 0x1030
andq $0x0, (%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1cd2
movq %rax, (%rbx)
addq $0x8, %rbx
jmp 0x1cc0
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/vdedios[P]minishell/srcs/builtin/ft_env.c
// Function: get_env
char			*get_env(t_shell *shell, char *arg)
{
	size_t it;
	size_t len;

	len = ft_strlen(arg);
	it = 0;
	while (shell->env[it])
	{
		if (!ft_strncmp(shell->env[it], arg, len))
			return (ft_strdup(ft_strchr(shell->env[it], '=') + 1));
		it++;
	}
	return (ft_strdup(""));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4f18
movq %rax, %r12
xorl %r13d, %r13d
leaq 0x331e(%rip), %r15      # 0x501e
movq 0x20(%rbx), %rax
movq (%rax,%r13), %rdi
testq %rdi, %rdi
je 0x1d38
movq %r14, %rsi
movq %r12, %rdx
callq 0x4f38
testl %eax, %eax
je 0x1d22
addq $0x8, %r13
jmp 0x1d00
movq 0x20(%rbx), %rax
movq (%rax,%r13), %rdi
pushq $0x3d
popq %rsi
callq 0x4d28
movq %rax, %r15
incq %r15
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4d48