LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x45a2
cmpl $0xa, %eax
setge %cl
movl %esi, %edi
andb $-0x4, %dil
cmpb $0x70, %dil
setne %dil
orb %cl, %dil
je 0x458e
leal -0xb(%rax), %ecx
cmpl $0x8, %ecx
ja 0x4570
movsbl %sil, %eax
addl $-0x64, %eax
cmpl $0xb, %eax
ja 0x45a2
movl $0x823, %ecx            # imm = 0x823
jmp 0x4589
addl $-0x15, %eax
cmpl $0x8, %eax
ja 0x45a2
movsbl %sil, %eax
addl $-0x61, %eax
cmpl $0x15, %eax
ja 0x45a2
movl $0x24c519, %ecx         # imm = 0x24C519
btl %eax, %ecx
jae 0x45a2
addb $-0x61, %sil
movl $0x1, %eax
movl %esi, %ecx
shll %cl, %eax
orl %eax, 0x4(%rdx)
xorl %eax, %eax
jmp 0x45b6
leaq 0x7(%rsp), %rsi
movl $0x4, %edi
callq 0x2738
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/util/reference.c
// Function: scan_standard
int				scan_standard(char *input)
{
	if (!ft_strcmp(input, "genrsa"))
		return (31);
	else if (!ft_strcmp(input, "rsautl"))
		return (32);
	else if (!ft_strcmp(input, "rsa"))
		return (33);
	else if (!ft_strcmp(input, "prime"))
		return (36);
	else if (!ft_strcmp(input, "version"))
		return (41);
	else if (!ft_strcmp(input, "rand"))
		return (42);
	return (0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x894c(%rip), %rsi      # 0xcf0f
callq 0x7d58
testl %eax, %eax
je 0x4635
leaq 0x8943(%rip), %rsi      # 0xcf16
movq %rbx, %rdi
callq 0x7d58
testl %eax, %eax
je 0x463c
leaq 0x892c(%rip), %rsi      # 0xcf12
movq %rbx, %rdi
callq 0x7d58
testl %eax, %eax
je 0x4643
leaq 0x88a4(%rip), %rsi      # 0xce9d
movq %rbx, %rdi
callq 0x7d58
testl %eax, %eax
je 0x464a
leaq 0x8911(%rip), %rsi      # 0xcf1d
movq %rbx, %rdi
callq 0x7d58
testl %eax, %eax
je 0x4651
leaq 0x8906(%rip), %rsi      # 0xcf25
movq %rbx, %rdi
callq 0x7d58
xorl %ecx, %ecx
testl %eax, %eax
movl $0x2a, %eax
cmovnel %ecx, %eax
jmp 0x4656
movl $0x1f, %eax
jmp 0x4656
movl $0x20, %eax
jmp 0x4656
movl $0x21, %eax
jmp 0x4656
movl $0x24, %eax
jmp 0x4656
movl $0x29, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/util/reference.c
// Function: scan_encode
int				scan_encode(char *input)
{
	if (!ft_strcmp(input, "des3-ecb"))
		return (28);
	else if (!ft_strcmp(input, "des3-cbc"))
		return (27);
	else if (!ft_strcmp(input, "des3-ofb"))
		return (26);
	else if (!ft_strcmp(input, "des3"))
		return (25);
	else if (!ft_strcmp(input, "des-ecb"))
		return (24);
	else if (!ft_strcmp(input, "des-cbc"))
		return (23);
	else if (!ft_strcmp(input, "des-ofb"))
		return (22);
	else if (!ft_strcmp(input, "des"))
		return (21);
	return (scan_standard(input));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x88c7(%rip), %rsi      # 0xcf2a
callq 0x7d58
testl %eax, %eax
je 0x4702
leaq 0x88bc(%rip), %rsi      # 0xcf33
movq %rbx, %rdi
callq 0x7d58
testl %eax, %eax
je 0x4709
leaq 0x88ae(%rip), %rsi      # 0xcf3c
movq %rbx, %rdi
callq 0x7d58
testl %eax, %eax
je 0x4710
leaq 0x88a4(%rip), %rsi      # 0xcf45
movq %rbx, %rdi
callq 0x7d58
testl %eax, %eax
je 0x4717
leaq 0x8896(%rip), %rsi      # 0xcf4a
movq %rbx, %rdi
callq 0x7d58
testl %eax, %eax
je 0x471e
leaq 0x888b(%rip), %rsi      # 0xcf52
movq %rbx, %rdi
callq 0x7d58
testl %eax, %eax
je 0x4725
leaq 0x8880(%rip), %rsi      # 0xcf5a
movq %rbx, %rdi
callq 0x7d58
testl %eax, %eax
je 0x472c
leaq 0x8875(%rip), %rsi      # 0xcf62
movq %rbx, %rdi
callq 0x7d58
testl %eax, %eax
je 0x4733
movq %rbx, %rdi
popq %rbx
jmp 0x45b8
movl $0x1c, %eax
jmp 0x4738
movl $0x1b, %eax
jmp 0x4738
movl $0x1a, %eax
jmp 0x4738
movl $0x19, %eax
jmp 0x4738
movl $0x18, %eax
jmp 0x4738
movl $0x17, %eax
jmp 0x4738
movl $0x16, %eax
jmp 0x4738
movl $0x15, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/util/reference.c
// Function: valid_command
int				valid_command(char *input, t_ssl *ssl)
{
	int		i;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %rax
movzbl (%rax), %ecx
testb $-0x21, %cl
je 0x4754
incq %rax
jmp 0x4747
movb $0x0, (%rax)
leaq 0x88d5(%rip), %rsi      # 0xd033
movq %r14, %rdi
callq 0x7d58
testl %eax, %eax
je 0x4802
leaq 0x87f1(%rip), %rsi      # 0xcf66
movq %r14, %rdi
callq 0x7d58
testl %eax, %eax
je 0x480b
leaq 0x87e1(%rip), %rsi      # 0xcf6d
movq %r14, %rdi
callq 0x7d58
testl %eax, %eax
je 0x4814
leaq 0x87d5(%rip), %rsi      # 0xcf74
movq %r14, %rdi
callq 0x7d58
testl %eax, %eax
je 0x481d
leaq 0x87c9(%rip), %rsi      # 0xcf7b
movq %r14, %rdi
callq 0x7d58
testl %eax, %eax
je 0x4826
leaq 0x87bd(%rip), %rsi      # 0xcf82
movq %r14, %rdi
callq 0x7d58
testl %eax, %eax
je 0x482f
leaq 0x8710(%rip), %rsi      # 0xcee8
movq %r14, %rdi
callq 0x7d58
testl %eax, %eax
je 0x4838
xorl %eax, %eax
cmpl $0x0, 0x8(%rbx)
jne 0x4841
movq %r14, %rdi
callq 0x4658
movl %eax, %ecx
movl %eax, 0x8(%rbx)
xorl %eax, %eax
testl %ecx, %ecx
sete %al
jmp 0x4841
movl $0x1, 0x8(%rbx)
jmp 0x483f
movl $0x2, 0x8(%rbx)
jmp 0x483f
movl $0x3, 0x8(%rbx)
jmp 0x483f
movl $0x4, 0x8(%rbx)
jmp 0x483f
movl $0x5, 0x8(%rbx)
jmp 0x483f
movl $0x6, 0x8(%rbx)
jmp 0x483f
movl $0xb, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/util/reference.c
// Function: show_supported
void			show_supported(void)
{
	dprintf(2, "%sStandard commands%s:\n", UWHT, NOCOL);
	dprintf(2, "genrsa\t\tprime\t\trand\n");
	dprintf(2, "rsa\t\trsautl\t\tversion\n\n");
	dprintf(2, "%sMessage Digest Commands%s:\n", UWHT, NOCOL);
	dprintf(2, "md5\t\tsha1\t\tsha224\t\tsha256\n");
	dprintf(2, "sha384\t\tsha512\n\n");
	dprintf(2, "%sCipher Commands%s:\n", UWHT, NOCOL);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x8733(%rip), %rsi      # 0xcf87
leaq 0x8744(%rip), %rbx      # 0xcf9f
leaq 0x79fd(%rip), %r14      # 0xc25f
movl $0x2, %edi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1090
leaq 0x872c(%rip), %rsi      # 0xcfa7
movl $0x2, %edi
xorl %eax, %eax
callq 0x1090
leaq 0x872e(%rip), %rsi      # 0xcfbc
movl $0x2, %edi
xorl %eax, %eax
callq 0x1090
leaq 0x8732(%rip), %rsi      # 0xcfd3
movl $0x2, %edi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1090
leaq 0x8737(%rip), %rsi      # 0xcff1
movl $0x2, %edi
xorl %eax, %eax
callq 0x1090
leaq 0x873f(%rip), %rsi      # 0xd00c
movl $0x2, %edi
xorl %eax, %eax
callq 0x1090
leaq 0x873d(%rip), %rsi      # 0xd01d
movl $0x2, %edi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1090
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/rsa/rsa.c
// Function: get_value
int				get_value(t_rsa *gg, __uint64_t value, int flag)
{
	if (!gg->n)
		gg->n = value;
	else if (!gg->e)
		gg->e = value;
	else if (!gg->d && !(flag))
		gg->d = value;
	else if (!gg->p && !(flag))
		gg->p = value;
	else if (!gg->q && !(flag))
		gg->q = value;
	else if (!gg->dmp1 && !(flag))
		gg->dmp1 = value;
	else if (!gg->dmq1 && !(flag))
		gg->dmq1 = value;
	else if (!gg->iqmp && !(flag))
		gg->iqmp = value;
	else
		return (0);
	return (1);
}

// Assembly:
cmpq $0x0, 0x10(%rdi)
je 0x491b
cmpq $0x0, 0x38(%rdi)
je 0x4921
testl %edx, %edx
jne 0x4927
cmpq $0x0, 0x40(%rdi)
jne 0x4927
addq $0x40, %rdi
jmp 0x4975
addq $0x10, %rdi
jmp 0x4975
addq $0x38, %rdi
jmp 0x4975
testl %edx, %edx
jne 0x4931
cmpq $0x0, (%rdi)
je 0x4975
testl %edx, %edx
jne 0x4942
cmpq $0x0, 0x8(%rdi)
jne 0x4942
addq $0x8, %rdi
jmp 0x4975
testl %edx, %edx
jne 0x4953
cmpq $0x0, 0x20(%rdi)
jne 0x4953
addq $0x20, %rdi
jmp 0x4975
testl %edx, %edx
jne 0x4964
cmpq $0x0, 0x28(%rdi)
jne 0x4964
addq $0x28, %rdi
jmp 0x4975
xorl %eax, %eax
testl %edx, %edx
jne 0x497d
cmpq $0x0, 0x30(%rdi)
jne 0x497d
addq $0x30, %rdi
movq %rsi, (%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/rsa/rsa.c
// Function: assign
int				assign(uint8_t *decoded, t_rsa *gg, int decode_len, int flag)
{
	int			i;
	int			len;
	__uint64_t	value;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq %rdi, (%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rdi, %rcx
incl %eax
cmpb $0x2, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0x499f
cmpl %ebp, %eax
jge 0x4a06
leaq 0x1(%r15), %r12
movslq %eax, %rcx
leaq 0x1(%rcx), %r13
cmpb $0x2, (%r15,%rcx)
jne 0x49fe
movzbl (%r15,%r13), %ecx
testl %ecx, %ecx
je 0x49f2
addq %r12, %r13
movl %ecx, %edx
xorl %edi, %edi
xorl %esi, %esi
movq %rsi, %r8
shlq $0x8, %r8
movzbl (%r13,%rdi), %esi
orq %r8, %rsi
incq %rdi
cmpl %edi, %edx
jne 0x49d2
leal (%rax,%rcx), %r13d
incl %r13d
jmp 0x49f4
xorl %esi, %esi
movq %r14, %rdi
movl %ebx, %edx
callq 0x48fc
movl %r13d, %eax
cmpl %ebp, %r13d
jl 0x49b2
movq %rsp, %rdi
callq 0x7eb0
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_O3/rpeepz[P]ft_ssl/srcs/rsa/rsa.c
// Function: validate_key
int				validate_key(char *buf, t_rsa *gg, int flag)
{
	uint8_t		seq_decode[3];
	uint8_t		*decoded;
	int			n;
	float		decode_len;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x15(%rsp), %r15
movq %r15, %rsi
movl $0x4, %edx
callq 0x1a6c
movzbl 0x1(%r15), %ecx
cvtsi2sd %ecx, %xmm0
divsd 0x75c0(%rip), %xmm0     # 0xc018
mulsd 0x85d8(%rip), %xmm0     # 0xd038
cvtsd2ss %xmm0, %xmm0
movl %eax, %r15d
movss %xmm0, 0x10(%rsp)
cvttss2si %xmm0, %eax
movslq %eax, %r12
movq %r12, %rdi
callq 0x7380
movq %rax, 0x8(%rsp)
movslq %r15d, %r13
leaq (%rbx,%r13), %rdi
movq %rax, %rsi
movl %r12d, %edx
callq 0x1a6c
addl %eax, %r13d
movslq %r13d, %r12
cmpb $0x2d, 0x1(%rbx,%r12)
je 0x4abf
leaq 0x8301(%rip), %rdi      # 0xcda9
xorl %r15d, %r15d
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x743c
testl %eax, %eax
jne 0x4b9b
leaq 0x1(%r12), %r15
movq %rbx, %rdi
movl $0x2d, %esi
callq 0x7d0b
cmpl $0x40, %r12d
jg 0x4adf
decl %eax
testb $0x3, %al
jne 0x4af4
jmp 0x4b20
cmpl %eax, %r15d
jne 0x4af4
movl %r13d, %eax
shrl $0x6, %eax
movl %r13d, %ecx
subl %eax, %ecx
testb $0x3, %cl
je 0x4b20
xorl %edi, %edi
cmpl $0x1, %ebp
adcl $0x7, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2738
testl %eax, %eax
je 0x4b20
leaq 0x8299(%rip), %rdi      # 0xcda9
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x743c
testl %eax, %eax
jne 0x4b7d
xorps %xmm0, %xmm0
cvtss2sd 0x10(%rsp), %xmm0
mulsd 0x850f(%rip), %xmm0     # 0xd040
mulsd 0x74df(%rip), %xmm0     # 0xc018
cvttpd2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movq 0x8(%rsp), %rdi
cvttss2si %xmm0, %edx
movq %r14, %rsi
movl %ebp, %ecx
callq 0x497e
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x48fc
testl %eax, %eax
je 0x4b85
cmpl $0x1, %ebp
adcl $0xd, %r12d
movl %r12d, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2738
testl %eax, %eax
je 0x4b85
movb $0x0, (%rbx)
xorl %r15d, %r15d
jmp 0x4b9b
cmpl $0x40, %r13d
jg 0x4b9b
movq %rbx, %rdi
movl $0x2d, %esi
callq 0x7d0b
movl %eax, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/rsa/rsa.c
// Function: read_key
int				read_key(char *buf, t_rsa *gg, int flag, int fd)
{
	if (flag & R_CHECK && flag & R_PUBIN)
		return (ft_error(20, NULL, NULL));
	ft_bzero(buf, PAGESIZE);
	read(fd, buf, PAGESIZE);
	flag = flag & R_PUBIN ? 1 : 0;
	if (ft_strncmp(buf, flag ? PUB_BEG : PRIV_BEG, flag ? 27 : 32))
	{
		buf += ft_strchri(buf, '\n');
		buf += ft_strchri(buf, '-');
		if (ft_strncmp(buf, flag ? PUB_BEG : PRIV_BEG, flag ? 27 : 32) &&\
			ft_error(flag ? 9 : 10, NULL, NULL))
			return (ft_printf("%s", flag ? EXPECT_PUB : EXPECT_PRV));
	}
	buf += flag ? 27 : 32;
	if (!*buf)
		return (ft_error(flag ? 11 : 12, NULL, NULL));
	buf += validate_key(buf, gg, flag);
	if (!*buf)
		return (1);
	if (ft_strncmp(buf, flag ? PUB_END : PRIV_END, flag ? 25 : 30))
		return (ft_error(flag ? 11 : 12, NULL, NULL));
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %eax
notl %eax
testb $0x30, %al
jne 0x4bca
movl $0x14, %edi
jmp 0x4cfb
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
andl $0x20, %ebx
movl $0x1000, %esi           # imm = 0x1000
callq 0x7370
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %r14, %rsi
callq 0x10b0
xorl %eax, %eax
testl %ebx, %ebx
sete %al
leaq 0x8466(%rip), %rcx      # 0xd064
leaq 0x8443(%rip), %r13      # 0xd048
cmoveq %rcx, %r13
leaq (%rax,%rax,4), %r12
addq $0x1b, %r12
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x7d80
testl %eax, %eax
je 0x4ca0
movq %r14, %rdi
movl $0xa, %esi
callq 0x7d0b
movslq %eax, %rbp
addq %r14, %rbp
movq %rbp, %rdi
movl $0x2d, %esi
callq 0x7d0b
movslq %eax, %r14
addq %rbp, %r14
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x7d80
testl %eax, %eax
je 0x4ca0
xorl %edi, %edi
cmpl $0x1, %ebx
adcl $0x9, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2738
testl %eax, %eax
je 0x4ca0
testl %ebx, %ebx
leaq 0x8423(%rip), %rax      # 0xd09c
leaq 0x8405(%rip), %rsi      # 0xd085
cmoveq %rax, %rsi
leaq 0x79ae(%rip), %rdi      # 0xc639
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7698
cmpb $0x0, (%r14,%r12)
je 0x4cf3
movl %ebx, %edx
shrl $0x5, %edx
addq %r12, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x4a1f
cltq
cmpb $0x0, (%r14,%rax)
je 0x4d12
addq %rax, %r14
xorl %eax, %eax
testl %ebx, %ebx
sete %al
leaq 0x83fe(%rip), %rcx      # 0xd0d2
leaq 0x83dd(%rip), %rsi      # 0xd0b8
cmoveq %rcx, %rsi
leaq (%rax,%rax,4), %rdx
addq $0x19, %rdx
movq %r14, %rdi
callq 0x7d80
testl %eax, %eax
je 0x4d19
xorl %edi, %edi
cmpl $0x1, %ebx
adcl $0xb, %edi
xorl %esi, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2738
movl $0x1, %eax
jmp 0x4d1b
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_O3/rpeepz[P]ft_ssl/srcs/rsa/rsa.c
// Function: rsa_command
t_rsa			rsa_command(t_rsa_out rsa)
{
	t_rsa		gg;
	char		buf[PAGESIZE];
	__uint64_t	tmp;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1068, %rsp           # imm = 0x1068
movq %rdi, %rbx
movl $0x48, %esi
callq 0x7370
movl 0x1090(%rsp), %ebp
movl %ebp, %eax
notl %eax
testl $0x220, %eax            # imm = 0x220
jne 0x4d6c
movl $0x13, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2738
testl %eax, %eax
jne 0x4e9a
leaq 0x1090(%rsp), %r15
movl 0x4(%r15), %r14d
xorl %eax, %eax
testl %r14d, %r14d
setne %al
movl 0x10(%r15,%rax,4), %ecx
leaq 0x60(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x4bad
testl %eax, %eax
jne 0x4e9a
movq 0x10(%rbx), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x4db8
movq %rcx, %rdx
incl %eax
shrq %rdx
cmpq $0x1, %rcx
movq %rdx, %rcx
ja 0x4daa
testl %r14d, %r14d
setne %cl
movl %eax, 0x8(%r15)
testb $0x4, %bpl
sete %al
orb %cl, %al
jne 0x4df6
leaq 0x18(%rsp), %rdi
movl $0x9, %ecx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x4f3f
movl (%r15), %ebp
testb %bpl, %bpl
jns 0x4e31
leaq 0x60(%rsp), %r14
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
callq 0x7370
movq 0x10(%rbx), %rdx
leaq 0x82d9(%rip), %rsi      # 0xd0f1
movq %r14, %rdi
xorl %eax, %eax
callq 0x7a1c
movl 0xc(%r15), %esi
movq %r14, %rdi
callq 0x7941
movl (%r15), %ebp
testb $0x10, %bpl
je 0x4e62
leaq 0x18(%rsp), %rdi
movl $0x9, %ecx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movl $0x63, %edi
callq 0x520a
cmpl $0x0, 0x4(%r15)
jne 0x4e9a
testb $0x8, (%r15)
jne 0x4e9a
leaq 0x18(%rsp), %rdi
movl $0x9, %ecx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movl $0x6f, %edi
callq 0x520a
movq %rbx, %rax
addq $0x1068, %rsp           # imm = 0x1068
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/rsa/rsa_out.c
// Function: debug_output
void			debug_output(t_ssl *ssl, t_rsa_out rsa)
{
	ft_printf("ssl flags  [%b]\n", ssl->flag);
	ft_printf("ssl type   [%d]\n", ssl->type);
	ft_printf("rsa bits   [%d]\n", rsa.bits);
	ft_printf("rsa fd in  [%d]\n", rsa.fd_in);
	ft_printf("rsa fd out [%d]\n", rsa.fd_out);
	ft_printf("rsa in key [%d]\n", rsa.fd_inkey);
	ft_printf("rsa flags  [%b]\n", rsa.flag);
	ft_printf("rsa type   [%d]\n", rsa.type);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %esi
leaq 0x8245(%rip), %rdi      # 0xd0ff
xorl %eax, %eax
callq 0x7698
movl 0x8(%rbx), %esi
leaq 0x8245(%rip), %rdi      # 0xd110
xorl %eax, %eax
callq 0x7698
movl 0x18(%rsp), %esi
leaq 0x8244(%rip), %rdi      # 0xd121
xorl %eax, %eax
callq 0x7698
movl 0x20(%rsp), %esi
leaq 0x8243(%rip), %rdi      # 0xd132
xorl %eax, %eax
callq 0x7698
movl 0x1c(%rsp), %esi
leaq 0x8242(%rip), %rdi      # 0xd143
xorl %eax, %eax
callq 0x7698
movl 0x24(%rsp), %esi
leaq 0x8241(%rip), %rdi      # 0xd154
xorl %eax, %eax
callq 0x7698
movl 0x10(%rsp), %esi
leaq 0x8240(%rip), %rdi      # 0xd165
xorl %eax, %eax
callq 0x7698
movl 0x14(%rsp), %esi
leaq 0x823f(%rip), %rdi      # 0xd176
xorl %eax, %eax
popq %rbx
jmp 0x7698
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/rsa/rsa_out.c
// Function: rsa_text_out
void			rsa_text_out(t_rsa_out rsa, t_rsa gg)
{
	char	buf[PAGESIZE];

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsp, %rbx
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
callq 0x7370
leaq 0x1030(%rsp), %r15
movl (%r15), %ebp
movl 0x8(%r15), %ecx
andl $0x20, %ebp
testl %ebp, %ebp
leaq 0x8229(%rip), %rax      # 0xd1a0
leaq 0x821b(%rip), %rdx      # 0xd199
cmoveq %rax, %rdx
leaq 0x81fe(%rip), %rsi      # 0xd187
leaq 0x8249(%rip), %rax      # 0xd1d9
leaq 0x8248(%rip), %r14      # 0xd1df
cmoveq %rax, %r14
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7a1c
movq %rbx, %rdi
callq 0x8082
leaq (%rsp,%rax), %rdi
movq 0x1058(%rsp), %rcx
leaq 0x81e8(%rip), %rsi      # 0xd1a8
movl %ebp, %edx
xorl $0x6d, %edx
movq %rcx, %r8
xorl %eax, %eax
callq 0x7a1c
movq %rbx, %rdi
callq 0x8082
leaq (%rsp,%rax), %rdi
movq 0x1080(%rsp), %rcx
leaq 0x81d6(%rip), %rsi      # 0xd1c0
movq %r14, %rdx
movq %rcx, %r8
xorl %eax, %eax
callq 0x7a1c
testl %ebp, %ebp
jne 0x50cf
leaq 0x1048(%rsp), %r14
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x8082
leaq (%rsp,%rax), %rdi
movq 0x40(%r14), %rcx
leaq 0x81c0(%rip), %rsi      # 0xd1e1
movq %rcx, %rdx
xorl %eax, %eax
callq 0x7a1c
movq %rbx, %rdi
callq 0x8082
leaq (%rsp,%rax), %rdi
movq (%r14), %rcx
leaq 0x81bf(%rip), %rsi      # 0xd200
movq %rcx, %rdx
xorl %eax, %eax
callq 0x7a1c
movq %rbx, %rdi
callq 0x8082
leaq (%rsp,%rax), %rdi
movq 0x8(%r14), %rcx
leaq 0x81b4(%rip), %rsi      # 0xd216
movq %rcx, %rdx
xorl %eax, %eax
callq 0x7a1c
movq %rbx, %rdi
callq 0x8082
leaq (%rsp,%rax), %rdi
movq 0x20(%r14), %rcx
leaq 0x81a9(%rip), %rsi      # 0xd22c
movq %rcx, %rdx
xorl %eax, %eax
callq 0x7a1c
movq %rbx, %rdi
callq 0x8082
leaq (%rsp,%rax), %rdi
movq 0x28(%r14), %rcx
leaq 0x81a1(%rip), %rsi      # 0xd245
movq %rcx, %rdx
xorl %eax, %eax
callq 0x7a1c
movq %rbx, %rdi
callq 0x8082
leaq (%rsp,%rax), %rdi
movq 0x30(%r14), %rcx
leaq 0x8199(%rip), %rsi      # 0xd25e
movq %rcx, %rdx
xorl %eax, %eax
callq 0x7a1c
movl 0xc(%r15), %esi
movq %rsp, %rdi
callq 0x7941
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/rsa/rsa_out.c
// Function: rsa_encode_out
void			rsa_encode_out(t_rsa_out rsa, t_rsa gg)
{
	int			len;
	int			i;
	uint8_t		buf[PAGESIZE];
	uint8_t		buf2[10];

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1060, %rsp           # imm = 0x1060
leaq 0x1098(%rsp), %rbx
leaq 0x60(%rsp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x7370
leaq 0x56(%rsp), %rdi
movl $0xa, %esi
callq 0x7370
movl $0x0, 0x50(%rsp)
movl 0x1080(%rsp), %ebp
movl $0x9, %ecx
movq %rsp, %rdi
movq %rbx, %rsi
testb $0x60, %bpl
je 0x515e
rep  movsq (%rsi), %es:(%rdi)
leaq 0x60(%rsp), %rbx
leaq 0x56(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x15d6
xorl %eax, %eax
movb %al, 0x10(%rbx)
movb %al, 0x13(%rbx)
jmp 0x5175
rep  movsq (%rsi), %es:(%rdi)
leaq 0x60(%rsp), %rdi
leaq 0x56(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x120c
leaq 0x1080(%rsp), %rax
movslq 0x50(%rsp), %rcx
testq %rcx, %rcx
jle 0x51a4
xorl %edx, %edx
cmpb $0x2, 0x60(%rsp,%rdx)
jne 0x519c
cmpb $-0x1, 0x62(%rsp,%rdx)
jne 0x519c
movb $0x0, 0x62(%rsp,%rdx)
incq %rdx
cmpq %rdx, %rcx
jne 0x5189
movl 0xc(%rax), %ebx
testb $0x60, %bpl
leaq 0x7eb2(%rip), %rax      # 0xd064
leaq 0x7e8f(%rip), %rdi      # 0xd048
cmoveq %rax, %rdi
leaq 0x7f0e(%rip), %rax      # 0xd0d2
leaq 0x7eed(%rip), %r14      # 0xd0b8
cmoveq %rax, %r14
movl %ebx, %esi
callq 0x7941
movl 0x50(%rsp), %esi
leaq 0x60(%rsp), %rdi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x1888
movq %r14, %rdi
movl %ebx, %esi
callq 0x7941
cmpl $0x2, %ebx
jl 0x51fe
movl %ebx, %edi
callq 0x1080
addq $0x1060, %rsp           # imm = 0x1060
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/rsa/rsa_out.c
// Function: rsa_out_options
void			rsa_out_options(t_rsa_out rsa, t_rsa gg, char option)
{
	if (option == 'o')
	{
		ft_putstr_fd("writing RSA key\n", 2);
		rsa_encode_out(rsa, gg);
	}
	else if (option == 'c' && !(option = 0))
	{
		if ((gg.p * gg.q != gg.n) && (option |= 0x1))
			ft_putstr_fd(N_NOT_PQ, rsa.fd_out);
		if (!(ft_is_primary(gg.p, 9.0F)) && (option |= 0x1))
			ft_putstr_fd(P_NOT_PRIME, rsa.fd_out);
		if (!(ft_is_primary(gg.q, 9.0F)) && (option |= 0x1))
			ft_putstr_fd(Q_NOT_PRIME, rsa.fd_out);
		if (mulmod(gg.q, gg.iqmp, gg.p) != 1 && (option |= 0x1))
			ft_putstr_fd(NOT_INV_Q, rsa.fd_out);
		if ((mulmod(gg.dmp1, gg.e, gg.p - 1) != 1 ||\
			mulmod(gg.dmq1, gg.e, gg.q - 1) != 1) && (option |= 0x1))
			ft_putstr_fd(DE_NOT_CONG, rsa.fd_out);
	}
	if (!option)
		ft_putstr_fd("RSA key ok\n", rsa.fd_out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x40(%rsp), %r12
cmpl $0x63, %edi
je 0x524e
movl %edi, %ebp
cmpl $0x6f, %edi
jne 0x532d
leaq 0x8048(%rip), %rdi      # 0xd279
movl $0x2, %esi
callq 0x7941
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x50e9
leaq 0x58(%rsp), %r13
movq (%r13), %r14
movq 0x8(%r13), %rbx
movq %rbx, %rax
imulq %r14, %rax
cmpq 0x10(%r13), %rax
jne 0x526c
xorl %ebp, %ebp
jmp 0x5280
movl 0xc(%r12), %esi
leaq 0x8012(%rip), %rdi      # 0xd28a
callq 0x7941
movb $0x1, %bpl
movss 0x7b78(%rip), %xmm0     # 0xce00
movq %r14, %rdi
callq 0x3680
testl %eax, %eax
jne 0x52a8
movl 0xc(%r12), %esi
leaq 0x800f(%rip), %rdi      # 0xd2af
callq 0x7941
movb $0x1, %bpl
movss 0x7b50(%rip), %xmm0     # 0xce00
movq %rbx, %rdi
callq 0x3680
testl %eax, %eax
jne 0x52d0
movl 0xc(%r12), %esi
leaq 0x8003(%rip), %rdi      # 0xd2cb
callq 0x7941
movb $0x1, %bpl
movq 0x30(%r13), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x390d
cmpq $0x1, %rax
je 0x52f9
movl 0xc(%r12), %esi
leaq 0x7ff6(%rip), %rdi      # 0xd2e7
callq 0x7941
movb $0x1, %bpl
movq 0x20(%r13), %rdi
movq 0x38(%r13), %r15
decq %r14
movq %r15, %rsi
movq %r14, %rdx
callq 0x390d
cmpq $0x1, %rax
jne 0x5341
movq 0x28(%r13), %rdi
decq %rbx
movq %r15, %rsi
movq %rbx, %rdx
callq 0x390d
cmpq $0x1, %rax
jne 0x5341
testb %bpl, %bpl
je 0x534f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0xc(%r12), %esi
leaq 0x7fc0(%rip), %rdi      # 0xd30d
jmp 0x535b
movl 0xc(%r12), %esi
leaq 0x7fd9(%rip), %rdi      # 0xd334
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7941
nop
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/rsa/rsautl.c
// Function: print_row_hex
void			print_row_hex(int bytes, int len, __uint8_t *msg, int fd)
{
	char	*hex;
	int		i;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %ebp
cmpl $0xf, %edi
jg 0x5395
leaq 0x8063(%rip), %rdi      # 0xd3f1
movl %ebx, %esi
callq 0x7941
movslq %ebp, %r12
xorl %r15d, %r15d
leaq 0x803e(%rip), %r13      # 0xd3e0
cmpq %r12, %r15
jge 0x53d1
movzbl (%r14,%r15), %eax
shrl $0x4, %eax
movsbl (%rax,%r13), %edi
movl %ebx, %esi
callq 0x7928
movzbl (%r14,%r15), %eax
andl $0xf, %eax
movsbl (%rax,%r13), %edi
movl %ebx, %esi
callq 0x7928
jmp 0x53df
leaq 0x8021(%rip), %rdi      # 0xd3f9
movl %ebx, %esi
callq 0x7941
leaq 0x1(%r15), %rbp
testb $0x7, %bpl
jne 0x5401
cmpq $0x7, %r15
movl $0x20, %edi
movl $0x2d, %eax
cmovel %eax, %edi
movl %ebx, %esi
callq 0x7928
movl $0x20, %edi
movl %ebx, %esi
callq 0x7928
movq %rbp, %r15
cmpq $0x10, %rbp
jne 0x53a2
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/rsa/rsautl.c
// Function: rsautl
void			rsautl(t_rsa_out rsa, t_rsa gg)
{
	__uint64_t		tmp;
	int				len;
	__uint8_t		buf[16];

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x78(%rsp), %r14
testq %r14, %r14
je 0x552d
leaq 0x68(%rsp), %r13
leaq 0x50(%rsp), %r15
movq %rsp, %rdi
movl $0x10, %esi
callq 0x7370
xorl %ebp, %ebp
movq %r14, %rax
movq %r14, %rcx
shrq %rcx
incl %ebp
cmpq $0x1, %rax
movq %rcx, %rax
ja 0x5460
movl 0x10(%r15), %edi
movq %rsp, %rsi
movl $0xf, %edx
callq 0x10b0
movq %rax, %rbx
shrl $0x3, %ebp
cmpl %ebx, %ebp
jne 0x54ba
movl (%r15), %r12d
movq 0x38(%r13), %rax
movq 0x40(%r13), %rsi
testl %ebx, %ebx
je 0x54ce
movl %ebx, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
xorl %edi, %edi
shlq $0x8, %rdi
movzbl (%rsp,%rdx), %r8d
incq %rdx
orq %r8, %rdi
cmpq %rdx, %rcx
jne 0x54a4
jmp 0x54d0
setle %al
movzbl %al, %edi
addl $0x15, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2738
jmp 0x552d
xorl %edi, %edi
movl 0xc(%r15), %ebp
btl $0x9, %r12d
cmovaeq %rax, %rsi
movq %r14, %rdx
callq 0x3977
movq %rax, %r14
leal -0x8(,%rbx,8), %esi
btl $0xa, %r12d
jb 0x5521
testl %ebx, %ebx
je 0x552d
movslq %esi, %r15
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
movq %r14, %rax
movl %r15d, %ecx
shrq %cl, %rax
movsbl %al, %edi
movl %ebp, %esi
callq 0x7928
addq $-0x8, %r15
decq %rbx
jne 0x5503
jmp 0x552d
movl %ebp, %edi
movl %ebx, %edx
movq %r14, %rcx
callq 0x553c
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/hash/sha1.c
// Function: sha1_cycle
void			sha1_cycle(int count, t_sha32bit *s, __uint32_t *w, int i)
{
	__uint32_t		pos;

	while (++i < 16)
		w[i] = s->message[count][i];
	i = 15;
	while (++i < 80)
	{
		pos = w[i - 3] ^ (w[i - 8]) ^ w[i - 14] ^ (w[i - 16]);
		w[i] = (pos << 1) | (pos >> (32 - 1));
	}
	s->a = s->hash[0];
	s->b = s->hash[1];
	s->c = s->hash[2];
	s->d = s->hash[3];
	s->e = s->hash[4];
	i = -1;
	while (++i < 80)
		sha1_loop(i, s, w);
	s->hash[0] += s->a;
	s->hash[1] += s->b;
	s->hash[2] += s->c;
	s->hash[3] += s->d;
	s->hash[4] += s->e;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0xe, %ecx
jg 0x5c5b
movq 0x48(%rsi), %rax
movslq %edi, %rdi
movq (%rax,%rdi,8), %rax
movslq %ecx, %rcx
incq %rcx
movl (%rax,%rcx,4), %edi
movl %edi, (%rdx,%rcx,4)
incq %rcx
cmpq $0x10, %rcx
jne 0x5c4c
xorl %eax, %eax
movl 0x20(%rdx,%rax,4), %ecx
xorl 0x34(%rdx,%rax,4), %ecx
xorl 0x8(%rdx,%rax,4), %ecx
xorl (%rdx,%rax,4), %ecx
roll %ecx
movl %ecx, 0x40(%rdx,%rax,4)
incq %rax
cmpq $0x40, %rax
jne 0x5c5d
movl (%rsi), %r9d
movl 0x4(%rsi), %r10d
movl %r9d, 0x24(%rsi)
movl %r10d, 0x28(%rsi)
movl 0x8(%rsi), %r8d
movl %r8d, 0x2c(%rsi)
movl 0xc(%rsi), %edi
movl %edi, 0x30(%rsi)
movl 0x10(%rsi), %r11d
movl %r11d, 0x34(%rsi)
movl $0xffffffd8, %ebp       # imm = 0xFFFFFFD8
xorl %r14d, %r14d
movl $0xcccccccd, %r15d      # imm = 0xCCCCCCCD
leaq 0x774b(%rip), %r12      # 0xd400
movl %r10d, -0xc(%rsp)
movl %r8d, %ebx
movl %edi, -0x8(%rsp)
movl %r9d, %r13d
movl %r11d, -0x4(%rsp)
movl %r11d, %eax
movl %r13d, %ecx
movl %edi, %r11d
movl %ebx, %edi
movl %r10d, %ebx
cmpq $0x13, %r14
ja 0x5ce8
movl %edi, %r10d
xorl %r11d, %r10d
andl %ebx, %r10d
jmp 0x5d10
movl %ebp, %r10d
addl $0x14, %r10d
jb 0x5d0a
cmpl $0x13, %ebp
ja 0x5d0a
movl %r11d, %r13d
orl %edi, %r13d
andl %ebx, %r13d
movl %r11d, %r10d
andl %edi, %r10d
orl %r13d, %r10d
jmp 0x5d13
movl %edi, %r10d
xorl %ebx, %r10d
xorl %r11d, %r10d
movl %r10d, 0x38(%rsi)
movl %ecx, %r13d
roll $0x5, %r13d
addl %eax, %r13d
addl %r10d, %r13d
movl %r14d, %eax
imulq %r15, %rax
shrq $0x22, %rax
andl $-0x4, %eax
addl (%rax,%r12), %r13d
addl (%rdx,%r14,4), %r13d
movl %r11d, 0x34(%rsi)
roll $0x1e, %ebx
movl %edi, 0x30(%rsi)
movl %ebx, 0x2c(%rsi)
movl %ecx, 0x28(%rsi)
movl %r13d, 0x24(%rsi)
incl %ebp
incq %r14
movl %ecx, %r10d
cmpq $0x50, %r14
jne 0x5cc9
addl %r9d, %r13d
movl %r13d, (%rsi)
addl -0xc(%rsp), %ecx
movl %ecx, 0x4(%rsi)
addl %r8d, %ebx
movl %ebx, 0x8(%rsi)
addl -0x8(%rsp), %edi
movl %edi, 0xc(%rsi)
addl -0x4(%rsp), %r11d
movl %r11d, 0x10(%rsi)
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/sha1.c
// Function: sha1
char			*sha1(char *buf, char *to_hash)
{
	t_sha32bit	s;
	__uint32_t	w[80];
	int			i;

	i = -1;
	ft_bzero(&s, sizeof(t_sha32bit));
	sha32_set(to_hash, &s);
	s.hash[0] = 0x67452301;
	s.hash[1] = 0xEFCDAB89;
	s.hash[2] = 0x98BADCFE;
	s.hash[3] = 0x10325476;
	s.hash[4] = 0xC3D2E1F0;
	while (++i < s.multiples)
		sha1_cycle(i, &s, w, -1);
	to_hash = buf;
	ft_sprintf(to_hash, "%.8x%.8x%.8x%.8x%.8x",
		s.hash[0], s.hash[1], s.hash[2], s.hash[3], s.hash[4]);
	free_message(s.multiples, (__uint64_t **)s.message);
	free(s.message);
	return (to_hash);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movl $0x50, %esi
movq %r15, %rdi
callq 0x7370
movq %r14, %rdi
movq %r15, %rsi
callq 0x6122
movaps 0x702b(%rip), %xmm0     # 0xcdf0
movaps %xmm0, (%r15)
movl $0xc3d2e1f0, 0x10(%r15) # imm = 0xC3D2E1F0
cmpl $0x0, 0x20(%r15)
jle 0x5e16
xorl %ebp, %ebp
leaq 0x10(%rsp), %r14
leaq 0x60(%rsp), %r15
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x5c2c
incl %ebp
cmpl 0x30(%rsp), %ebp
jl 0x5de4
movl 0x10(%rsp), %edx
movl 0x14(%rsp), %ecx
movl 0x18(%rsp), %r8d
movl 0x1c(%rsp), %r9d
movl 0x20(%rsp), %eax
jmp 0x5e31
movl $0x67452301, %edx       # imm = 0x67452301
movl $0xefcdab89, %ecx       # imm = 0xEFCDAB89
movl $0x98badcfe, %r8d       # imm = 0x98BADCFE
movl $0x10325476, %r9d       # imm = 0x10325476
movl $0xc3d2e1f0, %eax       # imm = 0xC3D2E1F0
movl %eax, (%rsp)
leaq 0x7621(%rip), %rsi      # 0xd45c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7a1c
movl 0x30(%rsp), %edi
movq 0x58(%rsp), %rsi
callq 0x7128
movq 0x58(%rsp), %rdi
callq 0x1030
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/hash/sha224.c
// Function: sha224
char			*sha224(char *buf, char *to_hash)
{
	t_sha32bit	s;
	__uint32_t	w[64];
	int			i;

	i = -1;
	ft_bzero(&s, sizeof(t_sha32bit));
	sha32_set(to_hash, &s);
	s.hash[0] = 0xc1059ed8;
	s.hash[1] = 0x367cd507;
	s.hash[2] = 0x3070dd17;
	s.hash[3] = 0xf70e5939;
	s.hash[4] = 0xffc00b31;
	s.hash[5] = 0x68581511;
	s.hash[6] = 0x64f98fa7;
	s.hash[7] = 0xbefa4fa4;
	while (++i < (int)(s.multiples))
		sha32_cycle(i, &s, w, -1);
	to_hash = buf;
	ft_sprintf(to_hash, "%.8x%.8x%.8x%.8x%.8x%.8x%.8x",
		s.hash[0], s.hash[1], s.hash[2], s.hash[3],
		s.hash[4], s.hash[5], s.hash[6]);
	free_message(s.multiples, (uint64_t **)s.message);
	free(s.message);
	return (to_hash);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movl $0x50, %esi
movq %r15, %rdi
callq 0x7370
movq %r14, %rdi
movq %r15, %rsi
callq 0x6122
movaps 0x756b(%rip), %xmm0     # 0xd410
movaps %xmm0, (%r15)
movaps 0x7570(%rip), %xmm0     # 0xd420
movaps %xmm0, 0x10(%r15)
cmpl $0x0, 0x20(%r15)
jle 0x5f02
xorl %ebp, %ebp
movq %rsp, %r14
leaq 0x50(%rsp), %r15
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x5f74
incl %ebp
cmpl 0x20(%rsp), %ebp
jl 0x5ec6
movl (%rsp), %edx
movl 0x4(%rsp), %ecx
movl 0x8(%rsp), %r8d
movl 0xc(%rsp), %r9d
movl 0x10(%rsp), %r10d
movl 0x14(%rsp), %r11d
movl 0x18(%rsp), %r14d
jmp 0x5f2a
movl $0xc1059ed8, %edx       # imm = 0xC1059ED8
movl $0x367cd507, %ecx       # imm = 0x367CD507
movl $0x3070dd17, %r8d       # imm = 0x3070DD17
movl $0xf70e5939, %r9d       # imm = 0xF70E5939
movl $0xffc00b31, %r10d      # imm = 0xFFC00B31
movl $0x68581511, %r11d      # imm = 0x68581511
movl $0x64f98fa7, %r14d      # imm = 0x64F98FA7
subq $0x8, %rsp
leaq 0x751f(%rip), %rsi      # 0xd454
movq %rbx, %rdi
xorl %eax, %eax
pushq %r14
pushq %r11
pushq %r10
callq 0x7a1c
addq $0x20, %rsp
movl 0x20(%rsp), %edi
movq 0x48(%rsp), %rsi
callq 0x7128
movq 0x48(%rsp), %rdi
callq 0x1030
movq %rbx, %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/hash/sha256.c
// Function: sha32_cycle
void			sha32_cycle(int count, t_sha32bit *s, __uint32_t *w, int i)
{
	while (++i < 16)
		w[i] = s->message[count][i];
	i = 15;
	while (++i < 64)
		w[i] = w[i - 16] + s0_32(w[i - 15]) + w[i - 7] + s1_32(w[i - 2]);
	s->a = s->hash[0];
	s->b = s->hash[1];
	s->c = s->hash[2];
	s->d = s->hash[3];
	s->e = s->hash[4];
	s->f = s->hash[5];
	s->g = s->hash[6];
	s->h = s->hash[7];
	i = -1;
	while (++i < 64)
		sha256_loop(i, s, w);
	s->hash[0] += s->a;
	s->hash[1] += s->b;
	s->hash[2] += s->c;
	s->hash[3] += s->d;
	s->hash[4] += s->e;
	s->hash[5] += s->f;
	s->hash[6] += s->g;
	s->hash[7] += s->h;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r15
cmpl $0xe, %ecx
jg 0x5fae
movq 0x48(%r15), %rax
movslq %edi, %rdx
movq (%rax,%rdx,8), %rax
movslq %ecx, %rcx
incq %rcx
movl (%rax,%rcx,4), %edx
movl %edx, (%r12,%rcx,4)
incq %rcx
cmpq $0x10, %rcx
jne 0x5f9e
movl $0x10, %ebx
movl -0x40(%r12,%rbx,4), %r14d
movl -0x3c(%r12,%rbx,4), %edi
callq 0x2ed3
movl %eax, %ebp
addl %r14d, %ebp
addl -0x1c(%r12,%rbx,4), %ebp
movl -0x8(%r12,%rbx,4), %edi
callq 0x2ee5
addl %ebp, %eax
movl %eax, (%r12,%rbx,4)
incq %rbx
cmpq $0x40, %rbx
jne 0x5fb3
movdqu (%r15), %xmm0
movdqu %xmm0, 0x24(%r15)
movl 0x10(%r15), %ebp
movl %ebp, 0x34(%r15)
movq %r12, 0x8(%rsp)
movl 0x14(%r15), %r12d
movl %r12d, 0x38(%r15)
movl 0x18(%r15), %esi
movl %esi, 0x3c(%r15)
movl 0x1c(%r15), %edi
movl %edi, 0x40(%r15)
movl (%r15), %eax
movl 0x4(%r15), %ecx
movl 0x8(%r15), %ebx
movq %r15, %r14
xorl %r13d, %r13d
movl %edi, 0x4(%rsp)
movq %r13, 0x10(%rsp)
movl %ebx, %edx
xorl %ecx, %edx
andl %eax, %edx
andl %ecx, %ebx
xorl %edx, %ebx
movl %ebp, %edi
movq %rsi, %r13
callq 0x2ec1
movl %eax, %r15d
xorl %r13d, %r12d
andl %ebp, %r12d
xorl %r13d, %r12d
movq 0x10(%rsp), %r13
addl 0x4(%rsp), %r15d
addl %r12d, %r15d
leaq 0x741d(%rip), %rax      # 0xd480
addl (%r13,%rax), %r15d
movq 0x8(%rsp), %rax
addl (%rax,%r13), %r15d
movl 0x24(%r14), %edi
callq 0x2eaf
movq 0x38(%r14), %rsi
movq %rsi, %xmm0
pshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
movd %xmm1, %edi
movq %rsi, 0x3c(%r14)
movl 0x34(%r14), %r12d
movl %r12d, 0x38(%r14)
movl 0x30(%r14), %ebp
addl %r15d, %ebp
movl %ebp, 0x34(%r14)
movq 0x28(%r14), %rdx
movq %rdx, 0x2c(%r14)
movl 0x24(%r14), %ecx
movl %ecx, 0x28(%r14)
addl %ebx, %eax
addl %r15d, %eax
movl %eax, 0x24(%r14)
addq $0x4, %r13
movl %edx, %ebx
cmpq $0x100, %r13            # imm = 0x100
jne 0x6026
movq %rdx, %xmm1
movd %ecx, %xmm2
movd %eax, %xmm3
punpckldq %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
punpcklqdq %xmm1, %xmm3    # xmm3 = xmm3[0],xmm1[0]
movdqu (%r14), %xmm1
paddd %xmm3, %xmm1
movdqu 0x10(%r14), %xmm2
movdqu %xmm1, (%r14)
movd %r12d, %xmm1
movd %ebp, %xmm3
punpckldq %xmm1, %xmm3    # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
punpcklqdq %xmm0, %xmm3    # xmm3 = xmm3[0],xmm0[0]
paddd %xmm2, %xmm3
movdqu %xmm3, 0x10(%r14)
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/hash/sha256.c
// Function: sha32_set
void			sha32_set(char *to_hash, t_sha32bit *s)
{
	int			i;
	__uint64_t	len;

	i = -1;
	len = (ft_strlen(to_hash) * 8) + 1;
	while (len % 512 != 448)
		len++;
	s->multiples = (len += 64) / 512;
	s->message = (__uint32_t**)malloc(sizeof(__uint32_t*) * s->multiples);
	while (++i < s->multiples)
	{
		s->message[i] = (__uint32_t*)malloc(sizeof(__uint32_t) * 16);
		ft_bzero(s->message[i], sizeof(__uint32_t) * 16);
	}
	sha_pad(to_hash, s, ft_strlen(to_hash));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x8082
leaq 0x40(,%rax,8), %r15
shlq $0x1a, %rax
addq $0x20000000, %rax       # imm = 0x20000000
leal -0x3f(%r15), %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
addq $0x800000, %rax         # imm = 0x800000
incq %r15
cmpl $0x1c0, %ecx            # imm = 0x1C0
jne 0x6144
shrq $0x9, %r15
movl %r15d, 0x20(%rbx)
sarq $0x1d, %rax
movq %rax, %rdi
callq 0x10d0
movq %rax, 0x48(%rbx)
testl %r15d, %r15d
jle 0x61af
xorl %r15d, %r15d
movl $0x40, %edi
callq 0x10d0
movq 0x48(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x48(%rbx), %rax
movq (%rax,%r15,8), %rdi
movl $0x40, %esi
callq 0x7370
incq %r15
movslq 0x20(%rbx), %rax
cmpq %rax, %r15
jl 0x617f
movq %r14, %rdi
callq 0x8082
xorl %edi, %edi
movq 0x48(%rbx), %rsi
testq %rax, %rax
je 0x620f
xorl %r9d, %r9d
xorl %r8d, %r8d
movsbl (%r14,%r9), %r10d
movl %edi, %edx
andb $0x18, %dl
movl %edx, %ecx
xorb $0x18, %cl
shll %cl, %r10d
movl %edx, %ecx
shll %cl, %r10d
shrl %cl, %r10d
movl %r8d, %ecx
movq (%rsi,%rcx,8), %rcx
movl %r9d, %edx
andl $0x3c, %edx
orl %r10d, (%rcx,%rdx)
incq %r9
movl %r9d, %ecx
andl $0x3f, %ecx
cmpq $0x1, %rcx
adcl $0x0, %r8d
addl $0x8, %edi
cmpq %r9, %rax
jne 0x61c8
movl %r8d, %edi
leal (,%rax,8), %edx
movl %edx, %ecx
notb %cl
andb $0x18, %cl
movl $0x80, %r8d
shll %cl, %r8d
movq (%rsi,%rdi,8), %rcx
movl %eax, %edi
andl $0x3c, %edi
orl %r8d, (%rcx,%rdi)
shrq $0x1d, %rax
movslq 0x20(%rbx), %rcx
movq -0x8(%rsi,%rcx,8), %rcx
movl %eax, 0x38(%rcx)
movslq 0x20(%rbx), %rax
movq -0x8(%rsi,%rax,8), %rax
movl %edx, 0x3c(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/hash/sha256.c
// Function: sha256
char			*sha256(char *buf, char *to_hash)
{
	t_sha32bit	s;
	__uint32_t	w[64];
	int			i;

	i = -1;
	ft_bzero(&s, sizeof(t_sha32bit));
	sha32_set(to_hash, &s);
	s.hash[0] = 0x6a09e667;
	s.hash[1] = 0xbb67ae85;
	s.hash[2] = 0x3c6ef372;
	s.hash[3] = 0xa54ff53a;
	s.hash[4] = 0x510e527f;
	s.hash[5] = 0x9b05688c;
	s.hash[6] = 0x1f83d9ab;
	s.hash[7] = 0x5be0cd19;
	while (++i < s.multiples)
		sha32_cycle(i, &s, w, -1);
	to_hash = buf;
	ft_sprintf(to_hash, "%.8x%.8x%.8x%.8x%.8x%.8x%.8x%.8x",
		s.hash[0], s.hash[1], s.hash[2], s.hash[3],
		s.hash[4], s.hash[5], s.hash[6], s.hash[7]);
	free_message(s.multiples, (__uint64_t **)s.message);
	free(s.message);
	return (to_hash);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movl $0x50, %esi
movq %r15, %rdi
callq 0x7370
movq %r14, %rdi
movq %r15, %rsi
callq 0x6122
movaps 0x71a6(%rip), %xmm0     # 0xd430
movaps %xmm0, (%r15)
movaps 0x71ab(%rip), %xmm0     # 0xd440
movaps %xmm0, 0x10(%r15)
cmpl $0x0, 0x20(%r15)
jle 0x62ec
xorl %ebp, %ebp
movq %rsp, %r14
leaq 0x50(%rsp), %r15
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x5f74
incl %ebp
cmpl 0x20(%rsp), %ebp
jl 0x62ab
movl (%rsp), %edx
movl 0x4(%rsp), %ecx
movl 0x8(%rsp), %r8d
movl 0xc(%rsp), %r9d
movl 0x10(%rsp), %r10d
movl 0x14(%rsp), %r11d
movl 0x18(%rsp), %r14d
movl 0x1c(%rsp), %r15d
jmp 0x631a
movl $0x6a09e667, %edx       # imm = 0x6A09E667
movl $0xbb67ae85, %ecx       # imm = 0xBB67AE85
movl $0x3c6ef372, %r8d       # imm = 0x3C6EF372
movl $0xa54ff53a, %r9d       # imm = 0xA54FF53A
movl $0x510e527f, %r10d      # imm = 0x510E527F
movl $0x9b05688c, %r11d      # imm = 0x9B05688C
movl $0x1f83d9ab, %r14d      # imm = 0x1F83D9AB
movl $0x5be0cd19, %r15d      # imm = 0x5BE0CD19
leaq 0x712f(%rip), %rsi      # 0xd450
movq %rbx, %rdi
xorl %eax, %eax
pushq %r15
pushq %r14
pushq %r11
pushq %r10
callq 0x7a1c
addq $0x20, %rsp
movl 0x20(%rsp), %edi
movq 0x48(%rsp), %rsi
callq 0x7128
movq 0x48(%rsp), %rdi
callq 0x1030
movq %rbx, %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/hash/sha384.c
// Function: sha384
char			*sha384(char *buf, char *to_hash)
{
	t_sha64bit	s;
	__uint64_t	w[80];
	int			i;

	i = -1;
	ft_bzero(&s, sizeof(t_sha64bit));
	sha64_start(to_hash, &s);
	s.hash[0] = 0xcbbb9d5dc1059ed8;
	s.hash[1] = 0x629a292a367cd507;
	s.hash[2] = 0x9159015a3070dd17;
	s.hash[3] = 0x152fecd8f70e5939;
	s.hash[4] = 0x67332667ffc00b31;
	s.hash[5] = 0x8eb44a8768581511;
	s.hash[6] = 0xdb0c2e0d64f98fa7;
	s.hash[7] = 0x47b5481dbefa4fa4;
	while (++i < (s.multiples))
		sha64_cycle(i, &s, w, -1);
	to_hash = buf;
	ft_sprintf(to_hash,
		"%.16llx%.16llx%.16llx%.16llx%.16llx%.16llx",
		s.hash[0], s.hash[1], s.hash[2], s.hash[3],
		s.hash[4], s.hash[5]);
	free_message(s.multiples, s.message);
	free(s.message);
	return (to_hash);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x328, %rsp            # imm = 0x328
movq %rsi, %rbp
movq %rdi, 0x8(%rsp)
movabsq $-0x6ea6fea5cf8f22e9, %r15 # imm = 0x9159015A3070DD17
movabsq $-0x714bb57897a7eaef, %r14 # imm = 0x8EB44A8768581511
movabsq $0x629a292a367cd507, %r12 # imm = 0x629A292A367CD507
movabsq $0x152fecd8f70e5939, %r13 # imm = 0x152FECD8F70E5939
leaq 0x10(%rsp), %rbx
movl $0x90, %esi
movq %rbx, %rdi
callq 0x7370
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x6668
movabsq $-0x344462a23efa6128, %rdx # imm = 0xCBBB9D5DC1059ED8
movabsq $0x67332667ffc00b31, %r10 # imm = 0x67332667FFC00B31
movq %rdx, (%rbx)
movq %r12, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq %r13, 0x18(%rbx)
movq %r10, 0x20(%rbx)
movq %r14, 0x28(%rbx)
movabsq $-0x24f3d1f29b067059, %rax # imm = 0xDB0C2E0D64F98FA7
movq %rax, 0x30(%rbx)
movabsq $0x47b5481dbefa4fa4, %rax # imm = 0x47B5481DBEFA4FA4
movq %rax, 0x38(%rbx)
cmpl $0x0, 0x40(%rbx)
jle 0x6452
xorl %ebp, %ebp
leaq 0x10(%rsp), %r14
leaq 0xa0(%rsp), %r15
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x64ac
incl %ebp
cmpl 0x50(%rsp), %ebp
jl 0x641a
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %r12
movq 0x20(%rsp), %r15
movq 0x28(%rsp), %r13
movq 0x30(%rsp), %r10
movq 0x38(%rsp), %r14
leaq 0x7135(%rip), %rsi      # 0xd58e
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rcx
movq %r15, %r8
movq %r13, %r9
xorl %eax, %eax
pushq %r14
pushq %r10
callq 0x7a1c
addq $0x10, %rsp
movl 0x50(%rsp), %edi
movq 0x98(%rsp), %rsi
callq 0x7128
movq 0x98(%rsp), %rdi
callq 0x1030
movq %rbx, %rax
addq $0x328, %rsp            # imm = 0x328
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq