LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x7cd6(%rip), %rsi      # 0xbef3
callq 0x70f4
testl %eax, %eax
je 0x428d
leaq 0x7ccd(%rip), %rsi      # 0xbefa
movq %rbx, %rdi
callq 0x70f4
testl %eax, %eax
je 0x4291
leaq 0x7cb6(%rip), %rsi      # 0xbef6
movq %rbx, %rdi
callq 0x70f4
testl %eax, %eax
je 0x4295
leaq 0x7c2e(%rip), %rsi      # 0xbe81
movq %rbx, %rdi
callq 0x70f4
testl %eax, %eax
je 0x4299
leaq 0x7c9b(%rip), %rsi      # 0xbf01
movq %rbx, %rdi
callq 0x70f4
testl %eax, %eax
je 0x429d
leaq 0x7c90(%rip), %rsi      # 0xbf09
movq %rbx, %rdi
callq 0x70f4
xorl %ecx, %ecx
testl %eax, %eax
pushq $0x2a
popq %rax
cmovnel %ecx, %eax
jmp 0x42a0
pushq $0x1f
jmp 0x429f
pushq $0x20
jmp 0x429f
pushq $0x21
jmp 0x429f
pushq $0x24
jmp 0x429f
pushq $0x29
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7c61(%rip), %rsi      # 0xbf0e
callq 0x70f4
testl %eax, %eax
je 0x4348
leaq 0x7c56(%rip), %rsi      # 0xbf17
movq %rbx, %rdi
callq 0x70f4
testl %eax, %eax
je 0x434c
leaq 0x7c4c(%rip), %rsi      # 0xbf20
movq %rbx, %rdi
callq 0x70f4
testl %eax, %eax
je 0x4350
leaq 0x7c42(%rip), %rsi      # 0xbf29
movq %rbx, %rdi
callq 0x70f4
testl %eax, %eax
je 0x4354
leaq 0x7c34(%rip), %rsi      # 0xbf2e
movq %rbx, %rdi
callq 0x70f4
testl %eax, %eax
je 0x4358
leaq 0x7c29(%rip), %rsi      # 0xbf36
movq %rbx, %rdi
callq 0x70f4
testl %eax, %eax
je 0x435c
leaq 0x7c1e(%rip), %rsi      # 0xbf3e
movq %rbx, %rdi
callq 0x70f4
testl %eax, %eax
je 0x4360
leaq 0x7c13(%rip), %rsi      # 0xbf46
movq %rbx, %rdi
callq 0x70f4
testl %eax, %eax
je 0x4364
movq %rbx, %rdi
popq %rbx
jmp 0x4212
pushq $0x1c
jmp 0x4366
pushq $0x1b
jmp 0x4366
pushq $0x1a
jmp 0x4366
pushq $0x19
jmp 0x4366
pushq $0x18
jmp 0x4366
pushq $0x17
jmp 0x4366
pushq $0x16
jmp 0x4366
pushq $0x15
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4383
incq %rax
jmp 0x4376
movb $0x0, (%rax)
leaq 0x7c8a(%rip), %rsi      # 0xc017
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x4431
leaq 0x7ba6(%rip), %rsi      # 0xbf4a
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x443a
leaq 0x7b96(%rip), %rsi      # 0xbf51
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x4443
leaq 0x7b8a(%rip), %rsi      # 0xbf58
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x444c
leaq 0x7b7e(%rip), %rsi      # 0xbf5f
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x4455
leaq 0x7b72(%rip), %rsi      # 0xbf66
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x445e
leaq 0x7ac5(%rip), %rsi      # 0xbecc
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x4467
xorl %eax, %eax
cmpl $0x0, 0x8(%rbx)
jne 0x4470
movq %r14, %rdi
callq 0x42a2
movl %eax, %ecx
movl %eax, 0x8(%rbx)
xorl %eax, %eax
testl %ecx, %ecx
sete %al
jmp 0x4470
movl $0x1, 0x8(%rbx)
jmp 0x446e
movl $0x2, 0x8(%rbx)
jmp 0x446e
movl $0x3, 0x8(%rbx)
jmp 0x446e
movl $0x4, 0x8(%rbx)
jmp 0x446e
movl $0x5, 0x8(%rbx)
jmp 0x446e
movl $0x6, 0x8(%rbx)
jmp 0x446e
movl $0xb, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/util/reference.c
// Function: show_supported
void			show_supported(void)
{
	dprintf(2, "%sStandard commands%s:\n", UWHT, NOCOL);
	dprintf(2, "genrsa\t\tprime\t\trand\n");
	dprintf(2, "rsa\t\trsautl\t\tversion\n\n");
	dprintf(2, "%sMessage Digest Commands%s:\n", UWHT, NOCOL);
	dprintf(2, "md5\t\tsha1\t\tsha224\t\tsha256\n");
	dprintf(2, "sha384\t\tsha512\n\n");
	dprintf(2, "%sCipher Commands%s:\n", UWHT, NOCOL);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x7ae8(%rip), %rsi      # 0xbf6b
leaq 0x7af9(%rip), %rbx      # 0xbf83
leaq 0x6dce(%rip), %r14      # 0xb25f
pushq $0x2
popq %rbp
movl %ebp, %edi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1080
leaq 0x7ae1(%rip), %rsi      # 0xbf8b
movl %ebp, %edi
xorl %eax, %eax
callq 0x1080
leaq 0x7ae6(%rip), %rsi      # 0xbfa0
movl %ebp, %edi
xorl %eax, %eax
callq 0x1080
leaq 0x7aed(%rip), %rsi      # 0xbfb7
movl %ebp, %edi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1080
leaq 0x7af5(%rip), %rsi      # 0xbfd5
movl %ebp, %edi
xorl %eax, %eax
callq 0x1080
leaq 0x7b00(%rip), %rsi      # 0xbff0
movl %ebp, %edi
xorl %eax, %eax
callq 0x1080
leaq 0x7b01(%rip), %rsi      # 0xc001
movl %ebp, %edi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1080
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x4533
cmpq $0x0, 0x38(%rdi)
je 0x4539
testl %edx, %edx
jne 0x453f
cmpq $0x0, 0x40(%rdi)
jne 0x453f
addq $0x40, %rdi
jmp 0x458d
addq $0x10, %rdi
jmp 0x458d
addq $0x38, %rdi
jmp 0x458d
testl %edx, %edx
jne 0x4549
cmpq $0x0, (%rdi)
je 0x458d
testl %edx, %edx
jne 0x455a
cmpq $0x0, 0x8(%rdi)
jne 0x455a
addq $0x8, %rdi
jmp 0x458d
testl %edx, %edx
jne 0x456b
cmpq $0x0, 0x20(%rdi)
jne 0x456b
addq $0x20, %rdi
jmp 0x458d
testl %edx, %edx
jne 0x457c
cmpq $0x0, 0x28(%rdi)
jne 0x457c
addq $0x28, %rdi
jmp 0x458d
xorl %eax, %eax
testl %edx, %edx
jne 0x4593
cmpq $0x0, 0x30(%rdi)
jne 0x4593
addq $0x30, %rdi
movq %rsi, (%rdi)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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)
pushq $-0x1
popq %r12
movq %rdi, %rax
incl %r12d
cmpb $0x2, (%rax)
leaq 0x1(%rax), %rax
jne 0x45b4
leaq 0x2(%r15), %r13
cmpl %ebp, %r12d
jge 0x4606
movslq %r12d, %rax
leaq 0x1(%rax), %r12
cmpb $0x2, (%r15,%rax)
jne 0x45c4
movzbl (%r15,%r12), %ecx
addq %r13, %rax
xorl %edx, %edx
xorl %esi, %esi
cmpl %edx, %ecx
je 0x45f7
shlq $0x8, %rsi
movzbl (%rax,%rdx), %edi
orq %rdi, %rsi
incq %rdx
jmp 0x45e3
addl %ecx, %r12d
movq %r14, %rdi
movl %ebx, %edx
callq 0x4514
jmp 0x45c4
movq %rsp, %rdi
callq 0x71f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/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
pushq $0x4
popq %rdx
movq %r15, %rsi
callq 0x1a1e
movzbl 0x1(%r15), %ecx
cvtsi2sd %ecx, %xmm0
divsd 0x69c2(%rip), %xmm0     # 0xb018
mulsd 0x79c2(%rip), %xmm0     # 0xc020
cvtsd2ss %xmm0, %xmm0
movl %eax, %r15d
movss %xmm0, 0x10(%rsp)
cvttss2si %xmm0, %eax
movslq %eax, %r12
movq %r12, %rdi
callq 0x6731
movq %rax, 0x8(%rsp)
movslq %r15d, %r13
leaq (%rbx,%r13), %rdi
movq %rax, %rsi
movl %r12d, %edx
callq 0x1a1e
addl %eax, %r13d
movslq %r13d, %r12
cmpb $0x2d, 0x1(%rbx,%r12)
je 0x46bd
leaq 0x7703(%rip), %rdi      # 0xbda9
xorl %r15d, %r15d
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x67f0
testl %eax, %eax
jne 0x4792
leaq 0x1(%r12), %r15
pushq $0x2d
popq %rsi
movq %rbx, %rdi
callq 0x70af
cmpl $0x40, %r12d
jg 0x46db
decl %eax
testb $0x3, %al
jne 0x46f0
jmp 0x471c
cmpl %eax, %r15d
jne 0x46f0
movl %r13d, %eax
shrl $0x6, %eax
movl %r13d, %ecx
subl %eax, %ecx
testb $0x3, %cl
je 0x471c
xorl %edi, %edi
cmpl $0x1, %ebp
adcl $0x7, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2608
testl %eax, %eax
je 0x471c
leaq 0x769d(%rip), %rdi      # 0xbda9
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x67f0
testl %eax, %eax
jne 0x4776
cvtss2sd 0x10(%rsp), %xmm0
mulsd 0x78fe(%rip), %xmm0     # 0xc028
mulsd 0x68e6(%rip), %xmm0     # 0xb018
cvttpd2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movq 0x8(%rsp), %rdi
cvttss2si %xmm0, %edx
movq %r14, %rsi
movl %ebp, %ecx
callq 0x4594
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x4514
testl %eax, %eax
je 0x477e
cmpl $0x1, %ebp
adcl $0xd, %r12d
movl %r12d, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2608
testl %eax, %eax
je 0x477e
movb $0x0, (%rbx)
xorl %r15d, %r15d
jmp 0x4792
cmpl $0x40, %r13d
jg 0x4792
pushq $0x2d
popq %rsi
movq %rbx, %rdi
callq 0x70af
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_O2/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 0x47bf
pushq $0x14
popq %rdi
jmp 0x48ec
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
andl $0x20, %ebx
movl $0x1000, %esi           # imm = 0x1000
callq 0x6720
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %r14, %rsi
callq 0x10a0
xorl %eax, %eax
testl %ebx, %ebx
sete %al
leaq 0x7859(%rip), %rcx      # 0xc04c
leaq 0x7836(%rip), %r13      # 0xc030
cmoveq %rcx, %r13
leaq (%rax,%rax,4), %r12
addq $0x1b, %r12
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x7110
testl %eax, %eax
je 0x4891
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x70af
movslq %eax, %rbp
addq %r14, %rbp
pushq $0x2d
popq %rsi
movq %rbp, %rdi
callq 0x70af
movslq %eax, %r14
addq %rbp, %r14
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x7110
testl %eax, %eax
je 0x4891
xorl %edi, %edi
cmpl $0x1, %ebx
adcl $0x9, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2608
testl %eax, %eax
je 0x4891
testl %ebx, %ebx
leaq 0x781a(%rip), %rax      # 0xc084
leaq 0x77fc(%rip), %rsi      # 0xc06d
cmoveq %rax, %rsi
leaq 0x6dbd(%rip), %rdi      # 0xb639
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6a50
cmpb $0x0, (%r14,%r12)
je 0x48e4
movl %ebx, %edx
shrl $0x5, %edx
addq %r12, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x461f
cltq
cmpb $0x0, (%r14,%rax)
je 0x4903
addq %rax, %r14
xorl %eax, %eax
testl %ebx, %ebx
sete %al
leaq 0x77f5(%rip), %rcx      # 0xc0ba
leaq 0x77d4(%rip), %rsi      # 0xc0a0
cmoveq %rcx, %rsi
leaq (%rax,%rax,4), %rdx
addq $0x19, %rdx
movq %r14, %rdi
callq 0x7110
testl %eax, %eax
je 0x4908
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 0x2608
pushq $0x1
popq %rax
jmp 0x490a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/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
pushq $0x48
popq %rsi
callq 0x6720
movl 0x1090(%rsp), %ebp
movl %ebp, %eax
notl %eax
testw $0x220, %ax             # imm = 0x220
jne 0x4956
pushq $0x13
popq %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2608
testl %eax, %eax
jne 0x4a70
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 0x47a4
testl %eax, %eax
jne 0x4a70
movq 0x10(%rbx), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x4998
incl %eax
shrq %rcx
jmp 0x498c
testl %r14d, %r14d
setne %cl
movl %eax, 0x8(%r15)
testb $0x4, %bpl
sete %al
orb %cl, %al
jne 0x49d4
leaq 0x18(%rsp), %rdi
pushq $0x9
popq %rcx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x4b17
movl (%r15), %ebp
testb %bpl, %bpl
jns 0x4a0f
leaq 0x60(%rsp), %r14
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
callq 0x6720
movq 0x10(%rbx), %rdx
leaq 0x76e3(%rip), %rsi      # 0xc0d9
movq %r14, %rdi
xorl %eax, %eax
callq 0x6dd0
movl 0xc(%r15), %esi
movq %r14, %rdi
callq 0x6d07
movl (%r15), %ebp
testb $0x10, %bpl
je 0x4a3c
leaq 0x18(%rsp), %rdi
pushq $0x9
popq %rcx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
pushq $0x63
popq %rdi
callq 0x4dd8
cmpl $0x0, 0x4(%r15)
jne 0x4a70
testb $0x8, (%r15)
jne 0x4a70
leaq 0x18(%rsp), %rdi
pushq $0x9
popq %rcx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
pushq $0x6f
popq %rdi
callq 0x4dd8
movq %rbx, %rax
addq $0x1068, %rsp           # imm = 0x1068
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x7655(%rip), %rdi      # 0xc0e7
xorl %eax, %eax
callq 0x6a50
movl 0x8(%rbx), %esi
leaq 0x7655(%rip), %rdi      # 0xc0f8
xorl %eax, %eax
callq 0x6a50
movl 0x18(%rsp), %esi
leaq 0x7654(%rip), %rdi      # 0xc109
xorl %eax, %eax
callq 0x6a50
movl 0x20(%rsp), %esi
leaq 0x7653(%rip), %rdi      # 0xc11a
xorl %eax, %eax
callq 0x6a50
movl 0x1c(%rsp), %esi
leaq 0x7652(%rip), %rdi      # 0xc12b
xorl %eax, %eax
callq 0x6a50
movl 0x24(%rsp), %esi
leaq 0x7651(%rip), %rdi      # 0xc13c
xorl %eax, %eax
callq 0x6a50
movl 0x10(%rsp), %esi
leaq 0x7650(%rip), %rdi      # 0xc14d
xorl %eax, %eax
callq 0x6a50
movl 0x14(%rsp), %esi
leaq 0x764f(%rip), %rdi      # 0xc15e
xorl %eax, %eax
popq %rbx
jmp 0x6a50
// File: /workspace/github_c_makefile_star2_O2/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 0x6720
leaq 0x1030(%rsp), %r15
movl (%r15), %ebp
movl 0x8(%r15), %ecx
andl $0x20, %ebp
testl %ebp, %ebp
leaq 0x7639(%rip), %rax      # 0xc188
leaq 0x762b(%rip), %rdx      # 0xc181
cmoveq %rax, %rdx
leaq 0x760e(%rip), %rsi      # 0xc16f
leaq 0x7659(%rip), %rax      # 0xc1c1
leaq 0x7658(%rip), %r14      # 0xc1c7
cmoveq %rax, %r14
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6dd0
movq %rbx, %rdi
callq 0x739e
leaq (%rsp,%rax), %rdi
movq 0x1058(%rsp), %rcx
leaq 0x75f8(%rip), %rsi      # 0xc190
movl %ebp, %edx
xorl $0x6d, %edx
movq %rcx, %r8
xorl %eax, %eax
callq 0x6dd0
movq %rbx, %rdi
callq 0x739e
leaq (%rsp,%rax), %rdi
movq 0x1080(%rsp), %rcx
leaq 0x75e6(%rip), %rsi      # 0xc1a8
movq %r14, %rdx
movq %rcx, %r8
xorl %eax, %eax
callq 0x6dd0
testl %ebp, %ebp
jne 0x4ca7
leaq 0x1048(%rsp), %r14
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x739e
leaq (%rsp,%rax), %rdi
movq 0x40(%r14), %rcx
leaq 0x75d0(%rip), %rsi      # 0xc1c9
movq %rcx, %rdx
xorl %eax, %eax
callq 0x6dd0
movq %rbx, %rdi
callq 0x739e
leaq (%rsp,%rax), %rdi
movq (%r14), %rcx
leaq 0x75cf(%rip), %rsi      # 0xc1e8
movq %rcx, %rdx
xorl %eax, %eax
callq 0x6dd0
movq %rbx, %rdi
callq 0x739e
leaq (%rsp,%rax), %rdi
movq 0x8(%r14), %rcx
leaq 0x75c4(%rip), %rsi      # 0xc1fe
movq %rcx, %rdx
xorl %eax, %eax
callq 0x6dd0
movq %rbx, %rdi
callq 0x739e
leaq (%rsp,%rax), %rdi
movq 0x20(%r14), %rcx
leaq 0x75b9(%rip), %rsi      # 0xc214
movq %rcx, %rdx
xorl %eax, %eax
callq 0x6dd0
movq %rbx, %rdi
callq 0x739e
leaq (%rsp,%rax), %rdi
movq 0x28(%r14), %rcx
leaq 0x75b1(%rip), %rsi      # 0xc22d
movq %rcx, %rdx
xorl %eax, %eax
callq 0x6dd0
movq %rbx, %rdi
callq 0x739e
leaq (%rsp,%rax), %rdi
movq 0x30(%r14), %rcx
leaq 0x75a9(%rip), %rsi      # 0xc246
movq %rcx, %rdx
xorl %eax, %eax
callq 0x6dd0
movl 0xc(%r15), %esi
movq %rsp, %rdi
callq 0x6d07
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6720
leaq 0x56(%rsp), %rdi
pushq $0xa
popq %rsi
callq 0x6720
andl $0x0, 0x50(%rsp)
movl 0x1080(%rsp), %ebp
pushq $0x9
popq %rcx
movq %rsp, %rdi
movq %rbx, %rsi
testb $0x60, %bpl
je 0x4d2f
rep  movsq (%rsi), %es:(%rdi)
leaq 0x60(%rsp), %rbx
leaq 0x56(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x15a5
xorl %eax, %eax
movb %al, 0x10(%rbx)
movb %al, 0x13(%rbx)
jmp 0x4d46
rep  movsq (%rsi), %es:(%rdi)
leaq 0x60(%rsp), %rdi
leaq 0x56(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x11ec
leaq 0x1080(%rsp), %rax
movslq 0x50(%rsp), %rcx
xorl %edx, %edx
cmpq %rcx, %rdx
jge 0x4d72
cmpb $0x2, 0x60(%rsp,%rdx)
jne 0x4d6d
cmpb $-0x1, 0x62(%rsp,%rdx)
jne 0x4d6d
movb $0x0, 0x62(%rsp,%rdx)
incq %rdx
jmp 0x4d55
movl 0xc(%rax), %ebx
testb $0x60, %bpl
leaq 0x72cc(%rip), %rax      # 0xc04c
leaq 0x72a9(%rip), %rdi      # 0xc030
cmoveq %rax, %rdi
leaq 0x7328(%rip), %rax      # 0xc0ba
leaq 0x7307(%rip), %r14      # 0xc0a0
cmoveq %rax, %r14
movl %ebx, %esi
callq 0x6d07
movl 0x50(%rsp), %esi
leaq 0x60(%rsp), %rdi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x1848
movq %r14, %rdi
movl %ebx, %esi
callq 0x6d07
cmpl $0x2, %ebx
jl 0x4dcc
movl %ebx, %edi
callq 0x1070
addq $0x1060, %rsp           # imm = 0x1060
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4e1a
movl %edi, %ebp
cmpl $0x6f, %edi
jne 0x4ef9
leaq 0x7462(%rip), %rdi      # 0xc261
pushq $0x2
popq %rsi
callq 0x6d07
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4cc1
leaq 0x58(%rsp), %r13
movq (%r13), %r14
movq 0x8(%r13), %rbx
movq %rbx, %rax
imulq %r14, %rax
cmpq 0x10(%r13), %rax
jne 0x4e38
xorl %ebp, %ebp
jmp 0x4e4c
movl 0xc(%r12), %esi
leaq 0x742e(%rip), %rdi      # 0xc272
callq 0x6d07
movb $0x1, %bpl
movss 0x6f90(%rip), %xmm0     # 0xbde4
movq %r14, %rdi
callq 0x33e7
testl %eax, %eax
jne 0x4e74
movl 0xc(%r12), %esi
leaq 0x742b(%rip), %rdi      # 0xc297
callq 0x6d07
movb $0x1, %bpl
movss 0x6f68(%rip), %xmm0     # 0xbde4
movq %rbx, %rdi
callq 0x33e7
testl %eax, %eax
jne 0x4e9c
movl 0xc(%r12), %esi
leaq 0x741f(%rip), %rdi      # 0xc2b3
callq 0x6d07
movb $0x1, %bpl
movq 0x30(%r13), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3615
cmpq $0x1, %rax
je 0x4ec5
movl 0xc(%r12), %esi
leaq 0x7412(%rip), %rdi      # 0xc2cf
callq 0x6d07
movb $0x1, %bpl
movq 0x20(%r13), %rdi
movq 0x38(%r13), %r15
decq %r14
movq %r15, %rsi
movq %r14, %rdx
callq 0x3615
cmpq $0x1, %rax
jne 0x4f0d
movq 0x28(%r13), %rdi
decq %rbx
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3615
cmpq $0x1, %rax
jne 0x4f0d
testb %bpl, %bpl
je 0x4f1b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0xc(%r12), %esi
leaq 0x73dc(%rip), %rdi      # 0xc2f5
jmp 0x4f27
movl 0xc(%r12), %esi
leaq 0x73f5(%rip), %rdi      # 0xc31c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6d07
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x4f61
leaq 0x73df(%rip), %rdi      # 0xc339
movl %ebx, %esi
callq 0x6d07
movslq %ebp, %r12
xorl %r13d, %r13d
leaq 0x73ba(%rip), %r15      # 0xc328
pushq $0x20
popq %rbp
cmpq $0x10, %r13
je 0x4fdd
cmpq %r12, %r13
jge 0x4fa6
movzbl (%r14,%r13), %eax
shrl $0x4, %eax
movsbl (%rax,%r15), %edi
movl %ebx, %esi
callq 0x6cf0
movzbl (%r14,%r13), %eax
andl $0xf, %eax
movsbl (%rax,%r15), %edi
movl %ebx, %esi
callq 0x6cf0
jmp 0x4fb4
leaq 0x7394(%rip), %rdi      # 0xc341
movl %ebx, %esi
callq 0x6d07
leal 0x1(%r13), %eax
testb $0x7, %al
jne 0x4fcf
cmpq $0x7, %r13
movl %ebp, %edi
pushq $0x2d
popq %rax
cmovel %eax, %edi
movl %ebx, %esi
callq 0x6cf0
movl %ebp, %edi
movl %ebx, %esi
callq 0x6cf0
incq %r13
jmp 0x4f71
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/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 %r12
pushq %rbx
subq $0x10, %rsp
movq 0x68(%rsp), %rbx
testq %rbx, %rbx
je 0x50d9
leaq 0x58(%rsp), %r12
leaq 0x40(%rsp), %r15
movq %rsp, %rdi
pushq $0x10
popq %rsi
callq 0x6720
xorl %ebp, %ebp
movq %rbx, %rax
testq %rax, %rax
je 0x502c
incl %ebp
shrq %rax
jmp 0x5020
movl 0x10(%r15), %edi
movq %rsp, %rsi
pushq $0xf
popq %rdx
callq 0x10a0
movq %rax, %r14
shrl $0x3, %ebp
cmpl %r14d, %ebp
jne 0x5073
movq 0x38(%r12), %rax
movq 0x40(%r12), %rsi
movl (%r15), %r12d
movl 0xc(%r15), %ebp
movl %r14d, %r15d
xorl %ecx, %ecx
xorl %edi, %edi
cmpq %rcx, %r15
je 0x5087
shlq $0x8, %rdi
movzbl (%rsp,%rcx), %edx
incq %rcx
orq %rdx, %rdi
jmp 0x505e
setle %al
movzbl %al, %edi
addl $0x15, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2608
jmp 0x50d9
btl $0x9, %r12d
cmovaeq %rax, %rsi
movq %rbx, %rdx
callq 0x3675
movq %rax, %rbx
leal -0x8(,%r14,8), %esi
btl $0xa, %r12d
jb 0x50cc
movslq %esi, %r14
subq $0x1, %r15
jb 0x50d9
movq %rbx, %rax
movl %r14d, %ecx
shrq %cl, %rax
movsbl %al, %edi
movl %ebp, %esi
callq 0x6cf0
addq $-0x8, %r14
jmp 0x50ad
movl %ebp, %edi
movl %r14d, %edx
movq %rbx, %rcx
callq 0x50e6
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/rsa/rsautl.c
// Function: hex_dump
static void		hex_dump(int fd, int size, int len, __uint64_t msg)
{
	__uint8_t	s[len];
	int			i;
	int			j;

	i = 0;
	s[len] = 0;
	while (i < len)
	{
		s[i] = (char)(msg >> (size - (i * 8)));
		++i;
	}
	i = 0;
	while (i < len)
	{
		print_row_hex(i, len - i, s + i, fd);
		j = 0;
		while (j < 16 && j < len - i)
		{
			ft_putchar_fd(ft_isprint(s[i + j]) ? s[i + j] : '.', fd);
			j++;
		}
		ft_putchar_fd('\n', fd);
		i += 16;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rax
movl %edi, %r14d
movl %edx, %ecx
movq %rsp, %r9
addq $0xf, %rcx
andq $-0x10, %rcx
subq %rcx, %r9
movq %r9, %rsp
movslq %edx, %rdi
movb $0x0, (%rdi,%r9)
movslq %esi, %rcx
xorl %r8d, %r8d
movq %rdi, -0x40(%rbp)
testl %edi, %edi
movl $0x0, %esi
movl %edx, -0x2c(%rbp)
cmovgl %edx, %esi
cmpq %r8, %rsi
je 0x5147
movq %rax, %rdi
shrq %cl, %rdi
movb %dil, (%r9,%r8)
incq %r8
addq $-0x8, %rcx
jmp 0x512f
xorl %edi, %edi
movq %r9, %r12
movq %r9, -0x38(%rbp)
movq -0x40(%rbp), %r15
subq %rdi, %r15
jle 0x51bf
movl -0x2c(%rbp), %esi
subl %edi, %esi
leaq (%r9,%rdi), %rdx
movq %rdi, -0x48(%rbp)
movl %r14d, %ecx
callq 0x4f3c
xorl %ebx, %ebx
cmpq $0xf, %rbx
ja 0x51a2
cmpq %r15, %rbx
jge 0x51a2
movzbl (%r12,%rbx), %r13d
movl %r13d, %edi
callq 0x6708
pushq $0x2e
popq %rcx
testl %eax, %eax
je 0x5192
movl %r13d, %ecx
movsbl %cl, %edi
movl %r14d, %esi
callq 0x6cf0
incq %rbx
jmp 0x5170
pushq $0xa
popq %rdi
movl %r14d, %esi
callq 0x6cf0
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
addq $0x10, %r12
movq -0x38(%rbp), %r9
jmp 0x5150
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/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
movq %rdx, %r8
movslq %edi, %rax
movslq %ecx, %rcx
cmpq $0xf, %rcx
jge 0x51ff
movq 0x48(%rsi), %rdx
movq (%rdx,%rax,8), %rdx
movl 0x4(%rdx,%rcx,4), %edx
movl %edx, 0x4(%r8,%rcx,4)
incq %rcx
jmp 0x51e3
xorl %eax, %eax
cmpq $0x40, %rax
je 0x5226
movl 0x20(%r8,%rax,4), %ecx
xorl 0x34(%r8,%rax,4), %ecx
xorl 0x8(%r8,%rax,4), %ecx
xorl (%r8,%rax,4), %ecx
roll %ecx
movl %ecx, 0x40(%r8,%rax,4)
incq %rax
jmp 0x5201
movl (%rsi), %ebx
movl 0x4(%rsi), %r9d
movl %ebx, 0x24(%rsi)
movl %r9d, 0x28(%rsi)
movl 0x8(%rsi), %ecx
movl %ecx, 0x2c(%rsi)
movl 0xc(%rsi), %ebp
movl %ebp, 0x30(%rsi)
movl 0x10(%rsi), %eax
movl %eax, 0x34(%rsi)
movl $0xffffffd8, %r14d      # imm = 0xFFFFFFD8
xorl %edi, %edi
movl $0x14, %r12d
leaq 0x7106(%rip), %r13      # 0xc360
movl %eax, -0x4(%rsp)
movl %ebx, %r10d
movl %ebp, -0x8(%rsp)
movl %ecx, %r11d
movl %r9d, -0xc(%rsp)
movl %r9d, %r15d
movl %r10d, %r9d
cmpq $0x50, %rdi
je 0x5300
cmpq $0x13, %rdi
ja 0x528d
movl %r11d, %edx
xorl %ebp, %edx
andl %r15d, %edx
jmp 0x52b4
movl %r14d, %edx
addl $0x14, %edx
jb 0x52ae
cmpl $0x13, %r14d
ja 0x52ae
movl %ebp, %r10d
orl %r11d, %r10d
andl %r15d, %r10d
movl %ebp, %edx
andl %r11d, %edx
orl %r10d, %edx
jmp 0x52b6
movl %r11d, %edx
xorl %r15d, %edx
xorl %ebp, %edx
movl %edx, 0x38(%rsi)
movl %r9d, %r10d
roll $0x5, %r10d
addl %eax, %r10d
addl %edx, %r10d
movl %edi, %eax
xorl %edx, %edx
divl %r12d
addl (%r13,%rax,4), %r10d
addl (%r8,%rdi,4), %r10d
movl %ebp, 0x34(%rsi)
movl %r11d, 0x30(%rsi)
roll $0x1e, %r15d
movl %r15d, 0x2c(%rsi)
movl %r9d, 0x28(%rsi)
movl %r10d, 0x24(%rsi)
incl %r14d
incq %rdi
movl %ebp, %eax
movl %r11d, %ebp
movl %r15d, %r11d
jmp 0x526d
addl %ebx, %r9d
movl %r9d, (%rsi)
addl -0xc(%rsp), %r15d
movl %r15d, 0x4(%rsi)
addl %ecx, %r11d
movl %r11d, 0x8(%rsi)
addl -0x8(%rsp), %ebp
movl %ebp, 0xc(%rsi)
addl -0x4(%rsp), %eax
movl %eax, 0x10(%rsi)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/hash/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 %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
pushq $0x50
popq %rsi
movq %r14, %rdi
callq 0x6720
movq %r15, %rdi
movq %r14, %rsi
callq 0x5634
movaps 0x6fea(%rip), %xmm0     # 0xc350
movaps %xmm0, (%r14)
movl $0xc3d2e1f0, 0x10(%r14) # imm = 0xC3D2E1F0
xorl %ebp, %ebp
leaq 0x60(%rsp), %r15
pushq $-0x1
popq %r12
cmpl 0x30(%rsp), %ebp
jge 0x5397
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
movl %r12d, %ecx
callq 0x51d0
incl %ebp
jmp 0x537d
movl 0x10(%rsp), %edx
movl 0x14(%rsp), %ecx
movl 0x18(%rsp), %r8d
movl 0x1c(%rsp), %r9d
movl 0x20(%rsp), %eax
movl %eax, (%rsp)
leaq 0x7005(%rip), %rsi      # 0xc3bc
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6dd0
movl 0x30(%rsp), %edi
movq 0x58(%rsp), %rsi
callq 0x6525
movq 0x58(%rsp), %rdi
callq 0x1030
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r14
pushq $0x50
popq %rsi
movq %r14, %rdi
callq 0x6720
movq %r15, %rdi
movq %r14, %rsi
callq 0x5634
movaps 0x6f4f(%rip), %xmm0     # 0xc370
movaps %xmm0, (%r14)
movaps 0x6f54(%rip), %xmm0     # 0xc380
movaps %xmm0, 0x10(%r14)
xorl %ebp, %ebp
leaq 0x50(%rsp), %r15
pushq $-0x1
popq %r12
cmpl 0x20(%rsp), %ebp
jge 0x5456
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
movl %r12d, %ecx
callq 0x54c0
incl %ebp
jmp 0x543c
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
subq $0x8, %rsp
leaq 0x6f33(%rip), %rsi      # 0xc3b4
movq %rbx, %rdi
xorl %eax, %eax
pushq %r14
pushq %r11
pushq %r10
callq 0x6dd0
addq $0x20, %rsp
movl 0x20(%rsp), %edi
movq 0x48(%rsp), %rsi
callq 0x6525
movq 0x48(%rsp), %rdi
callq 0x1030
movq %rbx, %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movslq %edi, %rax
movslq %ecx, %rcx
cmpq $0xf, %rcx
jge 0x54f6
movq 0x48(%rbx), %rdx
movq (%rdx,%rax,8), %rdx
movl 0x4(%rdx,%rcx,4), %edx
movl %edx, 0x4(%r12,%rcx,4)
incq %rcx
jmp 0x54da
pushq $0x10
popq %r14
cmpq $0x40, %r14
je 0x552e
movl -0x40(%r12,%r14,4), %r15d
movl -0x3c(%r12,%r14,4), %edi
callq 0x2cff
movl %eax, %ebp
addl %r15d, %ebp
addl -0x1c(%r12,%r14,4), %ebp
movl -0x8(%r12,%r14,4), %edi
callq 0x2d11
addl %ebp, %eax
movl %eax, (%r12,%r14,4)
incq %r14
jmp 0x54fa
movq %r12, 0x8(%rsp)
movl (%rbx), %eax
movl 0x4(%rbx), %ecx
movl %eax, 0x24(%rbx)
movl %ecx, 0x28(%rbx)
movl 0x8(%rbx), %r12d
movl %r12d, 0x2c(%rbx)
movl 0xc(%rbx), %edx
movl %edx, 0x30(%rbx)
movl 0x10(%rbx), %ebp
movl %ebp, 0x34(%rbx)
movl 0x14(%rbx), %r14d
movl %r14d, 0x38(%rbx)
movl 0x18(%rbx), %edi
movl %edi, 0x3c(%rbx)
movl 0x1c(%rbx), %r15d
movl %r15d, 0x40(%rbx)
xorl %r13d, %r13d
cmpq $0x100, %r13            # imm = 0x100
je 0x560b
movl %r12d, %edx
xorl %ecx, %edx
andl %eax, %edx
andl %ecx, %r12d
xorl %edx, %r12d
movq %r13, 0x10(%rsp)
movl %edi, %r13d
movl %ebp, %edi
callq 0x2ced
xorl %r13d, %r14d
andl %ebp, %r14d
xorl %r13d, %r14d
movq 0x10(%rsp), %r13
addl %eax, %r15d
addl %r14d, %r15d
leaq 0x6e31(%rip), %rax      # 0xc3e0
addl (%r13,%rax), %r15d
movq 0x8(%rsp), %rax
addl (%rax,%r13), %r15d
movl 0x24(%rbx), %edi
callq 0x2cdb
movl 0x3c(%rbx), %esi
movl %esi, 0x40(%rbx)
movl 0x38(%rbx), %edi
movl %edi, 0x3c(%rbx)
movl 0x34(%rbx), %r14d
movl %r14d, 0x38(%rbx)
movl 0x30(%rbx), %ebp
addl %r15d, %ebp
movl %ebp, 0x34(%rbx)
movl 0x2c(%rbx), %edx
movl %edx, 0x30(%rbx)
movl 0x24(%rbx), %ecx
addl %r12d, %eax
movl 0x28(%rbx), %r12d
movl %r12d, 0x2c(%rbx)
movl %ecx, 0x28(%rbx)
addl %r15d, %eax
movl %eax, 0x24(%rbx)
addq $0x4, %r13
movl %esi, %r15d
jmp 0x556b
addl %eax, (%rbx)
addl %ecx, 0x4(%rbx)
addl %r12d, 0x8(%rbx)
addl %edx, 0xc(%rbx)
addl %ebp, 0x10(%rbx)
addl %r14d, 0x14(%rbx)
addl %edi, 0x18(%rbx)
addl %r15d, 0x1c(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/srcs/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 %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x739e
leaq 0x40(,%rax,8), %r12
shlq $0x1a, %rax
addq $0x20000000, %rax       # imm = 0x20000000
leal -0x3f(%r12), %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
addq $0x800000, %rax         # imm = 0x800000
incq %r12
cmpl $0x1c0, %ecx            # imm = 0x1C0
jne 0x565a
shrq $0x9, %r12
movl %r12d, 0x20(%rbx)
sarq $0x1d, %rax
movq %rax, %rdi
callq 0x10b0
movq %rax, 0x48(%rbx)
xorl %r13d, %r13d
pushq $0x40
popq %r15
movslq %r12d, %rax
cmpq %rax, %r13
jge 0x56c6
movq %r15, %rdi
callq 0x10b0
movq 0x48(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x48(%rbx), %rax
movq (%rax,%r13,8), %rdi
movq %r15, %rsi
callq 0x6720
movl 0x20(%rbx), %r12d
incq %r13
jmp 0x5695
movq %r14, %rdi
callq 0x739e
xorl %esi, %esi
xorl %edi, %edi
xorl %r8d, %r8d
movl %edi, %r9d
cmpq %r8, %rax
je 0x571e
movsbl (%r14,%r8), %r10d
movl %esi, %edx
andb $0x18, %dl
movl %edx, %ecx
xorb $0x18, %cl
shll %cl, %r10d
movl %edx, %ecx
shll %cl, %r10d
shrl %cl, %r10d
movq 0x48(%rbx), %rcx
movq (%rcx,%r9,8), %rcx
movl %r8d, %edx
andl $0x3c, %edx
orl %r10d, (%rcx,%rdx)
incq %r8
movl %r8d, %ecx
andl $0x3f, %ecx
cmpq $0x1, %rcx
adcl $0x0, %edi
addl $0x8, %esi
jmp 0x56d5
leal (,%rax,8), %edx
movl %edx, %ecx
notb %cl
andb $0x18, %cl
movl $0x80, %esi
shll %cl, %esi
movq 0x48(%rbx), %rcx
movq (%rcx,%r9,8), %rdi
movl %eax, %r8d
andl $0x3c, %r8d
orl %esi, (%rdi,%r8)
shrq $0x1d, %rax
movslq 0x20(%rbx), %rsi
movq -0x8(%rcx,%rsi,8), %rsi
movl %eax, 0x38(%rsi)
movslq 0x20(%rbx), %rax
movq -0x8(%rcx,%rax,8), %rax
movl %edx, 0x3c(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r14
pushq $0x50
popq %rsi
movq %r14, %rdi
callq 0x6720
movq %r15, %rdi
movq %r14, %rsi
callq 0x5634
movaps 0x6bef(%rip), %xmm0     # 0xc390
movaps %xmm0, (%r14)
movaps 0x6bf4(%rip), %xmm0     # 0xc3a0
movaps %xmm0, 0x10(%r14)
xorl %ebp, %ebp
leaq 0x50(%rsp), %r15
pushq $-0x1
popq %r12
cmpl 0x20(%rsp), %ebp
jge 0x57d6
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
movl %r12d, %ecx
callq 0x54c0
incl %ebp
jmp 0x57bc
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
leaq 0x6bae(%rip), %rsi      # 0xc3b0
movq %rbx, %rdi
xorl %eax, %eax
pushq %r15
pushq %r14
pushq %r11
pushq %r10
callq 0x6dd0
addq $0x20, %rsp
movl 0x20(%rsp), %edi
movq 0x48(%rsp), %rsi
callq 0x6525
movq 0x48(%rsp), %rdi
callq 0x1030
movq %rbx, %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x320, %rsp            # imm = 0x320
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movl $0x90, %esi
movq %r14, %rdi
callq 0x6720
movq %r15, %rdi
movq %r14, %rsi
callq 0x5b0c
movabsq $-0x344462a23efa6128, %rax # imm = 0xCBBB9D5DC1059ED8
movq %rax, (%r14)
movabsq $0x629a292a367cd507, %rax # imm = 0x629A292A367CD507
movq %rax, 0x8(%r14)
movabsq $-0x6ea6fea5cf8f22e9, %rax # imm = 0x9159015A3070DD17
movq %rax, 0x10(%r14)
movabsq $0x152fecd8f70e5939, %rax # imm = 0x152FECD8F70E5939
movq %rax, 0x18(%r14)
movabsq $0x67332667ffc00b31, %rax # imm = 0x67332667FFC00B31
movq %rax, 0x20(%r14)
movabsq $-0x714bb57897a7eaef, %rax # imm = 0x8EB44A8768581511
movq %rax, 0x28(%r14)
movabsq $-0x24f3d1f29b067059, %rax # imm = 0xDB0C2E0D64F98FA7
movq %rax, 0x30(%r14)
movabsq $0x47b5481dbefa4fa4, %rax # imm = 0x47B5481DBEFA4FA4
movq %rax, 0x38(%r14)
xorl %ebp, %ebp
leaq 0xa0(%rsp), %r15
pushq $-0x1
popq %r12
cmpl 0x50(%rsp), %ebp
jge 0x590d
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
movl %r12d, %ecx
callq 0x596c
incl %ebp
jmp 0x58f3
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x28(%rsp), %r9
movups 0x30(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x6bbd(%rip), %rsi      # 0xc4ee
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6dd0
movl 0x50(%rsp), %edi
movq 0x98(%rsp), %rsi
callq 0x6525
movq 0x98(%rsp), %rdi
callq 0x1030
movq %rbx, %rax
addq $0x320, %rsp            # imm = 0x320
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq