LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/hash/md5.c
// Function: md5
char			*md5(char *buf, char *to_hash)
{
	t_md5		b;
	int			i;

	i = -1;
	ft_bzero(&b, sizeof(t_md5));
	md5_set(to_hash, &b, (int)-1, (uint64_t)0);
	b.hash[0] = 0x67452301;
	b.hash[1] = 0xefcdab89;
	b.hash[2] = 0x98badcfe;
	b.hash[3] = 0x10325476;
	while (++i < (int)b.multiples)
		md5_cycle(i, &b);
	endian_rev(&b.hash[0]);
	endian_rev(&b.hash[1]);
	endian_rev(&b.hash[2]);
	endian_rev(&b.hash[3]);
	to_hash = buf;
	ft_sprintf(to_hash, "%.8x%.8x%.8x%.8x",
		b.hash[0], b.hash[1], b.hash[2], b.hash[3]);
	free(b.message);
	return (to_hash);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x8c(%rbp) # imm = 0xFFFFFFFF
leaq -0x88(%rbp), %rdi
movl $0x78, %esi
callq 0xa600
movq -0x10(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %ecx
callq 0x52d0
movl $0x67452301, -0x88(%rbp) # imm = 0x67452301
movl $0xefcdab89, -0x84(%rbp) # imm = 0xEFCDAB89
movl $0x98badcfe, -0x80(%rbp) # imm = 0x98BADCFE
movl $0x10325476, -0x7c(%rbp) # imm = 0x10325476
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
cmpl -0x78(%rbp), %eax
jge 0x5241
movl -0x8c(%rbp), %edi
leaq -0x88(%rbp), %rsi
callq 0x5420
jmp 0x5219
leaq -0x88(%rbp), %rdi
callq 0x5540
leaq -0x88(%rbp), %rdi
addq $0x4, %rdi
callq 0x5540
leaq -0x88(%rbp), %rdi
addq $0x8, %rdi
callq 0x5540
leaq -0x88(%rbp), %rdi
addq $0xc, %rdi
callq 0x5540
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl -0x88(%rbp), %edx
movl -0x84(%rbp), %ecx
movl -0x80(%rbp), %r8d
movl -0x7c(%rbp), %r9d
leaq 0xf050(%rip), %rsi      # 0x142f4
movb $0x0, %al
callq 0xb3d0
movq -0x58(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/hash/md5.c
// Function: md5_set
static void		md5_set(char *to_hash, t_md5 *b, int i, uint64_t len)
{
	len = ft_strlen(to_hash);
	b->multiples = len ? ((len + 8) / 64) + 1 : 1;
	b->message = malloc(64 * b->multiples);
	ft_bzero(b->message, (uint32_t)(64 * b->multiples));
	ft_strcpy((char *)b->message, to_hash);
	b->message[len ? len : 0] = 0x80;
	len = len << 3;
	i = -1;
	while (++i < 8)
	{
		if (!(len >> (i * 8)))
			break ;
		b->message[((64 * b->multiples) - 8) + i] = len >> (i * 8);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbf10
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5311
movq -0x20(%rbp), %rax
addq $0x8, %rax
shrq $0x6, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x531c
movl $0x1, %eax
movq %rax, -0x28(%rbp)
jmp 0x531c
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
shll $0x6, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x10c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
shll $0x6, %eax
movl %eax, %eax
movl %eax, %esi
callq 0xa600
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xbac0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5390
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x5398
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x5398
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movb $-0x80, (%rax,%rcx)
movq -0x20(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x20(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x8, %eax
jge 0x540c
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rax
cmpq $0x0, %rax
jne 0x53dc
jmp 0x540c
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rax
movb %al, %dl
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
shll $0x6, %ecx
subl $0x8, %ecx
addl -0x14(%rbp), %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
jmp 0x53b7
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/hash/md5.c
// Function: md5_cycle
static void		md5_cycle(int count, t_md5 *b)
{
	int		i;
	int		j;

	i = -1;
	while (++i < 16)
	{
		j = -1;
		while (++j < 4)
			b->table[i][j] = b->message[(count * 64) + (i * 4) + j];
	}
	b->a = b->hash[0];
	b->b = b->hash[1];
	b->c = b->hash[2];
	b->d = b->hash[3];
	i = -1;
	while (++i < 64)
		md5_loop(i, b);
	b->hash[0] += b->a;
	b->hash[1] += b->b;
	b->hash[2] += b->c;
	b->hash[3] += b->d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x10, %eax
jge 0x5496
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x4, %eax
jge 0x5494
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x4(%rbp), %ecx
shll $0x6, %ecx
movl -0x14(%rbp), %edx
shll $0x2, %edx
addl %edx, %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
addq $0x38, %rax
movslq -0x14(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x544b
jmp 0x5436
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x40, %eax
jge 0x54f0
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x55c0
jmp 0x54d4
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x10(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/hash/md5.c
// Function: endian_rev
static void		endian_rev(unsigned int *c)
{
	unsigned int	num;
	int				i;

	num = 0;
	i = 0;
	num += *c & 0xff;
	num = num << 8;
	while (++i < 4)
	{
		num += *c >> (i * 8) & 0xff;
		if ((i * 8) == 24)
			break ;
		num = num << 8;
	}
	*c = num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x4, %eax
jge 0x55af
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl -0x10(%rbp), %ecx
shll $0x3, %ecx
shrl %cl, %eax
andl $0xff, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
shll $0x3, %eax
cmpl $0x18, %eax
jne 0x55a4
jmp 0x55af
movl -0xc(%rbp), %eax
shll $0x8, %eax
movl %eax, -0xc(%rbp)
jmp 0x5570
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/standard/prime.c
// Function: arg_err
int				arg_err(int err, char *arg, t_ssl *ssl)
{
	int		i;

	i = 0;
	if (!arg || !arg[i])
		err -= 1;
	else if (arg && arg[i] == '-')
		++i;
	if (!err && !arg[i])
		err = 1;
	while (arg && arg[i] && ++err)
	{
		if (++err && !ft_isdigit(arg[i++]))
		{
			err = 1;
			break ;
		}
	}
	if (err == -1)
		ft_putstr_fd("missing", 2);
	else if (err == 1)
		ft_putstr_fd("invalid", 2);
	else
		ft_putstr_fd("too small", 2);
	ft_putstr_fd(" n argument for -bits\n", 2);
	return (opt_desciption(ssl->type));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x57af
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x57ba
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x57dd
cmpq $0x0, -0x10(%rbp)
je 0x57db
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x57db
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x57dd
cmpl $0x0, -0x4(%rbp)
jne 0x57f8
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x57f8
movl $0x1, -0x4(%rbp)
jmp 0x57fa
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x1d(%rbp)
je 0x582e
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
je 0x582e
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x5837
jmp 0x5870
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, %eax
je 0x586e
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
callq 0xa4f0
cmpl $0x0, %eax
jne 0x586e
movl $0x1, -0x4(%rbp)
jmp 0x5870
jmp 0x57fa
cmpl $-0x1, -0x4(%rbp)
jne 0x5889
leaq 0xe513(%rip), %rdi      # 0x13d90
movl $0x2, %esi
callq 0xb230
jmp 0x58b5
cmpl $0x1, -0x4(%rbp)
jne 0x58a2
leaq 0xe502(%rip), %rdi      # 0x13d98
movl $0x2, %esi
callq 0xb230
jmp 0x58b3
leaq 0xe4f7(%rip), %rdi      # 0x13da0
movl $0x2, %esi
callq 0xb230
jmp 0x58b5
leaq 0xe4ee(%rip), %rdi      # 0x13daa
movl $0x2, %esi
callq 0xb230
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x2c70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/standard/prime.c
// Function: parse_prime
int				parse_prime(char **av, t_ssl *ssl, __uint64_t *n, int i)
{
	*n = 0;
	while ((av[++i]))
	{
		if (av[i][0] == '-')
		{
			if (valid_arg(av, ssl, &i))
				return (ft_error(6, &av[i][1], ssl));
		}
		else if (!ft_isdigit(av[i][0]))
			return (ft_error(6, av[i], ssl));
		else if (*n)
		{
			ft_putstr_fd(E_MANY, 2);
			return (opt_desciption(ssl->type));
		}
		else
			*n = ft_atoull(av[i]);
		if (ssl->fd[0] == -1)
			return (arg_err(0, av[i + 1], ssl));
	}
	if (ssl->fd[0] == 64 && ++ssl->fd[0])
		return (0);
	ssl->fd[0] = (ssl->fd[0] == 1 || (ssl->fd[0] && !(ssl->fd[0] % 64)) ||\
	ssl->fd[0] > 64) ? 16 : ssl->fd[0];
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x5a2e
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x5972
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x5ac0
cmpl $0x0, %eax
je 0x596d
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x1, %rsi
movq -0x18(%rbp), %rdx
movl $0x6, %edi
callq 0x33a0
movl %eax, -0x4(%rbp)
jmp 0x5aaa
jmp 0x59fb
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %edi
callq 0xa4f0
cmpl $0x0, %eax
jne 0x59ad
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rdx
movl $0x6, %edi
callq 0x33a0
movl %eax, -0x4(%rbp)
jmp 0x5aaa
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x59dc
leaq 0xe403(%rip), %rdi      # 0x13dc1
movl $0x2, %esi
callq 0xb230
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x2c70
movl %eax, -0x4(%rbp)
jmp 0x5aaa
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xa220
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x59f9
jmp 0x59fb
movq -0x18(%rbp), %rax
cmpl $-0x1, 0xc(%rax)
jne 0x5a29
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rdx
xorl %edi, %edi
callq 0x5780
movl %eax, -0x4(%rbp)
jmp 0x5aaa
jmp 0x5902
movq -0x18(%rbp), %rax
cmpl $0x40, 0xc(%rax)
jne 0x5a53
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %eax
addl $0x1, %eax
movl %eax, 0xc(%rcx)
cmpl $0x0, %eax
je 0x5a53
movl $0x0, -0x4(%rbp)
jmp 0x5aaa
movq -0x18(%rbp), %rax
cmpl $0x1, 0xc(%rax)
je 0x5a85
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x5a7b
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x5a85
movq -0x18(%rbp), %rax
cmpl $0x40, 0xc(%rax)
jle 0x5a8f
movl $0x10, %eax
movl %eax, -0x28(%rbp)
jmp 0x5a99
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/standard/prime.c
// Function: valid_arg
static int		valid_arg(char **av, t_ssl *ssl, int *i)
{
	if (!ft_strcmp(&av[*i][1], "bits"))
	{
		ssl->flag |= P_BITS;
		ssl->fd[0] = av[*i + 1] && ft_isdigit(av[*i + 1][0]) ?\
		ft_atoull(av[++(*i)]) : -1;
	}
	else if (!ft_strcmp(&av[*i][1], "generate"))
		ssl->flag |= P_GEN;
	else if (!ft_strcmp(&av[*i][1], "hex"))
		ssl->flag |= HEX;
	else
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x1, %rdi
leaq 0xe341(%rip), %rsi      # 0x13e2f
callq 0xb8e0
cmpl $0x0, %eax
jne 0x5b7e
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x5b62
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %edi
callq 0xa4f0
cmpl $0x0, %eax
je 0x5b62
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rdx
movl (%rdx), %ecx
addl $0x1, %ecx
movl %ecx, (%rdx)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0xa220
movq %rax, -0x28(%rbp)
jmp 0x5b6f
movq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5b6f
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x5bf1
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x1, %rdi
leaq 0xe29c(%rip), %rsi      # 0x13e34
callq 0xb8e0
cmpl $0x0, %eax
jne 0x5bb1
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x4(%rax)
jmp 0x5bef
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x1, %rdi
leaq 0xe272(%rip), %rsi      # 0x13e3d
callq 0xb8e0
cmpl $0x0, %eax
jne 0x5be4
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
orl $0x8, %ecx
movl %ecx, 0x4(%rax)
jmp 0x5bed
movl $0x1, -0x4(%rbp)
jmp 0x5bf8
jmp 0x5bef
jmp 0x5bf1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/standard/prime.c
// Function: prime_command
void			prime_command(char **av, t_ssl *ssl)
{
	__uint64_t	n;

	ssl->flag = 0;
	ssl->fd[0] = 0;
	if (parse_prime(av, ssl, &n, 1))
		;
	else if (!(ssl->flag & P_GEN) && ((!n && ssl->flag & P_BITS) || !av[2]))
	{
		ft_putstr_fd("No prime specified.\n", 2);
		opt_desciption(ssl->type);
	}
	else
	{
		if (ssl->flag & P_GEN)
		{
			if (!ssl->fd[0])
				ft_putstr_fd("Specify the number of bits.\n", 2);
			else
				ft_printf(ssl->flag & HEX ? "%llX\n" : "%llu\n",
				genprime(ssl->fd[0], 1));
		}
		else
			ft_printf(ssl->flag & HEX ? "%llX is %s\n" : "%llu is %s\n", n,
		ft_is_primary(n, 9.0F) ? "prime" : "not prime");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x58e0
cmpl $0x0, %eax
je 0x5c56
jmp 0x5d7e
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x5ca8
cmpq $0x0, -0x18(%rbp)
jne 0x5c7b
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x5c86
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x5ca8
leaq 0xe148(%rip), %rdi      # 0x13dd5
movl $0x2, %esi
callq 0xb230
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x2c70
jmp 0x5d7c
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x5d18
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x5cd4
leaq 0xe122(%rip), %rdi      # 0x13dea
movl $0x2, %esi
callq 0xb230
jmp 0x5d16
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
andl $0x8, %edx
leaq 0xe122(%rip), %rax      # 0x13e07
leaq 0xe395(%rip), %rcx      # 0x14081
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edi
movl $0x1, %esi
callq 0x34b0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0xad50
jmp 0x5d7a
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
andl $0x8, %edx
leaq 0xe0f0(%rip), %rax      # 0x13e19
leaq 0xe0dd(%rip), %rcx      # 0x13e0d
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movss 0xe03d(%rip), %xmm0     # 0x13d8c
callq 0x4b80
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl %eax, %ecx
leaq 0xe0c0(%rip), %rdx      # 0x13e25
leaq 0xe0bd(%rip), %rax      # 0x13e29
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movb $0x0, %al
callq 0xad50
jmp 0x5d7c
jmp 0x5d7e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/standard/rand.c
// Function: genrand
__uint64_t		genrand(__uint64_t min, __uint64_t max)
{
	int				fd;
	int				bytes;
	__uint64_t		tmp;
	unsigned char	*buf;

	tmp = max;
	bytes = 0;
	while (tmp && ++bytes)
		tmp >>= 8;
	buf = ft_memalloc(sizeof(unsigned char) * (bytes + 1));
	fd = open(RAND_DIR, O_RDONLY);
	while (1)
	{
		ft_bzero(buf, bytes);
		read(fd, buf, bytes);
		ft_memcpy(&tmp, buf, bytes);
		if (tmp >= min && tmp <= max)
			break ;
	}
	close(fd);
	free(buf);
	return (tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x29(%rbp)
je 0x5dcd
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x5dd6
jmp 0x5de4
movq -0x20(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x5daf
movl -0x18(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0xa650
movq %rax, -0x28(%rbp)
leaq 0xe040(%rip), %rdi      # 0x13e41
xorl %esi, %esi
movb $0x0, %al
callq 0x10d0
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0xa600
movl -0x14(%rbp), %edi
movq -0x28(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x10a0
movq -0x28(%rbp), %rsi
movslq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xa6a0
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jb 0x5e51
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x5e51
jmp 0x5e53
jmp 0x5e0d
movl -0x14(%rbp), %edi
callq 0x1070
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/standard/rand.c
// Function: do_rand
void			do_rand(t_ssl *ssl, int bytes)
{
	__uint64_t	n;
	uint8_t		buf[PAGESIZE];

	ft_bzero(buf, PAGESIZE);
	if (bytes <= 0 || bytes > 8)
	{
		opt_desciption(ssl->type);
		return ;
	}
	n = genrand(1ULL << (abs(bytes * 8) - 8), UINT64_MAX >> (64 - bytes * 8));
	if (ssl->flag & HEX)
	{
		ft_sprintf((char *)buf, "%0*llx\n", bytes * 2, n);
		ft_putstr_fd((char *)buf, ssl->fd[1]);
	}
	else if (ssl->flag & RAND_BASE64)
		base64_nstr_fd(byte_string(buf, n), byte_len(n), ssl->fd[1], 0);
	else
	{
		ft_sprintf((char *)buf, "%llu\n", n);
		ft_putstr_fd((char *)buf, ssl->fd[1]);
	}
	ssl->fd[1] > 1 ? close(ssl->fd[1]) : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x1020(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0xa600
cmpl $0x0, -0xc(%rbp)
jle 0x5e9f
cmpl $0x8, -0xc(%rbp)
jle 0x5eb0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x2c70
jmp 0x5fc5
movl -0xc(%rbp), %eax
shll $0x3, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
subl $0x8, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %edi
shlq %cl, %rdi
movl -0xc(%rbp), %ecx
shll $0x3, %ecx
movl $0x40, %eax
subl %ecx, %eax
movl %eax, %eax
movl %eax, %ecx
movq $-0x1, %rsi
shrq %cl, %rsi
callq 0x5d90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x5f32
leaq -0x1020(%rbp), %rdi
movl -0xc(%rbp), %edx
shll %edx
movq -0x18(%rbp), %rcx
leaq 0xdf38(%rip), %rsi      # 0x13e4e
movb $0x0, %al
callq 0xb3d0
leaq -0x1020(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
callq 0xb230
jmp 0x5fab
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x5f7d
leaq -0x1020(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1ba0
movq %rax, -0x1028(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1b70
movq -0x1028(%rbp), %rdi
movsbl %al, %esi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1db0
jmp 0x5fa9
leaq -0x1020(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xde78(%rip), %rsi      # 0x13e07
movb $0x0, %al
callq 0xb3d0
leaq -0x1020(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
callq 0xb230
jmp 0x5fab
movq -0x8(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jle 0x5fc3
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x1070
jmp 0x5fc5
jmp 0x5fc5
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/standard/rand.c
// Function: valid_rand_arg
static int		valid_rand_arg(char **av, t_ssl *ssl, int *i, char *fname)
{
	if (!ft_strcmp(&av[*i][1], "base64"))
		ssl->flag |= RAND_BASE64;
	else if (!ft_strcmp(&av[*i][1], "hex"))
		ssl->flag |= HEX;
	else if (ssl->fd[1] == 1 && !ft_strcmp(&av[*i][1], "out"))
	{
		ssl->flag |= RAND_OUT;
		if (!fname && (ssl->fd[1] = -1))
			ft_putstr_fd("missing file argument for -out\n", 2);
		return (!fname ? 1 : 0);
	}
	else
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x1, %rdi
leaq 0xdc62(%rip), %rsi      # 0x13e74
callq 0xb8e0
cmpl $0x0, %eax
jne 0x622e
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x4(%rax)
jmp 0x62f2
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x1, %rdi
leaq 0xdbf5(%rip), %rsi      # 0x13e3d
callq 0xb8e0
cmpl $0x0, %eax
jne 0x6264
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
orl $0x8, %ecx
movl %ecx, 0x4(%rax)
jmp 0x62f0
movq -0x18(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x62e7
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x1, %rdi
leaq 0xe0e8(%rip), %rsi      # 0x14370
callq 0xb8e0
cmpl $0x0, %eax
jne 0x62e7
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x4(%rax)
cmpq $0x0, -0x28(%rbp)
jne 0x62ca
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movb $0x1, %al
testb $0x1, %al
jne 0x62b9
jmp 0x62ca
leaq 0xdbbb(%rip), %rdi      # 0x13e7b
movl $0x2, %esi
callq 0xb230
cmpq $0x0, -0x28(%rbp)
setne %dl
xorb $-0x1, %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x62f9
movl $0x1, -0x4(%rbp)
jmp 0x62f9
jmp 0x62f2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/standard/rand.c
// Function: rand_command
void			rand_command(char **av, t_ssl *ssl, int bytes)
{
	int		ret;

	ssl->flag = 0;
	ssl->fd[1] = 1;
	if (!av[2] || (ret = parse_rand(av, ssl, &bytes, 1)))
	{
		if (((ssl->flag & RAND_BASE64 && ssl->flag & HEX) ||\
		ssl->flag & RAND_OUT) && bytes)
			;
		else if (ret != -1 && !bytes)
		{
			ft_putstr_fd("Specify the number of bytes.\n", 2);
			opt_desciption(ssl->type);
		}
	}
	else
		do_rand(ssl, bytes);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6362
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x14(%rbp), %rdx
movl $0x1, %ecx
callq 0x5fd0
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x63c4
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x6380
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x638f
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6397
cmpl $0x0, -0x14(%rbp)
je 0x6397
jmp 0x63c2
cmpl $-0x1, -0x18(%rbp)
je 0x63c0
cmpl $0x0, -0x14(%rbp)
jne 0x63c0
leaq 0xdaac(%rip), %rdi      # 0x13e56
movl $0x2, %esi
callq 0xb230
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x2c70
jmp 0x63c2
jmp 0x63d0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5e70
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/util/reference.c
// Function: valid_flags
int				valid_flags(t_ssl *ssl, char c)
{
	while (ssl->type)
	{
		if (ssl->type < 10 && (c == 'p' || c == 'q' || c == 'r' || c == 's'))
		{
			ssl->flag |= 1 << (c - 'a');
		}
		else if (ssl->type > 10 && ssl->type < 20 &&
		(c == 'd' || c == 'e' || c == 'i' || c == 'o'))
		{
			ssl->flag |= 1 << (c - 'a');
		}
		else if (ssl->type > 20 && ssl->type < 30 &&
		(c == 'a' || c == 'd' || c == 'e' || c == 'i' || c == 'k' ||
		c == 'o' || c == 'p' || c == 's' || c == 'v'))
		{
			ssl->flag |= 1 << (c - 'a');
		}
		else
			break ;
		return (0);
	}
	ft_error(4, &c, ssl);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x6534
movq -0x10(%rbp), %rax
cmpl $0xa, 0x8(%rax)
jge 0x644d
movsbl -0x11(%rbp), %eax
cmpl $0x70, %eax
je 0x642e
movsbl -0x11(%rbp), %eax
cmpl $0x71, %eax
je 0x642e
movsbl -0x11(%rbp), %eax
cmpl $0x72, %eax
je 0x642e
movsbl -0x11(%rbp), %eax
cmpl $0x73, %eax
jne 0x644d
movsbl -0x11(%rbp), %ecx
subl $0x61, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
jmp 0x652b
movq -0x10(%rbp), %rax
cmpl $0xa, 0x8(%rax)
jle 0x64a4
movq -0x10(%rbp), %rax
cmpl $0x14, 0x8(%rax)
jge 0x64a4
movsbl -0x11(%rbp), %eax
cmpl $0x64, %eax
je 0x6485
movsbl -0x11(%rbp), %eax
cmpl $0x65, %eax
je 0x6485
movsbl -0x11(%rbp), %eax
cmpl $0x69, %eax
je 0x6485
movsbl -0x11(%rbp), %eax
cmpl $0x6f, %eax
jne 0x64a4
movsbl -0x11(%rbp), %ecx
subl $0x61, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
jmp 0x6529
movq -0x10(%rbp), %rax
cmpl $0x14, 0x8(%rax)
jle 0x6525
movq -0x10(%rbp), %rax
cmpl $0x1e, 0x8(%rax)
jge 0x6525
movsbl -0x11(%rbp), %eax
cmpl $0x61, %eax
je 0x6509
movsbl -0x11(%rbp), %eax
cmpl $0x64, %eax
je 0x6509
movsbl -0x11(%rbp), %eax
cmpl $0x65, %eax
je 0x6509
movsbl -0x11(%rbp), %eax
cmpl $0x69, %eax
je 0x6509
movsbl -0x11(%rbp), %eax
cmpl $0x6b, %eax
je 0x6509
movsbl -0x11(%rbp), %eax
cmpl $0x6f, %eax
je 0x6509
movsbl -0x11(%rbp), %eax
cmpl $0x70, %eax
je 0x6509
movsbl -0x11(%rbp), %eax
cmpl $0x73, %eax
je 0x6509
movsbl -0x11(%rbp), %eax
cmpl $0x76, %eax
jne 0x6525
movsbl -0x11(%rbp), %ecx
subl $0x61, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
jmp 0x6527
jmp 0x6534
jmp 0x6529
jmp 0x652b
movl $0x0, -0x4(%rbp)
jmp 0x654d
movq -0x10(%rbp), %rdx
movl $0x4, %edi
leaq -0x11(%rbp), %rsi
callq 0x33a0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/util/reference.c
// Function: scan_standard
int				scan_standard(char *input)
{
	if (!ft_strcmp(input, "genrsa"))
		return (31);
	else if (!ft_strcmp(input, "rsautl"))
		return (32);
	else if (!ft_strcmp(input, "rsa"))
		return (33);
	else if (!ft_strcmp(input, "prime"))
		return (36);
	else if (!ft_strcmp(input, "version"))
		return (41);
	else if (!ft_strcmp(input, "rand"))
		return (42);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xd924(%rip), %rsi      # 0x13e9b
callq 0xb8e0
cmpl $0x0, %eax
jne 0x658d
movl $0x1f, -0x4(%rbp)
jmp 0x6637
movq -0x10(%rbp), %rdi
leaq 0xd90a(%rip), %rsi      # 0x13ea2
callq 0xb8e0
cmpl $0x0, %eax
jne 0x65ae
movl $0x20, -0x4(%rbp)
jmp 0x6637
movq -0x10(%rbp), %rdi
leaq 0xd8e5(%rip), %rsi      # 0x13e9e
callq 0xb8e0
cmpl $0x0, %eax
jne 0x65cc
movl $0x21, -0x4(%rbp)
jmp 0x6637
movq -0x10(%rbp), %rdi
leaq 0xd852(%rip), %rsi      # 0x13e29
callq 0xb8e0
cmpl $0x0, %eax
jne 0x65ea
movl $0x24, -0x4(%rbp)
jmp 0x6637
movq -0x10(%rbp), %rdi
leaq 0xd8b4(%rip), %rsi      # 0x13ea9
callq 0xb8e0
cmpl $0x0, %eax
jne 0x6608
movl $0x29, -0x4(%rbp)
jmp 0x6637
movq -0x10(%rbp), %rdi
leaq 0xd89e(%rip), %rsi      # 0x13eb1
callq 0xb8e0
cmpl $0x0, %eax
jne 0x6626
movl $0x2a, -0x4(%rbp)
jmp 0x6637
jmp 0x6628
jmp 0x662a
jmp 0x662c
jmp 0x662e
jmp 0x6630
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/util/reference.c
// Function: scan_encode
int				scan_encode(char *input)
{
	if (!ft_strcmp(input, "des3-ecb"))
		return (28);
	else if (!ft_strcmp(input, "des3-cbc"))
		return (27);
	else if (!ft_strcmp(input, "des3-ofb"))
		return (26);
	else if (!ft_strcmp(input, "des3"))
		return (25);
	else if (!ft_strcmp(input, "des-ecb"))
		return (24);
	else if (!ft_strcmp(input, "des-cbc"))
		return (23);
	else if (!ft_strcmp(input, "des-ofb"))
		return (22);
	else if (!ft_strcmp(input, "des"))
		return (21);
	return (scan_standard(input));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xd85f(%rip), %rsi      # 0x13eb6
callq 0xb8e0
cmpl $0x0, %eax
jne 0x666d
movl $0x1c, -0x4(%rbp)
jmp 0x6762
movq -0x10(%rbp), %rdi
leaq 0xd847(%rip), %rsi      # 0x13ebf
callq 0xb8e0
cmpl $0x0, %eax
jne 0x668e
movl $0x1b, -0x4(%rbp)
jmp 0x6762
movq -0x10(%rbp), %rdi
leaq 0xd82f(%rip), %rsi      # 0x13ec8
callq 0xb8e0
cmpl $0x0, %eax
jne 0x66af
movl $0x1a, -0x4(%rbp)
jmp 0x6762
movq -0x10(%rbp), %rdi
leaq 0xd817(%rip), %rsi      # 0x13ed1
callq 0xb8e0
cmpl $0x0, %eax
jne 0x66d0
movl $0x19, -0x4(%rbp)
jmp 0x6762
movq -0x10(%rbp), %rdi
leaq 0xd7fb(%rip), %rsi      # 0x13ed6
callq 0xb8e0
cmpl $0x0, %eax
jne 0x66ee
movl $0x18, -0x4(%rbp)
jmp 0x6762
movq -0x10(%rbp), %rdi
leaq 0xd7e5(%rip), %rsi      # 0x13ede
callq 0xb8e0
cmpl $0x0, %eax
jne 0x670c
movl $0x17, -0x4(%rbp)
jmp 0x6762
movq -0x10(%rbp), %rdi
leaq 0xd7cf(%rip), %rsi      # 0x13ee6
callq 0xb8e0
cmpl $0x0, %eax
jne 0x672a
movl $0x16, -0x4(%rbp)
jmp 0x6762
movq -0x10(%rbp), %rdi
leaq 0xd7b9(%rip), %rsi      # 0x13eee
callq 0xb8e0
cmpl $0x0, %eax
jne 0x6748
movl $0x15, -0x4(%rbp)
jmp 0x6762
jmp 0x674a
jmp 0x674c
jmp 0x674e
jmp 0x6750
jmp 0x6752
jmp 0x6754
jmp 0x6756
movq -0x10(%rbp), %rdi
callq 0x6560
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/util/reference.c
// Function: valid_command
int				valid_command(char *input, t_ssl *ssl)
{
	int		i;

	i = 0;
	while (input[i] && input[i] != ' ')
		i++;
	input[i] = '\0';
	if (!ft_strcmp(input, "md5\0"))
		ssl->type = 1;
	else if (!ft_strcmp(input, "sha224"))
		ssl->type = 2;
	else if (!ft_strcmp(input, "sha256"))
		ssl->type = 3;
	else if (!ft_strcmp(input, "sha384"))
		ssl->type = 4;
	else if (!ft_strcmp(input, "sha512"))
		ssl->type = 5;
	else if (!ft_strcmp(input, "sha1"))
		ssl->type = 6;
	else if (!ft_strcmp(input, "base64"))
		ssl->type = 11;
	if (!ssl->type)
		ssl->type = scan_encode(input);
	if (ssl->type)
		return (0);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
je 0x67b2
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x67bb
jmp 0x67c6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6787
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
leaq 0xd7e2(%rip), %rsi      # 0x13fbf
callq 0xb8e0
cmpl $0x0, %eax
jne 0x67f7
movq -0x18(%rbp), %rax
movl $0x1, 0x8(%rax)
jmp 0x68d3
movq -0x10(%rbp), %rdi
leaq 0xd6f0(%rip), %rsi      # 0x13ef2
callq 0xb8e0
cmpl $0x0, %eax
jne 0x681c
movq -0x18(%rbp), %rax
movl $0x2, 0x8(%rax)
jmp 0x68d1
movq -0x10(%rbp), %rdi
leaq 0xd6d2(%rip), %rsi      # 0x13ef9
callq 0xb8e0
cmpl $0x0, %eax
jne 0x6841
movq -0x18(%rbp), %rax
movl $0x3, 0x8(%rax)
jmp 0x68cf
movq -0x10(%rbp), %rdi
leaq 0xd6b4(%rip), %rsi      # 0x13f00
callq 0xb8e0
cmpl $0x0, %eax
jne 0x6863
movq -0x18(%rbp), %rax
movl $0x4, 0x8(%rax)
jmp 0x68cd
movq -0x10(%rbp), %rdi
leaq 0xd699(%rip), %rsi      # 0x13f07
callq 0xb8e0
cmpl $0x0, %eax
jne 0x6885
movq -0x18(%rbp), %rax
movl $0x5, 0x8(%rax)
jmp 0x68cb
movq -0x10(%rbp), %rdi
leaq 0xd67e(%rip), %rsi      # 0x13f0e
callq 0xb8e0
cmpl $0x0, %eax
jne 0x68a7
movq -0x18(%rbp), %rax
movl $0x6, 0x8(%rax)
jmp 0x68c9
movq -0x10(%rbp), %rdi
leaq 0xd5c2(%rip), %rsi      # 0x13e74
callq 0xb8e0
cmpl $0x0, %eax
jne 0x68c7
movq -0x18(%rbp), %rax
movl $0xb, 0x8(%rax)
jmp 0x68c9
jmp 0x68cb
jmp 0x68cd
jmp 0x68cf
jmp 0x68d1
jmp 0x68d3
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x68ef
movq -0x10(%rbp), %rdi
callq 0x6640
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x6902
movl $0x0, -0x4(%rbp)
jmp 0x6909
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/util/reference.c
// Function: show_supported
void			show_supported(void)
{
	dprintf(2, "%sStandard commands%s:\n", UWHT, NOCOL);
	dprintf(2, "genrsa\t\tprime\t\trand\n");
	dprintf(2, "rsa\t\trsautl\t\tversion\n\n");
	dprintf(2, "%sMessage Digest Commands%s:\n", UWHT, NOCOL);
	dprintf(2, "md5\t\tsha1\t\tsha224\t\tsha256\n");
	dprintf(2, "sha384\t\tsha512\n\n");
	dprintf(2, "%sCipher Commands%s:\n", UWHT, NOCOL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x2, %edi
leaq 0xd5e3(%rip), %rsi      # 0x13f13
leaq 0xd5f4(%rip), %rdx      # 0x13f2b
leaq 0xc8ca(%rip), %rcx      # 0x13208
movb $0x0, %al
callq 0x1080
movl $0x2, %edi
leaq 0xd5e2(%rip), %rsi      # 0x13f33
movb $0x0, %al
callq 0x1080
movl $0x2, %edi
leaq 0xd5e4(%rip), %rsi      # 0x13f48
movb $0x0, %al
callq 0x1080
movl $0x2, %edi
leaq 0xd5e8(%rip), %rsi      # 0x13f5f
leaq 0xd5ad(%rip), %rdx      # 0x13f2b
leaq 0xc883(%rip), %rcx      # 0x13208
movb $0x0, %al
callq 0x1080
movl $0x2, %edi
leaq 0xd5e5(%rip), %rsi      # 0x13f7d
movb $0x0, %al
callq 0x1080
movl $0x2, %edi
leaq 0xd5ed(%rip), %rsi      # 0x13f98
movb $0x0, %al
callq 0x1080
movl $0x2, %edi
leaq 0xd5eb(%rip), %rsi      # 0x13fa9
leaq 0xd566(%rip), %rdx      # 0x13f2b
leaq 0xc83c(%rip), %rcx      # 0x13208
movb $0x0, %al
callq 0x1080
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/rsa/rsa.c
// Function: get_value
int				get_value(t_rsa *gg, __uint64_t value, int flag)
{
	if (!gg->n)
		gg->n = value;
	else if (!gg->e)
		gg->e = value;
	else if (!gg->d && !(flag))
		gg->d = value;
	else if (!gg->p && !(flag))
		gg->p = value;
	else if (!gg->q && !(flag))
		gg->q = value;
	else if (!gg->dmp1 && !(flag))
		gg->dmp1 = value;
	else if (!gg->dmq1 && !(flag))
		gg->dmq1 = value;
	else if (!gg->iqmp && !(flag))
		gg->iqmp = value;
	else
		return (0);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x6a0b
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x6afc
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x6a27
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0x6afa
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x6a49
cmpl $0x0, -0x1c(%rbp)
jne 0x6a49
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
jmp 0x6af8
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x6a69
cmpl $0x0, -0x1c(%rbp)
jne 0x6a69
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x6af6
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x6a88
cmpl $0x0, -0x1c(%rbp)
jne 0x6a88
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x6af4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x6aa7
cmpl $0x0, -0x1c(%rbp)
jne 0x6aa7
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x6af2
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x6ac6
cmpl $0x0, -0x1c(%rbp)
jne 0x6ac6
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x6af0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x6ae5
cmpl $0x0, -0x1c(%rbp)
jne 0x6ae5
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x6aee
movl $0x0, -0x4(%rbp)
jmp 0x6b03
jmp 0x6af0
jmp 0x6af2
jmp 0x6af4
jmp 0x6af6
jmp 0x6af8
jmp 0x6afa
jmp 0x6afc
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/rsa/rsa.c
// Function: assign
int				assign(uint8_t *decoded, t_rsa *gg, int decode_len, int flag)
{
	int			i;
	int			len;
	__uint64_t	value;

	i = 0;
	while (decoded[i] != 0x2)
		++i;
	while (i < decode_len)
	{
		len = 0;
		if (decoded[i++] == 0x2)
		{
			len = decoded[i];
			value = 0;
			while (len--)
			{
				if (value)
					value <<= 8;
				value += decoded[++i];
			}
			get_value(gg, value, flag);
		}
	}
	ft_memdel((void**)&decoded);
	return (i < decode_len ? 1 : 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x2, %eax
je 0x6b49
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6b2d
jmp 0x6b4b
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6be6
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x2, %eax
jne 0x6be1
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x20(%rbp)
cmpl $0x0, %eax
je 0x6bd1
cmpq $0x0, -0x28(%rbp)
je 0x6bb3
movq -0x28(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x6b90
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x69e0
jmp 0x6b4b
leaq -0x8(%rbp), %rdi
callq 0xbbe0
movl -0x1c(%rbp), %edx
movl -0x14(%rbp), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovll %ecx, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/rsa/rsa_out.c
// Function: debug_output
void			debug_output(t_ssl *ssl, t_rsa_out rsa)
{
	ft_printf("ssl flags  [%b]\n", ssl->flag);
	ft_printf("ssl type   [%d]\n", ssl->type);
	ft_printf("rsa bits   [%d]\n", rsa.bits);
	ft_printf("rsa fd in  [%d]\n", rsa.fd_in);
	ft_printf("rsa fd out [%d]\n", rsa.fd_out);
	ft_printf("rsa in key [%d]\n", rsa.fd_inkey);
	ft_printf("rsa flags  [%b]\n", rsa.flag);
	ft_printf("rsa type   [%d]\n", rsa.type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0xcc95(%rip), %rdi      # 0x14087
movb $0x0, %al
callq 0xad50
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0xcc91(%rip), %rdi      # 0x14098
movb $0x0, %al
callq 0xad50
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0xcc8d(%rip), %rdi      # 0x140a9
movb $0x0, %al
callq 0xad50
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
leaq 0xcc89(%rip), %rdi      # 0x140ba
movb $0x0, %al
callq 0xad50
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
leaq 0xcc85(%rip), %rdi      # 0x140cb
movb $0x0, %al
callq 0xad50
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
leaq 0xcc81(%rip), %rdi      # 0x140dc
movb $0x0, %al
callq 0xad50
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq 0xcc7e(%rip), %rdi      # 0x140ed
movb $0x0, %al
callq 0xad50
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0xcc7a(%rip), %rdi      # 0x140fe
movb $0x0, %al
callq 0xad50
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/rsa/rsautl.c
// Function: print_row_hex
void			print_row_hex(int bytes, int len, __uint8_t *msg, int fd)
{
	char	*hex;
	int		i;

	hex = "0123456789abcdef";
	i = 0;
	if (bytes < 16)
		ft_putstr_fd("0000 - ", fd);
	while (i < 16)
	{
		if (i < len)
		{
			ft_putchar_fd(hex[(msg[i] / 16)], fd);
			ft_putchar_fd(hex[(msg[i] % 16)], fd);
		}
		else
			ft_putstr_fd("  ", fd);
		++i;
		if (i % 8 == 0)
			ft_putchar_fd(i == 8 ? '-' : ' ', fd);
		ft_putchar_fd(' ', fd);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
leaq 0xc6ac(%rip), %rax      # 0x142c8
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x10, -0x4(%rbp)
jge 0x7c3c
movl -0x14(%rbp), %esi
leaq 0xc6a2(%rip), %rdi      # 0x142d9
callq 0xb230
jmp 0x7c3e
cmpl $0x10, -0x24(%rbp)
jge 0x7d0e
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x7cb6
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movl -0x14(%rbp), %esi
movsbl %al, %edi
callq 0xb200
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movq -0x30(%rbp), %rax
movslq %edx, %rcx
movb (%rax,%rcx), %al
movl -0x14(%rbp), %esi
movsbl %al, %edi
callq 0xb200
jmp 0x7cc5
movl -0x14(%rbp), %esi
leaq 0xc621(%rip), %rdi      # 0x142e1
callq 0xb230
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x7cfc
movl -0x24(%rbp), %edx
movl $0x20, %eax
movl $0x2d, %ecx
cmpl $0x8, %edx
cmovel %ecx, %eax
movl -0x14(%rbp), %esi
movsbl %al, %edi
callq 0xb200
movl -0x14(%rbp), %esi
movl $0x20, %edi
callq 0xb200
jmp 0x7c3e
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/rsa/rsautl.c
// Function: rsautl
void			rsautl(t_rsa_out rsa, t_rsa gg)
{
	__uint64_t		tmp;
	int				len;
	__uint8_t		buf[16];

	if (!gg.n)
		return ;
	rsa.bits = 0;
	ft_bzero(buf, 16);
	tmp = gg.n;
	while (tmp && ++rsa.bits)
		tmp >>= 1;
	len = read(rsa.fd_in, buf, 15);
	if (rsa.bits >> 3 != len)
		ft_error(len < rsa.bits >> 3 ? 21 : 22, NULL, NULL);
	else
		rsa_crypt(rsa, gg, buf, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq 0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0x7d47
jmp 0x7e44
movq -0x28(%rbp), %rax
movl $0x0, 0x8(%rax)
leaq -0x20(%rbp), %rdi
movl $0x10, %esi
callq 0xa600
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x31(%rbp)
je 0x7d8e
movq -0x28(%rbp), %rcx
movl 0x8(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x8(%rcx)
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x7d97
jmp 0x7da4
movq -0x8(%rbp), %rax
shrq %rax
movq %rax, -0x8(%rbp)
jmp 0x7d6c
movq -0x28(%rbp), %rax
movl 0x10(%rax), %edi
leaq -0x20(%rbp), %rsi
movl $0xf, %edx
callq 0x10a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl %ecx, -0xc(%rbp)
movl 0x8(%rax), %eax
sarl $0x3, %eax
cmpl -0xc(%rbp), %eax
je 0x7df8
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movl 0x8(%rax), %edx
sarl $0x3, %edx
movl $0x16, %edi
movl $0x15, %eax
cmpl %edx, %ecx
cmovll %eax, %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x33a0
jmp 0x7e44
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rdx
leaq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
movq 0x40(%rdx), %r8
movq %rsp, %rax
movq %r8, 0x58(%rax)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups 0x20(%rdx), %xmm2
movups 0x30(%rdx), %xmm3
movups %xmm3, 0x48(%rax)
movups %xmm2, 0x38(%rax)
movups %xmm1, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
callq 0x7e50
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/rsa/rsautl.c
// Function: rsa_crypt
static void		rsa_crypt(t_rsa_out rsa, t_rsa gg, __uint8_t *buf, int len)
{
	__uint64_t	msg;
	int			size;
	int			i;

	i = 0;
	msg = 0;
	while (i < len)
	{
		msg <<= 8;
		msg += buf[i++];
	}
	msg = powmod(msg, rsa.flag & R_DECRYPT ? gg.d : gg.e, gg.n);
	i = 0;
	size = (len * 8) - 8;
	if (rsa.flag & R_HEXDUMP)
		hex_dump(rsa.fd_out, size, len, msg);
	else
	{
		while (i < len)
		{
			ft_putchar_fd((char)(msg >> (size - (i * 8))), rsa.fd_out);
			++i;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7eb2
movq -0x18(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x20(%rbp)
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x7e7e
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x7ed8
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x7ee4
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rsi
movq 0x10(%rax), %rdx
callq 0x50e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl -0xc(%rbp), %ecx
shll $0x3, %ecx
subl $0x8, %ecx
movl %ecx, -0x1c(%rbp)
movl (%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x7f3b
movq -0x28(%rbp), %rax
movl 0xc(%rax), %edi
movl -0x1c(%rbp), %esi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x7f80
jmp 0x7f75
jmp 0x7f3d
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7f73
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %edx
shll $0x3, %edx
subl %edx, %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq -0x28(%rbp), %rcx
movl 0xc(%rcx), %esi
movsbl %al, %edi
callq 0xb200
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7f3d
jmp 0x7f75
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)