LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x60, %rsp
leaq 0x98(%rsp), %rbx
leaq 0x80(%rsp), %r14
cmpl $0x63, %edi
je 0x5247
movl %edi, %ebp
cmpl $0x6f, %edi
jne 0x532a
leaq 0x8067(%rip), %rdi      # 0xd279
movl $0x2, %esi
callq 0x7225
leaq 0x18(%rsp), %rdi
movl $0x9, %ecx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
callq 0x50bd
jmp 0x5327
movq 0x8(%rbx), %rax
imulq (%rbx), %rax
cmpq 0x10(%rbx), %rax
jne 0x5259
xorl %ebp, %ebp
jmp 0x526c
movl 0xc(%r14), %esi
leaq 0x8026(%rip), %rdi      # 0xd28a
callq 0x7225
movb $0x1, %bpl
movq (%rbx), %rdi
movss 0x7b89(%rip), %xmm0     # 0xce00
callq 0x3654
testl %eax, %eax
jne 0x5293
movl 0xc(%r14), %esi
leaq 0x8024(%rip), %rdi      # 0xd2af
callq 0x7225
movb $0x1, %bpl
movq 0x8(%rbx), %rdi
movss 0x7b61(%rip), %xmm0     # 0xce00
callq 0x3654
testl %eax, %eax
jne 0x52bb
movl 0xc(%r14), %esi
leaq 0x8018(%rip), %rdi      # 0xd2cb
callq 0x7225
movb $0x1, %bpl
movq (%rbx), %rdx
movq 0x8(%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x3912
cmpq $0x1, %rax
je 0x52e4
movl 0xc(%r14), %esi
leaq 0x800b(%rip), %rdi      # 0xd2e7
callq 0x7225
movb $0x1, %bpl
movq (%rbx), %rdx
movq 0x20(%rbx), %rdi
movq 0x38(%rbx), %rsi
decq %rdx
callq 0x3912
cmpq $0x1, %rax
jne 0x5317
movq 0x8(%rbx), %rdx
movq 0x28(%rbx), %rdi
movq 0x38(%rbx), %rsi
decq %rdx
callq 0x3912
cmpq $0x1, %rax
je 0x532a
movl 0xc(%r14), %esi
leaq 0x7feb(%rip), %rdi      # 0xd30d
callq 0x7225
movb $0x1, %bpl
testb %bpl, %bpl
je 0x5338
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl 0xc(%r14), %esi
leaq 0x7ff1(%rip), %rdi      # 0xd334
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x7225
// File: /workspace/github_c_makefile_star2_O1/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 0x5375
leaq 0x7fe3(%rip), %rdi      # 0xd351
movl %ebx, %esi
callq 0x7225
movslq %ebp, %r12
xorl %r15d, %r15d
leaq 0x7fbe(%rip), %r13      # 0xd340
cmpq %r12, %r15
jge 0x53b1
movzbl (%r14,%r15), %eax
shrl $0x4, %eax
movsbl (%rax,%r13), %edi
movl %ebx, %esi
callq 0x720c
movzbl (%r14,%r15), %eax
andl $0xf, %eax
movsbl (%rax,%r13), %edi
movl %ebx, %esi
callq 0x720c
jmp 0x53bf
leaq 0x7fa1(%rip), %rdi      # 0xd359
movl %ebx, %esi
callq 0x7225
leaq 0x1(%r15), %rbp
testb $0x7, %bpl
jne 0x53e1
cmpq $0x7, %r15
movl $0x20, %edi
movl $0x2d, %eax
cmovel %eax, %edi
movl %ebx, %esi
callq 0x720c
movl $0x20, %edi
movl %ebx, %esi
callq 0x720c
movq %rbp, %r15
cmpq $0x10, %rbp
jne 0x5382
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/rsa/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), %r14
testq %r14, %r14
je 0x5519
leaq 0x58(%rsp), %r12
leaq 0x40(%rsp), %r15
movl $0x0, 0x8(%r15)
movq %rsp, %rdi
movl $0x10, %esi
callq 0x6c50
xorl %ebp, %ebp
movq %r14, %rax
movq %r14, %rcx
shrq %rcx
incl %ebp
cmpq $0x1, %rax
movq %rcx, %rax
ja 0x5446
movl %ebp, 0x8(%r15)
movl 0x10(%r15), %edi
movq %rsp, %rsi
movl $0xf, %edx
callq 0x10b0
movq %rax, %rbx
shrl $0x3, %ebp
cmpl %ebx, %ebp
jne 0x54a6
movq 0x38(%r12), %rax
movq 0x40(%r12), %rsi
movl (%r15), %r12d
testl %ebx, %ebx
jle 0x54ba
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 0x5490
jmp 0x54bc
setle %al
movzbl %al, %edi
addl $0x15, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2729
jmp 0x5519
xorl %edi, %edi
movl 0xc(%r15), %ebp
btl $0x9, %r12d
cmovaeq %rax, %rsi
movq %r14, %rdx
callq 0x397c
movq %rax, %r14
leal -0x8(,%rbx,8), %esi
btl $0xa, %r12d
jb 0x550d
testl %ebx, %ebx
jle 0x5519
movslq %esi, %r15
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
movq %r14, %rax
movl %r15d, %ecx
shrq %cl, %rax
movsbl %al, %edi
movl %ebp, %esi
callq 0x720c
addq $-0x8, %r15
decq %rbx
jne 0x54ef
jmp 0x5519
movl %ebp, %edi
movl %ebx, %edx
movq %r14, %rcx
callq 0x5526
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r13d
movq %rsp, %rdi
leaq 0xf(%r13), %rcx
andq $-0x10, %rcx
subq %rcx, %rdi
movq %rdi, %rsp
movl %edx, -0x2c(%rbp)
movslq %edx, %rcx
movb $0x0, (%rcx,%rdi)
testl %ecx, %ecx
jle 0x557a
movslq %esi, %rcx
xorl %edx, %edx
movq %rax, %rsi
shrq %cl, %rsi
movb %sil, (%rdi,%rdx)
incq %rdx
addq $-0x8, %rcx
cmpq %rdx, %r13
jne 0x5564
cmpl $0x0, -0x2c(%rbp)
jle 0x560b
xorl %r15d, %r15d
movq %rdi, %rbx
movq %r13, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movl -0x2c(%rbp), %esi
subl %r15d, %esi
leaq (%rdi,%r15), %rdx
movl %r15d, %edi
movl %r14d, %ecx
callq 0x5350
movq %r15, -0x48(%rbp)
subq %r15, %r13
jle 0x55e5
xorl %r15d, %r15d
movzbl (%rbx,%r15), %r12d
movl %r12d, %edi
callq 0x6c38
movl $0x2e, %ecx
testl %eax, %eax
je 0x55cc
movl %r12d, %ecx
movsbl %cl, %edi
movl %r14d, %esi
callq 0x720c
cmpq $0xe, %r15
ja 0x55e5
incq %r15
cmpq %r13, %r15
jl 0x55b3
movl $0xa, %edi
movl %r14d, %esi
callq 0x720c
movq -0x48(%rbp), %r15
addq $0x10, %r15
addq $0x10, %rbx
movq -0x40(%rbp), %r13
cmpq %r13, %r15
movq -0x38(%rbp), %rdi
jb 0x5592
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x564b
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 0x563c
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 0x564d
movl (%rsi), %r13d
movl 0x4(%rsi), %eax
movl %r13d, 0x24(%rsi)
movl %eax, 0x28(%rsi)
movl 0x8(%rsi), %r8d
movl %r8d, 0x2c(%rsi)
movl 0xc(%rsi), %edi
movl %edi, 0x30(%rsi)
movl 0x10(%rsi), %r12d
movl %r12d, 0x34(%rsi)
movl $0xffffffd8, %r10d      # imm = 0xFFFFFFD8
xorl %r11d, %r11d
movl $0xcccccccd, %ebx       # imm = 0xCCCCCCCD
leaq 0x7cbd(%rip), %r14      # 0xd360
movl %eax, %ecx
movl %r8d, %ebp
movl %edi, -0x8(%rsp)
movl %r13d, -0xc(%rsp)
movl %r12d, -0x4(%rsp)
movl %r12d, %r9d
movl %edi, %r12d
movl %ebp, %edi
cmpq $0x13, %r11
ja 0x56cd
movl %edi, %ebp
xorl %r12d, %ebp
andl %ecx, %ebp
jmp 0x56f2
movl %r10d, %ebp
addl $0x14, %ebp
jb 0x56ee
cmpl $0x13, %r10d
ja 0x56ee
movl %r12d, %r15d
orl %edi, %r15d
andl %ecx, %r15d
movl %r12d, %ebp
andl %edi, %ebp
orl %r15d, %ebp
jmp 0x56f5
movl %edi, %ebp
xorl %ecx, %ebp
xorl %r12d, %ebp
movl %ebp, 0x38(%rsi)
movl %r13d, %r15d
roll $0x5, %r15d
addl %r9d, %r15d
addl %ebp, %r15d
movl %r11d, %r9d
imulq %rbx, %r9
shrq $0x22, %r9
andl $-0x4, %r9d
addl (%r9,%r14), %r15d
addl (%rdx,%r11,4), %r15d
movl %r12d, 0x34(%rsi)
movl %edi, 0x30(%rsi)
movl %ecx, %ebp
roll $0x1e, %ebp
movl %ebp, 0x2c(%rsi)
movl %r13d, 0x28(%rsi)
movl %r15d, 0x24(%rsi)
incl %r10d
incq %r11
movl %r13d, %ecx
movl %r15d, %r13d
cmpq $0x50, %r11
jne 0x56b6
movl 0x24(%rsi), %ecx
addl -0xc(%rsp), %ecx
movl %ecx, (%rsi)
addl 0x28(%rsi), %eax
movl %eax, 0x4(%rsi)
addl 0x2c(%rsi), %r8d
movl %r8d, 0x8(%rsi)
movl -0x8(%rsp), %eax
addl 0x30(%rsi), %eax
movl %eax, 0xc(%rsi)
movl -0x4(%rsp), %eax
addl 0x34(%rsi), %eax
movl %eax, 0x10(%rsi)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/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 0x6c50
movq %r14, %rdi
movq %r15, %rsi
callq 0x5a65
movaps 0x763a(%rip), %xmm0     # 0xcdf0
movups %xmm0, (%r15)
movl $0xc3d2e1f0, 0x10(%r15) # imm = 0xC3D2E1F0
cmpl $0x0, 0x20(%r15)
jle 0x57ef
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 0x561c
incl %ebp
cmpl 0x30(%rsp), %ebp
jl 0x57d5
movl 0x10(%rsp), %edx
movl 0x14(%rsp), %ecx
movl 0x18(%rsp), %r8d
movl 0x1c(%rsp), %r9d
movl 0x20(%rsp), %eax
movl %eax, (%rsp)
leaq 0x7bad(%rip), %rsi      # 0xd3bc
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7300
movl 0x30(%rsp), %edi
movq 0x58(%rsp), %rsi
callq 0x6a07
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_O1/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 0x6c50
movq %r14, %rdi
movq %r15, %rsi
callq 0x5a65
movaps 0x7af7(%rip), %xmm0     # 0xd370
movups %xmm0, (%r15)
movaps 0x7afc(%rip), %xmm0     # 0xd380
movups %xmm0, 0x10(%r15)
cmpl $0x0, 0x20(%r15)
jle 0x58b4
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 0x591c
incl %ebp
cmpl 0x20(%rsp), %ebp
jl 0x589a
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 0x7ad5(%rip), %rsi      # 0xd3b4
movq %rbx, %rdi
xorl %eax, %eax
pushq %r14
pushq %r11
pushq %r10
callq 0x7300
addq $0x20, %rsp
movl 0x20(%rsp), %edi
movq 0x48(%rsp), %rsi
callq 0x6a07
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_O1/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
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
cmpl $0xe, %ecx
jg 0x5953
movq 0x48(%rbx), %rax
movslq %edi, %rdx
movq (%rax,%rdx,8), %rax
movslq %ecx, %rcx
incq %rcx
movl (%rax,%rcx,4), %edx
movl %edx, (%r14,%rcx,4)
incq %rcx
cmpq $0x10, %rcx
jne 0x5943
movl $0x10, %r15d
movl -0x40(%r14,%r15,4), %r12d
movl -0x3c(%r14,%r15,4), %edi
callq 0x2e73
movl %eax, %ebp
addl %r12d, %ebp
addl -0x1c(%r14,%r15,4), %ebp
movl -0x8(%r14,%r15,4), %edi
callq 0x2e85
addl %ebp, %eax
movl %eax, (%r14,%r15,4)
incq %r15
cmpq $0x40, %r15
jne 0x5959
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm0, 0x24(%rbx)
movups %xmm1, 0x34(%rbx)
xorl %r15d, %r15d
movl 0x34(%rbx), %edi
movl 0x3c(%rbx), %eax
movl 0x28(%rbx), %ecx
movl 0x2c(%rbx), %r13d
movl %r13d, %edx
xorl %ecx, %edx
andl 0x24(%rbx), %edx
andl %ecx, %r13d
xorl %edx, %r13d
movl 0x38(%rbx), %r12d
xorl %eax, %r12d
andl %edi, %r12d
xorl %eax, %r12d
addl 0x40(%rbx), %r12d
callq 0x2e61
movl %eax, %ebp
addl %r12d, %ebp
leaq 0x7a06(%rip), %rax      # 0xd3e0
addl (%r15,%rax), %ebp
addl (%r14,%r15), %ebp
movl 0x24(%rbx), %edi
callq 0x2e4f
movl 0x3c(%rbx), %ecx
movl %ecx, 0x40(%rbx)
movq 0x34(%rbx), %rcx
movq %rcx, 0x38(%rbx)
movl 0x30(%rbx), %ecx
addl %ebp, %ecx
movl %ecx, 0x34(%rbx)
movl 0x2c(%rbx), %ecx
movl %ecx, 0x30(%rbx)
movq 0x24(%rbx), %rcx
movq %rcx, 0x28(%rbx)
addl %r13d, %eax
addl %ebp, %eax
movl %eax, 0x24(%rbx)
addq $0x4, %r15
cmpq $0x100, %r15            # imm = 0x100
jne 0x599d
movl 0x24(%rbx), %eax
movl 0x28(%rbx), %ecx
addl %eax, (%rbx)
addl %ecx, 0x4(%rbx)
movl 0x2c(%rbx), %eax
addl %eax, 0x8(%rbx)
movl 0x30(%rbx), %eax
addl %eax, 0xc(%rbx)
movl 0x34(%rbx), %eax
addl %eax, 0x10(%rbx)
movl 0x38(%rbx), %eax
addl %eax, 0x14(%rbx)
movl 0x3c(%rbx), %eax
addl %eax, 0x18(%rbx)
movl 0x40(%rbx), %eax
addl %eax, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/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 0x7952
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 0x5a87
shrq $0x9, %r15
movl %r15d, 0x20(%rbx)
sarq $0x1d, %rax
movq %rax, %rdi
callq 0x10d0
movq %rax, 0x48(%rbx)
testl %r15d, %r15d
jle 0x5af2
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 0x6c50
incq %r15
movslq 0x20(%rbx), %rax
cmpq %rax, %r15
jl 0x5ac2
movq %r14, %rdi
callq 0x7952
xorl %esi, %esi
testq %rax, %rax
je 0x5b57
movq 0x48(%rbx), %rdi
xorl %r9d, %r9d
xorl %r8d, %r8d
movsbl (%r14,%r9), %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
movl %r8d, %ecx
movq (%rdi,%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, %esi
cmpq %r9, %rax
jne 0x5b0b
movl %r8d, %esi
movq %rax, %rdx
jmp 0x5b59
xorl %edx, %edx
leal (,%rdx,8), %ecx
notb %cl
andb $0x18, %cl
movl $0x80, %edi
shll %cl, %edi
movq 0x48(%rbx), %rcx
movq (%rcx,%rsi,8), %rsi
andl $0x3c, %edx
orl %edi, (%rsi,%rdx)
movq %rax, %rdx
shrq $0x1d, %rdx
movslq 0x20(%rbx), %rsi
movq -0x8(%rcx,%rsi,8), %rsi
movl %edx, 0x38(%rsi)
leal (,%rax,8), %eax
movslq 0x20(%rbx), %rdx
movq -0x8(%rcx,%rdx,8), %rcx
movl %eax, 0x3c(%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6c50
movq %r14, %rdi
movq %r15, %rsi
callq 0x5a65
movaps 0x77b5(%rip), %xmm0     # 0xd390
movups %xmm0, (%r15)
movaps 0x77ba(%rip), %xmm0     # 0xd3a0
movups %xmm0, 0x10(%r15)
cmpl $0x0, 0x20(%r15)
jle 0x5c16
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 0x591c
incl %ebp
cmpl 0x20(%rsp), %ebp
jl 0x5bfc
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 0x776e(%rip), %rsi      # 0xd3b0
movq %rbx, %rdi
xorl %eax, %eax
pushq %r15
pushq %r14
pushq %r11
pushq %r10
callq 0x7300
addq $0x20, %rsp
movl 0x20(%rsp), %edi
movq 0x48(%rsp), %rsi
callq 0x6a07
movq 0x48(%rsp), %rdi
callq 0x1030
movq %rbx, %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x328, %rsp            # imm = 0x328
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movl $0x90, %esi
movq %r15, %rdi
callq 0x6c50
movq %r14, %rdi
movq %r15, %rsi
callq 0x5f38
movabsq $-0x344462a23efa6128, %rax # imm = 0xCBBB9D5DC1059ED8
movq %rax, (%r15)
movabsq $0x629a292a367cd507, %rax # imm = 0x629A292A367CD507
movq %rax, 0x8(%r15)
movabsq $-0x6ea6fea5cf8f22e9, %rax # imm = 0x9159015A3070DD17
movq %rax, 0x10(%r15)
movabsq $0x152fecd8f70e5939, %rax # imm = 0x152FECD8F70E5939
movq %rax, 0x18(%r15)
movabsq $0x67332667ffc00b31, %rax # imm = 0x67332667FFC00B31
movq %rax, 0x20(%r15)
movabsq $-0x714bb57897a7eaef, %rax # imm = 0x8EB44A8768581511
movq %rax, 0x28(%r15)
movabsq $-0x24f3d1f29b067059, %rax # imm = 0xDB0C2E0D64F98FA7
movq %rax, 0x30(%r15)
movabsq $0x47b5481dbefa4fa4, %rax # imm = 0x47B5481DBEFA4FA4
movq %rax, 0x38(%r15)
cmpl $0x0, 0x40(%r15)
jle 0x5d53
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 0x5db0
incl %ebp
cmpl 0x50(%rsp), %ebp
jl 0x5d39
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x28(%rsp), %r9
movups 0x30(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x7777(%rip), %rsi      # 0xd4ee
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7300
movl 0x50(%rsp), %edi
movq 0x98(%rsp), %rsi
callq 0x6a07
movq 0x98(%rsp), %rdi
callq 0x1030
movq %rbx, %rax
addq $0x328, %rsp            # imm = 0x328
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/hash/sha512.c
// Function: sha64_cycle
void			sha64_cycle(int count, t_sha64bit *s, __uint64_t *w, int i)
{
	while (++i < 16)
		w[i] = s->message[count][i];
	i = 15;
	while (++i < 80)
		w[i] = w[i - 16] + s0(w[i - 15]) + w[i - 7] + s1(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 < 80)
		sha512_loop(s, i, 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
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
cmpl $0xe, %ecx
jg 0x5deb
movq 0x88(%rbx), %rax
movslq %edi, %rdx
movq (%rax,%rdx,8), %rax
movslq %ecx, %rcx
incq %rcx
movq (%rax,%rcx,8), %rdx
movq %rdx, (%r14,%rcx,8)
incq %rcx
cmpq $0x10, %rcx
jne 0x5dda
xorl %r12d, %r12d
movq (%r14,%r12,8), %r13
movq 0x8(%r14,%r12,8), %rdi
callq 0x2ed4
movq %rax, %r15
addq %r13, %r15
addq 0x48(%r14,%r12,8), %r15
movq 0x70(%r14,%r12,8), %rdi
callq 0x2eec
addq %r15, %rax
movq %rax, 0x80(%r14,%r12,8)
incq %r12
cmpq $0x40, %r12
jne 0x5dee
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups 0x30(%rbx), %xmm3
movups %xmm0, 0x48(%rbx)
movups %xmm1, 0x58(%rbx)
movups %xmm2, 0x68(%rbx)
movups %xmm3, 0x78(%rbx)
xorl %r12d, %r12d
movq 0x68(%rbx), %rdi
movq 0x78(%rbx), %rax
movq 0x50(%rbx), %rcx
movq 0x58(%rbx), %rbp
movq %rbp, %rdx
xorq %rcx, %rdx
andq 0x48(%rbx), %rdx
andq %rcx, %rbp
xorq %rdx, %rbp
movq 0x70(%rbx), %r13
xorq %rax, %r13
andq %rdi, %r13
xorq %rax, %r13
addq 0x80(%rbx), %r13
callq 0x2ebb
movq %rax, %r15
addq %r13, %r15
leaq 0x7693(%rip), %rax      # 0xd520
addq (%r12,%rax), %r15
addq (%r14,%r12), %r15
movq 0x48(%rbx), %rdi
callq 0x2ea2
movq 0x78(%rbx), %rcx
movq %rcx, 0x80(%rbx)
movups 0x68(%rbx), %xmm0
movups %xmm0, 0x70(%rbx)
movq 0x60(%rbx), %rcx
addq %r15, %rcx
movq %rcx, 0x68(%rbx)
movq 0x58(%rbx), %rcx
movq %rcx, 0x60(%rbx)
movups 0x48(%rbx), %xmm0
movups %xmm0, 0x50(%rbx)
addq %rbp, %rax
addq %r15, %rax
movq %rax, 0x48(%rbx)
addq $0x8, %r12
cmpq $0x280, %r12            # imm = 0x280
jne 0x5e47
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rcx
addq %rax, (%rbx)
addq %rcx, 0x8(%rbx)
movq 0x58(%rbx), %rax
addq %rax, 0x10(%rbx)
movq 0x60(%rbx), %rax
addq %rax, 0x18(%rbx)
movq 0x68(%rbx), %rax
addq %rax, 0x20(%rbx)
movq 0x70(%rbx), %rax
addq %rax, 0x28(%rbx)
movq 0x78(%rbx), %rax
addq %rax, 0x30(%rbx)
movq 0x80(%rbx), %rax
addq %rax, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/hash/sha512.c
// Function: sha64_start
void			sha64_start(char *to_hash, t_sha64bit *s)
{
	int			i;
	__uint64_t	len;

	i = -1;
	len = (ft_strlen(to_hash) * 8) + 1;
	while (len % 1024 != 896)
		len++;
	s->multiples = (len += 128) / 1024;
	s->message = (__uint64_t**)malloc(sizeof(__uint64_t*) * s->multiples);
	while (++i < s->multiples)
	{
		s->message[i] = (__uint64_t*)malloc(sizeof(__uint64_t) * 16);
		ft_bzero(s->message[i], sizeof(__uint64_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 0x7952
leaq 0x80(,%rax,8), %r15
shlq $0x19, %rax
addq $0x20000000, %rax       # imm = 0x20000000
leal -0x7f(%r15), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
addq $0x400000, %rax         # imm = 0x400000
incq %r15
cmpl $0x380, %ecx            # imm = 0x380
jne 0x5f5a
shrq $0xa, %r15
movl %r15d, 0x40(%rbx)
sarq $0x1d, %rax
movq %rax, %rdi
callq 0x10d0
movq %rax, 0x88(%rbx)
testl %r15d, %r15d
jle 0x5fce
xorl %r15d, %r15d
movl $0x80, %edi
callq 0x10d0
movq 0x88(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x88(%rbx), %rax
movq (%rax,%r15,8), %rdi
movl $0x80, %esi
callq 0x6c50
incq %r15
movslq 0x40(%rbx), %rax
cmpq %rax, %r15
jl 0x5f98
movq %r14, %rdi
callq 0x7952
xorl %edi, %edi
testq %rax, %rax
je 0x6046
movq 0x88(%rbx), %r8
movl $0x38, %r9d
xorl %r10d, %r10d
movl $0x38, %edx
movl %r10d, %esi
andl $0x7, %esi
addl $-0x8, %edx
testq %rsi, %rsi
cmovel %r9d, %edx
movsbq (%r14,%r10), %r11
movl %edx, %ecx
shlq %cl, %r11
shll $0x3, %esi
movl %esi, %ecx
shlq %cl, %r11
shrq %cl, %r11
movl %edi, %ecx
movq (%r8,%rcx,8), %rcx
movl %r10d, %esi
andl $0x78, %esi
orq %r11, (%rcx,%rsi)
incq %r10
movl %r10d, %ecx
andl $0x7f, %ecx
cmpq $0x1, %rcx
adcl $0x0, %edi
cmpq %r10, %rax
jne 0x5ff2
addl $-0x8, %edx
movl %edi, %edi
movq %rax, %rsi
jmp 0x604d
movl $0x30, %edx
xorl %esi, %esi
movl $0x80, %r8d
movl %edx, %ecx
shlq %cl, %r8
testb $0x7, %sil
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmovneq %r8, %rcx
movq 0x88(%rbx), %rdx
movq (%rdx,%rdi,8), %rdi
andl $0x78, %esi
orq %rcx, (%rdi,%rsi)
shlq $0x3, %rax
movq %rax, %rcx
shrq $0x38, %rcx
movslq 0x40(%rbx), %rsi
movq -0x8(%rdx,%rsi,8), %rdx
movq %rcx, 0x70(%rdx)
movq %rax, 0x78(%rdx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/hash/sha512.c
// Function: sha512
char			*sha512(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] = 0x6a09e667f3bcc908;
	s.hash[1] = 0xbb67ae8584caa73b;
	s.hash[2] = 0x3c6ef372fe94f82b;
	s.hash[3] = 0xa54ff53a5f1d36f1;
	s.hash[4] = 0x510e527fade682d1;
	s.hash[5] = 0x9b05688c2b3e6c1f;
	s.hash[6] = 0x1f83d9abfb41bd6b;
	s.hash[7] = 0x5be0cd19137e2179;
	while (++i < (s.multiples))
		sha64_cycle(i, &s, w, -1);
	to_hash = buf;
	ft_sprintf(to_hash,
		"%.16llx%.16llx%.16llx%.16llx%.16llx%.16llx%.16llx%.16llx",
		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, s.message);
	free(s.message);
	return (to_hash);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x338, %rsp            # imm = 0x338
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movl $0x90, %esi
movq %r15, %rdi
callq 0x6c50
movq %r14, %rdi
movq %r15, %rsi
callq 0x5f38
movabsq $0x6a09e667f3bcc908, %rax # imm = 0x6A09E667F3BCC908
movq %rax, (%r15)
movabsq $-0x4498517a7b3558c5, %rax # imm = 0xBB67AE8584CAA73B
movq %rax, 0x8(%r15)
movabsq $0x3c6ef372fe94f82b, %rax # imm = 0x3C6EF372FE94F82B
movq %rax, 0x10(%r15)
movabsq $-0x5ab00ac5a0e2c90f, %rax # imm = 0xA54FF53A5F1D36F1
movq %rax, 0x18(%r15)
movabsq $0x510e527fade682d1, %rax # imm = 0x510E527FADE682D1
movq %rax, 0x20(%r15)
movabsq $-0x64fa9773d4c193e1, %rax # imm = 0x9B05688C2B3E6C1F
movq %rax, 0x28(%r15)
movabsq $0x1f83d9abfb41bd6b, %rax # imm = 0x1F83D9ABFB41BD6B
movq %rax, 0x30(%r15)
movabsq $0x5be0cd19137e2179, %rax # imm = 0x5BE0CD19137E2179
movq %rax, 0x38(%r15)
cmpl $0x0, 0x40(%r15)
jle 0x616d
xorl %ebp, %ebp
leaq 0x20(%rsp), %r14
leaq 0xb0(%rsp), %r15
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x5db0
incl %ebp
cmpl 0x60(%rsp), %ebp
jl 0x6153
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x38(%rsp), %r9
movups 0x40(%rsp), %xmm0
movups 0x50(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x7345(%rip), %rsi      # 0xd4e0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7300
movl 0x60(%rsp), %edi
movq 0xa8(%rsp), %rsi
callq 0x6a07
movq 0xa8(%rsp), %rdi
callq 0x1030
movq %rbx, %rax
addq $0x338, %rsp            # imm = 0x338
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/rsa/ssl_rsa.c
// Function: check_utl_arg
int				check_utl_arg(t_rsa_out *rsa, char *arg)
{
	if (!ft_strcmp(arg, "pubin"))
		rsa->flag |= R_PUBIN;
	else if (!ft_strcmp(arg, "encrypt"))
		rsa->flag |= R_ENCRYPT;
	else if (!ft_strcmp(arg, "decrypt"))
		rsa->flag |= R_DECRYPT;
	else if (!ft_strcmp(arg, "hexdump"))
		rsa->flag |= R_HEXDUMP;
	else
		return (1);
	return (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x75bb(%rip), %rsi      # 0xd7a0
movq %r14, %rdi
callq 0x7644
testl %eax, %eax
je 0x6238
leaq 0x75ae(%rip), %rsi      # 0xd7a6
movq %r14, %rdi
callq 0x7644
testl %eax, %eax
je 0x623f
leaq 0x75a3(%rip), %rsi      # 0xd7ae
movq %r14, %rdi
callq 0x7644
testl %eax, %eax
je 0x6246
leaq 0x7598(%rip), %rsi      # 0xd7b6
movq %r14, %rdi
callq 0x7644
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x624f
movl $0x400, %eax            # imm = 0x400
jmp 0x624b
movl $0x20, %eax
jmp 0x624b
movl $0x100, %eax            # imm = 0x100
jmp 0x624b
movl $0x200, %eax            # imm = 0x200
orl %eax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/rsa/ssl_rsa.c
// Function: check_rsa_arg
int				check_rsa_arg(t_rsa_out *rsa, char *arg)
{
	if (!ft_strcmp(arg, "text"))
		rsa->flag |= R_TEXT;
	else if (!ft_strcmp(arg, "noout"))
		rsa->flag |= R_NOOUT;
	else if (!ft_strcmp(arg, "check"))
		rsa->flag |= R_CHECK;
	else if (!ft_strcmp(arg, "pubin"))
		rsa->flag |= R_PUBIN;
	else if (!ft_strcmp(arg, "pubout"))
		rsa->flag |= R_PUBOUT;
	else if (!ft_strcmp(arg, "modulus"))
		rsa->flag |= R_MODULUS;
	else
		return (1);
	return (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7556(%rip), %rsi      # 0xd7be
movq %r14, %rdi
callq 0x7644
testl %eax, %eax
je 0x62e1
leaq 0x7548(%rip), %rsi      # 0xd7c3
movq %r14, %rdi
callq 0x7644
testl %eax, %eax
je 0x62e8
leaq 0x753b(%rip), %rsi      # 0xd7c9
movq %r14, %rdi
callq 0x7644
testl %eax, %eax
je 0x62ef
leaq 0x74ff(%rip), %rsi      # 0xd7a0
movq %r14, %rdi
callq 0x7644
testl %eax, %eax
je 0x62f6
leaq 0x751b(%rip), %rsi      # 0xd7cf
movq %r14, %rdi
callq 0x7644
testl %eax, %eax
je 0x62fd
leaq 0x750f(%rip), %rsi      # 0xd7d6
movq %r14, %rdi
callq 0x7644
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x6306
movl $0x80, %eax
jmp 0x6302
movl $0x4, %eax
jmp 0x6302
movl $0x8, %eax
jmp 0x6302
movl $0x10, %eax
jmp 0x6302
movl $0x20, %eax
jmp 0x6302
movl $0x40, %eax
orl %eax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/rsa/ssl_rsa.c
// Function: ssl_rsa
void			ssl_rsa(char **av, t_ssl *ssl)
{
	t_rsa_out	rsa;

	ft_bzero(&rsa, sizeof(t_rsa_out));
	rsa.fd_out = 1;
	rsa.bits = MAX_BIT_KEY;
	if (parse_rsa(av, ssl, &rsa, 1))
	{
		if (rsa.bits == -1)
			ft_putstr_fd(KEY_SMALL, 2);
		else
			return ;
	}
	if (ssl->type == 31 && rsa.bits > 15)
		genrsa(rsa);
	else if (ssl->type == 32 && !(rsa.flag & F_INK))
		ft_error(rsa.flag & R_PUBIN ? 23 : 24, av[1], ssl);
	else if (ssl->type == 32 && (rsa.type = 1))
		rsautl(rsa, rsa_command(rsa));
	else if (ssl->type == 33)
		rsa_command(rsa);
	else if (ssl->type == 36)
		prime_command(av, ssl);
	DEBUG ? debug_output(ssl, rsa) : 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x68(%rsp), %r15
movl $0x18, %esi
movq %r15, %rdi
callq 0x6c50
movabsq $0x100000040, %rax      # imm = 0x100000040
movq %rax, 0x8(%r15)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x630e
testl %eax, %eax
je 0x6605
cmpl $-0x1, 0x70(%rsp)
jne 0x670a
leaq 0x71e3(%rip), %rdi      # 0xd7de
movl $0x2, %esi
callq 0x7225
movl 0x8(%rbx), %eax
cmpl $0x1f, %eax
jne 0x6631
cmpl $0x10, 0x70(%rsp)
jl 0x6631
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x68(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x2929
jmp 0x670a
cmpl $0x24, %eax
je 0x66ff
cmpl $0x21, %eax
je 0x66dd
cmpl $0x20, %eax
jne 0x670a
movl 0x68(%rsp), %ecx
testb $0x4, %cl
jne 0x6671
andl $0x20, %ecx
xorl %edi, %edi
cmpl $0x1, %ecx
adcl $0x17, %edi
movq 0x8(%r14), %rsi
movq %rbx, %rdx
callq 0x2729
jmp 0x670a
cmpl $0x24, %eax
je 0x66ff
cmpl $0x21, %eax
je 0x66dd
cmpl $0x20, %eax
jne 0x670a
movl $0x1, 0x6c(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x68(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0xc8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4cf6
leaq 0x18(%rsp), %rdi
movl $0x9, %ecx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x68(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x5405
jmp 0x670a
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x68(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x80(%rsp), %rdi
callq 0x4cf6
jmp 0x670a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4002
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/util/utils.c
// Function: open_file_to_fd
int				open_file_to_fd(int *fd, char *fname, int type)
{
	int		tmp;

	if (type)
	{
		tmp = open(fname, O_RDWR | O_CREAT | O_TRUNC, 0644);
	}
	else
	{
		tmp = open(fname, O_RDONLY);
	}
	if (tmp < 0)
	{
		fname ? ft_printf("%s: %s\n", fname, strerror(errno)) : 0;
		return (1);
	}
	*fd = tmp;
	return (0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
testl %edx, %edx
je 0x673c
movl $0x242, %esi            # imm = 0x242
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x10e0
jmp 0x6745
xorl %esi, %esi
xorl %eax, %eax
callq 0x10e0
testl %eax, %eax
js 0x6750
movl %eax, (%r14)
xorl %ebp, %ebp
jmp 0x677a
movl $0x1, %ebp
testq %rbx, %rbx
je 0x677a
callq 0x1040
movl (%rax), %edi
callq 0x1100
leaq 0x70c3(%rip), %rdi      # 0xd830
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x6f7c
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/util/utils.c
// Function: read_files
int				read_files(char **av, t_ssl *ssl, int i, int j)
{
	DIR		*dir;

	if (!i)
		return (0);
	while (av[i])
	{
		dir = opendir(av[i]);
		if (!(ft_strncmp(strerror(errno), "No such file or directory", 26)))
			ft_printf("%s: %s: %s\n", av[1], av[i], strerror(errno));
		else if (dir)
			ft_printf("%s: %s: %s\n", av[1], av[i], "Is a directory");
		else
		{
			ssl->fd[j] = open(av[i], O_RDONLY);
			ssl->file_index[j] = i;
			j++;
		}
		if (dir)
			closedir(dir);
		errno = 0;
		i++;
	}
	return (j ? j : j);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
testl %edx, %edx
je 0x6892
movl %edx, %ebp
movq %rdi, %r15
movq %rcx, (%rsp)
movslq %edx, %rax
movq (%rdi,%rax,8), %rdi
testq %rdi, %rdi
je 0x689a
leaq (%r15,%rax,8), %rbx
leaq 0x7052(%rip), %r12      # 0xd812
movq %r15, 0x10(%rsp)
callq 0x1060
movq %rax, %r13
callq 0x1040
movq %rax, %r14
movl (%rax), %edi
callq 0x1100
movl $0x1a, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x7664
testl %eax, %eax
je 0x680c
testq %r13, %r13
je 0x6840
movq 0x8(%r15), %rsi
movq (%rbx), %rdx
leaq 0x7029(%rip), %rdi      # 0xd82c
leaq 0x702e(%rip), %rcx      # 0xd838
jmp 0x6837
movq 0x8(%r15), %r12
movq (%rbx), %r15
movl (%r14), %edi
callq 0x1100
leaq 0x700a(%rip), %rdi      # 0xd82c
movq %r12, %rsi
leaq 0x6fe6(%rip), %r12      # 0xd812
movq %r15, %rdx
movq 0x10(%rsp), %r15
movq %rax, %rcx
xorl %eax, %eax
callq 0x6f7c
jmp 0x6869
movq (%rbx), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10e0
movq (%rsp), %rcx
movslq %ecx, %rcx
movq 0x8(%rsp), %rdx
movl %eax, 0xc(%rdx,%rcx,4)
movl %ebp, 0x408(%rdx,%rcx,4)
incl %ecx
movq %rcx, (%rsp)
testq %r13, %r13
je 0x6876
movq %r13, %rdi
callq 0x10a0
movl $0x0, (%r14)
movq 0x8(%rbx), %rdi
addq $0x8, %rbx
incl %ebp
testq %rdi, %rdi
jne 0x67c5
jmp 0x689a
movq $0x0, (%rsp)
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/util/utils.c
// Function: get_stdin
int				get_stdin(char **line, char *str, int x, int i)
{
	char	buf[PAGESIZE + 1];
	char	*tmp;

	tmp = NULL;
	while (((i = read(0, buf, PAGESIZE))))
	{
		!str ? (str = ft_strdup("")) : 0;
		buf[i] = 0;
		tmp = ft_strjoin(str, buf);
		ft_strdel(&str);
		if (!x && ft_strchr(buf, 10))
		{
			i = ft_strlen(tmp);
			tmp[i - 1] = 0;
			str = ft_strdup(tmp);
			break ;
		}
		str = ft_strdup(tmp);
		ft_strdel(&tmp);
	}
	ft_strdel(&tmp);
	*line = i == 1 ? ft_strjoin(str, "\n") : ft_strdup(str);
	ft_strdel(&str);
	return (x);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1028, %rsp           # imm = 0x1028
movl %edx, %ebx
movq %rdi, 0x18(%rsp)
movq %rsi, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
xorl %edi, %edi
callq 0x10b0
movq %rax, %r14
testl %r14d, %r14d
je 0x6981
leaq 0x63e3(%rip), %r15      # 0xccda
leaq 0x20(%rsp), %r12
leaq 0x8(%rsp), %r13
leaq 0x10(%rsp), %rbp
cmpq $0x0, 0x8(%rsp)
jne 0x691b
movq %r15, %rdi
callq 0x7ab8
movq %rax, 0x8(%rsp)
movslq %r14d, %rax
movb $0x0, 0x20(%rsp,%rax)
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x77bc
movq %rax, 0x10(%rsp)
movq %r13, %rdi
callq 0x779b
testl %ebx, %ebx
jne 0x6953
movq %r12, %rdi
movl $0xa, %esi
callq 0x7598
testq %rax, %rax
jne 0x69bb
movq 0x10(%rsp), %rdi
callq 0x7ab8
movq %rax, 0x8(%rsp)
movq %rbp, %rdi
callq 0x779b
movl $0x1000, %edx           # imm = 0x1000
xorl %edi, %edi
movq %r12, %rsi
callq 0x10b0
movq %rax, %r14
testl %r14d, %r14d
jne 0x6906
leaq 0x10(%rsp), %rdi
callq 0x779b
movq 0x8(%rsp), %rdi
callq 0x7ab8
movq 0x18(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x8(%rsp), %rdi
callq 0x779b
movl %ebx, %eax
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rsp), %r14
movq (%r14), %rdi
callq 0x7952
movq %rax, %r15
movq (%r14), %rax
leal -0x1(%r15), %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq (%r14), %rdi
callq 0x7ab8
movq %rax, 0x8(%rsp)
movq %r14, %rdi
callq 0x779b
cmpl $0x1, %r15d
jne 0x698b
movq 0x8(%rsp), %rdi
leaq 0x62d9(%rip), %rsi      # 0xccd9
callq 0x77bc
jmp 0x6995
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_atoi.c
// Function: ft_atoi
int					ft_atoi(const char *str)
{
	int		i;
	int		res;
	int		neg;

	res = 0;
	if (!str)
		return (res);
	i = 0;
	neg = 1;
	while (str[i] == ' ' || str[i] == '\t' || str[i] == '\r' ||\
			str[i] == '\f' || str[i] == '\n' || str[i] == '\v')
		i++;
	if (str[i] == '-' || str[i] == '+')
	{
		if (str[i] == '-')
			neg = -1;
		i++;
	}
	while (str[i] >= '0' && str[i] <= '9')
	{
		res = (res * 10) + (str[i] - '0');
		i++;
	}
	return (res * neg);
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x6aa8
movb (%rdi,%rax), %cl
movzbl %cl, %edx
leal -0x9(%rdx), %esi
cmpl $0x5, %esi
jae 0x6a4a
incq %rax
jmp 0x6a37
cmpl $0x20, %edx
je 0x6a45
cmpl $0x2b, %edx
je 0x6a59
cmpl $0x2d, %edx
jne 0x6a6c
xorl %edx, %edx
cmpb $0x2d, %cl
setne %dl
leal -0x1(,%rdx,2), %ecx
incl %eax
jmp 0x6a71
movl $0x1, %ecx
movslq %eax, %rsi
movb (%rdi,%rsi), %dl
leal -0x30(%rdx), %r8d
xorl %eax, %eax
cmpb $0x9, %r8b
ja 0x6aa5
addq %rdi, %rsi
incq %rsi
xorl %eax, %eax
leal (%rax,%rax,4), %eax
addb $-0x30, %dl
movzbl %dl, %edx
leal (%rdx,%rax,2), %eax
movb (%rsi), %dl
leal -0x30(%rdx), %edi
incq %rsi
cmpb $0xa, %dil
jb 0x6a8b
imull %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_atoi.c
// Function: ft_atoull
unsigned long long	ft_atoull(const char *str)
{
	int					i;
	unsigned long long	n;

	n = 0;
	if (!str)
		return (n);
	i = 0;
	while (str[i] == ' ' || str[i] == '\t' || str[i] == '\r' ||\
			str[i] == '\f' || str[i] == '\n' || str[i] == '\v')
		i++;
	while (ft_isdigit(str[i]))
	{
		n = (n * 10) + (str[i] - '0');
		i++;
	}
	return (n);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6b18
movq %rdi, %rbx
leaq 0x1(%rdi), %r15
xorl %eax, %eax
movzbl -0x1(%r15), %ecx
leal -0x9(%rcx), %edx
cmpl $0x5, %edx
jae 0x6ad4
incq %rax
incq %r15
jmp 0x6abf
cmpl $0x20, %ecx
je 0x6acc
movl %eax, %r14d
movsbl (%rbx,%r14), %edi
callq 0x6bf4
testl %eax, %eax
je 0x6b18
addq %r14, %rbx
xorl %r14d, %r14d
movq %r15, %r12
leaq (%r14,%r14,4), %rax
movsbq (%rbx), %rcx
leaq (%rcx,%rax,2), %r14
addq $-0x30, %r14
movsbl (%r15), %edi
callq 0x6bf4
incq %r15
movq %r12, %rbx
testl %eax, %eax
jne 0x6af0
jmp 0x6b1b
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_islower.c
// Function: ft_strtolower
char	*ft_strtolower(char *str)
{
	int		i;

	if (!str)
		return (NULL);
	i = 0;
	while (str[i])
	{
		str[i] = ft_tolower(str[i]);
		i++;
	}
	return (str);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x6b8a
movq %rdi, %rbx
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x6b8c
leaq 0x1(%rbx), %r14
movsbl %bpl, %edi
callq 0x6b94
testl %eax, %eax
je 0x6b75
addb $0x20, %bpl
movzbl %bpl, %eax
movb %al, -0x1(%r14)
movb (%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0x6b64
jmp 0x6b8c
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_isupper.c
// Function: ft_strtoupper
char	*ft_strtoupper(char *str)
{
	int		i;

	i = 0;
	while (str[i])
	{
		str[i] = ft_toupper(str[i]);
		i++;
	}
	return (str);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x6beb
leaq 0x1(%rbx), %r14
movsbl %bpl, %edi
callq 0x6b2c
testl %eax, %eax
je 0x6bd8
addb $-0x20, %bpl
movzbl %bpl, %eax
movb %al, -0x1(%r14)
movb (%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0x6bc7
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_memcpy.c
// Function: ft_memcpy
void	*ft_memcpy(void *dst, const void *src, size_t n)
{
	unsigned char	*d;
	unsigned char	*s;
	size_t			i;

	if (!src)
		return (0);
	d = (unsigned char *)dst;
	s = (unsigned char *)src;
	i = -1;
	while (++i < n)
		(d[i] = s[i]);
	return (dst);
}

// Assembly:
testq %rsi, %rsi
je 0x6ca8
movq %rdi, %rax
testq %rdx, %rdx
je 0x6ca7
xorl %ecx, %ecx
movb (%rsi,%rcx), %dil
movb %dil, (%rax,%rcx)
incq %rcx
cmpq %rcx, %rdx
jne 0x6c97
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_strchr.c
// Function: ft_strrchr
char	*ft_strrchr(const char *s, int c)
{
	size_t	i;

	if (!s)
		return (NULL);
	i = ft_strlen(s) + 1;
	while (i--)
		if (s[i] == (char)c)
			return ((char*)&s[i]);
	return (NULL);
}

// Assembly:
testq %rdi, %rdi
je 0x75f4
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x7952
movq %rax, %rcx
movsbl %bpl, %edx
xorl %eax, %eax
cmpq $-0x1, %rcx
je 0x75ed
movsbl (%rbx,%rcx), %esi
decq %rcx
cmpl %esi, %edx
jne 0x75d5
leaq (%rbx,%rcx), %rax
incq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_strchr.c
// Function: ft_strrchri
int		ft_strrchri(const char *s, int c)
{
	size_t		i;
	int			z;

	i = 0;
	z = 0;
	if (!s)
		return (0);
	while (s[i])
		if (s[i++] == (char)c)
			z = i;
	return (z);
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x7643
movb (%rdi), %cl
testb %cl, %cl
je 0x7643
movsbl %sil, %edx
xorl %eax, %eax
movl $0x1, %esi
movsbl %cl, %ecx
cmpl %ecx, %edx
cmovel %esi, %eax
movb (%rdi,%rsi), %cl
incq %rsi
testb %cl, %cl
jne 0x7631
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_strcmp.c
// Function: ft_strncmp
int		ft_strncmp(const char *s1, const char *s2, size_t n)
{
	int		i;

	i = 0;
	while ((s1[i] != '\0') && (s1[i] == s2[i]) && (i < (int)n))
		i++;
	if (i != (int)n)
		return ((unsigned char)s1[i] - (unsigned char)s2[i]);
	return (0);
}

// Assembly:
movb (%rdi), %cl
xorl %eax, %eax
testb %cl, %cl
je 0x768e
movslq %edx, %r9
xorl %r8d, %r8d
cmpq %r9, %r8
jge 0x7689
cmpb (%rsi,%r8), %cl
jne 0x7689
movb 0x1(%rdi,%r8), %cl
incq %r8
testb %cl, %cl
jne 0x7672
movl %r8d, %edi
jmp 0x7693
xorl %edi, %edi
xorl %r8d, %r8d
cmpl %edx, %edi
je 0x76a1
movzbl %cl, %eax
movzbl (%rsi,%r8), %ecx
subl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_strcpy.c
// Function: ft_strcpy
char	*ft_strcpy(char *dst, const char *src)
{
	int		i;

	i = -1;
	while (src[++i])
		dst[i] = src[i];
	dst[i] = '\0';
	return (dst);
}

// Assembly:
movq %rdi, %rax
movb (%rsi), %dl
xorl %ecx, %ecx
testb %dl, %dl
je 0x7713
movb %dl, (%rax,%rcx)
movb 0x1(%rsi,%rcx), %dl
incq %rcx
jmp 0x7703
movb $0x0, (%rax,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_strcpy.c
// Function: ft_strncpy
char	*ft_strncpy(char *dst, const char *src, size_t len)
{
	size_t	i;

	i = -1;
	while (++i < len)
	{
		if (src[i])
			dst[i] = src[i];
		else
		{
			while (i < len)
				dst[i++] = '\0';
		}
	}
	return (dst);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x7758
movq %rdx, %rbx
movq %rsi, %r15
xorl %edi, %edi
movb (%r15,%rdi), %al
testb %al, %al
je 0x773b
movb %al, (%r14,%rdi)
jmp 0x7750
movq %rbx, %rdx
subq %rdi, %rdx
jbe 0x7750
addq %r14, %rdi
xorl %esi, %esi
callq 0x1070
movq %rbx, %rdi
incq %rdi
cmpq %rbx, %rdi
jb 0x772d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq