LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/rsa/is_primary.c
// Function: ft_is_primary
int				ft_is_primary(__uint64_t number, float probability)
{
	t_primary	checks;
	int			ret;

	if (number == 2 || number == 3)
		return (1);
	if (number == 1 || !(number & 0x1))
		return (0);
	checks.d = number - 1;
	checks.r = 0;
	while (!(checks.d & 0x1) && ++checks.r)
		checks.d /= 2;
	checks.a = get_a(number);
	ret = witness(number, &checks, (int)probability);
	free(checks.a);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rax
andq $-0x2, %rax
movl $0x1, %ebp
cmpq $0x2, %rax
je 0x3784
cmpq $0x1, %rdi
sete %al
testb $0x1, %dil
sete %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x3784
movss %xmm0, 0x4(%rsp)
leaq -0x1(%rdi), %rcx
movq %rcx, %rax
xorl %ebp, %ebp
movq %rbp, %r13
cmpq $-0x1, %rbp
je 0x36bb
movq %rax, %r15
shrq %r15
leaq 0x1(%r13), %rbp
testb $0x2, %al
movq %r15, %rax
je 0x369f
jmp 0x36c0
xorl %ebp, %ebp
movq %rax, %r15
movq %rcx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
callq 0x342a
movq 0x8(%rsp), %r8
movq %rax, %rbx
cmpq $0x0, (%rax)
je 0x375a
negq %r13
movq $-0x1, %r14
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rdi
movq %r15, %rsi
movq %r8, %rdx
callq 0x397c
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %rsi
cmpq $0x1, %rax
je 0x375a
cmpq %rsi, %rax
je 0x375a
cmpq $0x1, %rbp
jne 0x371e
cmpq $0x0, 0x10(%rbx,%r14,8)
jne 0x374a
jmp 0x377a
imulq %rax, %rax
xorl %edx, %edx
divq %r8
movq %r13, %rcx
cmpq %rsi, %rdx
je 0x374a
incq %rcx
je 0x3714
imulq %rdx, %rdx
movq %rdx, %rax
xorl %edx, %edx
divq %r8
cmpq %rsi, %rdx
jne 0x372f
testq %rcx, %rcx
je 0x3714
incq %r14
cmpq $0x0, 0x8(%rbx,%r12,8)
leaq 0x1(%r12), %r12
jne 0x36ea
cvttss2si 0x4(%rsp), %eax
movl $0x1, %ebp
testl %eax, %eax
jne 0x377c
movl $0x2b, %edi
movl $0x2, %esi
callq 0x720c
jmp 0x377c
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x1030
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/main.c
// Function: clean_exit
int				clean_exit(int ac, char **av)
{
	int		i;

	i = 0;
	while (ac ? i < ac : av[i] != 0)
	{
		ft_strdel(&av[i]);
		i++;
	}
	ft_memdel((void**)&av);
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movq %rsi, (%rsp)
movslq %edi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
testl %ebx, %ebx
je 0x37bb
cmpq %r14, %r12
setl %al
jmp 0x37c7
movq (%rsp), %rax
cmpq $0x0, (%rax,%r15)
setne %al
testb %al, %al
je 0x37e0
movq (%rsp), %rdi
addq %r15, %rdi
callq 0x779b
incq %r12
addq $0x8, %r15
jmp 0x37af
movq %rsp, %rdi
callq 0x777c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/main.c
// Function: main
int				main(int ac, char **av)
{
	t_ssl	ssl;
	char	**tmp;

	ft_bzero(&ssl, (sizeof(t_ssl)));
	tmp = av;
	while (handle_inputs(&ac, &av, &ssl))
	{
		if (!ssl.stdin)
			break ;
		clean_exit(ac, av);
		ft_bzero(&ssl, (sizeof(t_ssl)));
		ac = 1;
		av = tmp;
	}
	DEBUG ? system("leaks ft_ssl") : 0;
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
leaq 0x4(%rsp), %rbx
movl %edi, (%rbx)
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
leaq 0x14(%rsp), %r15
movl $0x804, %esi            # imm = 0x804
movq %r15, %rdi
callq 0x6c50
movq (%r14), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3214
testl %eax, %eax
je 0x3891
cmpl $0x0, 0x14(%rsp)
je 0x3891
leaq 0x14(%rsp), %rbx
leaq 0x4(%rsp), %r14
leaq 0x8(%rsp), %r15
movl 0x4(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x3798
movl $0x804, %esi            # imm = 0x804
movq %rbx, %rdi
callq 0x6c50
movl $0x1, 0x4(%rsp)
movq %r12, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3214
testl %eax, %eax
je 0x3891
cmpl $0x0, 0x14(%rsp)
jne 0x3850
xorl %eax, %eax
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/util/maths.c
// Function: mod_inverse
__uint64_t		mod_inverse(__uint64_t a, __uint64_t b)
{
	__uint64_t	b0;
	__int64_t	t;
	__uint64_t	q;
	__int64_t	x0;
	__int64_t	x1;

	b0 = b;
	x0 = 0;
	x1 = 1;
	if (a == b)
		return (0);
	while (a > 1)
	{
		!b ? ft_putendl_fd("Error divide by 0", 2) : 0;
		if (!b)
			exit(0);
		q = a / b;
		t = b;
		b = a % b;
		a = t;
		t = x0;
		x0 = x1 - q * x0;
		x1 = t;
	}
	return (x1 < 0 ? x1 += b0 : x1);
}

// Assembly:
cmpq %rsi, %rdi
jne 0x38ac
xorl %eax, %eax
retq
movq %rdi, %rax
movl $0x1, %ecx
cmpq $0x2, %rdi
jb 0x38eb
movl $0x1, %edi
xorl %r9d, %r9d
movq %rsi, %r8
testq %r8, %r8
je 0x38f9
movq %r9, %rcx
xorl %edx, %edx
divq %r8
imulq %r9, %rax
movq %rdi, %r9
subq %rax, %r9
movq %rcx, %rdi
movq %r8, %rax
cmpq $0x1, %r8
movq %rdx, %r8
jne 0x38c5
movq %rcx, %rax
sarq $0x3f, %rax
andq %rsi, %rax
addq %rcx, %rax
retq
pushq %rax
leaq 0x94ab(%rip), %rdi      # 0xcdac
movl $0x2, %esi
callq 0x72a8
xorl %edi, %edi
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/util/maths.c
// Function: mulmod
__uint64_t		mulmod(__uint64_t a, __uint64_t b, __uint64_t m)
{
	__uint64_t	res;
	__uint64_t	temp_b;

	res = 0;
	if (b >= m)
		b = (m > UINT64_MAX >> 1) ? b - m : b % m;
	while (a)
	{
		if (a & 1)
		{
			if (b >= m - res)
				res -= m;
			res += b;
		}
		a >>= 1;
		temp_b = b;
		if (b >= m - b)
			temp_b -= m;
		b += temp_b;
	}
	return (res);
}

// Assembly:
movq %rdx, %rcx
movq %rsi, %rdx
subq %rcx, %rdx
jae 0x3922
movq %rsi, %rdx
jmp 0x392f
testq %rcx, %rcx
js 0x392f
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
xorl %eax, %eax
testq %rdi, %rdi
je 0x397b
testb $0x1, %dil
je 0x3954
movq %rcx, %rsi
subq %rax, %rsi
cmpq %rsi, %rdx
jb 0x394c
movq %rcx, %rsi
jmp 0x394e
xorl %esi, %esi
addq %rdx, %rax
subq %rsi, %rax
movq %rcx, %rsi
subq %rdx, %rsi
cmpq %rsi, %rdx
jb 0x3964
movq %rcx, %rsi
jmp 0x3966
xorl %esi, %esi
movq %rdi, %r8
shrq %r8
addq %rdx, %rdx
subq %rsi, %rdx
cmpq $0x1, %rdi
movq %r8, %rdi
ja 0x3936
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/util/maths.c
// Function: powmod
__uint64_t		powmod(__uint64_t num, __uint64_t exp, __uint64_t mod)
{
	__uint64_t	x;

	if (mod < 2 || num == 0)
	{
		if (mod == 0)
			write(2, "Cannot take modpow with modulus 0\n", 34);
		return (0);
	}
	if (exp == 0)
		return (1);
	x = 1;
	num = num % mod;
	while (exp)
	{
		if (exp & 1)
			x = mulmod(x, num, mod);
		num = mulmod(num, num, mod);
		exp >>= 1;
	}
	return (x);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpq $0x2, %rdx
setae %al
testq %rdi, %rdi
setne %cl
testb %al, %cl
jne 0x39b8
testq %rbx, %rbx
jne 0x39b3
leaq 0x941a(%rip), %rsi      # 0xcdbe
movl $0x22, %edx
movl $0x2, %edi
callq 0x1050
xorl %r15d, %r15d
jmp 0x3a10
movq %rsi, %r14
testq %rsi, %rsi
je 0x3a0a
movq %rdi, %rax
xorl %edx, %edx
divq %rbx
movq %rdx, %r12
movl $0x1, %r15d
testb $0x1, %r14b
je 0x39e8
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3912
movq %rax, %r15
movq %r12, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3912
movq %rax, %r12
movq %r14, %rax
shrq %rax
cmpq $0x1, %r14
movq %rax, %r14
ja 0x39d1
jmp 0x3a10
movl $0x1, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
testq %rsi, %rsi
je 0x3dac
movzbl (%r14), %eax
cmpl $0x2d, %eax
je 0x3db3
xorl %r15d, %r15d
testl %eax, %eax
jne 0x3db9
decl %ebp
xorl %r15d, %r15d
jmp 0x3db9
movl $0x1, %r15d
testl %ebp, %ebp
jne 0x3dcb
movl %r15d, %eax
xorl %ebp, %ebp
cmpb $0x0, (%r14,%rax)
sete %bpl
testq %r14, %r14
je 0x3e00
movslq %r15d, %rax
movsbl (%r14,%rax), %edi
testl %edi, %edi
je 0x3e00
cmpl $-0x1, %ebp
je 0x3df7
cmpl $-0x2, %ebp
je 0x3df2
callq 0x6bf4
testl %eax, %eax
je 0x3dfb
incl %r15d
addl $0x2, %ebp
jmp 0x3dcb
xorl %ebp, %ebp
jmp 0x3e00
movl $0x1, %ebp
cmpl $0x1, %ebp
leaq 0x9002(%rip), %rax      # 0xce0c
leaq 0x9003(%rip), %rcx      # 0xce14
cmoveq %rax, %rcx
cmpl $-0x1, %ebp
leaq 0x8fe5(%rip), %rdi      # 0xce04
cmovneq %rcx, %rdi
movl $0x2, %esi
callq 0x7225
leaq 0x8fea(%rip), %rdi      # 0xce1e
movl $0x2, %esi
callq 0x7225
movl 0x8(%rbx), %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21a8
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, (%rdx)
movslq %ebp, %r12
movq 0x8(%r14,%r12,8), %rdi
testq %rdi, %rdi
je 0x3f6e
leal 0x1(%r12), %ebp
leaq 0x1(%r12), %r13
movsbl (%rdi), %eax
cmpl $0x2d, %eax
jne 0x3ed5
incq %rdi
leaq 0x9009(%rip), %rsi      # 0xcea3
callq 0x7644
testl %eax, %eax
je 0x3efc
movq (%r14,%r13,8), %rdi
incq %rdi
leaq 0x8ff7(%rip), %rsi      # 0xcea8
callq 0x7644
testl %eax, %eax
je 0x3f34
movq (%r14,%r13,8), %rdi
incq %rdi
leaq 0x8fe9(%rip), %rsi      # 0xceb1
callq 0x7644
testl %eax, %eax
je 0x3f3a
xorl %eax, %eax
jmp 0x3f40
movl %eax, %edi
callq 0x6bf4
testl %eax, %eax
je 0x3f99
cmpq $0x0, (%r15)
jne 0x3fb8
movq (%r14,%r13,8), %rdi
callq 0x6aa9
movq %rax, (%r15)
jmp 0x3f44
orb $0x1, 0x4(%rbx)
movq 0x8(%r14,%r13,8), %rax
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x3f2e
movsbl (%rax), %edi
callq 0x6bf4
testl %eax, %eax
je 0x3f2e
leal 0x2(%r12), %ebp
movq 0x10(%r14,%r12,8), %rdi
callq 0x6aa9
movq %rax, %r13
movl %r13d, 0xc(%rbx)
jmp 0x3f3e
orb $0x4, 0x4(%rbx)
jmp 0x3f3e
orb $0x8, 0x4(%rbx)
movb $0x1, %al
testb %al, %al
je 0x3f8d
cmpl $-0x1, 0xc(%rbx)
jne 0x3e6d
movslq %ebp, %rax
movq 0x8(%r14,%rax,8), %rsi
xorl %edi, %edi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3d88
movl 0xc(%rbx), %eax
testl %eax, %eax
je 0x3fe3
movl $0x10, %ecx
cmpl $0x1, %eax
je 0x3fee
cmpl $0x40, %eax
jne 0x3fdf
movl $0x41, 0xc(%rbx)
jmp 0x3ff1
movslq %ebp, %rax
movq (%r14,%rax,8), %rsi
incq %rsi
jmp 0x3f9d
movq (%r14,%r13,8), %rsi
movl $0x6, %edi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2729
leaq 0x8e76(%rip), %rdi      # 0xce35
movl $0x2, %esi
callq 0x7225
movl 0x8(%rbx), %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a8
testb $0x3f, %al
je 0x3fee
cmpl $0x41, %eax
movl $0x10, %ecx
cmovll %eax, %ecx
movl %ecx, 0xc(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movl %eax, 0x4(%rsi)
movl %eax, 0xc(%rsi)
movq %rsp, %rdx
movl $0x1, %ecx
callq 0x3e50
testl %eax, %eax
je 0x402d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x4(%rbx), %eax
testb $0x4, %al
jne 0x40a2
testb $0x1, %al
je 0x4043
cmpq $0x0, (%rsp)
je 0x40db
cmpq $0x0, 0x10(%r14)
je 0x40db
testb $0x4, %al
jne 0x40a2
testb $0x8, %al
leaq 0x8e32(%rip), %rax      # 0xce8d
leaq 0x8e1f(%rip), %rbx      # 0xce81
cmoveq %rax, %rbx
movq (%rsp), %r14
movss 0x8d8e(%rip), %xmm0     # 0xce00
movq %r14, %rdi
callq 0x3654
testl %eax, %eax
leaq 0x8e16(%rip), %rax      # 0xce99
leaq 0x8e13(%rip), %rdx      # 0xce9d
cmoveq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6f7c
movl 0xc(%rbx), %edi
testl %edi, %edi
je 0x40fb
testb $0x8, %al
leaq 0x8dc9(%rip), %rax      # 0xce7b
leaq 0x9040(%rip), %rbx      # 0xd0f9
cmoveq %rax, %rbx
movl $0x1, %esi
callq 0x2814
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6f7c
leaq 0x8d67(%rip), %rdi      # 0xce49
movl $0x2, %esi
callq 0x7225
movl 0x8(%rbx), %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a8
leaq 0x8d5c(%rip), %rdi      # 0xce5e
movl $0x2, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7225
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
testq %rsi, %rsi
je 0x4148
movq %rbx, %rcx
movq %rbx, %rax
incl %r13d
shrq $0x8, %rax
cmpq $0xff, %rcx
movq %rax, %rcx
ja 0x4133
jmp 0x414b
movq %rbx, %rax
movq %rsp, %r15
movq %rax, (%r15)
leal 0x1(%r13), %edi
callq 0x6c60
movq %rax, %r12
leaq 0x8d51(%rip), %rdi      # 0xceb5
xorl %esi, %esi
xorl %eax, %eax
callq 0x10e0
movl %eax, %ebp
movl %r13d, %r13d
movq %r12, %rdi
movq %r13, %rsi
callq 0x6c50
movl %ebp, %edi
movq %r12, %rsi
movq %r13, %rdx
callq 0x10b0
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x6c88
movq (%rsp), %rax
cmpq %r14, %rax
setb %cl
cmpq %rbx, %rax
seta %al
orb %cl, %al
jne 0x4172
movl %ebp, %edi
callq 0x1080
movq %r12, %rdi
callq 0x1030
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movl %esi, %r14d
movq %rdi, %rbx
movq %rsp, %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x6c50
leal -0x9(%r14), %eax
cmpl $-0x9, %eax
ja 0x4205
movl 0x8(%rbx), %edi
callq 0x21a8
jmp 0x42b5
leal (,%r14,8), %eax
leal -0x8(%rax), %ecx
movl $0x1, %edi
shlq %cl, %rdi
negb %al
movq $-0x1, %rsi
movl %eax, %ecx
shrq %cl, %rsi
callq 0x4114
movq %rax, %r15
movl 0x4(%rbx), %eax
testb $0x8, %al
jne 0x4258
testb $0x2, %al
jne 0x4282
leaq 0x8c3b(%rip), %rsi      # 0xce7b
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x7300
movl 0x10(%rbx), %esi
movq %r14, %rdi
jmp 0x427b
addl %r14d, %r14d
leaq 0x8c60(%rip), %rsi      # 0xcec2
movq %rsp, %r12
movq %r12, %rdi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x7300
movl 0x10(%rbx), %esi
movq %r12, %rdi
callq 0x7225
jmp 0x42a8
movq %rsp, %rdi
movq %r15, %rsi
callq 0x179d
movq %rax, %r14
movq %r15, %rdi
callq 0x1780
movsbl %al, %esi
movl 0x10(%rbx), %edx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x1888
movl 0x10(%rbx), %edi
cmpl $0x2, %edi
jl 0x42b5
callq 0x1080
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/standard/rand.c
// Function: parse_rand
int				parse_rand(char **av, t_ssl *ssl, int *bytes, int i)
{
	while (av[++i])
	{
		if (av[i][0] == '-')
		{
			if (valid_rand_arg(av, ssl, &i, av[i + 1]))
				return (ssl->fd[1] == -1 ? opt_desciption(ssl->type) :\
				ft_error(6, &av[i][1], ssl));
		}
		else if (!ft_isdigit(av[i][0]))
			return (ft_error(6, av[i], ssl));
		else if (*bytes || (ssl->flag & RAND_BASE64 && ssl->flag & HEX))
		{
			ft_putstr_fd(E_MANY, 2);
			return (opt_desciption(ssl->type) && (*bytes = 1));
		}
		else
			*bytes = ft_atoi(av[i]);
	}
	if (!*bytes || (ssl->flag & RAND_BASE64 && ssl->flag & HEX))
	{
		ssl->flag & RAND_BASE64 && ssl->flag & HEX ?\
		ft_putstr_fd(E_MANY, 2) : 0;
		return (1 && !(*bytes = 0));
	}
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rax
movslq %ecx, %rcx
movq 0x8(%rdi,%rcx,8), %rdi
testq %rdi, %rdi
je 0x43aa
leaq (%rax,%rcx,8), %rbp
addq $0x8, %rbp
leaq 0x8bf0(%rip), %r15      # 0xcee8
leaq 0x8bb2(%rip), %r12      # 0xceb1
movsbl (%rdi), %eax
cmpl $0x2d, %eax
jne 0x4362
movq 0x8(%rbp), %r13
incq %rdi
movq %r15, %rsi
callq 0x7644
testl %eax, %eax
je 0x438d
movq (%rbp), %rdi
incq %rdi
movq %r12, %rsi
callq 0x7644
testl %eax, %eax
je 0x4394
cmpl $0x1, 0x10(%r14)
jne 0x443f
movq (%rbp), %rdi
incq %rdi
leaq 0x948c(%rip), %rsi      # 0xd7d2
callq 0x7644
testl %eax, %eax
jne 0x443f
orb $0x4, 0x4(%r14)
testq %r13, %r13
jne 0x4399
jmp 0x4426
movl %eax, %edi
callq 0x6bf4
testl %eax, %eax
je 0x4420
cmpl $0x0, (%rbx)
jne 0x43e4
movl 0x4(%r14), %eax
notl %eax
testb $0xa, %al
je 0x43e4
movq (%rbp), %rdi
callq 0x6a30
movl %eax, (%rbx)
jmp 0x4399
orb $0x2, 0x4(%r14)
jmp 0x4399
orb $0x8, 0x4(%r14)
movq 0x8(%rbp), %rdi
addq $0x8, %rbp
testq %rdi, %rdi
jne 0x42ff
cmpl $0x0, (%rbx)
je 0x43bc
movl 0x4(%r14), %ecx
notl %ecx
xorl %eax, %eax
testb $0xa, %cl
jne 0x4411
movl 0x4(%r14), %eax
notl %eax
testb $0xa, %al
jne 0x43d7
leaq 0x8a68(%rip), %rdi      # 0xce35
movl $0x2, %esi
callq 0x7225
movl $0x0, (%rbx)
movl $0x1, %eax
jmp 0x4411
leaq 0x8a4a(%rip), %rdi      # 0xce35
movl $0x2, %esi
callq 0x7225
movl 0x8(%r14), %edi
callq 0x21a8
movl %eax, %ecx
testl %eax, %eax
je 0x440a
movl $0x1, (%rbx)
xorl %eax, %eax
testl %ecx, %ecx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbp), %rsi
jmp 0x444d
movl $0xffffffff, 0x10(%r14) # imm = 0xFFFFFFFF
leaq 0x8aba(%rip), %rdi      # 0xceef
movl $0x2, %esi
callq 0x7225
cmpl $-0x1, 0x10(%r14)
je 0x4468
movq (%rbp), %rsi
incq %rsi
movl $0x6, %edi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2729
movl 0x8(%r14), %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a8
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edx, 0xc(%rsp)
movl $0x0, 0x4(%rsi)
movl $0x1, 0x10(%rsi)
cmpq $0x0, 0x10(%rdi)
je 0x44c7
leaq 0xc(%rsp), %rdx
movq %rbx, %rsi
movl $0x1, %ecx
callq 0x42c4
testl %eax, %eax
jne 0x44c7
movl 0xc(%rsp), %esi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x41ce
movl 0x4(%rbx), %ecx
movl %ecx, %edx
notl %edx
testb $0xa, %dl
je 0x44d8
testb $0x4, %cl
je 0x44e5
cmpl $0x0, 0xc(%rsp)
je 0x44e5
addq $0x10, %rsp
popq %rbx
retq
cmpl $-0x1, %eax
je 0x44df
cmpl $0x0, 0xc(%rsp)
jne 0x44df
leaq 0x89d2(%rip), %rdi      # 0xceca
movl $0x2, %esi
callq 0x7225
movl 0x8(%rbx), %edi
addq $0x10, %rsp
popq %rbx
jmp 0x21a8
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movq %rdi, %rdx
movb %sil, 0x7(%rsp)
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x4589
cmpl $0xa, %eax
setge %cl
movl %esi, %edi
andb $-0x4, %dil
cmpb $0x70, %dil
setne %dil
orb %cl, %dil
je 0x4575
leal -0xb(%rax), %ecx
cmpl $0x8, %ecx
ja 0x4557
movsbl %sil, %ecx
addl $-0x64, %ecx
cmpl $0xb, %ecx
ja 0x4557
movl $0x823, %edi            # imm = 0x823
btl %ecx, %edi
jb 0x4575
addl $-0x15, %eax
cmpl $0x8, %eax
ja 0x4589
movsbl %sil, %eax
addl $-0x61, %eax
cmpl $0x15, %eax
ja 0x4589
movl $0x24c519, %ecx         # imm = 0x24C519
btl %eax, %ecx
jae 0x4589
addb $-0x61, %sil
movl $0x1, %eax
movl %esi, %ecx
shll %cl, %eax
orl %eax, 0x4(%rdx)
xorl %eax, %eax
jmp 0x459d
leaq 0x7(%rsp), %rsi
movl $0x4, %edi
callq 0x2729
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
leaq 0x8965(%rip), %rsi      # 0xcf0f
callq 0x7644
testl %eax, %eax
je 0x461c
leaq 0x895c(%rip), %rsi      # 0xcf16
movq %rbx, %rdi
callq 0x7644
testl %eax, %eax
je 0x4623
leaq 0x8945(%rip), %rsi      # 0xcf12
movq %rbx, %rdi
callq 0x7644
testl %eax, %eax
je 0x462a
leaq 0x88bd(%rip), %rsi      # 0xce9d
movq %rbx, %rdi
callq 0x7644
testl %eax, %eax
je 0x4631
leaq 0x892a(%rip), %rsi      # 0xcf1d
movq %rbx, %rdi
callq 0x7644
testl %eax, %eax
je 0x4638
leaq 0x891f(%rip), %rsi      # 0xcf25
movq %rbx, %rdi
callq 0x7644
xorl %ecx, %ecx
testl %eax, %eax
movl $0x2a, %eax
cmovnel %ecx, %eax
jmp 0x463d
movl $0x1f, %eax
jmp 0x463d
movl $0x20, %eax
jmp 0x463d
movl $0x21, %eax
jmp 0x463d
movl $0x24, %eax
jmp 0x463d
movl $0x29, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
leaq 0x88e0(%rip), %rsi      # 0xcf2a
callq 0x7644
testl %eax, %eax
je 0x46e9
leaq 0x88d5(%rip), %rsi      # 0xcf33
movq %rbx, %rdi
callq 0x7644
testl %eax, %eax
je 0x46f0
leaq 0x88c7(%rip), %rsi      # 0xcf3c
movq %rbx, %rdi
callq 0x7644
testl %eax, %eax
je 0x46f7
leaq 0x88bd(%rip), %rsi      # 0xcf45
movq %rbx, %rdi
callq 0x7644
testl %eax, %eax
je 0x46fe
leaq 0x88af(%rip), %rsi      # 0xcf4a
movq %rbx, %rdi
callq 0x7644
testl %eax, %eax
je 0x4705
leaq 0x88a4(%rip), %rsi      # 0xcf52
movq %rbx, %rdi
callq 0x7644
testl %eax, %eax
je 0x470c
leaq 0x8899(%rip), %rsi      # 0xcf5a
movq %rbx, %rdi
callq 0x7644
testl %eax, %eax
je 0x4713
leaq 0x888e(%rip), %rsi      # 0xcf62
movq %rbx, %rdi
callq 0x7644
testl %eax, %eax
je 0x471a
movq %rbx, %rdi
popq %rbx
jmp 0x459f
movl $0x1c, %eax
jmp 0x471f
movl $0x1b, %eax
jmp 0x471f
movl $0x1a, %eax
jmp 0x471f
movl $0x19, %eax
jmp 0x471f
movl $0x18, %eax
jmp 0x471f
movl $0x17, %eax
jmp 0x471f
movl $0x16, %eax
jmp 0x471f
movl $0x15, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %rax
movzbl (%rax), %ecx
testb $-0x21, %cl
je 0x473b
incq %rax
jmp 0x472e
movb $0x0, (%rax)
leaq 0x88ee(%rip), %rsi      # 0xd033
movq %r14, %rdi
callq 0x7644
testl %eax, %eax
je 0x47ca
leaq 0x880e(%rip), %rsi      # 0xcf66
movq %r14, %rdi
callq 0x7644
testl %eax, %eax
je 0x47d1
leaq 0x8802(%rip), %rsi      # 0xcf6d
movq %r14, %rdi
callq 0x7644
testl %eax, %eax
je 0x47d8
leaq 0x87f6(%rip), %rsi      # 0xcf74
movq %r14, %rdi
callq 0x7644
testl %eax, %eax
je 0x47df
leaq 0x87ea(%rip), %rsi      # 0xcf7b
movq %r14, %rdi
callq 0x7644
testl %eax, %eax
je 0x47e6
leaq 0x87de(%rip), %rsi      # 0xcf82
movq %r14, %rdi
callq 0x7644
testl %eax, %eax
je 0x47ed
leaq 0x8731(%rip), %rsi      # 0xcee8
movq %r14, %rdi
callq 0x7644
testl %eax, %eax
jne 0x47f5
movl $0xb, %eax
jmp 0x47f2
movl $0x1, %eax
jmp 0x47f2
movl $0x2, %eax
jmp 0x47f2
movl $0x3, %eax
jmp 0x47f2
movl $0x4, %eax
jmp 0x47f2
movl $0x5, %eax
jmp 0x47f2
movl $0x6, %eax
movl %eax, 0x8(%rbx)
cmpl $0x0, 0x8(%rbx)
jne 0x4806
movq %r14, %rdi
callq 0x463f
movl %eax, 0x8(%rbx)
xorl %eax, %eax
cmpl $0x0, 0x8(%rbx)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
leaq 0x8765(%rip), %rsi      # 0xcf87
leaq 0x8776(%rip), %rbx      # 0xcf9f
leaq 0x7a2f(%rip), %r14      # 0xc25f
movl $0x2, %edi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1090
leaq 0x875e(%rip), %rsi      # 0xcfa7
movl $0x2, %edi
xorl %eax, %eax
callq 0x1090
leaq 0x8760(%rip), %rsi      # 0xcfbc
movl $0x2, %edi
xorl %eax, %eax
callq 0x1090
leaq 0x8764(%rip), %rsi      # 0xcfd3
movl $0x2, %edi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1090
leaq 0x8769(%rip), %rsi      # 0xcff1
movl $0x2, %edi
xorl %eax, %eax
callq 0x1090
leaq 0x8771(%rip), %rsi      # 0xd00c
movl $0x2, %edi
xorl %eax, %eax
callq 0x1090
leaq 0x876f(%rip), %rsi      # 0xd01d
movl $0x2, %edi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1090
nop
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq $0x0, 0x10(%rdi)
je 0x48e7
cmpq $0x0, 0x38(%rdi)
je 0x48ed
testl %edx, %edx
jne 0x48f3
cmpq $0x0, 0x40(%rdi)
jne 0x48f3
addq $0x40, %rdi
jmp 0x4941
addq $0x10, %rdi
jmp 0x4941
addq $0x38, %rdi
jmp 0x4941
testl %edx, %edx
jne 0x48fd
cmpq $0x0, (%rdi)
je 0x4941
testl %edx, %edx
jne 0x490e
cmpq $0x0, 0x8(%rdi)
jne 0x490e
addq $0x8, %rdi
jmp 0x4941
testl %edx, %edx
jne 0x491f
cmpq $0x0, 0x20(%rdi)
jne 0x491f
addq $0x20, %rdi
jmp 0x4941
testl %edx, %edx
jne 0x4930
cmpq $0x0, 0x28(%rdi)
jne 0x4930
addq $0x28, %rdi
jmp 0x4941
xorl %eax, %eax
testl %edx, %edx
jne 0x4949
cmpq $0x0, 0x30(%rdi)
jne 0x4949
addq $0x30, %rdi
movq %rsi, (%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq %rdi, (%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rdi, %rcx
incl %eax
cmpb $0x2, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0x496b
cmpl %ebp, %eax
jge 0x49d2
leaq 0x1(%r15), %r12
movslq %eax, %rcx
leaq 0x1(%rcx), %r13
cmpb $0x2, (%r15,%rcx)
jne 0x49ca
movzbl (%r15,%r13), %ecx
testl %ecx, %ecx
je 0x49be
addq %r12, %r13
movl %ecx, %edx
xorl %edi, %edi
xorl %esi, %esi
movq %rsi, %r8
shlq $0x8, %r8
movzbl (%r13,%rdi), %esi
orq %r8, %rsi
incq %rdi
cmpl %edi, %edx
jne 0x499e
leal (%rax,%rcx), %r13d
incl %r13d
jmp 0x49c0
xorl %esi, %esi
movq %r14, %rdi
movl %ebx, %edx
callq 0x48c8
movl %r13d, %eax
cmpl %ebp, %r13d
jl 0x497e
movq %rsp, %rdi
callq 0x777c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/rsa/rsa.c
// Function: validate_key
int				validate_key(char *buf, t_rsa *gg, int flag)
{
	uint8_t		seq_decode[3];
	uint8_t		*decoded;
	int			n;
	float		decode_len;

	decode_len = 0;
	n = base64_decode((uint8_t *)buf, seq_decode, 4);
	decode_len = (((float)seq_decode[1] / 3.0) * 4.0);
	decoded = ft_memalloc((int)decode_len);
	n += base64_decode((uint8_t *)buf + n, decoded, (int)decode_len);
	if (buf[n + 1] != '-' && ft_pipewrench("-s", &decoded))
		return (0);
	if ((n <= 64 ? ((ft_strchri(buf, '-') - 1) % 4) :\
	((n + 1 != ft_strchri(buf, '-')) || ((n - (65 * (n / 64))) % 4))) &&\
		ft_error(flag ? 7 : 8, NULL, NULL) && ft_pipewrench("-s", &decoded))
		return ((buf[0] = 0));
	decode_len = (int)((decode_len / 4.0) * 3.0);
	if (assign(decoded, gg, (int)decode_len, flag))
		return (0);
	if (get_value(gg, 0, flag) && ft_error(flag ? 13 : 14, NULL, NULL))
		return ((buf[0] = 0));
	return (n <= 64 ? ft_strchri(buf, '-') : n + 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x15(%rsp), %r15
movq %r15, %rsi
movl $0x4, %edx
callq 0x1a7a
movzbl 0x1(%r15), %ecx
cvtsi2sd %ecx, %xmm0
divsd 0x75f4(%rip), %xmm0     # 0xc018
mulsd 0x860c(%rip), %xmm0     # 0xd038
cvtsd2ss %xmm0, %xmm0
movl %eax, %r15d
movss %xmm0, 0x10(%rsp)
cvttss2si %xmm0, %eax
movslq %eax, %r12
movq %r12, %rdi
callq 0x6c60
movq %rax, 0x8(%rsp)
movslq %r15d, %r13
leaq (%rbx,%r13), %rdi
movq %rax, %rsi
movl %r12d, %edx
callq 0x1a7a
addl %eax, %r13d
movslq %r13d, %r12
cmpb $0x2d, 0x1(%rbx,%r12)
je 0x4a8b
leaq 0x8335(%rip), %rdi      # 0xcda9
xorl %r15d, %r15d
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x6d18
testl %eax, %eax
jne 0x4b67
leaq 0x1(%r12), %r15
movq %rbx, %rdi
movl $0x2d, %esi
callq 0x75f7
cmpl $0x40, %r12d
jg 0x4aab
decl %eax
testb $0x3, %al
jne 0x4ac0
jmp 0x4aec
cmpl %eax, %r15d
jne 0x4ac0
movl %r13d, %eax
shrl $0x6, %eax
movl %r13d, %ecx
subl %eax, %ecx
testb $0x3, %cl
je 0x4aec
xorl %edi, %edi
cmpl $0x1, %ebp
adcl $0x7, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2729
testl %eax, %eax
je 0x4aec
leaq 0x82cd(%rip), %rdi      # 0xcda9
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x6d18
testl %eax, %eax
jne 0x4b49
xorps %xmm0, %xmm0
cvtss2sd 0x10(%rsp), %xmm0
mulsd 0x8543(%rip), %xmm0     # 0xd040
mulsd 0x7513(%rip), %xmm0     # 0xc018
cvttpd2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movq 0x8(%rsp), %rdi
cvttss2si %xmm0, %edx
movq %r14, %rsi
movl %ebp, %ecx
callq 0x494a
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x48c8
testl %eax, %eax
je 0x4b51
cmpl $0x1, %ebp
adcl $0xd, %r12d
movl %r12d, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2729
testl %eax, %eax
je 0x4b51
movb $0x0, (%rbx)
xorl %r15d, %r15d
jmp 0x4b67
cmpl $0x40, %r13d
jg 0x4b67
movq %rbx, %rdi
movl $0x2d, %esi
callq 0x75f7
movl %eax, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/rsa/rsa.c
// Function: read_key
int				read_key(char *buf, t_rsa *gg, int flag, int fd)
{
	if (flag & R_CHECK && flag & R_PUBIN)
		return (ft_error(20, NULL, NULL));
	ft_bzero(buf, PAGESIZE);
	read(fd, buf, PAGESIZE);
	flag = flag & R_PUBIN ? 1 : 0;
	if (ft_strncmp(buf, flag ? PUB_BEG : PRIV_BEG, flag ? 27 : 32))
	{
		buf += ft_strchri(buf, '\n');
		buf += ft_strchri(buf, '-');
		if (ft_strncmp(buf, flag ? PUB_BEG : PRIV_BEG, flag ? 27 : 32) &&\
			ft_error(flag ? 9 : 10, NULL, NULL))
			return (ft_printf("%s", flag ? EXPECT_PUB : EXPECT_PRV));
	}
	buf += flag ? 27 : 32;
	if (!*buf)
		return (ft_error(flag ? 11 : 12, NULL, NULL));
	buf += validate_key(buf, gg, flag);
	if (!*buf)
		return (1);
	if (ft_strncmp(buf, flag ? PUB_END : PRIV_END, flag ? 25 : 30))
		return (ft_error(flag ? 11 : 12, NULL, NULL));
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %eax
notl %eax
testb $0x30, %al
jne 0x4b96
movl $0x14, %edi
jmp 0x4cc7
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
andl $0x20, %ebx
movl $0x1000, %esi           # imm = 0x1000
callq 0x6c50
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %r14, %rsi
callq 0x10b0
xorl %eax, %eax
testl %ebx, %ebx
sete %al
leaq 0x849a(%rip), %rcx      # 0xd064
leaq 0x8477(%rip), %r13      # 0xd048
cmoveq %rcx, %r13
leaq (%rax,%rax,4), %r12
addq $0x1b, %r12
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x7664
testl %eax, %eax
je 0x4c6c
movq %r14, %rdi
movl $0xa, %esi
callq 0x75f7
movslq %eax, %rbp
addq %r14, %rbp
movq %rbp, %rdi
movl $0x2d, %esi
callq 0x75f7
movslq %eax, %r14
addq %rbp, %r14
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x7664
testl %eax, %eax
je 0x4c6c
xorl %edi, %edi
cmpl $0x1, %ebx
adcl $0x9, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2729
testl %eax, %eax
je 0x4c6c
testl %ebx, %ebx
leaq 0x8457(%rip), %rax      # 0xd09c
leaq 0x8439(%rip), %rsi      # 0xd085
cmoveq %rax, %rsi
leaq 0x79e2(%rip), %rdi      # 0xc639
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6f7c
cmpb $0x0, (%r14,%r12)
je 0x4cbf
movl %ebx, %edx
shrl $0x5, %edx
addq %r12, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x49eb
cltq
cmpb $0x0, (%r14,%rax)
je 0x4cde
addq %rax, %r14
xorl %eax, %eax
testl %ebx, %ebx
sete %al
leaq 0x8432(%rip), %rcx      # 0xd0d2
leaq 0x8411(%rip), %rsi      # 0xd0b8
cmoveq %rcx, %rsi
leaq (%rax,%rax,4), %rdx
addq $0x19, %rdx
movq %r14, %rdi
callq 0x7664
testl %eax, %eax
je 0x4ce5
xorl %edi, %edi
cmpl $0x1, %ebx
adcl $0xb, %edi
xorl %esi, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2729
movl $0x1, %eax
jmp 0x4ce7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/rsa/rsa.c
// Function: rsa_command
t_rsa			rsa_command(t_rsa_out rsa)
{
	t_rsa		gg;
	char		buf[PAGESIZE];
	__uint64_t	tmp;

	ft_bzero(&gg, sizeof(t_rsa));
	rsa.bits = 0;
	if ((rsa.flag & R_PUBIN && rsa.flag & R_DECRYPT && ft_error(19, NULL, NULL))
	|| read_key(buf, &gg, rsa.flag, rsa.type ? rsa.fd_inkey : rsa.fd_in))
		return (gg);
	tmp = gg.n;
	while (tmp && ++rsa.bits)
		tmp >>= 1;
	if (!rsa.type && rsa.flag & R_TEXT)
		rsa_text_out(rsa, gg);
	if (rsa.flag & R_MODULUS)
	{
		ft_bzero(buf, PAGESIZE);
		ft_sprintf(buf, "Modulus=%llX\n", gg.n);
		ft_putstr_fd(buf, rsa.fd_out);
	}
	if (rsa.flag & R_CHECK)
		rsa_out_options(rsa, gg, 'c');
	if (!rsa.type && !(rsa.flag & R_NOOUT))
		rsa_out_options(rsa, gg, 'o');
	return (gg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1060, %rsp           # imm = 0x1060
movq %rdi, %rbx
movl $0x48, %esi
callq 0x6c50
movl $0x0, 0x1088(%rsp)
movl 0x1080(%rsp), %eax
notl %eax
testl $0x220, %eax            # imm = 0x220
jne 0x4d40
movl $0x13, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2729
testl %eax, %eax
jne 0x4e6f
leaq 0x1080(%rsp), %r15
movl (%r15), %edx
xorl %eax, %eax
cmpl $0x0, 0x4(%r15)
setne %al
movl 0x10(%r15,%rax,4), %ecx
leaq 0x60(%rsp), %rdi
movq %rbx, %rsi
callq 0x4b79
testl %eax, %eax
jne 0x4e6f
movq 0x10(%rbx), %rcx
movl 0x8(%r15), %eax
testq %rcx, %rcx
je 0x4d96
cmpl $-0x1, %eax
je 0x4d94
movq %rcx, %rdx
shrq %rdx
incl %eax
cmpq $0x2, %rcx
movq %rdx, %rcx
jae 0x4d7c
jmp 0x4d96
xorl %eax, %eax
movl %eax, 0x8(%r15)
cmpl $0x0, 0x4(%r15)
jne 0x4dcd
testb $0x4, (%r15)
je 0x4dcd
leaq 0x18(%rsp), %rdi
movl $0x9, %ecx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x4f13
testb $-0x80, (%r15)
je 0x4e06
leaq 0x60(%rsp), %r14
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
callq 0x6c50
movq 0x10(%rbx), %rdx
leaq 0x8301(%rip), %rsi      # 0xd0f1
movq %r14, %rdi
xorl %eax, %eax
callq 0x7300
movl 0xc(%r15), %esi
movq %r14, %rdi
callq 0x7225
testb $0x10, (%r15)
je 0x4e37
leaq 0x18(%rsp), %rdi
movl $0x9, %ecx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movl $0x63, %edi
callq 0x51e3
cmpl $0x0, 0x4(%r15)
jne 0x4e6f
testb $0x8, (%r15)
jne 0x4e6f
leaq 0x18(%rsp), %rdi
movl $0x9, %ecx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movl $0x6f, %edi
callq 0x51e3
movq %rbx, %rax
addq $0x1060, %rsp           # imm = 0x1060
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %esi
leaq 0x8271(%rip), %rdi      # 0xd0ff
xorl %eax, %eax
callq 0x6f7c
movl 0x8(%rbx), %esi
leaq 0x8271(%rip), %rdi      # 0xd110
xorl %eax, %eax
callq 0x6f7c
movl 0x18(%rsp), %esi
leaq 0x8270(%rip), %rdi      # 0xd121
xorl %eax, %eax
callq 0x6f7c
movl 0x20(%rsp), %esi
leaq 0x826f(%rip), %rdi      # 0xd132
xorl %eax, %eax
callq 0x6f7c
movl 0x1c(%rsp), %esi
leaq 0x826e(%rip), %rdi      # 0xd143
xorl %eax, %eax
callq 0x6f7c
movl 0x24(%rsp), %esi
leaq 0x826d(%rip), %rdi      # 0xd154
xorl %eax, %eax
callq 0x6f7c
movl 0x10(%rsp), %esi
leaq 0x826c(%rip), %rdi      # 0xd165
xorl %eax, %eax
callq 0x6f7c
movl 0x14(%rsp), %esi
leaq 0x826b(%rip), %rdi      # 0xd176
xorl %eax, %eax
popq %rbx
jmp 0x6f7c
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/rsa/rsa_out.c
// Function: rsa_text_out
void			rsa_text_out(t_rsa_out rsa, t_rsa gg)
{
	char	buf[PAGESIZE];

	ft_bzero(buf, PAGESIZE);
	ft_sprintf(buf, "%s-Key: (%d bit)\n",
	rsa.flag & R_PUBIN ? "Public" : "Private", rsa.bits);
	ft_sprintf(&buf[ft_strlen(buf)], "%codulus: %llu (%#llx)\n",\
	rsa.flag & R_PUBIN ? 'M' : 'm', gg.n, gg.n);
	ft_sprintf(&buf[ft_strlen(buf)], "%sxponent: %llu (%#llx)\n",
	rsa.flag & R_PUBIN ? "E" : "publicE", gg.e, gg.e);
	if (!(rsa.flag & R_PUBIN))
	{
		ft_sprintf(&buf[ft_strlen(buf)],
		"privateExponent: %llu (%#llx)\n", gg.d, gg.d);
		ft_sprintf(&buf[ft_strlen(buf)], "prime1: %llu (%#llx)\n", gg.p, gg.p);
		ft_sprintf(&buf[ft_strlen(buf)], "prime2: %llu (%#llx)\n", gg.q, gg.q);
		ft_sprintf(&buf[ft_strlen(buf)],
		"exponent1: %llu (%#llx)\n", gg.dmp1, gg.dmp1);
		ft_sprintf(&buf[ft_strlen(buf)],
		"exponent2: %llu (%#llx)\n", gg.dmq1, gg.dmq1);
		ft_sprintf(&buf[ft_strlen(buf)],
		"coefficient: %llu (%#llx)\n", gg.iqmp, gg.iqmp);
	}
	ft_putstr_fd(buf, rsa.fd_out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsp, %rbx
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
callq 0x6c50
leaq 0x1030(%rsp), %r15
movl (%r15), %ebp
movl 0x8(%r15), %ecx
andl $0x20, %ebp
testl %ebp, %ebp
leaq 0x8255(%rip), %rax      # 0xd1a0
leaq 0x8247(%rip), %rdx      # 0xd199
cmoveq %rax, %rdx
leaq 0x822a(%rip), %rsi      # 0xd187
leaq 0x8275(%rip), %rax      # 0xd1d9
leaq 0x8274(%rip), %r14      # 0xd1df
cmoveq %rax, %r14
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7300
movq %rbx, %rdi
callq 0x7952
leaq (%rsp,%rax), %rdi
movq 0x1058(%rsp), %rcx
leaq 0x8214(%rip), %rsi      # 0xd1a8
movl %ebp, %edx
xorl $0x6d, %edx
movq %rcx, %r8
xorl %eax, %eax
callq 0x7300
movq %rbx, %rdi
callq 0x7952
leaq (%rsp,%rax), %rdi
movq 0x1080(%rsp), %rcx
leaq 0x8202(%rip), %rsi      # 0xd1c0
movq %r14, %rdx
movq %rcx, %r8
xorl %eax, %eax
callq 0x7300
testl %ebp, %ebp
jne 0x50a3
leaq 0x1048(%rsp), %r14
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x7952
leaq (%rsp,%rax), %rdi
movq 0x40(%r14), %rcx
leaq 0x81ec(%rip), %rsi      # 0xd1e1
movq %rcx, %rdx
xorl %eax, %eax
callq 0x7300
movq %rbx, %rdi
callq 0x7952
leaq (%rsp,%rax), %rdi
movq (%r14), %rcx
leaq 0x81eb(%rip), %rsi      # 0xd200
movq %rcx, %rdx
xorl %eax, %eax
callq 0x7300
movq %rbx, %rdi
callq 0x7952
leaq (%rsp,%rax), %rdi
movq 0x8(%r14), %rcx
leaq 0x81e0(%rip), %rsi      # 0xd216
movq %rcx, %rdx
xorl %eax, %eax
callq 0x7300
movq %rbx, %rdi
callq 0x7952
leaq (%rsp,%rax), %rdi
movq 0x20(%r14), %rcx
leaq 0x81d5(%rip), %rsi      # 0xd22c
movq %rcx, %rdx
xorl %eax, %eax
callq 0x7300
movq %rbx, %rdi
callq 0x7952
leaq (%rsp,%rax), %rdi
movq 0x28(%r14), %rcx
leaq 0x81cd(%rip), %rsi      # 0xd245
movq %rcx, %rdx
xorl %eax, %eax
callq 0x7300
movq %rbx, %rdi
callq 0x7952
leaq (%rsp,%rax), %rdi
movq 0x30(%r14), %rcx
leaq 0x81c5(%rip), %rsi      # 0xd25e
movq %rcx, %rdx
xorl %eax, %eax
callq 0x7300
movl 0xc(%r15), %esi
movq %rsp, %rdi
callq 0x7225
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/rsa/rsa_out.c
// Function: rsa_encode_out
void			rsa_encode_out(t_rsa_out rsa, t_rsa gg)
{
	int			len;
	int			i;
	uint8_t		buf[PAGESIZE];
	uint8_t		buf2[10];

	ft_bzero(buf, PAGESIZE);
	ft_bzero(buf2, 10);
	len = 0;
	(rsa.flag & R_PUBOUT || rsa.flag & R_PUBIN) ?\
	asn1_pub(gg, buf, buf2, &len) : asn1(gg, buf, buf2, &len);
	DEBUG ? ft_printf("asn1 len:[%d]\n", len) : 0;
	(rsa.flag & R_PUBOUT || rsa.flag & R_PUBIN) ? buf[16] = 0x00 : 0;
	(rsa.flag & R_PUBOUT || rsa.flag & R_PUBIN) ? buf[19] = 0x00 : 0;
	i = -1;
	while (++i < len)
		if (buf[i] == 0x02 && buf[i + 2] == 0xFF)
			buf[i + 2] = 0x00;
	ft_putstr_fd((rsa.flag & R_PUBOUT || rsa.flag & R_PUBIN) ?\
	PUB_BEG : PRIV_BEG, rsa.fd_out);
	base64_nstr_fd(buf, len, rsa.fd_out, 0);
	ft_putstr_fd((rsa.flag & R_PUBOUT || rsa.flag & R_PUBIN) ?\
	PUB_END : PRIV_END, rsa.fd_out);
	rsa.fd_out > 1 ? close(rsa.fd_out) : 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1060, %rsp           # imm = 0x1060
leaq 0x1098(%rsp), %rbx
leaq 0x60(%rsp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x6c50
leaq 0x56(%rsp), %rdi
movl $0xa, %esi
callq 0x6c50
movl $0x0, 0x50(%rsp)
movl 0x1080(%rsp), %ebp
movl $0x9, %ecx
movq %rsp, %rdi
movq %rbx, %rsi
testb $0x60, %bpl
je 0x5127
rep  movsq (%rsi), %es:(%rdi)
leaq 0x60(%rsp), %rdi
leaq 0x56(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x15d6
jmp 0x513e
rep  movsq (%rsi), %es:(%rdi)
leaq 0x60(%rsp), %rdi
leaq 0x56(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x120c
testb $0x60, %bpl
je 0x514e
xorl %eax, %eax
movb %al, 0x70(%rsp)
movb %al, 0x73(%rsp)
leaq 0x1080(%rsp), %rax
movslq 0x50(%rsp), %rcx
testq %rcx, %rcx
jle 0x517d
xorl %edx, %edx
cmpb $0x2, 0x60(%rsp,%rdx)
jne 0x5175
cmpb $-0x1, 0x62(%rsp,%rdx)
jne 0x5175
movb $0x0, 0x62(%rsp,%rdx)
incq %rdx
cmpq %rdx, %rcx
jne 0x5162
movl 0xc(%rax), %ebx
testb $0x60, %bpl
leaq 0x7ed9(%rip), %rax      # 0xd064
leaq 0x7eb6(%rip), %rdi      # 0xd048
cmoveq %rax, %rdi
leaq 0x7f35(%rip), %rax      # 0xd0d2
leaq 0x7f14(%rip), %r14      # 0xd0b8
cmoveq %rax, %r14
movl %ebx, %esi
callq 0x7225
movl 0x50(%rsp), %esi
leaq 0x60(%rsp), %rdi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x1888
movq %r14, %rdi
movl %ebx, %esi
callq 0x7225
cmpl $0x2, %ebx
jl 0x51d7
movl %ebx, %edi
callq 0x1080
addq $0x1060, %rsp           # imm = 0x1060
popq %rbx
popq %r14
popq %rbp
retq