LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/error.c
// Function: rsa_error
void			rsa_error(int e)
{
	if (e == 20)
		ft_putstr_fd("Only private keys can be checked\n", 2);
	if (e == 19)
		ft_putstr_fd("A private key is needed for this operation\n", 2);
	else
	{
		e > 22 ? ft_putstr_fd("no keyfile specified\n", 2) : 0;
		ft_putstr_fd("Unable to load", 2);
		ft_putstr_fd(e % 2 ? " Public " : " Private ", 2);
		ft_putstr_fd("Key\n", 2);
	}
	if (e <= 8)
		ft_putstr_fd("PEM routines:PEM_read_bio:bad base64 decode\n", 2);
	else if (e <= 10)
		ft_putstr_fd("PEM routines:PEM_read_bio:no start line\n", 2);
	else if (e <= 12)
		ft_putstr_fd("PEM routines:PEM_read_bio:bad end line\n", 2);
	else if (e <= 14)
		ft_putstr_fd("asn1 encoding routines:ASN1_CHECK_T:wrong tag\n", 2);
}

// Assembly:
pushq %rbx
cmpl $0x13, %edi
je 0x2566
movl %edi, %ebx
cmpl $0x14, %edi
jne 0x2572
leaq 0xa534(%rip), %rdi      # 0xca98
jmp 0x257e
leaq 0xa54d(%rip), %rdi      # 0xcaba
jmp 0x25ff
cmpl $0x17, %ebx
jl 0x2588
leaq 0xa568(%rip), %rdi      # 0xcae6
movl $0x2, %esi
callq 0x7941
leaq 0xa56d(%rip), %rdi      # 0xcafc
movl $0x2, %esi
callq 0x7941
testb $0x1, %bl
leaq 0xa571(%rip), %rax      # 0xcb14
leaq 0xa561(%rip), %rdi      # 0xcb0b
cmoveq %rax, %rdi
movl $0x2, %esi
callq 0x7941
leaq 0xa55f(%rip), %rdi      # 0xcb1e
movl $0x2, %esi
callq 0x7941
cmpl $0x9, %ebx
jge 0x25d7
leaq 0xa54e(%rip), %rdi      # 0xcb23
jmp 0x25ff
cmpl $0xb, %ebx
jae 0x25e5
leaq 0xa56d(%rip), %rdi      # 0xcb50
jmp 0x25ff
cmpl $0xd, %ebx
jae 0x25f3
leaq 0xa588(%rip), %rdi      # 0xcb79
jmp 0x25ff
cmpl $0xe, %ebx
ja 0x260a
leaq 0xa5a2(%rip), %rdi      # 0xcba1
movl $0x2, %esi
popq %rbx
jmp 0x7941
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x26c7
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa5fa(%rip), %rsi      # 0xcc21
callq 0x7d58
testl %eax, %eax
je 0x2685
leaq 0xa5ef(%rip), %rsi      # 0xcc26
movq %r14, %rdi
callq 0x7d58
testl %eax, %eax
je 0x2685
leaq 0xb1f9(%rip), %rsi      # 0xd843
movq %r14, %rdi
callq 0x7d58
testl %eax, %eax
je 0x2685
leaq 0xa5cb(%rip), %rsi      # 0xcc28
movq %r14, %rdi
callq 0x7d58
testl %eax, %eax
je 0x2685
cmpl $-0x2a, 0x4(%rbx)
je 0x2685
leaq 0xa5b8(%rip), %rsi      # 0xcc2e
movl $0x2, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1090
movl 0x8(%rbx), %eax
addl $-0x1f, %eax
cmpl $0x2, %eax
ja 0x26ba
movl %eax, %eax
leaq 0x9b03(%rip), %rcx      # 0xc19c
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq 0x9bb0(%rip), %rdx      # 0xc257
leaq 0x9bb1(%rip), %rcx      # 0xc25f
movl $0x2, %edi
xorl %eax, %eax
callq 0x1090
movl 0x8(%rbx), %edi
popq %rbx
popq %r14
popq %r15
jmp 0x21bc
movl %edx, %r15d
leal -0x15(%r15), %eax
cmpl $0x1, %eax
ja 0x272b
leaq 0xa4f6(%rip), %rdi      # 0xcbd0
movl $0x2, %esi
callq 0x7941
leaq 0xa4fa(%rip), %rdi      # 0xcbe5
movl $0x2, %esi
callq 0x7941
testb $0x1, %r15b
leaq 0xa50b(%rip), %rax      # 0xcc0b
leaq 0xa4fc(%rip), %rdi      # 0xcc03
cmoveq %rax, %rdi
movl $0x2, %esi
callq 0x7941
leaq 0xa4f7(%rip), %rdi      # 0xcc13
movl $0x2, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x7941
movl %r15d, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x2550
// File: /workspace/github_c_makefile_star2_O3/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 0x27ee
leaq 0x9a31(%rip), %rcx      # 0xc188
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xa547(%rip), %rsi      # 0xccae
movl $0x2, %edi
xorl %eax, %eax
callq 0x1090
callq 0x4849
jmp 0x2800
leaq 0xa59b(%rip), %rsi      # 0xcd1f
movl $0x2, %edi
xorl %eax, %eax
callq 0x1090
jmp 0x2800
movl 0x8(%r14), %esi
movq %rdx, %rdi
callq 0x24cb
cmpl $0x0, 0x4(%r14)
je 0x2800
movl 0x8(%r14), %edi
callq 0x21bc
jmp 0x2800
movsbl (%rdx), %edx
cmpl $0x68, %edx
je 0x2800
leaq 0xa54a(%rip), %rsi      # 0xcd09
movl $0x2, %edi
xorl %eax, %eax
callq 0x1090
jmp 0x2800
movl 0x4(%r14), %ecx
leaq 0xa503(%rip), %rsi      # 0xccdb
movl $0x2, %edi
xorl %eax, %eax
callq 0x1090
movl $0x0, 0x4(%r14)
jmp 0x2800
cmpl $0x6, %ebx
jl 0x2800
movq %rdx, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x260c
xorl %eax, %eax
negl %ebx
sbbl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 $0x1, %edx
shlq %cl, %rdx
movq %rdx, 0x10(%rsp)
movq $-0x1, %r15
movl %ebx, %ecx
shlq %cl, %r15
movl %esi, %ebp
movl $0x1, %r14d
notq %r15
addl %ebx, %ebx
movl %eax, %ecx
shlq %cl, %r14
cvtsi2ss %esi, %xmm0
movss %xmm0, 0xc(%rsp)
xorl %r13d, %r13d
movl %r13d, %eax
xorl %edx, %edx
divl %ebx
testl %edx, %edx
je 0x2885
movq %r12, %rdi
movss 0xc(%rsp), %xmm0
callq 0x3680
testl %eax, %eax
jne 0x28f0
testl %ebp, %ebp
jne 0x28e4
jmp 0x28d5
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x4114
movq %rax, %r12
orq %r14, %r12
orq $0x1, %r12
testl %ebp, %ebp
je 0x28b4
movq %r12, %rdi
movss 0xc(%rsp), %xmm0
callq 0x3680
testl %eax, %eax
je 0x28e4
jmp 0x2903
movl $0x2e, %edi
movl $0x2, %esi
callq 0x7928
movq %r12, %rdi
movss 0xc(%rsp), %xmm0
callq 0x3680
testl %eax, %eax
jne 0x28f4
movl $0x2e, %edi
movl $0x2, %esi
callq 0x7928
addq $-0x2, %r12
incl %r13d
jmp 0x2862
testl %ebp, %ebp
jne 0x2903
movl $0xa, %edi
movl $0x2, %esi
callq 0x7928
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_O3/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)
jo 0x294a
leal -0x1(%rdi), %ecx
movzbl %cl, %ecx
btq %rcx, %rax
jae 0x294a
cmpl $0x40, %edi
setne %dl
movl $0x1, %esi
movl %edi, %ecx
shlq %cl, %rsi
cmpq %rax, %rsi
setb %cl
andb %dl, %cl
cmpb $0x1, %cl
jne 0x294f
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x50, %esi
movq %r14, %rdi
callq 0x7370
leaq 0x68(%rsp), %r15
movl $0x48, %esi
movq %r15, %rdi
callq 0x7370
movl 0x8(%rbx), %ebx
leaq 0xa3a4(%rip), %rsi      # 0xcd3e
leaq 0xa3b6(%rip), %rdx      # 0xcd57
movq %r14, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x7a1c
movq %r14, %rdi
movl $0x2, %esi
callq 0x7941
movl 0x10(%r15), %esi
movl %ebx, %r14d
shrl $0x1f, %r14d
addl %ebx, %r14d
sarl %r14d
leal 0x1(%r14), %ebp
leal -0x1(%rbx), %ecx
movl $0x1, %r15d
movl $0x1, %r13d
shlq %cl, %r13
movl $0x1, %r12d
movl %ebx, %ecx
shlq %cl, %r12
movl %r14d, %edi
callq 0x2810
movq %rax, 0x68(%rsp)
movl 0x78(%rsp), %esi
movl %ebp, %edi
callq 0x2810
movq %rax, %r8
movq 0x68(%rsp), %rcx
movq %rcx, %rax
mulq %r8
seto %sil
movl $0x1, %edx
cmpq %rax, %r12
jb 0x2a23
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)
movl $0x1, %esi
cmpq $0x1, %rdx
je 0x29ec
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 0x38a0
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 0x38a0
movq %rax, 0x30(%rbx)
leaq 0xb0(%rsp), %r14
movl $0x50, %esi
movq %r14, %rdi
callq 0x7370
movq 0x38(%rbx), %rcx
leaq 0xa2a9(%rip), %rsi      # 0xcd72
movq %r14, %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x7a1c
movq %r14, %rdi
movl $0x2, %esi
callq 0x7941
leaq 0x18(%rsp), %rdi
movl $0x9, %ecx
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 0x50e9
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_O3/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 0x7ef0
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
movq %rax, %rdi
callq 0x8082
movq %r14, %rdi
callq 0x7ecf
movq %r15, %rdi
callq 0x81d4
movq %rax, (%r14)
movq %r12, %rdi
callq 0x7ecf
movq (%r14), %rax
movq %rax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7370
movq $0x0, 0x8(%rsp)
movq (%r14), %rdi
movq %rdi, (%r15)
movslq %ebp, %r13
cmpl $0x3, 0xc(%rbx,%r13,4)
jl 0x2c69
leaq 0xa0f9(%rip), %rdi      # 0xccda
callq 0x81d4
movq %rax, %r15
movq %rax, 0x8(%rsp)
movl 0xc(%rbx,%r13,4), %edi
leaq 0x10(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x10b0
testq %rax, %rax
jle 0x2c45
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2b28
movl $0x1000, %esi           # imm = 0x1000
movq %r15, %rdi
callq 0x7370
movl 0xc(%rbx,%r13,4), %edi
movl $0x1000, %edx           # imm = 0x1000
movq %r15, %rsi
callq 0x10b0
testq %rax, %rax
jg 0x2c11
movq 0x8(%rsp), %r15
movl 0xc(%rbx,%r13,4), %edi
callq 0x1080
movq %r15, %rdi
callq 0x81d4
movq %rax, (%r14)
leaq 0x8(%rsp), %rdi
callq 0x7ecf
movq (%r14), %rsi
jmp 0x2c74
callq 0x81d4
movq %rax, %rsi
movq %rax, (%r14)
movslq 0x8(%rbx), %rax
leaq 0xf121(%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_O3/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
testl $0x38000, %eax          # imm = 0x38000
jne 0x2d32
btl $0x12, %eax
jb 0x2cd3
testl %ebp, %ebp
js 0x2d32
movl %ebp, %ecx
cmpl $0x0, 0xc(%rbx,%rcx,4)
je 0x2d32
callq 0x72d4
leaq 0xa0a4(%rip), %rdi      # 0xcd83
movq %rax, %rsi
xorl %eax, %eax
callq 0x7698
movslq %ebp, %r15
cmpl $0x0, 0xc(%rbx,%r15,4)
jg 0x2cfe
movl $0x22, %edi
callq 0x7967
leaq 0x9934(%rip), %rdi      # 0xc639
movq %r14, %rsi
xorl %eax, %eax
callq 0x7698
cmpl $0x0, 0xc(%rbx,%r15,4)
jg 0x2d21
movl $0x22, %edi
callq 0x7967
leaq 0xa060(%rip), %rdi      # 0xcd88
xorl %eax, %eax
callq 0x7698
movl 0x4(%rbx), %eax
testl $0x70000, %eax          # imm = 0x70000
jne 0x2d5d
testw %ax, %ax
js 0x2d4c
testl %eax, %eax
je 0x2d5d
movslq %ebp, %rax
cmpl $0x0, 0xc(%rbx,%rax,4)
je 0x2d5d
leaq 0x98e6(%rip), %rdi      # 0xc639
movq %r14, %rsi
xorl %eax, %eax
callq 0x7698
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x2b91
movl $0x38000, %r14d         # imm = 0x38000
movl 0x4(%rbx), %ecx
andl %r14d, %ecx
movl $0x20000, %r15d         # imm = 0x20000
cmpl %r15d, %ecx
movl $0x20, %ecx
movl $0xa, %edx
cmovel %ecx, %edx
leaq 0x9ff3(%rip), %rdi      # 0xcd8d
movq %rax, %rsi
xorl %eax, %eax
callq 0x7698
andl 0x4(%rbx), %r14d
cmpl %r15d, %r14d
jne 0x2dff
movslq %ebp, %r14
cmpl $0x0, 0xc(%rbx,%r14,4)
jg 0x2dd0
movl $0x22, %edi
callq 0x7967
cmpl $0x0, 0xc(%rbx,%r14,4)
jne 0x2dd0
testb $0x2, 0x6(%rbx)
je 0x2deb
movq 0x10(%rsp), %rsi
leaq 0x985d(%rip), %rdi      # 0xc639
xorl %eax, %eax
callq 0x7698
cmpl $0x0, 0xc(%rbx,%r14,4)
jg 0x2df5
movl $0x22, %edi
callq 0x7967
movl $0xa, %edi
callq 0x7967
leaq 0x8(%rsp), %rdi
callq 0x7ecf
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2e2d
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 0x2e73
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 0x2c9a
movb $0x1, %al
testw %bp, %bp
jns 0x2e9e
orb $-0x80, 0x5(%rbx)
movb $0x1, %al
jmp 0x2e9e
movslq (%rsi), %rax
leaq 0x1(%rax), %rcx
movl %ecx, (%rsi)
movq 0x8(%rdi,%rax,8), %rax
testq %rax, %rax
je 0x2e9c
cmpb $0x0, (%rax)
je 0x2e9c
andb $0x7f, 0x5(%rbx)
movq 0x8(%rdi), %rax
movslq (%rsi), %rcx
movq (%rdi,%rcx,8), %rsi
jmp 0x2e57
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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, %r13
movq %rdi, %r14
movslq (%rdi), %rax
leal 0x1(%rax), %ecx
movl %ecx, (%rdi)
leaq 0x10(,%rax,8), %rdi
callq 0x10d0
movq %rax, %r15
movq (%r13), %rax
movq (%rax), %rdi
callq 0x81d4
movq %rax, (%r15)
leaq 0x9deb(%rip), %rdi      # 0xcd92
callq 0x81d4
movq %rax, 0x8(%r15)
movq %r15, %r12
addq $0x8, %r12
leaq 0x9dd6(%rip), %rbx      # 0xcd94
movq (%r12), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0x2fd2
testl %eax, %eax
jne 0x30d9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7698
movq %r12, %rdi
callq 0x7ecf
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6fce
movq (%r12), %rdi
testq %rdi, %rdi
je 0x30c2
movl $0x20, %esi
callq 0x8264
cmpl $0x2, %eax
jl 0x2fbe
movq %r13, (%rsp)
movq 0x8(%r15), %rdi
movl $0x20, %esi
callq 0x8264
movl (%r14), %ecx
leal (%rcx,%rax), %edx
addl %ecx, %eax
decl %eax
movl %eax, (%r14)
movslq %edx, %rdi
shlq $0x3, %rdi
callq 0x10d0
movq %rax, %r13
movq 0x8(%r15), %rdi
movl $0x20, %esi
callq 0x82db
movq %rax, %rbx
movq (%r15), %rdi
callq 0x81d4
movq %rax, (%r13)
leaq 0x9d47(%rip), %rdi      # 0xcda7
xorl %ebp, %ebp
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x743c
movq %r15, %rdi
callq 0x1030
cmpl $0x2, (%r14)
jl 0x30a5
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x81d4
movq %rax, 0x8(%r13,%r15,8)
movq (%rbx,%r15,8), %rdi
callq 0x1030
incq %r15
movslq (%r14), %rax
decq %rax
cmpq %rax, %r15
jl 0x3080
movq %rbx, %rdi
callq 0x1030
movslq (%r14), %rax
movq $0x0, (%r13,%rax,8)
movq (%rsp), %rax
movq %r13, (%rax)
jmp 0x30ea
movq %r15, %rdi
callq 0x7ecf
movq %r15, %rdi
callq 0x1030
movl $0x1, %ebp
jmp 0x30ea
movslq (%r14), %rax
movq $0x0, (%r15,%rax,8)
movq %r15, (%r13)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, 0x8(%rsp)
leal 0x1(%rdx), %ecx
movl %ecx, 0xc(%rsp)
movslq %edx, %rax
movq 0x8(%rdi,%rax,8), %rax
xorl %ebp, %ebp
testq %rax, %rax
je 0x31ed
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %r15
leaq 0x8(%rsp), %r12
cmpb $0x2d, (%rax)
jne 0x31e7
movl $0x0, 0x8(%rsp)
cmpb $0x0, 0x1(%rax)
je 0x31e7
movl $0x1, 0x8(%rsp)
movb 0x1(%rax), %al
testb %al, %al
je 0x31af
movsbl %al, %esi
movq %rbx, %rdi
callq 0x452c
testl %eax, %eax
jne 0x31c8
cmpl $0x9, 0x8(%rbx)
movslq 0xc(%rsp), %rcx
movq (%r14,%rcx,8), %rax
movslq 0x8(%rsp), %rdx
jg 0x3188
cmpb $0x73, (%rax,%rdx)
je 0x3196
leaq 0x1(%rdx), %rsi
movl %esi, 0x8(%rsp)
movb 0x1(%rax,%rdx), %al
jmp 0x315b
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2e14
movl 0xc(%rsp), %ecx
testb %al, %al
je 0x31fc
movslq %ecx, %rax
incl %ecx
movl %ecx, 0xc(%rsp)
movq 0x8(%r14,%rax,8), %rax
testq %rax, %rax
jne 0x3135
jmp 0x31ed
movslq 0xc(%rsp), %rax
movq (%r14,%rax,8), %rax
movslq 0x8(%rsp), %rcx
xorl %ebp, %ebp
cmpb $0x68, (%rax,%rcx)
sete %bpl
movl %ebp, 0x4(%rbx)
incl %ebp
jmp 0x31ed
addl %ecx, 0x408(%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movslq %ecx, %rax
leaq -0x1(%rax), %rcx
movl %ecx, 0xc(%rsp)
movq -0x8(%r14,%rax,8), %rax
movslq 0x8(%rsp), %rcx
leaq -0x1(%rcx), %rdx
movl %edx, 0x8(%rsp)
movsbl -0x1(%rax,%rcx), %eax
movl %eax, 0x4(%rbx)
movq 0x8(%r14), %rdi
callq 0x7270
movl $0x2, %edi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x2738
movl %eax, %ebp
jmp 0x31ed
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
cmpl $0x1, (%rdi)
jg 0x326a
movl $0x1, (%rbx)
movq %r15, %rsi
callq 0x2f68
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x326a
popq %rbx
popq %r14
popq %r15
retq
movq (%r15), %r14
movq 0x8(%r14), %rdi
leaq 0x9b25(%rip), %rsi      # 0xcd9d
callq 0x7d58
testl %eax, %eax
je 0x32bb
movq 0x8(%r14), %rdi
leaq 0x9b16(%rip), %rsi      # 0xcda2
callq 0x7d58
testl %eax, %eax
je 0x32bb
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x473a
testl %eax, %eax
je 0x32ca
movq 0x8(%r14), %rsi
movl $0x1, %edi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2738
xorl %edi, %edi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x37a4
movl 0x8(%rbx), %eax
cmpl $0xb, %eax
jl 0x32f6
movl %eax, %eax
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
imulq %rax, %rcx
shrq $0x20, %rcx
andl $-0x8, %ecx
leaq 0xeae5(%rip), %rax      # 0x11dd0
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rcx,%rax)
jmp 0x335c
movq (%r15), %rdi
movq %rbx, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x30fb
testl %eax, %eax
je 0x3317
movq 0x8(%r14), %rsi
movl $0x3, %edi
jmp 0x32ae
movl 0x408(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x6e99
testl %eax, %eax
jne 0x3351
cmpl $0x9, 0x8(%rbx)
jg 0x3351
movl 0x4(%rbx), %eax
testl $0x38000, %eax          # imm = 0x38000
setne %cl
testl %eax, %eax
sete %al
orb %cl, %al
jne 0x3351
cmpl $0x0, 0x408(%rbx)
je 0x335c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ec0
movl $0x1, %eax
jmp 0x3264
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movl %edi, %ebx
leaq 0x20(%rsp), %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0x33ca
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 0x10d0
movabsq $0x3000000008, %rcx     # imm = 0x3000000008
movq %rcx, (%rsp)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq %r15, 0x10(%rsp)
testl %r14d, %r14d
jle 0x3441
movl (%rsp), %ecx
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %r8
movl %ebx, %esi
xorl %edi, %edi
cmpl $0x28, %ecx
ja 0x3426
movq %r8, %r9
movl %ecx, %r8d
addq %rdx, %r8
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x342f
leaq 0x8(%r8), %r9
movq %r9, 0x8(%rsp)
movslq (%r8), %r8
movq %r8, (%rax,%rdi,8)
incq %rdi
movq %r9, %r8
cmpq %rdi, %rsi
jne 0x3410
movq $0x0, (%rax,%r14,8)
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3790
movq %rdi, %rbx
cmpq $0x1, %rdi
sete %al
testb $0x1, %bl
sete %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x3790
movss %xmm0, 0x14(%rsp)
leaq -0x1(%rbx), %r12
xorl %ecx, %ecx
movq %r12, %rax
movq %rcx, %r13
cmpq $0x1, %rcx
je 0x36e9
movq %rax, %r15
shrq %r15
leaq -0x1(%r13), %rcx
testb $0x2, %al
movq %r15, %rax
je 0x36cd
jmp 0x36ec
movq %rax, %r15
movq %rbx, %rdi
callq 0x3456
movq %rax, 0x8(%rsp)
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3764
movq $-0x1, %rbp
xorl %r14d, %r14d
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3977
cmpq $0x1, %rax
je 0x3764
movq %rax, %rdx
cmpq %r12, %rax
je 0x3764
testq %r13, %r13
je 0x3742
movq %r13, %rcx
imulq %rdx, %rdx
movq %rdx, %rax
xorl %edx, %edx
divq %rbx
cmpq %r12, %rdx
je 0x374f
incq %rcx
jne 0x372c
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax,%rbp,8)
je 0x3784
movq 0x8(%rsp), %rax
movq 0x8(%rax,%r14,8), %rdi
incq %r14
incq %rbp
testq %rdi, %rdi
jne 0x370b
cvttss2si 0x14(%rsp), %eax
movl $0x1, %ebp
testl %eax, %eax
jne 0x3786
movl $0x2b, %edi
movl $0x2, %esi
callq 0x7928
jmp 0x3786
xorl %ebp, %ebp
movq 0x8(%rsp), %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_O3/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 0x37c5
cmpq %r14, %r15
jl 0x37cb
jmp 0x37dc
cmpq $0x0, (%rbx)
je 0x37dc
movq %rbx, %rdi
callq 0x7ecf
incq %r15
addq $0x8, %rbx
jmp 0x37ba
movq %rsp, %rdi
callq 0x7eb0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7370
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x323e
testl %eax, %eax
je 0x388d
cmpl $0x0, 0x14(%rsp)
je 0x388d
leaq 0x14(%rsp), %r14
leaq 0x4(%rsp), %r15
leaq 0x8(%rsp), %r12
movl 0x4(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x37a4
movl $0x804, %esi            # imm = 0x804
movq %r14, %rdi
callq 0x7370
movl $0x1, 0x4(%rsp)
movq %rbx, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x323e
testl %eax, %eax
je 0x388d
cmpl $0x0, 0x14(%rsp)
jne 0x384c
xorl %eax, %eax
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x38a9
xorl %ecx, %ecx
jmp 0x38f0
movq %rdi, %rax
movl $0x1, %ecx
cmpq $0x2, %rdi
jb 0x38f0
xorl %r9d, %r9d
movq %rsi, %r8
testq %r8, %r8
je 0x38f4
movq %r9, %rdi
xorl %edx, %edx
divq %r8
imulq %r9, %rax
movq %rcx, %r9
subq %rax, %r9
movq %rdi, %rcx
movq %r8, %rax
cmpq $0x1, %r8
movq %rdx, %r8
jne 0x38bd
movq %rdi, %rcx
sarq $0x3f, %rcx
andq %rsi, %rcx
addq %rdi, %rcx
movq %rcx, %rax
retq
pushq %rax
leaq 0x94b0(%rip), %rdi      # 0xcdac
movl $0x2, %esi
callq 0x79c4
xorl %edi, %edi
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/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 0x391d
movq %rsi, %rdx
jmp 0x392a
testq %rcx, %rcx
js 0x392a
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
xorl %eax, %eax
testq %rdi, %rdi
je 0x3976
testb $0x1, %dil
je 0x394f
movq %rcx, %rsi
subq %rax, %rsi
cmpq %rsi, %rdx
jb 0x3947
movq %rcx, %rsi
jmp 0x3949
xorl %esi, %esi
addq %rdx, %rax
subq %rsi, %rax
movq %rcx, %rsi
subq %rdx, %rsi
cmpq %rsi, %rdx
jb 0x395f
movq %rcx, %rsi
jmp 0x3961
xorl %esi, %esi
movq %rdi, %r8
shrq %r8
addq %rdx, %rdx
subq %rsi, %rdx
cmpq $0x1, %rdi
movq %r8, %rdi
ja 0x3931
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x39b3
testq %rbx, %rbx
jne 0x39ae
leaq 0x941f(%rip), %rsi      # 0xcdbe
movl $0x22, %edx
movl $0x2, %edi
callq 0x1050
xorl %r15d, %r15d
jmp 0x3a0b
movq %rsi, %r14
testq %rsi, %rsi
je 0x3a05
movq %rdi, %rax
xorl %edx, %edx
divq %rbx
movq %rdx, %r12
movl $0x1, %r15d
testb $0x1, %r14b
je 0x39e3
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x390d
movq %rax, %r15
movq %r12, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x390d
movq %rax, %r12
movq %r14, %rax
shrq %rax
cmpq $0x1, %r14
movq %rax, %r14
ja 0x39cc
jmp 0x3a0b
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_O3/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, %ebp
testq %rsi, %rsi
je 0x3d80
movzbl (%r14), %eax
cmpl $0x2d, %eax
je 0x3d87
xorl %r12d, %r12d
testl %eax, %eax
jne 0x3d8d
decl %ebp
xorl %r12d, %r12d
jmp 0x3d8d
movl $0x1, %r12d
movl %r12d, %eax
testl %ebp, %ebp
je 0x3d9b
testq %r14, %r14
jne 0x3da6
jmp 0x3de7
xorl %ebp, %ebp
cmpb $0x0, (%r14,%rax)
sete %bpl
movb (%r14,%rax), %al
testb %al, %al
je 0x3de7
negl %ebp
leaq 0x905d(%rip), %r15      # 0xce14
leaq 0x904e(%rip), %r13      # 0xce0c
cmpl $0x1, %ebp
je 0x3e0a
cmpl $0x2, %ebp
je 0x3dd7
movsbl %al, %edi
callq 0x7314
testl %eax, %eax
je 0x3e3e
incl %r12d
movslq %r12d, %rax
movb (%r14,%rax), %al
addl $-0x2, %ebp
testb %al, %al
jne 0x3dbe
negl %ebp
cmpl $0x1, %ebp
leaq 0x901b(%rip), %rax      # 0xce0c
leaq 0x901c(%rip), %rcx      # 0xce14
cmoveq %rax, %rcx
cmpl $-0x1, %ebp
leaq 0x8ffe(%rip), %r15      # 0xce04
cmovneq %rcx, %r15
movq %r15, %rdi
movl $0x2, %esi
callq 0x7941
leaq 0x9000(%rip), %rdi      # 0xce1e
movl $0x2, %esi
callq 0x7941
movl 0x8(%rbx), %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21bc
movq %r13, %r15
jmp 0x3e0a
// File: /workspace/github_c_makefile_star2_O3/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 0x3f45
leal 0x1(%r12), %ebp
leaq 0x1(%r12), %r13
movsbl (%rdi), %eax
cmpl $0x2d, %eax
jne 0x3ed2
incq %rdi
leaq 0x9016(%rip), %rsi      # 0xcea3
callq 0x7d58
testl %eax, %eax
je 0x3f07
movq (%r14,%r13,8), %rdi
incq %rdi
leaq 0x9004(%rip), %rsi      # 0xcea8
callq 0x7d58
testl %eax, %eax
je 0x3f3f
movq (%r14,%r13,8), %rdi
incq %rdi
leaq 0x8ff2(%rip), %rsi      # 0xceb1
callq 0x7d58
testl %eax, %eax
jne 0x3fd4
orb $0x8, 0x4(%rbx)
jmp 0x3ef7
movl %eax, %edi
callq 0x7314
testl %eax, %eax
je 0x3f84
cmpq $0x0, (%r15)
jne 0x3f8a
movq (%r14,%r13,8), %rdi
callq 0x71ce
movq %rax, (%r15)
movl 0xc(%rbx), %r13d
cmpl $-0x1, %r13d
jne 0x3e60
jmp 0x3f64
orb $0x1, 0x4(%rbx)
movq 0x8(%r14,%r13,8), %rax
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x3f39
movsbl (%rax), %edi
callq 0x7314
testl %eax, %eax
je 0x3f39
leal 0x2(%r12), %ebp
movq 0x10(%r14,%r12,8), %rdi
callq 0x71ce
movq %rax, %r13
movl %r13d, 0xc(%rbx)
jmp 0x3efb
orb $0x4, 0x4(%rbx)
jmp 0x3ef7
movl 0xc(%rbx), %eax
testl %eax, %eax
je 0x3fb5
movl $0x10, %ecx
cmpl $0x1, %eax
je 0x3fc0
cmpl $0x40, %eax
jne 0x3fb1
movl $0x41, 0xc(%rbx)
jmp 0x3fc3
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 0x3d58
movq (%r14,%r13,8), %rsi
jmp 0x3fdb
leaq 0x8ea4(%rip), %rdi      # 0xce35
movl $0x2, %esi
callq 0x7941
movl 0x8(%rbx), %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21bc
testb $0x3f, %al
je 0x3fc0
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
movq (%r14,%r13,8), %rsi
incq %rsi
movl $0x6, %edi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2738
// File: /workspace/github_c_makefile_star2_O3/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
movq %rdi, %r15
xorl %eax, %eax
movl %eax, 0x4(%rsi)
movl %eax, 0xc(%rsi)
leaq 0x8(%rsp), %rdx
movl $0x1, %ecx
callq 0x3e43
testl %eax, %eax
je 0x402a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl 0x4(%rbx), %eax
testb $0x4, %al
jne 0x409d
movq 0x8(%rsp), %r14
testq %r14, %r14
sete %cl
testb %cl, %al
jne 0x40d8
cmpq $0x0, 0x10(%r15)
je 0x40d8
testb $0x8, %al
leaq 0x8e35(%rip), %rax      # 0xce8d
leaq 0x8e22(%rip), %rbx      # 0xce81
cmoveq %rax, %rbx
movss 0x8d95(%rip), %xmm0     # 0xce00
movq %r14, %rdi
callq 0x3680
testl %eax, %eax
leaq 0x8e1d(%rip), %rax      # 0xce99
leaq 0x8e1a(%rip), %rdx      # 0xce9d
cmoveq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7698
movl 0xc(%rbx), %edi
testl %edi, %edi
je 0x40fa
testb $0x8, %al
leaq 0x8dce(%rip), %rax      # 0xce7b
leaq 0x9045(%rip), %rbx      # 0xd0f9
cmoveq %rax, %rbx
movl $0x1, %esi
callq 0x2810
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7698
leaq 0x8d6a(%rip), %rdi      # 0xce49
movl $0x2, %esi
callq 0x7941
movl 0x8(%rbx), %edi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x21bc
leaq 0x8d5d(%rip), %rdi      # 0xce5e
movl $0x2, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7941
// File: /workspace/github_c_makefile_star2_O3/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
testq %rsi, %rsi
je 0x4148
xorl %r13d, %r13d
movq %rbx, %rcx
movq %rbx, %rax
incl %r13d
shrq $0x8, %rax
cmpq $0xff, %rcx
movq %rax, %rcx
ja 0x4133
jmp 0x414d
xorl %eax, %eax
xorl %r13d, %r13d
movq %rsp, %r15
movq %rax, (%r15)
leal 0x1(%r13), %edi
callq 0x7380
movq %rax, %r12
leaq 0x8d4f(%rip), %rdi      # 0xceb5
xorl %esi, %esi
xorl %eax, %eax
callq 0x10e0
movl %eax, %ebp
movl %r13d, %r13d
movq %r12, %rdi
movq %r13, %rsi
callq 0x7370
movl %ebp, %edi
movq %r12, %rsi
movq %r13, %rdx
callq 0x10b0
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x73ac
movq (%rsp), %rax
cmpq %r14, %rax
setb %cl
cmpq %rbx, %rax
seta %al
orb %cl, %al
jne 0x4174
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_O3/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 0x7370
leal -0x9(%r14), %eax
cmpl $-0x9, %eax
ja 0x4207
movl 0x8(%rbx), %edi
callq 0x21bc
jmp 0x42b7
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 0x425a
testb $0x2, %al
jne 0x4284
leaq 0x8c39(%rip), %rsi      # 0xce7b
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x7a1c
movl 0x10(%rbx), %esi
movq %r14, %rdi
jmp 0x427d
addl %r14d, %r14d
leaq 0x8c5e(%rip), %rsi      # 0xcec2
movq %rsp, %r12
movq %r12, %rdi
movl %r14d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x7a1c
movl 0x10(%rbx), %esi
movq %r12, %rdi
callq 0x7941
jmp 0x42aa
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 0x42b7
callq 0x1080
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x43ae
leaq (%rax,%rcx,8), %rbp
addq $0x8, %rbp
leaq 0x8bee(%rip), %r15      # 0xcee8
leaq 0x8bb0(%rip), %r12      # 0xceb1
movsbl (%rdi), %eax
cmpl $0x2d, %eax
jne 0x4366
movq 0x8(%rbp), %r13
incq %rdi
movq %r15, %rsi
callq 0x7d58
testl %eax, %eax
je 0x4391
movq (%rbp), %rdi
incq %rdi
movq %r12, %rsi
callq 0x7d58
testl %eax, %eax
je 0x4398
movl 0x10(%r14), %eax
cmpl $0x1, %eax
jne 0x444b
movq (%rbp), %rdi
incq %rdi
leaq 0x9528(%rip), %rsi      # 0xd872
callq 0x7d58
testl %eax, %eax
jne 0x4447
orb $0x4, 0x4(%r14)
testq %r13, %r13
jne 0x439d
jmp 0x442e
movl %eax, %edi
callq 0x7314
testl %eax, %eax
je 0x4428
cmpl $0x0, (%rbx)
jne 0x43ec
movl 0x4(%r14), %eax
notl %eax
testb $0xa, %al
je 0x43ec
movq (%rbp), %rdi
callq 0x7154
movl %eax, (%rbx)
jmp 0x439d
orb $0x2, 0x4(%r14)
jmp 0x439d
orb $0x8, 0x4(%r14)
movq 0x8(%rbp), %rdi
addq $0x8, %rbp
testq %rdi, %rdi
jne 0x4301
cmpl $0x0, (%rbx)
sete %al
movl 0x4(%r14), %ecx
notl %ecx
testb $0xa, %cl
sete %dl
orb %al, %dl
xorl %eax, %eax
cmpb $0x1, %dl
jne 0x4419
testb $0xa, %cl
jne 0x43df
leaq 0x8a60(%rip), %rdi      # 0xce35
movl $0x2, %esi
callq 0x7941
movl $0x0, (%rbx)
movl $0x1, %eax
jmp 0x4419
leaq 0x8a42(%rip), %rdi      # 0xce35
movl $0x2, %esi
callq 0x7941
movl 0x8(%r14), %edi
callq 0x21bc
movl %eax, %ecx
testl %eax, %eax
je 0x4412
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 0x4457
movl $0xffffffff, 0x10(%r14) # imm = 0xFFFFFFFF
leaq 0x8ab2(%rip), %rdi      # 0xceef
movl $0x2, %esi
callq 0x7941
movl 0x10(%r14), %eax
cmpl $-0x1, %eax
je 0x4472
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 0x2738
movl 0x8(%r14), %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21bc
// File: /workspace/github_c_makefile_star2_O3/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
movl %edx, 0xc(%rsp)
movl $0x0, 0x4(%rsi)
movl $0x1, 0x10(%rsi)
cmpq $0x0, 0x10(%rdi)
je 0x4506
movq %rsi, %rbx
leaq 0xc(%rsp), %rdx
movl $0x1, %ecx
callq 0x42c6
testl %eax, %eax
je 0x44d4
movl 0x4(%rbx), %ecx
movl %ecx, %edx
notl %edx
testb $0xa, %dl
jne 0x44e5
cmpl $0x0, 0xc(%rsp)
jne 0x4506
xorl %edx, %edx
jmp 0x44f7
movl 0xc(%rsp), %esi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x41d0
shrb $0x2, %cl
movl 0xc(%rsp), %edx
testl %edx, %edx
setne %sil
testb %sil, %cl
jne 0x4506
cmpl $-0x1, %eax
sete %al
testl %edx, %edx
setne %cl
orb %al, %cl
je 0x450c
addq $0x10, %rsp
popq %rbx
retq
leaq 0x89b7(%rip), %rdi      # 0xceca
movl $0x2, %esi
callq 0x7941
movl 0x8(%rbx), %edi
addq $0x10, %rsp
popq %rbx
jmp 0x21bc
nop