LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
movq %rsp, %rax
movq %rax, -0x20(%rbp)
movq %rcx, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rax
subq %rdx, %rax
movq %rax, -0x38(%rbp)
movq %rax, %rsp
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8003
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rdx
movl -0x8(%rbp), %ecx
movl -0x2c(%rbp), %esi
shll $0x3, %esi
subl %esi, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
movb %cl, %dl
movslq -0x2c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7fcc
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x80cd
movq -0x38(%rbp), %rdx
movl -0x2c(%rbp), %edi
movl -0xc(%rbp), %esi
subl -0x2c(%rbp), %esi
movslq -0x2c(%rbp), %rax
addq %rax, %rdx
movl -0x4(%rbp), %ecx
callq 0x7c00
movl $0x0, -0x30(%rbp)
xorl %eax, %eax
cmpl $0x10, -0x30(%rbp)
movb %al, -0x39(%rbp)
jge 0x8055
movl -0x30(%rbp), %eax
movl -0xc(%rbp), %ecx
subl -0x2c(%rbp), %ecx
cmpl %ecx, %eax
setl %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x805e
jmp 0x80b2
movq -0x38(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl -0x30(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0xa5a0
cmpl $0x0, %eax
je 0x808f
movq -0x38(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl -0x30(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x40(%rbp)
jmp 0x8099
movl $0x2e, %eax
movl %eax, -0x40(%rbp)
jmp 0x8099
movl -0x40(%rbp), %eax
movl -0x4(%rbp), %esi
movsbl %al, %edi
callq 0xb200
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x8039
movl -0x4(%rbp), %esi
movl $0xa, %edi
callq 0xb200
movl -0x2c(%rbp), %eax
addl $0x10, %eax
movl %eax, -0x2c(%rbp)
jmp 0x800a
movq -0x20(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x10, %eax
jge 0x8128
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x80f6
movl $0xf, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x50, %eax
jge 0x819a
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x3, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %edx
subl $0x8, %edx
movslq %edx, %rdx
xorl (%rcx,%rdx,4), %eax
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %edx
subl $0xe, %edx
movslq %edx, %rdx
xorl (%rcx,%rdx,4), %eax
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %edx
subl $0x10, %edx
movslq %edx, %rdx
xorl (%rcx,%rdx,4), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edx
shll %edx
movl -0x20(%rbp), %eax
shrl $0x1f, %eax
orl %eax, %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x812f
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x50, %eax
jge 0x8206
movl -0x1c(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x8260
jmp 0x81e6
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
movq -0x10(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl 0x34(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/hash/sha1.c
// Function: sha1_loop
static void		sha1_loop(int i, t_sha32bit *s, __uint32_t *w)
{
	__uint32_t		tmp;

	if (i >= 0 && i < 20)
		s->f = (s->b & s->c) | ((~s->b) & s->d);
	else if (i >= 20 && i < 40)
		s->f = s->b ^ s->c ^ s->d;
	else if (i >= 40 && i < 60)
		s->f = (s->b & s->c) | (s->b & s->d) | (s->c & s->d);
	else
		s->f = s->b ^ s->c ^ s->d;
	tmp = ((s->a << 5) | (s->a >> (32 - 5))) + s->f + s->e + g_k[i / 20] + w[i];
	s->e = s->d;
	s->d = s->c;
	s->c = ((s->b << 30) | (s->b >> (32 - 30)));
	s->b = s->a;
	s->a = tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x82a8
cmpl $0x14, -0x4(%rbp)
jge 0x82a8
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x10(%rbp), %rax
andl 0x2c(%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
xorl $-0x1, %eax
movq -0x10(%rbp), %rdx
andl 0x30(%rdx), %eax
orl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
jmp 0x8335
cmpl $0x14, -0x4(%rbp)
jl 0x82d2
cmpl $0x28, -0x4(%rbp)
jge 0x82d2
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x10(%rbp), %rax
xorl 0x2c(%rax), %ecx
movq -0x10(%rbp), %rax
xorl 0x30(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
jmp 0x8333
cmpl $0x28, -0x4(%rbp)
jl 0x8315
cmpl $0x3c, -0x4(%rbp)
jge 0x8315
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x10(%rbp), %rax
andl 0x2c(%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x10(%rbp), %rdx
andl 0x30(%rdx), %eax
orl %eax, %ecx
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x10(%rbp), %rdx
andl 0x30(%rdx), %eax
orl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
jmp 0x8331
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x10(%rbp), %rax
xorl 0x2c(%rax), %ecx
movq -0x10(%rbp), %rax
xorl 0x30(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
jmp 0x8333
jmp 0x8335
movq -0x10(%rbp), %rax
movl 0x24(%rax), %eax
shll $0x5, %eax
movq -0x10(%rbp), %rcx
movl 0x24(%rcx), %ecx
shrl $0x1b, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
addl 0x38(%rcx), %eax
movq -0x10(%rbp), %rcx
addl 0x34(%rcx), %eax
movl %eax, -0x20(%rbp)
movl -0x4(%rbp), %eax
movl $0x14, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x20(%rbp), %eax
movslq %ecx, %rdx
leaq 0x1003a(%rip), %rcx     # 0x183b0
addl (%rcx,%rdx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x4(%rbp), %rdx
addl (%rcx,%rdx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
shll $0x1e, %ecx
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
shrl $0x2, %eax
orl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x1a4(%rbp) # imm = 0xFFFFFFFF
leaq -0x60(%rbp), %rdi
movl $0x50, %esi
callq 0xa600
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x88f0
movl $0x67452301, -0x60(%rbp) # imm = 0x67452301
movl $0xefcdab89, -0x5c(%rbp) # imm = 0xEFCDAB89
movl $0x98badcfe, -0x58(%rbp) # imm = 0x98BADCFE
movl $0x10325476, -0x54(%rbp) # imm = 0x10325476
movl $0xc3d2e1f0, -0x50(%rbp) # imm = 0xC3D2E1F0
movl -0x1a4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a4(%rbp)
cmpl -0x40(%rbp), %eax
jge 0x846c
movl -0x1a4(%rbp), %edi
leaq -0x1a0(%rbp), %rdx
leaq -0x60(%rbp), %rsi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x80e0
jmp 0x843b
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl -0x60(%rbp), %edx
movl -0x5c(%rbp), %ecx
movl -0x58(%rbp), %r8d
movl -0x54(%rbp), %r9d
movl -0x50(%rbp), %eax
leaq 0xbe60(%rip), %rsi      # 0x142f0
movl %eax, (%rsp)
movb $0x0, %al
callq 0xb3d0
movl -0x40(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0xa060
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x164(%rbp) # imm = 0xFFFFFFFF
leaq -0x60(%rbp), %rdi
movl $0x50, %esi
callq 0xa600
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x88f0
movl $0xc1059ed8, -0x60(%rbp) # imm = 0xC1059ED8
movl $0x367cd507, -0x5c(%rbp) # imm = 0x367CD507
movl $0x3070dd17, -0x58(%rbp) # imm = 0x3070DD17
movl $0xf70e5939, -0x54(%rbp) # imm = 0xF70E5939
movl $0xffc00b31, -0x50(%rbp) # imm = 0xFFC00B31
movl $0x68581511, -0x4c(%rbp) # imm = 0x68581511
movl $0x64f98fa7, -0x48(%rbp) # imm = 0x64F98FA7
movl $0xbefa4fa4, -0x44(%rbp) # imm = 0xBEFA4FA4
movl -0x164(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x164(%rbp)
cmpl -0x40(%rbp), %eax
jge 0x8561
movl -0x164(%rbp), %edi
leaq -0x160(%rbp), %rdx
leaq -0x60(%rbp), %rsi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x85d0
jmp 0x8530
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl -0x60(%rbp), %edx
movl -0x5c(%rbp), %ecx
movl -0x58(%rbp), %r8d
movl -0x54(%rbp), %r9d
movl -0x50(%rbp), %r11d
movl -0x4c(%rbp), %r10d
movl -0x48(%rbp), %eax
leaq 0xbd5b(%rip), %rsi      # 0x142e8
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movb $0x0, %al
callq 0xb3d0
movl -0x40(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0xa060
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/hash/sha256.c
// Function: sha256_loop
static void		sha256_loop(int i, t_sha32bit *s, __uint32_t *w)
{
	__uint32_t	t1;
	__uint32_t	t2;
	__uint32_t	ch;
	__uint32_t	maj;

	ch = (s->e & s->f) ^ ((~s->e) & s->g);
	maj = (s->a & s->b) ^ (s->a & s->c) ^ (s->b & s->c);
	t1 = s->h + e1_32(s->e) + ch + g_sha32bit_k[i] + w[i];
	t2 = e0_32(s->a) + maj;
	s->h = s->g;
	s->g = s->f;
	s->f = s->e;
	s->e = s->d + t1;
	s->d = s->c;
	s->c = s->b;
	s->b = s->a;
	s->a = t1 + t2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
movq -0x10(%rbp), %rcx
andl 0x38(%rcx), %eax
movq -0x10(%rbp), %rcx
movl 0x34(%rcx), %ecx
xorl $-0x1, %ecx
movq -0x10(%rbp), %rdx
andl 0x3c(%rdx), %ecx
xorl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x10(%rbp), %rcx
andl 0x28(%rcx), %eax
movq -0x10(%rbp), %rcx
movl 0x24(%rcx), %ecx
movq -0x10(%rbp), %rdx
andl 0x2c(%rdx), %ecx
xorl %ecx, %eax
movq -0x10(%rbp), %rcx
movl 0x28(%rcx), %ecx
movq -0x10(%rbp), %rdx
andl 0x2c(%rdx), %ecx
xorl %ecx, %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x34(%rax), %edi
callq 0x3e90
movl %eax, %ecx
movl -0x2c(%rbp), %eax
addl %ecx, %eax
addl -0x24(%rbp), %eax
movslq -0x4(%rbp), %rdx
leaq 0xfb6d(%rip), %rcx      # 0x183c0
addl (%rcx,%rdx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x4(%rbp), %rdx
addl (%rcx,%rdx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %edi
callq 0x3e40
addl -0x28(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x3c(%rax)
movq -0x10(%rbp), %rax
movl 0x34(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
addl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movl -0x1c(%rbp), %ecx
addl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
callq 0xbf10
shlq $0x3, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
andq $0x1ff, %rax            # imm = 0x1FF
cmpq $0x1c0, %rax            # imm = 0x1C0
je 0x893c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x891c
movq -0x20(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x20(%rbp)
shrq $0x9, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movslq 0x20(%rax), %rdi
shlq $0x3, %rdi
callq 0x10c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x89bc
movl $0x40, %edi
callq 0x10c0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x40, %esi
callq 0xa600
jmp 0x8971
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbf10
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x89f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/hash/sha256.c
// Function: sha_pad
static void		sha_pad(char *to_hash, t_sha32bit *s, __uint64_t len)
{
	int			i;
	__uint64_t	n;

	n = 0;
	i = 0;
	while (n < len)
	{
		s->message[i][n % 64 / 4] |=
		((to_hash[n] << (3 - ((n) % 4)) * 8) & (0xffffffff >> (((n) % 4)) * 8));
		(((++n) % 64)) == 0 ? i++ : 0;
	}
	s->message[i][(n) % 64 / 4] |= 0x80 << (3 - ((n) % 4)) * 8;
	s->message[s->multiples - 1][14] = (__uint32_t)((len * 8) >> 32);
	s->message[s->multiples - 1][15] = (__uint32_t)((len * 8) & 0xffffffff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x8aa2
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %edx
movq -0x28(%rbp), %rcx
andq $0x3, %rcx
movl $0x3, %eax
subq %rcx, %rax
shlq $0x3, %rax
movl %eax, %ecx
shll %cl, %edx
movq -0x28(%rbp), %rax
andq $0x3, %rax
shlq $0x3, %rax
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shrl %cl, %eax
andl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
andq $0x3f, %rcx
shrq $0x2, %rcx
orl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
andq $0x3f, %rax
cmpq $0x0, %rax
jne 0x8a9b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8a9d
jmp 0x8a9d
jmp 0x8a0f
movq -0x28(%rbp), %rcx
andq $0x3, %rcx
movl $0x3, %eax
subq %rcx, %rax
shlq $0x3, %rax
movl %eax, %ecx
movl $0x80, %edx
shll %cl, %edx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
andq $0x3f, %rcx
shrq $0x2, %rcx
orl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
shlq $0x3, %rax
shrq $0x20, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rdx
movl 0x20(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x38(%rax)
movq -0x18(%rbp), %rax
shlq $0x3, %rax
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
andq %rcx, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rdx
movl 0x20(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x3c(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0xffffffff, -0x174(%rbp) # imm = 0xFFFFFFFF
leaq -0x68(%rbp), %rdi
movl $0x50, %esi
callq 0xa600
movq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x88f0
movl $0x6a09e667, -0x68(%rbp) # imm = 0x6A09E667
movl $0xbb67ae85, -0x64(%rbp) # imm = 0xBB67AE85
movl $0x3c6ef372, -0x60(%rbp) # imm = 0x3C6EF372
movl $0xa54ff53a, -0x5c(%rbp) # imm = 0xA54FF53A
movl $0x510e527f, -0x58(%rbp) # imm = 0x510E527F
movl $0x9b05688c, -0x54(%rbp) # imm = 0x9B05688C
movl $0x1f83d9ab, -0x50(%rbp) # imm = 0x1F83D9AB
movl $0x5be0cd19, -0x4c(%rbp) # imm = 0x5BE0CD19
movl -0x174(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x174(%rbp)
cmpl -0x48(%rbp), %eax
jge 0x8be2
movl -0x174(%rbp), %edi
leaq -0x170(%rbp), %rdx
leaq -0x68(%rbp), %rsi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x85d0
jmp 0x8bb1
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0x68(%rbp), %edx
movl -0x64(%rbp), %ecx
movl -0x60(%rbp), %r8d
movl -0x5c(%rbp), %r9d
movl -0x58(%rbp), %ebx
movl -0x54(%rbp), %r11d
movl -0x50(%rbp), %r10d
movl -0x4c(%rbp), %eax
leaq 0xb6d3(%rip), %rsi      # 0x142e4
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movb $0x0, %al
callq 0xb3d0
movl -0x48(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0xa060
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x340, %rsp            # imm = 0x340
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x324(%rbp) # imm = 0xFFFFFFFF
leaq -0xa0(%rbp), %rdi
movl $0x90, %esi
callq 0xa600
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x9150
movabsq $-0x344462a23efa6128, %rax # imm = 0xCBBB9D5DC1059ED8
movq %rax, -0xa0(%rbp)
movabsq $0x629a292a367cd507, %rax # imm = 0x629A292A367CD507
movq %rax, -0x98(%rbp)
movabsq $-0x6ea6fea5cf8f22e9, %rax # imm = 0x9159015A3070DD17
movq %rax, -0x90(%rbp)
movabsq $0x152fecd8f70e5939, %rax # imm = 0x152FECD8F70E5939
movq %rax, -0x88(%rbp)
movabsq $0x67332667ffc00b31, %rax # imm = 0x67332667FFC00B31
movq %rax, -0x80(%rbp)
movabsq $-0x714bb57897a7eaef, %rax # imm = 0x8EB44A8768581511
movq %rax, -0x78(%rbp)
movabsq $-0x24f3d1f29b067059, %rax # imm = 0xDB0C2E0D64F98FA7
movq %rax, -0x70(%rbp)
movabsq $0x47b5481dbefa4fa4, %rax # imm = 0x47B5481DBEFA4FA4
movq %rax, -0x68(%rbp)
movl -0x324(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x324(%rbp)
cmpl -0x60(%rbp), %eax
jge 0x8d3e
movl -0x324(%rbp), %edi
leaq -0x320(%rbp), %rdx
leaq -0xa0(%rbp), %rsi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x8db0
jmp 0x8d0a
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0xa0(%rbp), %rdx
movq -0x98(%rbp), %rcx
movq -0x90(%rbp), %r8
movq -0x88(%rbp), %r9
movq -0x80(%rbp), %r10
movq -0x78(%rbp), %rax
leaq 0xb59e(%rip), %rsi      # 0x14313
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0xb3d0
movl -0x60(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0xa060
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
addq $0x340, %rsp            # imm = 0x340
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/hash/sha512.c
// Function: sha512_loop
static void		sha512_loop(t_sha64bit *s, int i, __uint64_t *w)
{
	__uint64_t	t1;
	__uint64_t	t2;
	__uint64_t	ch;
	__uint64_t	maj;

	ch = (s->e & s->f) ^ ((~s->e) & s->g);
	maj = (s->a & s->b) ^ (s->a & s->c) ^ (s->b & s->c);
	t1 = s->h + e1(s->e) + ch + g_sha64bit_k[i] + w[i];
	t2 = e0(s->a) + maj;
	s->h = s->g;
	s->g = s->f;
	s->f = s->e;
	s->e = s->d + t1;
	s->d = s->c;
	s->c = s->b;
	s->b = s->a;
	s->a = t1 + t2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x8(%rbp), %rcx
andq 0x70(%rcx), %rax
movq -0x8(%rbp), %rcx
movq 0x68(%rcx), %rcx
xorq $-0x1, %rcx
movq -0x8(%rbp), %rdx
andq 0x78(%rdx), %rcx
xorq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
andq 0x50(%rcx), %rax
movq -0x8(%rbp), %rcx
movq 0x48(%rcx), %rcx
movq -0x8(%rbp), %rdx
andq 0x58(%rdx), %rcx
xorq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x50(%rcx), %rcx
movq -0x8(%rbp), %rdx
andq 0x58(%rdx), %rcx
xorq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x3ff0
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
addq -0x30(%rbp), %rax
movslq -0xc(%rbp), %rdx
leaq 0xf433(%rip), %rcx      # 0x184c0
addq (%rcx,%rdx,8), %rax
movq -0x18(%rbp), %rcx
movslq -0xc(%rbp), %rdx
addq (%rcx,%rdx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x3f90
addq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
addq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x20(%rbp), %rcx
addq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
callq 0xbf10
shlq $0x3, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
andq $0x3ff, %rax            # imm = 0x3FF
cmpq $0x380, %rax            # imm = 0x380
je 0x919c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x917c
movq -0x20(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x20(%rbp)
shrq $0xa, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x10(%rbp), %rax
movslq 0x40(%rax), %rdi
shlq $0x3, %rdi
callq 0x10c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jge 0x9227
movl $0x80, %edi
callq 0x10c0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x80, %esi
callq 0xa600
jmp 0x91d6
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbf10
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x9260
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/hash/sha512.c
// Function: sha_pad
static void		sha_pad(char *to_hash, t_sha64bit *s, __uint64_t len)
{
	int			i;
	int			u;
	__uint64_t	n;

	n = 0;
	i = 0;
	u = 56;
	while (n < len)
	{
		u = (n % 8 ? u - 8 : 56);
		s->message[i][(n % 128) / 8] |=
		(((uint64_t)to_hash[n] << u) & (0xffffffffffffffff >> (((n) % 8)) * 8));
		((++n) % 128) ? 0 : i++;
	}
	u = (n % 8) ? u - 8 : 56;
	s->message[i][(n) % 128 / 8] |= (__uint64_t)0x80 << u;
	s->message[s->multiples - 1][14] = ((__uint64_t)len * 8) >> 56;
	s->message[s->multiples - 1][15] = ((uint64_t)len * 8) & 0xffffffffffffffff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x38, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x9338
movq -0x28(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x92ad
movl -0x20(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x2c(%rbp)
jmp 0x92b7
movl $0x38, %eax
movl %eax, -0x2c(%rbp)
jmp 0x92b7
movl -0x2c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbq (%rax,%rcx), %rdx
movl -0x20(%rbp), %eax
movl %eax, %ecx
shlq %cl, %rdx
movq -0x28(%rbp), %rcx
andq $0x7, %rcx
shlq $0x3, %rcx
movq $-0x1, %rax
shrq %cl, %rax
andq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
andq $0x7f, %rcx
shrq $0x3, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
andq $0x7f, %rax
cmpq $0x0, %rax
je 0x932a
jmp 0x9333
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9286
movq -0x28(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x9351
movl -0x20(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x30(%rbp)
jmp 0x935b
movl $0x38, %eax
movl %eax, -0x30(%rbp)
jmp 0x935b
movl -0x30(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %ecx
movl $0x80, %edx
shlq %cl, %rdx
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
andq $0x7f, %rcx
shrq $0x3, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rcx
shlq $0x3, %rcx
shrq $0x38, %rcx
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x10(%rbp), %rdx
movl 0x40(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x70(%rax)
movq -0x18(%rbp), %rcx
shlq $0x3, %rcx
andq $-0x1, %rcx
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x10(%rbp), %rdx
movl 0x40(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x78(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
pushq %rbx
subq $0x358, %rsp            # imm = 0x358
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0xffffffff, -0x334(%rbp) # imm = 0xFFFFFFFF
leaq -0xa8(%rbp), %rdi
movl $0x90, %esi
callq 0xa600
movq -0x18(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x9150
movabsq $0x6a09e667f3bcc908, %rax # imm = 0x6A09E667F3BCC908
movq %rax, -0xa8(%rbp)
movabsq $-0x4498517a7b3558c5, %rax # imm = 0xBB67AE8584CAA73B
movq %rax, -0xa0(%rbp)
movabsq $0x3c6ef372fe94f82b, %rax # imm = 0x3C6EF372FE94F82B
movq %rax, -0x98(%rbp)
movabsq $-0x5ab00ac5a0e2c90f, %rax # imm = 0xA54FF53A5F1D36F1
movq %rax, -0x90(%rbp)
movabsq $0x510e527fade682d1, %rax # imm = 0x510E527FADE682D1
movq %rax, -0x88(%rbp)
movabsq $-0x64fa9773d4c193e1, %rax # imm = 0x9B05688C2B3E6C1F
movq %rax, -0x80(%rbp)
movabsq $0x1f83d9abfb41bd6b, %rax # imm = 0x1F83D9ABFB41BD6B
movq %rax, -0x78(%rbp)
movabsq $0x5be0cd19137e2179, %rax # imm = 0x5BE0CD19137E2179
movq %rax, -0x70(%rbp)
movl -0x334(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x334(%rbp)
cmpl -0x68(%rbp), %eax
jge 0x94e2
movl -0x334(%rbp), %edi
leaq -0x330(%rbp), %rdx
leaq -0xa8(%rbp), %rsi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x8db0
jmp 0x94ae
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0xa8(%rbp), %rdx
movq -0xa0(%rbp), %rcx
movq -0x98(%rbp), %r8
movq -0x90(%rbp), %r9
movq -0x88(%rbp), %rbx
movq -0x80(%rbp), %r11
movq -0x78(%rbp), %r10
movq -0x70(%rbp), %rax
leaq 0xade1(%rip), %rsi      # 0x14305
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movb $0x0, %al
callq 0xb3d0
movl -0x68(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0xa060
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
addq $0x358, %rsp            # imm = 0x358
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xadb3(%rip), %rsi      # 0x1433e
callq 0xb8e0
cmpl $0x0, %eax
jne 0x95a2
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x20, %ecx
movl %ecx, (%rax)
jmp 0x9620
movq -0x18(%rbp), %rdi
leaq 0xad97(%rip), %rsi      # 0x14344
callq 0xb8e0
cmpl $0x0, %eax
jne 0x95c7
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, (%rax)
jmp 0x961e
movq -0x18(%rbp), %rdi
leaq 0xad7a(%rip), %rsi      # 0x1434c
callq 0xb8e0
cmpl $0x0, %eax
jne 0x95ec
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x200, %ecx            # imm = 0x200
movl %ecx, (%rax)
jmp 0x961c
movq -0x18(%rbp), %rdi
leaq 0xad5d(%rip), %rsi      # 0x14354
callq 0xb8e0
cmpl $0x0, %eax
jne 0x9611
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x400, %ecx            # imm = 0x400
movl %ecx, (%rax)
jmp 0x961a
movl $0x1, -0x4(%rbp)
jmp 0x9627
jmp 0x961c
jmp 0x961e
jmp 0x9620
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xad11(%rip), %rsi      # 0x1435c
callq 0xb8e0
cmpl $0x0, %eax
jne 0x9665
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x4, %ecx
movl %ecx, (%rax)
jmp 0x9728
movq -0x18(%rbp), %rdi
leaq 0xacf1(%rip), %rsi      # 0x14361
callq 0xb8e0
cmpl $0x0, %eax
jne 0x968a
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x8, %ecx
movl %ecx, (%rax)
jmp 0x9726
movq -0x18(%rbp), %rdi
leaq 0xacd2(%rip), %rsi      # 0x14367
callq 0xb8e0
cmpl $0x0, %eax
jne 0x96ac
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x10, %ecx
movl %ecx, (%rax)
jmp 0x9724
movq -0x18(%rbp), %rdi
leaq 0xac87(%rip), %rsi      # 0x1433e
callq 0xb8e0
cmpl $0x0, %eax
jne 0x96ce
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x20, %ecx
movl %ecx, (%rax)
jmp 0x9722
movq -0x18(%rbp), %rdi
leaq 0xac94(%rip), %rsi      # 0x1436d
callq 0xb8e0
cmpl $0x0, %eax
jne 0x96f0
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x40, %ecx
movl %ecx, (%rax)
jmp 0x9720
movq -0x18(%rbp), %rdi
leaq 0xac79(%rip), %rsi      # 0x14374
callq 0xb8e0
cmpl $0x0, %eax
jne 0x9715
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x80, %ecx
movl %ecx, (%rax)
jmp 0x971e
movl $0x1, -0x4(%rbp)
jmp 0x972f
jmp 0x9720
jmp 0x9722
jmp 0x9724
jmp 0x9726
jmp 0x9728
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/rsa/ssl_rsa.c
// Function: valid_arg
static int		valid_arg(t_ssl *ssl, t_rsa_out *rsa, char *arg, char *fname)
{
	if ((rsa->fd_out == 1) && !ft_strcmp(arg, "out"))
	{
		rsa->flag |= F_OUT;
		return (!fname ? 1 : 0);
	}
	else if (ssl->type == 31)
		return (1);
	else if (!ft_strcmp(arg, "in"))
	{
		rsa->flag |= F_IN;
		return ((!fname || open_file_to_fd(&ssl->fd[254], fname, 0)) ? 1 : 0);
	}
	else if (ssl->type == 32)
	{
		if (!ft_strcmp(arg, "inkey"))
		{
			rsa->flag |= F_INK;
			return ((!fname || open_file_to_fd(&ssl->fd[254], fname, 0)) ?\
			1 : 0);
		}
		return (check_utl_arg(rsa, arg));
	}
	else if (ssl->type == 33)
		return (check_rsa_arg(rsa, arg));
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, 0xc(%rax)
jne 0x99e2
movq -0x20(%rbp), %rdi
leaq 0xa9c3(%rip), %rsi      # 0x14370
callq 0xb8e0
cmpl $0x0, %eax
jne 0x99e2
movq -0x18(%rbp), %rax
movl (%rax), %ecx
orl $0x1, %ecx
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
setne %dl
xorb $-0x1, %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x9b0a
movq -0x10(%rbp), %rax
cmpl $0x1f, 0x8(%rax)
jne 0x99f8
movl $0x1, -0x4(%rbp)
jmp 0x9b0a
movq -0x20(%rbp), %rdi
leaq 0xa93e(%rip), %rsi      # 0x14341
callq 0xb8e0
cmpl $0x0, %eax
jne 0x9a5f
movq -0x18(%rbp), %rax
movl (%rax), %ecx
orl $0x2, %ecx
movl %ecx, (%rax)
movb $0x1, %al
cmpq $0x0, -0x28(%rbp)
movb %al, -0x29(%rbp)
je 0x9a47
movq -0x10(%rbp), %rdi
addq $0xc, %rdi
addq $0x3f8, %rdi            # imm = 0x3F8
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x9ce0
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x9b0a
movq -0x10(%rbp), %rax
cmpl $0x20, 0x8(%rax)
jne 0x9adf
movq -0x20(%rbp), %rdi
leaq 0xa15d(%rip), %rsi      # 0x13bd1
callq 0xb8e0
cmpl $0x0, %eax
jne 0x9acd
movq -0x18(%rbp), %rax
movl (%rax), %ecx
orl $0x4, %ecx
movl %ecx, (%rax)
movb $0x1, %al
cmpq $0x0, -0x28(%rbp)
movb %al, -0x2a(%rbp)
je 0x9ab8
movq -0x10(%rbp), %rdi
addq $0xc, %rdi
addq $0x3f8, %rdi            # imm = 0x3F8
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x9ce0
cmpl $0x0, %eax
setne %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x9b0a
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9570
movl %eax, -0x4(%rbp)
jmp 0x9b0a
movq -0x10(%rbp), %rax
cmpl $0x21, 0x8(%rax)
jne 0x9afb
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9630
movl %eax, -0x4(%rbp)
jmp 0x9b0a
jmp 0x9afd
jmp 0x9aff
jmp 0x9b01
jmp 0x9b03
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x18, %esi
callq 0xa600
movl $0x1, -0x1c(%rbp)
movl $0x40, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
movl $0x1, %ecx
callq 0x9740
cmpl $0x0, %eax
je 0x9b8a
cmpl $-0x1, -0x20(%rbp)
jne 0x9b83
leaq 0xa805(%rip), %rdi      # 0x1437c
movl $0x2, %esi
callq 0xb230
jmp 0x9b88
jmp 0x9cd6
jmp 0x9b8a
movq -0x10(%rbp), %rax
cmpl $0x1f, 0x8(%rax)
jne 0x9bc1
cmpl $0xf, -0x20(%rbp)
jle 0x9bc1
leaq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x3660
jmp 0x9cd6
movq -0x10(%rbp), %rax
cmpl $0x20, 0x8(%rax)
jne 0x9c02
movl -0x28(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x9c02
movl -0x28(%rbp), %ecx
andl $0x20, %ecx
movl $0x18, %edi
movl $0x17, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x33a0
jmp 0x9cd4
movq -0x10(%rbp), %rax
cmpl $0x20, 0x8(%rax)
jne 0x9c82
movl $0x1, -0x24(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x9c1b
jmp 0x9c82
leaq -0x70(%rbp), %rdi
leaq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x70e0
movq -0x30(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x58(%rax)
movups -0x70(%rbp), %xmm0
movups -0x60(%rbp), %xmm1
movups -0x50(%rbp), %xmm2
movups -0x40(%rbp), %xmm3
movups %xmm3, 0x48(%rax)
movups %xmm2, 0x38(%rax)
movups %xmm1, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movups -0x28(%rbp), %xmm0
movups %xmm0, (%rax)
callq 0x7d20
jmp 0x9cd2
movq -0x10(%rbp), %rax
cmpl $0x21, 0x8(%rax)
jne 0x9cb7
leaq -0xb8(%rbp), %rdi
leaq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x70e0
jmp 0x9cd0
movq -0x10(%rbp), %rax
cmpl $0x24, 0x8(%rax)
jne 0x9cce
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5c10
jmp 0x9cd0
jmp 0x9cd2
jmp 0x9cd4
jmp 0x9cd6
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x9d13
movq -0x18(%rbp), %rdi
movl $0x242, %esi            # imm = 0x242
movl $0x1a4, %edx            # imm = 0x1A4
movb $0x0, %al
callq 0x10d0
movl %eax, -0x20(%rbp)
jmp 0x9d23
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x10d0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x9d66
cmpq $0x0, -0x18(%rbp)
je 0x9d5b
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x10f0
movq -0x28(%rbp), %rsi
movq %rax, %rdx
leaq 0xa67c(%rip), %rdi      # 0x143ce
movb $0x0, %al
callq 0xad50
jmp 0x9d5d
jmp 0x9d5d
movl $0x1, -0x4(%rbp)
jmp 0x9d76
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x9da8
movl $0x0, -0x4(%rbp)
jmp 0x9eef
jmp 0x9daa
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x9ed5
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1060
movq %rax, -0x28(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x10f0
movq %rax, %rdi
leaq 0xa5c8(%rip), %rsi      # 0x143b0
movl $0x1a, %edx
callq 0xb960
cmpl $0x0, %eax
jne 0x9e3a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x10f0
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
leaq 0xa599(%rip), %rdi      # 0x143ca
movb $0x0, %al
callq 0xad50
jmp 0x9eac
cmpq $0x0, -0x28(%rbp)
je 0x9e6c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0xa56e(%rip), %rdi      # 0x143ca
leaq 0xa573(%rip), %rcx      # 0x143d6
movb $0x0, %al
callq 0xad50
jmp 0x9eaa
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x10d0
movl %eax, %edx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl %edx, 0xc(%rax,%rcx,4)
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl %edx, 0x408(%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9eac
cmpq $0x0, -0x28(%rbp)
je 0x9ebc
movq -0x28(%rbp), %rdi
callq 0x1090
callq 0x1040
movl $0x0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9daa
cmpl $0x0, -0x20(%rbp)
je 0x9ee3
movl -0x20(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x9ee9
movl -0x20(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)