LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/error.c
// Function: ft_error2
void			ft_error2(char *s, t_ssl *ssl, int e)
{
	if (e != 6)
	{
		e > 20 && e < 23 ? ft_putstr_fd("RSA operation error\n", 2) : 0;
		if (e == 21 || e == 22)
		{
			ft_putstr_fd("RSA_padding_add_none:data too", 2);
			ft_putstr_fd(e % 2 ? " small " : " large ", 2);
			ft_putstr_fd("for key size\n", 2);
		}
		else
			rsa_error(e);
		return ;
	}
	else if (!(!ft_strcmp(s, "help") || !ft_strcmp(s, "h") ||\
	!ft_strcmp(s, "in") || !ft_strcmp(s, "inkey") || ssl->flag == -42))
		dprintf(2, "ft_ssl: Error: invalid option: \'%s\'\n", s);
	if (ssl->type == 31)
		dprintf(2, "%susage%s: genrsa [args] [numbits]\n", YEL, NOCOL);
	else if (ssl->type == 32)
		dprintf(2, "%susage%s: rsautl [options]\n", YEL, NOCOL);
	else if (ssl->type == 33)
		dprintf(2, "%susage%s: rsa [options]\n", YEL, NOCOL);
	opt_desciption(ssl->type);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x6, %edx
jne 0x25a0
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x971d(%rip), %rsi      # 0xbc21
callq 0x70f4
testl %eax, %eax
je 0x2560
leaq 0x9712(%rip), %rsi      # 0xbc26
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x2560
leaq 0xa27c(%rip), %rsi      # 0xc7a3
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x2560
leaq 0x96ee(%rip), %rsi      # 0xbc28
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x2560
cmpl $-0x2a, 0x4(%rbx)
je 0x2560
leaq 0x96db(%rip), %rsi      # 0xbc2e
pushq $0x2
popq %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1080
movl 0x8(%rbx), %eax
addl $-0x1f, %eax
cmpl $0x2, %eax
ja 0x2593
movl %eax, %eax
leaq 0x8c28(%rip), %rcx      # 0xb19c
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq 0x8cd5(%rip), %rdx      # 0xb257
leaq 0x8cd6(%rip), %rcx      # 0xb25f
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x1080
movl 0x8(%rbx), %edi
popq %rbx
popq %r14
popq %r15
jmp 0x20b0
movl %edx, %r15d
leal -0x15(%r15), %eax
cmpl $0x1, %eax
ja 0x25fb
leaq 0x961d(%rip), %rdi      # 0xbbd0
pushq $0x2
popq %rbx
movl %ebx, %esi
callq 0x6d07
leaq 0x9621(%rip), %rdi      # 0xbbe5
movl %ebx, %esi
callq 0x6d07
testb $0x1, %r15b
leaq 0x9635(%rip), %rax      # 0xbc0b
leaq 0x9626(%rip), %rdi      # 0xbc03
cmoveq %rax, %rdi
movl %ebx, %esi
callq 0x6d07
leaq 0x9624(%rip), %rdi      # 0xbc13
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x6d07
movl %r15d, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x242b
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/error.c
// Function: ft_error
int				ft_error(int err, char *ex, t_ssl *ssl)
{
	if (err == 1)
	{
		dprintf(2, "ft_ssl: Error: '%s' is an invalid command.\n\n", ex);
		show_supported();
	}
	if (err == 2)
	{
		dprintf(2, "Error: %s: option requires an argument -- %c\n",
		ex, ssl->flag);
		ssl->flag = 0;
	}
	if (err == 3)
	{
		full_usage(ex, ssl->type);
		if (ssl->flag || VERBOSE)
			opt_desciption(ssl->type);
	}
	if (err == 4 && *ex != 'h')
		dprintf(2, "unknown option '-%c'\n", *ex);
	if (err == 5)
		dprintf(2, "ft_ssl: Error: %s need a flag\n", ex);
	if (err >= 6)
		ft_error2(ex, ssl, err);
	return (!err ? 0 : -1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rdx
movl %edi, %ebx
leal -0x1(%rbx), %eax
cmpl $0x4, %eax
ja 0x26b0
leaq 0x8b61(%rip), %rcx      # 0xb188
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x9677(%rip), %rsi      # 0xbcae
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x1080
callq 0x4478
jmp 0x26c2
leaq 0x96d0(%rip), %rsi      # 0xbd1f
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x1080
jmp 0x26c2
movl 0x8(%r14), %esi
movq %rdx, %rdi
callq 0x23ad
cmpl $0x0, 0x4(%r14)
je 0x26c2
movl 0x8(%r14), %edi
callq 0x20b0
jmp 0x26c2
movsbl (%rdx), %edx
cmpl $0x68, %edx
je 0x26c2
leaq 0x9681(%rip), %rsi      # 0xbd09
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x1080
jmp 0x26c2
movl 0x4(%r14), %ecx
leaq 0x963c(%rip), %rsi      # 0xbcdb
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x1080
andl $0x0, 0x4(%r14)
jmp 0x26c2
cmpl $0x6, %ebx
jl 0x26c2
movq %rdx, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x24e9
xorl %eax, %eax
negl %ebx
sbbl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/rsa/genrsa.c
// Function: genprime
__uint64_t		genprime(int bits, int out)
{
	__uint64_t			p;
	__uint64_t			min;
	__uint64_t			max;
	unsigned int		i;

	min = 1ULL << (abs(bits - 1));
	max = (1ULL << bits) - 1;
	i = 0;
	while (1)
	{
		if (i % (bits * 2) == 0)
		{
			p = genrand(min, max) | 1;
			p |= 1ULL << (bits - 1);
			out ? 0 : ft_putchar_fd('.', 2);
		}
		if (ft_is_primary(p, out))
			break ;
		out ? 0 : ft_putchar_fd('.', 2);
		p -= 2;
		i++;
	}
	DEBUG ? ft_printf("\nSUCCESS\tprime --> [%llb]", p) : 0;
	out ? 0 : ft_putchar_fd('\n', 2);
	return (p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
leal -0x1(%rbx), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
movl %esi, %ebp
pushq $0x1
popq %r14
movq %r14, %rdx
shlq %cl, %rdx
movq %rdx, 0x10(%rsp)
pushq $-0x1
popq %r15
movl %ebx, %ecx
shlq %cl, %r15
movl %eax, %ecx
shlq %cl, %r14
notq %r15
cvtsi2ss %esi, %xmm0
movss %xmm0, 0xc(%rsp)
addl %ebx, %ebx
xorl %r13d, %r13d
movl %r13d, %eax
xorl %edx, %edx
divl %ebx
testl %edx, %edx
jne 0x274c
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x3db4
movq %rax, %r12
orq %r14, %r12
orq $0x1, %r12
testl %ebp, %ebp
jne 0x274c
pushq $0x2e
popq %rdi
pushq $0x2
popq %rsi
callq 0x6cf0
movq %r12, %rdi
movss 0xc(%rsp), %xmm0
callq 0x33e7
testl %eax, %eax
jne 0x2776
testl %ebp, %ebp
jne 0x276d
pushq $0x2e
popq %rdi
pushq $0x2
popq %rsi
callq 0x6cf0
addq $-0x2, %r12
incl %r13d
jmp 0x271b
testl %ebp, %ebp
jne 0x2785
pushq $0xa
popq %rdi
pushq $0x2
popq %rsi
callq 0x6cf0
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/rsa/genrsa.c
// Function: valid_modulus
__uint64_t		valid_modulus(t_rsa gg, int bits)
{
	__uint64_t	n;

	n = gg.p * gg.q;
	if ((n / gg.p == gg.q) && n & 1ULL << (bits - 1) &&\
	n <= (bits == 64 ? UINT64_MAX : (1ULL << bits)))
		return (n);
	return (1);
}

// Assembly:
movq 0x8(%rsp), %rax
mulq 0x10(%rsp)
pushq $0x1
popq %rdx
jo 0x27cf
leal -0x1(%rdi), %ecx
movzbl %cl, %ecx
btq %rcx, %rax
jae 0x27cf
cmpl $0x40, %edi
setne %sil
movq %rdx, %r8
movl %edi, %ecx
shlq %cl, %r8
cmpq %rax, %r8
setb %cl
andb %sil, %cl
cmpb $0x1, %cl
jne 0x27d2
movq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/rsa/genrsa.c
// Function: genrsa
__uint64_t		genrsa(t_rsa_out rsa)
{
	t_rsa		gg;
	char		buf[80];

	ft_bzero(buf, 80);
	ft_bzero(&gg, sizeof(gg));
	ft_sprintf(buf, "%s, %d bit long modulus\n", GEN_PRV, rsa.bits);
	ft_putstr_fd(buf, 2);
	while (1)
	{
		gg.p = genprime((rsa.bits / 2), (int)gg.n);
		gg.q = genprime((rsa.bits / 2) + 1, (int)gg.n);
		if ((gg.n = valid_modulus(gg, rsa.bits)) != 1)
			break ;
	}
	gg.e = 65537;
	gg.phi = (gg.p - 1) * (gg.q - 1);
	gg.d = mod_inverse(gg.e, gg.phi);
	gg.dmp1 = gg.d % (gg.p - 1);
	gg.dmq1 = gg.d % (gg.q - 1);
	gg.iqmp = mod_inverse(gg.q, gg.p);
	ft_bzero(buf, 80);
	ft_sprintf(buf, "e is %llu (%#x)\n", gg.e, gg.e);
	ft_putstr_fd(buf, 2);
	rsa_encode_out(rsa, gg);
	return (gg.n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
leaq 0x140(%rsp), %rbx
leaq 0xb0(%rsp), %r14
pushq $0x50
popq %rsi
movq %r14, %rdi
callq 0x6720
leaq 0x68(%rsp), %r15
pushq $0x48
popq %rsi
movq %r15, %rdi
callq 0x6720
movl 0x8(%rbx), %ebx
leaq 0x9525(%rip), %rsi      # 0xbd3e
leaq 0x9537(%rip), %rdx      # 0xbd57
movq %r14, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x6dd0
pushq $0x2
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x6d07
movl 0x10(%r15), %esi
movl %ebx, %eax
cltd
idivl %ebp
movl %eax, %ebp
leal -0x1(%rbx), %ecx
pushq $0x1
popq %r15
movq %r15, %r13
shlq %cl, %r13
movl %eax, %r14d
incl %r14d
movq %r15, %r12
movl %ebx, %ecx
shlq %cl, %r12
movl %ebp, %edi
callq 0x26d0
movq %rax, 0x68(%rsp)
movl 0x78(%rsp), %esi
movl %r14d, %edi
callq 0x26d0
movq %rax, %r8
movq 0x68(%rsp), %rcx
movq %rcx, %rax
mulq %r8
seto %sil
movq %r15, %rdx
cmpq %rax, %r12
jb 0x2894
movq %rax, %rdx
cmpl $0x40, %ebx
cmoveq %rax, %rdx
testq %r13, %rax
cmoveq %r15, %rdx
testb %sil, %sil
cmovneq %r15, %rdx
movq %r8, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
pushq $0x1
popq %rsi
cmpq $0x1, %rdx
je 0x285f
leaq 0x68(%rsp), %rbx
movq $0x10001, 0x38(%rbx)    # imm = 0x10001
decq %rcx
decq %r8
imulq %rcx, %r8
movq %r8, 0x18(%rbx)
movl $0x10001, %edi          # imm = 0x10001
movq %r8, %rsi
callq 0x35b4
movq %rax, %rcx
movq %rax, 0x40(%rbx)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdi
leaq -0x1(%rsi), %r8
xorl %edx, %edx
divq %r8
movq %rdx, 0x20(%rbx)
leaq -0x1(%rdi), %r8
movq %rcx, %rax
xorl %edx, %edx
divq %r8
movq %rdx, 0x28(%rbx)
callq 0x35b4
movq %rax, 0x30(%rbx)
leaq 0xb0(%rsp), %r14
pushq $0x50
popq %rsi
movq %r14, %rdi
callq 0x6720
movq 0x38(%rbx), %rcx
leaq 0x943c(%rip), %rsi      # 0xbd72
movq %r14, %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x6dd0
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x6d07
leaq 0x18(%rsp), %rdi
pushq $0x9
popq %rcx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x140(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x10(%rsp)
movups (%rcx), %xmm0
movups %xmm0, (%rsp)
callq 0x4cc1
movq 0x10(%rbx), %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/hash/hash.c
// Function: copy_free
void			copy_free(char *buf, char **acontents)
{
	char		*tmp;
	char		*contents;
	int			len;

	buf[PAGESIZE] = 0;
	tmp = NULL;
	contents = *acontents;
	tmp = ft_strjoin(contents, buf);
	len = ft_strlen(tmp);
	ft_strdel(&contents);
	contents = ft_strdup(tmp);
	ft_strdel(&tmp);
	*acontents = contents;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movb $0x0, 0x1000(%rdi)
movq (%rbx), %rdi
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
callq 0x7228
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
movq %rax, %rdi
callq 0x739e
movq %r14, %rdi
callq 0x720c
movq %r15, %rdi
callq 0x74dc
movq %rax, (%r14)
movq %r12, %rdi
callq 0x720c
movq (%r14), %rax
movq %rax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/hash/hash.c
// Function: get_hash
char			*get_hash(char **to_hash, char **input, t_ssl *ssl, int i)
{
	char		buf[PAGESIZE + 1];
	char		*contents;
	char		*tmp;
	static char	*(*hasher[6])(char *, char *) = {
				md5, sha224, sha256, sha384, sha512, sha1};

	ft_bzero(buf, PAGESIZE);
	contents = NULL;
	tmp = NULL;
	*input = *to_hash;
	if (ssl->fd[i] > 2)
	{
		contents = ft_strdup("");
		while (read(ssl->fd[i], buf, PAGESIZE) > 0)
		{
			copy_free(buf, &contents);
			ft_bzero(buf, PAGESIZE);
		}
		close(ssl->fd[i]);
		*to_hash = ft_strdup(contents);
		ft_strdel(&contents);
	}
	else
		*to_hash = ft_strdup(*to_hash);
	return ((*hasher[ssl->type - 1])(buf, *to_hash));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1018, %rsp           # imm = 0x1018
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x6720
andq $0x0, 0x8(%rsp)
movq (%r14), %rdi
movq %rdi, (%r15)
movslq %ebp, %r13
cmpl $0x3, 0xc(%rbx,%r13,4)
jl 0x2aac
leaq 0x9298(%rip), %rdi      # 0xbcda
callq 0x74dc
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
leaq 0x10(%rsp), %r12
movl 0xc(%rbx,%r13,4), %edi
movl $0x1000, %edx           # imm = 0x1000
movq %r12, %rsi
callq 0x10a0
testq %rax, %rax
jle 0x2a85
movq %r12, %rdi
movq %r15, %rsi
callq 0x2990
movl $0x1000, %esi           # imm = 0x1000
movq %r12, %rdi
callq 0x6720
jmp 0x2a54
movl 0xc(%rbx,%r13,4), %edi
callq 0x1070
leaq 0x8(%rsp), %r15
movq (%r15), %rdi
callq 0x74dc
movq %rax, (%r14)
movq %r15, %rdi
callq 0x720c
movq (%r14), %rsi
jmp 0x2ab7
callq 0x74dc
movq %rax, %rsi
movq %rax, (%r14)
movslq 0x8(%rbx), %rax
leaq 0xf2de(%rip), %rcx      # 0x11da0
leaq 0x10(%rsp), %rdi
callq *-0x8(%rcx,%rax,8)
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/hash/hash.c
// Function: hash
void			hash(char *input, char *to_hash, t_ssl *ssl, int i)
{
	if ((!(ssl->flag & 0x38000) &&
	(ssl->flag & S_FLAG || (i >= 0 && ssl->fd[i]))))
	{
		ft_printf("%s (", ft_strtoupper(input));
		ssl->fd[i] < 1 ? ft_putchar('\"') : 0;
		ft_printf("%s", to_hash);
		ssl->fd[i] < 1 ? ft_putchar('\"') : 0;
		ft_printf(") = ");
	}
	!(ssl->flag & 0x70000) && (ssl->flag & P_FLAG || (ssl->fd[i] && ssl->flag))
	? ft_printf("%s", to_hash) : 0;
	ft_printf("%s%c", get_hash(&to_hash, &input, ssl, i),
	((!(ssl->flag & R_FLAG) || ssl->flag & Q_FLAG) || (ssl->flag & R_FLAG &&
	!(ssl->flag & Q_FLAG) && (ssl->flag & P_FLAG)) ? '\n' : ' '));
	if (ssl->flag & R_FLAG && !(ssl->flag & 0x18000))
	{
		ssl->fd[i] < 1 ? ft_putchar('\"') : 0;
		(ssl->fd[i] || ssl->flag & R_FLAG) ? ft_printf("%s", input) : 0;
		ssl->fd[i] < 1 ? ft_putchar('\"') : 0;
		ft_putchar('\n');
	}
	ft_strdel(&to_hash);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl 0x4(%rdx), %eax
movslq %ecx, %r15
testl $0x38000, %eax          # imm = 0x38000
jne 0x2b71
btl $0x12, %eax
jb 0x2b19
testl %ebp, %ebp
js 0x2b71
movl %ebp, %ecx
cmpl $0x0, 0xc(%rbx,%rcx,4)
je 0x2b71
callq 0x669c
leaq 0x925e(%rip), %rdi      # 0xbd83
movq %rax, %rsi
xorl %eax, %eax
callq 0x6a50
cmpl $0x0, 0xc(%rbx,%r15,4)
jg 0x2b3f
pushq $0x22
popq %rdi
callq 0x6d2d
leaq 0x8af3(%rip), %rdi      # 0xb639
movq %r14, %rsi
xorl %eax, %eax
callq 0x6a50
cmpl $0x0, 0xc(%rbx,%r15,4)
jg 0x2b60
pushq $0x22
popq %rdi
callq 0x6d2d
leaq 0x9221(%rip), %rdi      # 0xbd88
xorl %eax, %eax
callq 0x6a50
movl 0x4(%rbx), %eax
testl $0x70000, %eax          # imm = 0x70000
jne 0x2b9a
testw %ax, %ax
js 0x2b89
testl %eax, %eax
je 0x2b9a
cmpl $0x0, 0xc(%rbx,%r15,4)
je 0x2b9a
leaq 0x8aa9(%rip), %rdi      # 0xb639
movq %r14, %rsi
xorl %eax, %eax
callq 0x6a50
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x29f9
movl $0x38000, %ebp          # imm = 0x38000
movl 0x4(%rbx), %ecx
andl %ebp, %ecx
movl $0x20000, %r14d         # imm = 0x20000
cmpl %r14d, %ecx
pushq $0x20
popq %rcx
pushq $0xa
popq %rdx
cmovel %ecx, %edx
leaq 0x91bc(%rip), %rdi      # 0xbd8d
movq %rax, %rsi
xorl %eax, %eax
callq 0x6a50
andl 0x4(%rbx), %ebp
cmpl %r14d, %ebp
jne 0x2c2c
cmpl $0x0, 0xc(%rbx,%r15,4)
jg 0x2c01
pushq $0x22
popq %rdi
callq 0x6d2d
cmpl $0x0, 0xc(%rbx,%r15,4)
jne 0x2c01
testb $0x2, 0x6(%rbx)
je 0x2c1c
movq 0x10(%rsp), %rsi
leaq 0x8a2c(%rip), %rdi      # 0xb639
xorl %eax, %eax
callq 0x6a50
cmpl $0x0, 0xc(%rbx,%r15,4)
jg 0x2c24
pushq $0x22
popq %rdi
callq 0x6d2d
pushq $0xa
popq %rdi
callq 0x6d2d
leaq 0x8(%rsp), %rdi
callq 0x720c
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/hash/hash.c
// Function: string_input
char			string_input(char **av, int *i, int *j, t_ssl *ssl)
{
	char	p_flag;

	p_flag = 0;
	if (ssl->flag & P_FLAG)
		p_flag = 1;
	if (!(ssl->flag & R_FLAG))
		ssl->flag |= S_FLAG;
	if (av[*i][++(*j)])
	{
		ssl->flag &= ~P_FLAG;
		hash(av[1], &av[*i][*j], ssl, 0);
		if (p_flag)
			ssl->flag |= P_FLAG;
		return (1);
	}
	if (av[++(*i)] && av[*i][0])
	{
		ssl->flag &= ~P_FLAG;
		hash(av[1], &av[*i][0], ssl, 0);
		if (p_flag)
			ssl->flag |= P_FLAG;
		return (1);
	}
	return (0);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl 0x4(%rcx), %ebp
btl $0x11, %ebp
jb 0x2c5a
movl %ebp, %eax
orl $0x40000, %eax          # imm = 0x40000
movl %eax, 0x4(%rbx)
movslq (%rsi), %rax
movq (%rdi,%rax,8), %rax
movslq (%rdx), %rcx
leaq 0x1(%rcx), %r8
movl %r8d, (%rdx)
cmpb $0x0, 0x1(%rax,%rcx)
je 0x2ca0
andb $0x7f, 0x5(%rbx)
movq 0x8(%rdi), %rax
movslq (%rsi), %rcx
movslq (%rdx), %rsi
addq (%rdi,%rcx,8), %rsi
movq %rax, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x2add
movb $0x1, %al
testw %bp, %bp
jns 0x2ccb
orb $-0x80, 0x5(%rbx)
movb $0x1, %al
jmp 0x2ccb
movslq (%rsi), %rax
leaq 0x1(%rax), %rcx
movl %ecx, (%rsi)
movq 0x8(%rdi,%rax,8), %rax
testq %rax, %rax
je 0x2cc9
cmpb $0x0, (%rax)
je 0x2cc9
andb $0x7f, 0x5(%rbx)
movq 0x8(%rdi), %rax
movslq (%rsi), %rcx
movq (%rdi,%rcx,8), %rsi
jmp 0x2c84
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/inputs.c
// Function: get_inputs
int				get_inputs(int *ac, char ***av)
{
	char	**replace;

	*ac += 1;
	replace = malloc(sizeof(*replace) * (*ac + 1));
	replace[0] = ft_strdup(**av);
	replace[1] = ft_strdup("\0");
	while (replace[1][0] == '\n' || replace[1][0] == '\0')
	{
		ft_printf("ft_ssl> ");
		ft_strdel(&replace[1]);
		get_stdin(&(replace[1]), 0, 0, 0);
		if (!replace[1])
		{
			ft_strdel(&replace[0]);
			free(replace);
			return (1);
		}
		if (check_for_spaces(replace, av, ac))
			return (0);
	}
	replace[*ac] = 0;
	*av = replace;
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq (%rdi), %rax
leal 0x1(%rax), %ecx
movl %ecx, (%rdi)
leaq 0x10(,%rax,8), %rdi
callq 0x10b0
movq %rax, %r15
movq (%rbx), %rax
movq (%rax), %rdi
callq 0x74dc
movq %rax, (%r15)
leaq 0x8fc0(%rip), %rdi      # 0xbd92
callq 0x74dc
movq %rax, 0x8(%r15)
movq %r15, %r12
addq $0x8, %r12
leaq 0x8fab(%rip), %r13      # 0xbd94
pushq $0x20
popq %rbp
movq (%r12), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0x2e00
testl %eax, %eax
jne 0x2ef7
movq %r13, %rdi
xorl %eax, %eax
callq 0x6a50
movq %r12, %rdi
callq 0x720c
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x63ee
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2ec8
movl %ebp, %esi
callq 0x7568
cmpl $0x2, %eax
jl 0x2dec
movq %rbx, (%rsp)
movq 0x8(%r15), %rdi
pushq $0x20
popq %rbp
movl %ebp, %esi
callq 0x7568
movl (%r14), %ecx
leal (%rcx,%rax), %edx
addl %ecx, %eax
decl %eax
movl %eax, (%r14)
movslq %edx, %rdi
shlq $0x3, %rdi
callq 0x10b0
movq %rax, %r13
movq 0x8(%r15), %rdi
movl %ebp, %esi
callq 0x75a7
movq %rax, %rbp
movq (%r15), %rdi
callq 0x74dc
movq %rax, (%r13)
leaq 0x8f1f(%rip), %rdi      # 0xbda7
xorl %ebx, %ebx
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x67f0
movq %r15, %rdi
callq 0x1030
movslq (%r14), %rax
decq %rax
cmpq %rax, %rbx
jge 0x2edd
movq (%rbp,%rbx,8), %rdi
callq 0x74dc
movq %rax, 0x8(%r13,%rbx,8)
movq (%rbp,%rbx,8), %rdi
callq 0x1030
incq %rbx
jmp 0x2e9f
movq %r15, %rdi
callq 0x720c
movq %r15, %rdi
callq 0x1030
pushq $0x1
popq %rax
jmp 0x2f04
movq %rbp, %rdi
callq 0x1030
movslq (%r14), %rax
andq $0x0, (%r13,%rax,8)
movq (%rsp), %rax
movq %r13, (%rax)
jmp 0x2f02
movslq (%r14), %rax
andq $0x0, (%r15,%rax,8)
movq %r15, (%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_O2/rpeepz[P]ft_ssl/srcs/inputs.c
// Function: parse_av
int				parse_av(char **av, t_ssl *ssl, int i, int j)
{
	while ((av[++i]) && av[i][0] == '-' && !(j = 0))
	{
		if (av[i][1])
			while (av[i][++j])
			{
				if (valid_flags(ssl, av[i][j]))
					return ((ssl->flag = av[i][j] == HELP_KEY ? 1 : 0) + 1);
				if (ssl->type < 10 && av[i][j] == 's')
				{
					if (ssl->type < 10 && string_input(av, &i, &j, ssl))
						break ;
					ssl->flag = av[--i][--j] ? av[i][j] : 0;
					return (ft_error(2, ft_strtolower(av[1]), ssl));
				}
			}
		else
			break ;
	}
	av[i] ? ssl->file_index[0] += i : 0;
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movl %ecx, (%r15)
leaq 0x4(%rsp), %r12
movslq %edx, %rax
incl %edx
movl %edx, 0x4(%rsp)
movq 0x8(%r14,%rax,8), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x300d
cmpb $0x2d, (%rcx)
jne 0x3019
andl $0x0, (%rsp)
cmpb $0x0, 0x1(%rcx)
je 0x3019
xorl %eax, %eax
cltq
leaq 0x1(%rax), %rsi
movl %esi, (%rsp)
movb 0x1(%rcx,%rax), %al
testb %al, %al
je 0x2f2c
movsbl %al, %esi
movq %rbx, %rdi
callq 0x418c
testl %eax, %eax
jne 0x2ff2
cmpl $0x9, 0x8(%rbx)
movslq 0x4(%rsp), %rdx
movq (%r14,%rdx,8), %rcx
movl (%rsp), %eax
jg 0x2f5e
movslq %eax, %rsi
cmpb $0x73, (%rcx,%rsi)
jne 0x2f5e
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2c41
movl 0x4(%rsp), %edx
testb %al, %al
jne 0x2f2c
movslq %edx, %rax
leaq -0x1(%rax), %rcx
movl %ecx, 0x4(%rsp)
movq -0x8(%r14,%rax,8), %rax
movslq (%rsp), %rcx
leaq -0x1(%rcx), %rdx
movl %edx, (%rsp)
movsbl -0x1(%rax,%rcx), %eax
movl %eax, 0x4(%rbx)
movq 0x8(%r14), %rdi
callq 0x664c
pushq $0x2
popq %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x2608
jmp 0x300d
movslq 0x4(%rsp), %rax
movq (%r14,%rax,8), %rcx
movslq (%rsp), %rdx
xorl %eax, %eax
cmpb $0x68, (%rcx,%rdx)
sete %al
movl %eax, 0x4(%rbx)
incl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
addl %edx, 0x408(%rbx)
jmp 0x300d
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/inputs.c
// Function: handle_inputs
int				handle_inputs(int *ac, char ***av, t_ssl *ssl)
{
	static void	(*choose[5])(char **, t_ssl *) = {
				ssl_md5, ssl_b64, ssl_des, ssl_rsa, ssl_standard};
	char		**pv;

	if (*ac < 2 && (ssl->stdin = 1))
		if (get_inputs(ac, av))
			return (0);
	pv = *av;
	if (!ft_strcmp(pv[1], "quit") || !ft_strcmp(pv[1], "exit"))
		return (clean_exit(0, pv));
	if (valid_command(pv[1], ssl))
		return (ft_error(1, pv[1], ssl));
	if (ssl->type > 10)
	{
		choose[ssl->type / 10](pv, ssl);
		return (1);
	}
	if (parse_av(*(av), ssl, 1, 0))
		return (ft_error(3, pv[1], ssl));
	if (!read_files(pv, ssl, ssl->file_index[0], 0))
		if ((ssl->type < 10) &&
		!(ssl->flag & 0x38000) && ssl->flag && !ssl->file_index[0])
			return (DEBUG ? ft_printf("Here I AM\n") : 1);
	choose[0](pv, ssl);
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
cmpl $0x1, (%rdi)
jg 0x3054
movl $0x1, (%rbx)
movq %r15, %rsi
callq 0x2d94
xorl %ebp, %ebp
testl %eax, %eax
je 0x3054
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %r14
movq 0x8(%r14), %rdi
leaq 0x8d3b(%rip), %rsi      # 0xbd9d
callq 0x70f4
testl %eax, %eax
je 0x30a8
movq 0x8(%r14), %rdi
leaq 0x8d2c(%rip), %rsi      # 0xbda2
callq 0x70f4
testl %eax, %eax
je 0x30a8
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x4369
testl %eax, %eax
je 0x30bc
movq 0x8(%r14), %rsi
pushq $0x1
popq %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2608
xorl %edi, %edi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x34e0
movl 0x8(%rbx), %eax
cmpl $0xb, %eax
jl 0x30e3
pushq $0xa
popq %rcx
xorl %edx, %edx
divl %ecx
leaq 0xecfe(%rip), %rcx      # 0x11dd0
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rcx,%rax,8)
pushq $0x1
popq %rbp
jmp 0x3047
movq (%r15), %rdi
pushq $0x1
popq %rbp
movq %rbx, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x2f13
testl %eax, %eax
je 0x3101
movq 0x8(%r14), %rsi
pushq $0x3
jmp 0x3095
movl 0x408(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x62cb
testl %eax, %eax
jne 0x313f
cmpl $0x9, 0x8(%rbx)
jg 0x313f
movl 0x4(%rbx), %eax
testl $0x38000, %eax          # imm = 0x38000
setne %cl
testl %eax, %eax
sete %al
orb %cl, %al
jne 0x313f
cmpl $0x0, 0x408(%rbx)
je 0x3047
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1de4
jmp 0x3047
nop
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/rsa/is_primary.c
// Function: array_make
__uint64_t		*array_make(int len, ...)
{
	va_list		ap;
	__uint64_t	*a;
	int			i;

	a = malloc(sizeof(__uint64_t) * (len + 1));
	i = 0;
	va_start(ap, len);
	while (i < len)
	{
		a[i] = va_arg(ap, int);
		i++;
	}
	a[len] = 0;
	va_end(ap);
	return (a);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
leaq 0x20(%rsp), %rbx
movq %rsi, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %rcx, 0x18(%rbx)
movq %r8, 0x20(%rbx)
movq %r9, 0x28(%rbx)
testb %al, %al
je 0x31ae
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movslq %edi, %r14
leaq 0x8(,%r14,8), %rdi
callq 0x10b0
movabsq $0x3000000008, %rcx     # imm = 0x3000000008
movq %rcx, (%rsp)
leaq 0xf0(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
pushq $0x8
popq %rcx
xorl %edx, %edx
testl %r14d, %r14d
movl $0x0, %esi
cmovgl %r14d, %esi
cmpq %rdx, %rsi
je 0x3221
cmpl $0x28, %ecx
ja 0x3209
movq %rdi, %r8
movl %ecx, %edi
addq %rbx, %rdi
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x3212
leaq 0x8(%rdi), %r8
movq %r8, 0x8(%rsp)
movslq (%rdi), %rdi
movq %rdi, (%rax,%rdx,8)
incq %rdx
movq %r8, %rdi
jmp 0x31ef
andq $0x0, (%rax,%r14,8)
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movq %rdi, %rax
andq $-0x2, %rax
cmpq $0x2, %rax
jne 0x3407
pushq $0x1
popq %rbp
jmp 0x34cd
movq %rdi, %rbx
cmpq $0x1, %rdi
sete %al
testb $0x1, %bl
sete %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x34cd
leaq -0x1(%rbx), %r12
xorl %r13d, %r13d
movq %r12, %r14
movss %xmm0, 0x4(%rsp)
testb $0x1, %r14b
jne 0x3444
incq %r13
je 0x3441
shrq %r14
jmp 0x3431
xorl %r13d, %r13d
movq %rbx, %rdi
callq 0x3231
movq %rax, %r15
cvttss2si 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
pushq $-0x1
popq %rbp
movq 0x8(%r15,%rbp,8), %rdi
testq %rdi, %rdi
je 0x34b0
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3675
cmpq $0x1, %rax
je 0x34b0
movq %rax, %rdx
cmpq %r12, %rax
je 0x34b0
leaq 0x1(%rbp), %rcx
movq %r13, %rsi
decq %rsi
je 0x34a1
imulq %rdx, %rdx
movq %rdx, %rax
xorl %edx, %edx
divq %rbx
cmpq %r12, %rdx
jne 0x3486
movq %rcx, %rbp
jmp 0x345c
cmpq $0x0, 0x10(%r15,%rbp,8)
movq %rcx, %rbp
jne 0x345c
xorl %ebp, %ebp
jmp 0x34c5
pushq $0x1
popq %rbp
cmpl $0x0, 0x4(%rsp)
jne 0x34c5
pushq $0x2b
popq %rdi
pushq $0x2
popq %rsi
callq 0x6cf0
movq %r15, %rdi
callq 0x1030
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movq %rsi, (%rsp)
movslq %edi, %r14
xorl %r15d, %r15d
testl %ebp, %ebp
je 0x3501
cmpq %r14, %r15
jl 0x3507
jmp 0x3518
cmpq $0x0, (%rbx)
je 0x3518
movq %rbx, %rdi
callq 0x720c
incq %r15
addq $0x8, %rbx
jmp 0x34f6
movq %rsp, %rdi
callq 0x71f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %rbx
leaq 0x4(%rsp), %r14
movl %edi, (%r14)
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
leaq 0x14(%rsp), %r12
movl $0x804, %esi            # imm = 0x804
movq %r12, %rdi
callq 0x6720
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3021
testl %eax, %eax
je 0x35a3
cmpl $0x0, 0x14(%rsp)
je 0x35a3
movl 0x4(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x34e0
movl $0x804, %esi            # imm = 0x804
movq %r12, %rdi
callq 0x6720
movl $0x1, 0x4(%rsp)
movq %rbx, 0x8(%rsp)
jmp 0x3560
xorl %eax, %eax
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x35bc
xorl %eax, %eax
retq
movq %rdi, %rax
pushq $0x1
popq %rcx
xorl %r8d, %r8d
movq %rsi, %rdx
cmpq $0x2, %rax
jb 0x35f0
movq %r8, %rdi
movq %rdx, %r8
testq %rdx, %rdx
je 0x35fe
xorl %edx, %edx
divq %r8
imulq %rdi, %rax
subq %rax, %rcx
movq %r8, %rax
movq %rcx, %r8
movq %rdi, %rcx
jmp 0x35c8
movq %rcx, %rax
sarq $0x3f, %rax
andq %rsi, %rax
addq %rcx, %rax
retq
pushq %rax
leaq 0x87a6(%rip), %rdi      # 0xbdac
pushq $0x2
popq %rsi
callq 0x6d80
xorl %edi, %edi
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/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 0x3625
movq %rsi, %rdx
jmp 0x3632
testq %rcx, %rcx
js 0x3632
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
xorl %eax, %eax
testq %rdi, %rdi
je 0x3674
testb $0x1, %dil
je 0x3657
movq %rcx, %rsi
subq %rax, %rsi
cmpq %rsi, %rdx
jb 0x364f
movq %rcx, %rsi
jmp 0x3651
xorl %esi, %esi
addq %rdx, %rax
subq %rsi, %rax
movq %rcx, %rsi
subq %rdx, %rsi
cmpq %rsi, %rdx
jb 0x3667
movq %rcx, %rsi
jmp 0x3669
xorl %esi, %esi
shrq %rdi
addq %rdx, %rdx
subq %rsi, %rdx
jmp 0x3634
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x36ad
testq %rbx, %rbx
jne 0x36a8
leaq 0x8721(%rip), %rsi      # 0xbdbe
pushq $0x2
popq %rdi
pushq $0x22
popq %rdx
callq 0x1050
xorl %r15d, %r15d
jmp 0x36fa
movq %rsi, %r14
testq %rsi, %rsi
je 0x36f6
movq %rdi, %rax
xorl %edx, %edx
divq %rbx
movq %rdx, %r12
pushq $0x1
popq %r15
testq %r14, %r14
je 0x36fa
testb $0x1, %r14b
je 0x36e0
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3615
movq %rax, %r15
movq %r12, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3615
movq %rax, %r12
shrq %r14
jmp 0x36c4
pushq $0x1
popq %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
movl (%rdi), %eax
movl %eax, %ecx
shll $0x8, %ecx
movzwl %cx, %edx
pushq $0x8
popq %rcx
movl %eax, %esi
shrl %cl, %esi
movzbl %sil, %esi
orl %edx, %esi
movl %esi, %edx
shll $0x8, %edx
addl $0x8, %ecx
cmpl $0x20, %ecx
jne 0x39eb
movl %esi, (%rdi)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r13d
testq %rsi, %rsi
je 0x3a31
movzbl (%r14), %eax
cmpl $0x2d, %eax
je 0x3a39
xorl %r12d, %r12d
testl %eax, %eax
jne 0x3a3d
decl %r13d
xorl %r12d, %r12d
jmp 0x3a3d
pushq $0x1
popq %r12
testl %r13d, %r13d
jne 0x3a51
movl %r12d, %eax
xorl %r13d, %r13d
cmpb $0x0, (%r14,%rax)
sete %r13b
leaq 0x83a0(%rip), %r15      # 0xbdf8
leaq 0x8391(%rip), %rax      # 0xbdf0
movl %r13d, %ebp
movl %r12d, %r12d
testq %r14, %r14
je 0x3a9f
movsbl (%r14,%r12), %edi
testl %edi, %edi
je 0x3a9c
cmpl $-0x1, %ebp
je 0x3ac4
addl $0x2, %ebp
je 0x3a65
incl %r12d
movq %rbx, (%rsp)
movq %rax, %rbx
callq 0x66c8
testl %eax, %eax
movq %rbx, %rax
movq (%rsp), %rbx
jne 0x3a62
movq %rax, %r15
jmp 0x3ac4
movl %ebp, %r13d
cmpl $0x1, %r13d
leaq 0x8346(%rip), %rax      # 0xbdf0
leaq 0x8347(%rip), %rcx      # 0xbdf8
cmoveq %rax, %rcx
cmpl $-0x1, %r13d
leaq 0x8328(%rip), %r15      # 0xbde8
cmovneq %rcx, %r15
pushq $0x2
popq %rbp
movq %r15, %rdi
movl %ebp, %esi
callq 0x6d07
leaq 0x832a(%rip), %rdi      # 0xbe02
movl %ebp, %esi
callq 0x6d07
movl 0x8(%rbx), %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rdx)
movslq %ebp, %r12
movq 0x8(%r14,%r12,8), %rdi
testq %rdi, %rdi
je 0x3bf2
leal 0x1(%r12), %ebp
leaq 0x1(%r12), %r13
movsbl (%rdi), %eax
cmpl $0x2d, %eax
jne 0x3b81
incq %rdi
leaq 0x834b(%rip), %rsi      # 0xbe87
callq 0x70f4
testl %eax, %eax
je 0x3bb4
movq (%r14,%r13,8), %rdi
incq %rdi
leaq 0x8339(%rip), %rsi      # 0xbe8c
callq 0x70f4
testl %eax, %eax
je 0x3be4
movq (%r14,%r13,8), %rdi
incq %rdi
leaq 0x8327(%rip), %rsi      # 0xbe95
callq 0x70f4
testl %eax, %eax
jne 0x3c7b
orb $0x8, 0x4(%rbx)
jmp 0x3ba6
movl %eax, %edi
callq 0x66c8
testl %eax, %eax
je 0x3c2f
cmpq $0x0, (%r15)
jne 0x3c35
movq (%r14,%r13,8), %rdi
callq 0x65c6
movq %rax, (%r15)
movl 0xc(%rbx), %eax
cmpl $-0x1, %eax
jne 0x3b0f
jmp 0x3c0f
orb $0x1, 0x4(%rbx)
movq 0x8(%r14,%r13,8), %rax
testq %rax, %rax
je 0x3bea
movsbl (%rax), %edi
callq 0x66c8
movl %eax, %ecx
pushq $-0x1
popq %rax
testl %ecx, %ecx
je 0x3bed
leal 0x2(%r12), %ebp
movq 0x10(%r14,%r12,8), %rdi
callq 0x65c6
jmp 0x3bed
orb $0x4, 0x4(%rbx)
jmp 0x3ba6
pushq $-0x1
popq %rax
movl %eax, 0xc(%rbx)
jmp 0x3ba9
movl 0xc(%rbx), %eax
testl %eax, %eax
je 0x3c5e
pushq $0x10
popq %rcx
cmpl $0x1, %eax
je 0x3c67
cmpl $0x40, %eax
jne 0x3c5a
movl $0x41, 0xc(%rbx)
jmp 0x3c6a
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 0x3a08
movq (%r14,%r13,8), %rsi
jmp 0x3c82
leaq 0x81dd(%rip), %rdi      # 0xbe19
pushq $0x2
popq %rsi
callq 0x6d07
movl 0x8(%rbx), %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
testb $0x3f, %al
je 0x3c67
cmpl $0x41, %eax
pushq $0x10
popq %rcx
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
movq (%r14,%r13,8), %rsi
incq %rsi
pushq $0x6
popq %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2608
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
andl $0x0, 0x4(%rsi)
movq %rdi, %r15
andl $0x0, 0xc(%rsi)
leaq 0x8(%rsp), %rdx
pushq $0x1
popq %rcx
callq 0x3af5
testl %eax, %eax
je 0x3ccd
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl 0x4(%rbx), %eax
testb $0x4, %al
jne 0x3d40
movq 0x8(%rsp), %r14
testq %r14, %r14
sete %cl
testb %cl, %al
jne 0x3d79
cmpq $0x0, 0x10(%r15)
je 0x3d79
testb $0x8, %al
leaq 0x8176(%rip), %rax      # 0xbe71
leaq 0x8163(%rip), %rbx      # 0xbe65
cmoveq %rax, %rbx
movss 0x80d6(%rip), %xmm0     # 0xbde4
movq %r14, %rdi
callq 0x33e7
testl %eax, %eax
leaq 0x815e(%rip), %rax      # 0xbe7d
leaq 0x815b(%rip), %rdx      # 0xbe81
cmoveq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x6a50
movl 0xc(%rbx), %edi
testl %edi, %edi
je 0x3d99
testb $0x8, %al
leaq 0x810f(%rip), %rax      # 0xbe5f
leaq 0x838a(%rip), %rbx      # 0xc0e1
cmoveq %rax, %rbx
pushq $0x1
popq %rsi
callq 0x26d0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x6a50
leaq 0x80ad(%rip), %rdi      # 0xbe2d
pushq $0x2
popq %rsi
callq 0x6d07
movl 0x8(%rbx), %edi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x20b0
leaq 0x80a2(%rip), %rdi      # 0xbe42
pushq $0x2
popq %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x6d07
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r15d, %r15d
movq %rsi, %rax
testq %rax, %rax
je 0x3dd9
shrq $0x8, %rax
incq %r15
jmp 0x3dcb
movq %rsp, %r12
andq $0x0, (%r12)
leaq 0x1(%r15), %rdi
callq 0x6731
movq %rax, %r13
leaq 0x80a5(%rip), %rdi      # 0xbe99
xorl %esi, %esi
xorl %eax, %eax
callq 0x10c0
movl %eax, %ebp
movq %r13, %rdi
movq %r15, %rsi
callq 0x6720
movl %ebp, %edi
movq %r13, %rsi
movq %r15, %rdx
callq 0x10a0
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x675c
movq (%rsp), %rax
cmpq %r14, %rax
setb %cl
cmpq %rbx, %rax
seta %al
orb %cl, %al
jne 0x3dff
movl %ebp, %edi
callq 0x1070
movq %r13, %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_O2/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 0x6720
leal -0x9(%r14), %eax
cmpl $-0x9, %eax
ja 0x3e92
movl 0x8(%rbx), %edi
callq 0x20b0
jmp 0x3f3c
leal (,%r14,8), %eax
leal -0x8(%rax), %ecx
pushq $0x1
popq %rdi
shlq %cl, %rdi
negb %al
pushq $-0x1
popq %rsi
movl %eax, %ecx
shrq %cl, %rsi
callq 0x3db4
movq %rax, %r15
movl 0x4(%rbx), %eax
testb $0x8, %al
jne 0x3edf
testb $0x2, %al
jne 0x3f09
leaq 0x7f98(%rip), %rsi      # 0xbe5f
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x6dd0
movl 0x10(%rbx), %esi
movq %r14, %rdi
jmp 0x3f02
addl %r14d, %r14d
leaq 0x7fbd(%rip), %rsi      # 0xbea6
movq %rsp, %r12
movq %r12, %rdi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x6dd0
movl 0x10(%rbx), %esi
movq %r12, %rdi
callq 0x6d07
jmp 0x3f2f
movq %rsp, %rdi
movq %r15, %rsi
callq 0x1758
movq %rax, %r14
movq %r15, %rdi
callq 0x1748
movsbl %al, %esi
movl 0x10(%rbx), %edx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x1848
movl 0x10(%rbx), %edi
cmpl $0x2, %edi
jl 0x3f3c
callq 0x1070
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
movslq %ecx, %rax
leaq (%rdi,%rax,8), %rbp
addq $0x8, %rbp
leaq 0x7f5e(%rip), %r15      # 0xbecc
leaq 0x7f20(%rip), %r12      # 0xbe95
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x4023
movsbl (%rdi), %eax
cmpl $0x2d, %eax
jne 0x3fe7
movq 0x8(%rbp), %r13
incq %rdi
movq %r15, %rsi
callq 0x70f4
testl %eax, %eax
je 0x400e
movq (%rbp), %rdi
incq %rdi
movq %r12, %rsi
callq 0x70f4
testl %eax, %eax
je 0x4015
movl 0x10(%r14), %eax
cmpl $0x1, %eax
jne 0x40ac
movq (%rbp), %rdi
incq %rdi
leaq 0x8807(%rip), %rsi      # 0xc7d2
callq 0x70f4
testl %eax, %eax
jne 0x40a8
orb $0x4, 0x4(%r14)
testq %r13, %r13
jne 0x401a
jmp 0x4094
movl %eax, %edi
callq 0x66c8
testl %eax, %eax
je 0x4065
cmpl $0x0, (%rbx)
jne 0x4038
movl 0x4(%r14), %eax
notl %eax
testb $0xa, %al
je 0x4038
movq (%rbp), %rdi
callq 0x6554
movl %eax, (%rbx)
jmp 0x401a
orb $0x2, 0x4(%r14)
jmp 0x401a
orb $0x8, 0x4(%r14)
addq $0x8, %rbp
jmp 0x3f75
movl 0x4(%r14), %ecx
andl $0xa, %ecx
cmpl $0x0, (%rbx)
je 0x406b
xorl %eax, %eax
cmpl $0xa, %ecx
je 0x4070
jmp 0x4085
leaq 0x7dda(%rip), %rdi      # 0xbe19
pushq $0x2
popq %rsi
callq 0x6d07
movl 0x8(%r14), %edi
callq 0x20b0
movl %eax, %ecx
testl %eax, %eax
je 0x405c
movl $0x1, (%rbx)
xorl %eax, %eax
testl %ecx, %ecx
setne %al
jmp 0x4085
movq (%rbp), %rsi
jmp 0x40b8
cmpl $0xa, %ecx
jne 0x407f
leaq 0x7da2(%rip), %rdi      # 0xbe19
pushq $0x2
popq %rsi
callq 0x6d07
andl $0x0, (%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
orl $-0x1, 0x10(%r14)
leaq 0x7e33(%rip), %rdi      # 0xbed3
pushq $0x2
popq %rsi
callq 0x6d07
movl 0x10(%r14), %eax
cmpl $-0x1, %eax
je 0x40d1
movq (%rbp), %rsi
incq %rsi
pushq $0x6
popq %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2608
movl 0x8(%r14), %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
// File: /workspace/github_c_makefile_star2_O2/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)
andl $0x0, 0x4(%rsi)
movl $0x1, 0x10(%rsi)
cmpq $0x0, 0x10(%rdi)
je 0x4137
leaq 0xc(%rsp), %rdx
pushq $0x1
popq %rcx
movq %rbx, %rsi
callq 0x3f4b
testl %eax, %eax
je 0x415d
movl 0x4(%rbx), %ecx
cmpl $-0x1, %eax
sete %al
movl %ecx, %edx
notl %edx
testb $0xa, %dl
jne 0x4139
cmpl $0x0, 0xc(%rsp)
jne 0x4157
xorl %edx, %edx
jmp 0x414b
xorl %ecx, %ecx
shrb $0x2, %cl
movl 0xc(%rsp), %edx
testl %edx, %edx
setne %sil
testb %sil, %cl
jne 0x4157
testl %edx, %edx
setne %cl
orb %al, %cl
testb $0x1, %cl
je 0x416e
addq $0x10, %rsp
popq %rbx
retq
movl 0xc(%rsp), %esi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x3e5b
leaq 0x7d39(%rip), %rdi      # 0xbeae
pushq $0x2
popq %rsi
callq 0x6d07
movl 0x8(%rbx), %edi
addq $0x10, %rsp
popq %rbx
jmp 0x20b0
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x4200
cmpl $0xa, %eax
setge %cl
movl %esi, %edi
andb $-0x4, %dil
cmpb $0x70, %dil
setne %dil
orb %cl, %dil
je 0x41ee
leal -0xb(%rax), %ecx
cmpl $0x8, %ecx
ja 0x41d0
movsbl %sil, %eax
addl $-0x64, %eax
cmpl $0xb, %eax
ja 0x4200
movl $0x823, %ecx            # imm = 0x823
jmp 0x41e9
addl $-0x15, %eax
cmpl $0x8, %eax
ja 0x4200
movsbl %sil, %eax
addl $-0x61, %eax
cmpl $0x15, %eax
ja 0x4200
movl $0x24c519, %ecx         # imm = 0x24C519
btl %eax, %ecx
jae 0x4200
addb $-0x61, %sil
pushq $0x1
popq %rax
movl %esi, %ecx
shll %cl, %eax
orl %eax, 0x4(%rdx)
xorl %eax, %eax
jmp 0x4210
pushq $0x4
popq %rdi
leaq 0x7(%rsp), %rsi
callq 0x2608
pushq $0x1
popq %rax
popq %rcx
retq