LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/rsa/asn1_helper.c
// Function: byte_string
uint8_t		*byte_string(uint8_t *buf, __uint64_t n)
{
	int		i;
	int		p;
	int		trig;

	i = -1;
	p = 0;
	trig = 0;
	ft_bzero(buf, 10);
	while (++i < 8)
	{
		if (trig || (n & (0xFFULL << 8 * (7 - i))) >> 8 * (7 - i))
		{
			buf[p] = (n & (0xFFULL << 8 * (7 - i))) >> 8 * (7 - i);
			DEBUG ? ft_printf("[%02x]", buf[p]) : 0;
			if (!trig && (buf[p] & 0x80))
			{
				buf[p + 1] = buf[p];
				buf[p++] = 0xFF;
			}
			p++;
			trig = 1;
		}
	}
	DEBUG ? ft_printf(" [%llu]\n", n) : 0;
	return (buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0xa600
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x8, %eax
jge 0x1cc2
cmpl $0x0, -0x1c(%rbp)
jne 0x1c24
movq -0x10(%rbp), %rax
movl $0x7, %ecx
subl -0x14(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
movl $0xff, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
movl $0x7, %ecx
subl -0x14(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rax
cmpq $0x0, %rax
je 0x1cbd
movq -0x10(%rbp), %rax
movl $0x7, %ecx
subl -0x14(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
movl $0xff, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
movl $0x7, %ecx
subl -0x14(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
cmpl $0x0, -0x1c(%rbp)
jne 0x1cad
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x1cad
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x18(%rbp)
movslq %ecx, %rcx
movb $-0x1, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
jmp 0x1bd3
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/rsa/asn1_helper.c
// Function: dump_to_buf
void		dump_to_buf(uint8_t *buf, char c, uint8_t *s, int *len)
{
	int		i;
	int		n;

	if (!s)
	{
		buf[*len] = c;
		++(*len);
	}
	else
	{
		i = 0;
		n = ft_strlen((char*)s);
		if (n == 1 && s[2] == '\x01')
			n = 3;
		DEBUG ? ft_printf("len:[%d] ", n) : 0;
		while (i < n || s[n])
		{
			DEBUG ? ft_printf("{%d}", i) : 0;
			buf[*len] = s[i];
			++(*len);
			++i;
		}
		DEBUG ? ft_printf(" ---\n") : 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1d12
movb -0x9(%rbp), %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x1d9d
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbf10
movl %eax, -0x28(%rbp)
cmpl $0x1, -0x28(%rbp)
jne 0x1d3f
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x1, %eax
jne 0x1d3f
movl $0x3, -0x28(%rbp)
jmp 0x1d41
movl -0x24(%rbp), %ecx
movb $0x1, %al
cmpl -0x28(%rbp), %ecx
movb %al, -0x29(%rbp)
jl 0x1d63
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x1d6c
jmp 0x1d9b
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1d41
jmp 0x1d9d
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/encode/base64.c
// Function: decode_driver
void			decode_driver(t_parse *b64)
{
	uint8_t		buf[66];
	uint8_t		dec[50];
	int			len;

	ft_bzero(buf, 66);
	ft_bzero(dec, 50);
	while ((len = read(b64->fd_in, buf, 65)) == 65)
	{
		buf[ft_strchri((char *)buf, '\n')] = 0;
		base64_decode(buf, dec, len);
		dec[(len / 4) * 3] = 0;
		ft_putstr_fd((char *)dec, b64->fd_out);
		ft_bzero(buf, 65);
		ft_bzero(dec, 49);
	}
	buf[ft_strchri((char *)buf, '\n')] = 0;
	base64_decode(buf, dec, len);
	dec[(int)((float)(len * 2) / 3.0)] = 0;
	ft_putstr_fd((char *)dec, b64->fd_out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x50(%rbp), %rdi
movl $0x42, %esi
callq 0xa600
leaq -0x90(%rbp), %rdi
movl $0x32, %esi
callq 0xa600
movq -0x8(%rbp), %rax
movl (%rax), %edi
leaq -0x50(%rbp), %rsi
movl $0x41, %edx
callq 0x10a0
movl %eax, -0x94(%rbp)
cmpl $0x41, %eax
jne 0x233a
leaq -0x50(%rbp), %rdi
movl $0xa, %esi
callq 0xb7f0
cltq
movb $0x0, -0x50(%rbp,%rax)
leaq -0x50(%rbp), %rdi
leaq -0x90(%rbp), %rsi
movl -0x94(%rbp), %edx
callq 0x2030
movl -0x94(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
imull $0x3, %eax, %eax
cltq
movb $0x0, -0x90(%rbp,%rax)
leaq -0x90(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xb230
leaq -0x50(%rbp), %rdi
movl $0x41, %esi
callq 0xa600
leaq -0x90(%rbp), %rdi
movl $0x31, %esi
callq 0xa600
jmp 0x229e
leaq -0x50(%rbp), %rdi
movl $0xa, %esi
callq 0xb7f0
cltq
movb $0x0, -0x50(%rbp,%rax)
leaq -0x50(%rbp), %rdi
leaq -0x90(%rbp), %rsi
movl -0x94(%rbp), %edx
callq 0x2030
movl -0x94(%rbp), %eax
shll %eax
cvtsi2ss %eax, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x10c9b(%rip), %xmm1    # 0x13018
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
cltq
movb $0x0, -0x90(%rbp,%rax)
leaq -0x90(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xb230
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/choose.c
// Function: ssl_b64
void			ssl_b64(char **av, t_ssl *ssl)
{
	t_parse		b64;
	uint8_t		buf[64];
	int			len;
	int			i;

	ft_bzero(&b64, sizeof(b64));
	ft_bzero(buf, 64);
	b64.fd_out = 1;
	if (parse_b64(av, &b64, ssl, 1))
		;
	else
	{
		i = 0;
		if (b64.flag & D_FLAG)
			decode_driver(&b64);
		else
		{
			while ((len = read(b64.fd_in, buf, 63)) == 63)
			{
				base64_nstr_fd(buf, len, b64.fd_out, &i);
				ft_bzero(buf, 64);
			}
			base64_nstr_fd(buf, len, b64.fd_out, &i);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x1c(%rbp), %rdi
movl $0xc, %esi
callq 0xa600
leaq -0x60(%rbp), %rdi
movl $0x40, %esi
callq 0xa600
movl $0x1, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x1c(%rbp), %rsi
movl $0x1, %ecx
callq 0x23b0
cmpl $0x0, %eax
je 0x29b0
jmp 0x2a28
movl $0x0, -0x68(%rbp)
movw -0x14(%rbp), %ax
andw $0xfff, %ax             # imm = 0xFFF
movzwl %ax, %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x29d5
leaq -0x1c(%rbp), %rdi
callq 0x2270
jmp 0x2a26
jmp 0x29d7
movl -0x1c(%rbp), %edi
leaq -0x60(%rbp), %rsi
movl $0x3f, %edx
callq 0x10a0
movl %eax, -0x64(%rbp)
cmpl $0x3f, %eax
jne 0x2a13
leaq -0x60(%rbp), %rdi
movl -0x64(%rbp), %esi
movl -0x18(%rbp), %edx
leaq -0x68(%rbp), %rcx
callq 0x1db0
leaq -0x60(%rbp), %rdi
movl $0x40, %esi
callq 0xa600
jmp 0x29d7
leaq -0x60(%rbp), %rdi
movl -0x64(%rbp), %esi
movl -0x18(%rbp), %edx
leaq -0x68(%rbp), %rcx
callq 0x1db0
jmp 0x2a28
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/choose.c
// Function: ssl_standard
void			ssl_standard(char **av, t_ssl *ssl)
{
	if (ssl->type == 41 && ft_printf("%s%s", VERSION, COPYRIGHT))
		;
	else if (ssl->type == 42)
		rand_command(av, ssl, 0);
	else if (ssl->type == 43 && opt_desciption(ssl->type))
		;
	(void)av;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x29, 0x8(%rax)
jne 0x2a9d
leaq 0x10b5f(%rip), %rdi     # 0x135e0
leaq 0x10622(%rip), %rsi     # 0x130aa
leaq 0x10651(%rip), %rdx     # 0x130e0
movb $0x0, %al
callq 0xad50
cmpl $0x0, %eax
je 0x2a9d
jmp 0x2ad9
movq -0x10(%rbp), %rax
cmpl $0x2a, 0x8(%rax)
jne 0x2ab8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x6310
jmp 0x2ad7
movq -0x10(%rbp), %rax
cmpl $0x2b, 0x8(%rax)
jne 0x2ad5
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x2c70
cmpl $0x0, %eax
je 0x2ad5
jmp 0x2ad5
jmp 0x2ad7
jmp 0x2ad9
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/encode/encode.c
// Function: p_k_s_v
int					p_k_s_v(char **av, int *i, int *j, t_ssl *ssl)
{
	if (av[*i][++(*j)])
	{
		ft_printf("will use '%s' as parameter of function '%c'\n",
		&av[*i][*j], av[*i][(*j) - 1]);
		return (1);
	}
	if (av[++(*i)] && av[*i][0])
	{
		ft_printf("will use '%s' as parameter of function '%c'\n",
		&av[*i][0], av[(*i) - 1][(*j) - 1]);
		return (1);
	}
	ssl->fd[104] = 0;
	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 -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rdx
movl (%rdx), %ecx
addl $0x1, %ecx
movl %ecx, (%rdx)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x2b6d
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x20(%rbp), %rax
movslq (%rax), %rax
addq %rax, %rsi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edx
leaq 0x105b5(%rip), %rdi     # 0x1310f
movb $0x0, %al
callq 0xad50
movl $0x1, -0x4(%rbp)
jmp 0x2bfc
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdx
movl (%rdx), %ecx
addl $0x1, %ecx
movl %ecx, (%rdx)
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x2be7
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2be7
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edx
leaq 0x10538(%rip), %rdi     # 0x1310f
movb $0x0, %al
callq 0xad50
movl $0x1, -0x4(%rbp)
jmp 0x2bfc
movq -0x28(%rbp), %rax
movl $0x0, 0x1ac(%rax)
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/error.c
// Function: full_usage
void			full_usage(char *ex, int type)
{
	dprintf(2, "%susage%s: ", YEL, NOCOL);
	if (type < 10)
		dprintf(2, "%s [-pqr] [-s string] [files ...]\n", ex);
	else if (type < 30)
	{
		dprintf(2, "%s [-a | -d | -e] [-p passwd] [-k key] [-s salt] ", ex);
		dprintf(2, "[-v vector] [-in file] [-out file]\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x2, %edi
leaq 0x10961(%rip), %rsi     # 0x139bc
leaq 0x1019e(%rip), %rdx     # 0x13200
leaq 0x1019f(%rip), %rcx     # 0x13208
movb $0x0, %al
callq 0x1080
cmpl $0xa, -0xc(%rbp)
jge 0x308f
movq -0x8(%rbp), %rdx
movl $0x2, %edi
leaq 0x10942(%rip), %rsi     # 0x139c8
movb $0x0, %al
callq 0x1080
jmp 0x30c1
cmpl $0x1e, -0xc(%rbp)
jge 0x30bf
movq -0x8(%rbp), %rdx
movl $0x2, %edi
leaq 0x10946(%rip), %rsi     # 0x139eb
movb $0x0, %al
callq 0x1080
movl $0x2, %edi
leaq 0x10965(%rip), %rsi     # 0x13a1d
movb $0x0, %al
callq 0x1080
jmp 0x30c1
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/error.c
// Function: rsa_error
void			rsa_error(int e)
{
	if (e == 20)
		ft_putstr_fd("Only private keys can be checked\n", 2);
	if (e == 19)
		ft_putstr_fd("A private key is needed for this operation\n", 2);
	else
	{
		e > 22 ? ft_putstr_fd("no keyfile specified\n", 2) : 0;
		ft_putstr_fd("Unable to load", 2);
		ft_putstr_fd(e % 2 ? " Public " : " Private ", 2);
		ft_putstr_fd("Key\n", 2);
	}
	if (e <= 8)
		ft_putstr_fd("PEM routines:PEM_read_bio:bad base64 decode\n", 2);
	else if (e <= 10)
		ft_putstr_fd("PEM routines:PEM_read_bio:no start line\n", 2);
	else if (e <= 12)
		ft_putstr_fd("PEM routines:PEM_read_bio:bad end line\n", 2);
	else if (e <= 14)
		ft_putstr_fd("asn1 encoding routines:ASN1_CHECK_T:wrong tag\n", 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x14, -0x4(%rbp)
jne 0x30f2
leaq 0x10959(%rip), %rdi     # 0x13a41
movl $0x2, %esi
callq 0xb230
cmpl $0x13, -0x4(%rbp)
jne 0x310b
leaq 0x10964(%rip), %rdi     # 0x13a63
movl $0x2, %esi
callq 0xb230
jmp 0x3172
cmpl $0x16, -0x4(%rbp)
jle 0x3124
leaq 0x10977(%rip), %rdi     # 0x13a8f
movl $0x2, %esi
callq 0xb230
jmp 0x3126
jmp 0x3126
leaq 0x10978(%rip), %rdi     # 0x13aa5
movl $0x2, %esi
callq 0xb230
movl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
leaq 0x10974(%rip), %rdi     # 0x13abd
leaq 0x10964(%rip), %rax     # 0x13ab4
cmpl $0x0, %edx
cmovneq %rax, %rdi
movl $0x2, %esi
callq 0xb230
leaq 0x1095f(%rip), %rdi     # 0x13ac7
movl $0x2, %esi
callq 0xb230
cmpl $0x8, -0x4(%rbp)
jg 0x318b
leaq 0x1094d(%rip), %rdi     # 0x13acc
movl $0x2, %esi
callq 0xb230
jmp 0x31da
cmpl $0xa, -0x4(%rbp)
jg 0x31a4
leaq 0x10961(%rip), %rdi     # 0x13af9
movl $0x2, %esi
callq 0xb230
jmp 0x31d8
cmpl $0xc, -0x4(%rbp)
jg 0x31bd
leaq 0x10971(%rip), %rdi     # 0x13b22
movl $0x2, %esi
callq 0xb230
jmp 0x31d6
cmpl $0xe, -0x4(%rbp)
jg 0x31d4
leaq 0x10980(%rip), %rdi     # 0x13b4a
movl $0x2, %esi
callq 0xb230
jmp 0x31d6
jmp 0x31d8
jmp 0x31da
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/error.c
// Function: ft_error2
void			ft_error2(char *s, t_ssl *ssl, int e)
{
	if (e != 6)
	{
		e > 20 && e < 23 ? ft_putstr_fd("RSA operation error\n", 2) : 0;
		if (e == 21 || e == 22)
		{
			ft_putstr_fd("RSA_padding_add_none:data too", 2);
			ft_putstr_fd(e % 2 ? " small " : " large ", 2);
			ft_putstr_fd("for key size\n", 2);
		}
		else
			rsa_error(e);
		return ;
	}
	else if (!(!ft_strcmp(s, "help") || !ft_strcmp(s, "h") ||\
	!ft_strcmp(s, "in") || !ft_strcmp(s, "inkey") || ssl->flag == -42))
		dprintf(2, "ft_ssl: Error: invalid option: \'%s\'\n", s);
	if (ssl->type == 31)
		dprintf(2, "%susage%s: genrsa [args] [numbits]\n", YEL, NOCOL);
	else if (ssl->type == 32)
		dprintf(2, "%susage%s: rsautl [options]\n", YEL, NOCOL);
	else if (ssl->type == 33)
		dprintf(2, "%susage%s: rsa [options]\n", YEL, NOCOL);
	opt_desciption(ssl->type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x6, -0x14(%rbp)
je 0x3285
cmpl $0x14, -0x14(%rbp)
jle 0x321c
cmpl $0x17, -0x14(%rbp)
jge 0x321c
leaq 0x10969(%rip), %rdi     # 0x13b79
movl $0x2, %esi
callq 0xb230
jmp 0x321e
jmp 0x321e
cmpl $0x15, -0x14(%rbp)
je 0x322a
cmpl $0x16, -0x14(%rbp)
jne 0x3278
leaq 0x1095d(%rip), %rdi     # 0x13b8e
movl $0x2, %esi
callq 0xb230
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
leaq 0x10967(%rip), %rdi     # 0x13bb4
leaq 0x10958(%rip), %rax     # 0x13bac
cmpl $0x0, %edx
cmovneq %rax, %rdi
movl $0x2, %esi
callq 0xb230
leaq 0x10950(%rip), %rdi     # 0x13bbc
movl $0x2, %esi
callq 0xb230
jmp 0x3280
movl -0x14(%rbp), %edi
callq 0x30d0
jmp 0x3391
movq -0x8(%rbp), %rdi
leaq 0x1093a(%rip), %rsi     # 0x13bca
callq 0xb8e0
cmpl $0x0, %eax
je 0x32fa
movq -0x8(%rbp), %rdi
leaq 0x1092a(%rip), %rsi     # 0x13bcf
callq 0xb8e0
cmpl $0x0, %eax
je 0x32fa
movq -0x8(%rbp), %rdi
leaq 0x11087(%rip), %rsi     # 0x14341
callq 0xb8e0
cmpl $0x0, %eax
je 0x32fa
movq -0x8(%rbp), %rdi
leaq 0x10902(%rip), %rsi     # 0x13bd1
callq 0xb8e0
cmpl $0x0, %eax
je 0x32fa
movq -0x10(%rbp), %rax
cmpl $-0x2a, 0x4(%rax)
je 0x32fa
movq -0x8(%rbp), %rdx
movl $0x2, %edi
leaq 0x108e4(%rip), %rsi     # 0x13bd7
movb $0x0, %al
callq 0x1080
jmp 0x32fc
movq -0x10(%rbp), %rax
cmpl $0x1f, 0x8(%rax)
jne 0x3329
movl $0x2, %edi
leaq 0x108ea(%rip), %rsi     # 0x13bfc
leaq 0xfee7(%rip), %rdx      # 0x13200
leaq 0xfee8(%rip), %rcx      # 0x13208
movb $0x0, %al
callq 0x1080
jmp 0x3385
movq -0x10(%rbp), %rax
cmpl $0x20, 0x8(%rax)
jne 0x3356
movl $0x2, %edi
leaq 0x108e1(%rip), %rsi     # 0x13c20
leaq 0xfeba(%rip), %rdx      # 0x13200
leaq 0xfebb(%rip), %rcx      # 0x13208
movb $0x0, %al
callq 0x1080
jmp 0x3383
movq -0x10(%rbp), %rax
cmpl $0x21, 0x8(%rax)
jne 0x3381
movl $0x2, %edi
leaq 0x108d1(%rip), %rsi     # 0x13c3d
leaq 0xfe8d(%rip), %rdx      # 0x13200
leaq 0xfe8e(%rip), %rcx      # 0x13208
movb $0x0, %al
callq 0x1080
jmp 0x3383
jmp 0x3385
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x2c70
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/error.c
// Function: ft_error
int				ft_error(int err, char *ex, t_ssl *ssl)
{
	if (err == 1)
	{
		dprintf(2, "ft_ssl: Error: '%s' is an invalid command.\n\n", ex);
		show_supported();
	}
	if (err == 2)
	{
		dprintf(2, "Error: %s: option requires an argument -- %c\n",
		ex, ssl->flag);
		ssl->flag = 0;
	}
	if (err == 3)
	{
		full_usage(ex, ssl->type);
		if (ssl->flag || VERBOSE)
			opt_desciption(ssl->type);
	}
	if (err == 4 && *ex != 'h')
		dprintf(2, "unknown option '-%c'\n", *ex);
	if (err == 5)
		dprintf(2, "ft_ssl: Error: %s need a flag\n", ex);
	if (err >= 6)
		ft_error2(ex, ssl, err);
	return (!err ? 0 : -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x1, -0x4(%rbp)
jne 0x33d5
movq -0x10(%rbp), %rdx
movl $0x2, %edi
leaq 0x1088e(%rip), %rsi     # 0x13c57
movb $0x0, %al
callq 0x1080
callq 0x6920
cmpl $0x2, -0x4(%rbp)
jne 0x3404
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movl $0x2, %edi
leaq 0x10892(%rip), %rsi     # 0x13c84
movb $0x0, %al
callq 0x1080
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
cmpl $0x3, -0x4(%rbp)
jne 0x3432
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x3040
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x3430
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x2c70
jmp 0x3432
cmpl $0x4, -0x4(%rbp)
jne 0x345e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x68, %eax
je 0x345e
movq -0x10(%rbp), %rax
movsbl (%rax), %edx
movl $0x2, %edi
leaq 0x1085b(%rip), %rsi     # 0x13cb2
movb $0x0, %al
callq 0x1080
cmpl $0x5, -0x4(%rbp)
jne 0x347b
movq -0x10(%rbp), %rdx
movl $0x2, %edi
leaq 0x10854(%rip), %rsi     # 0x13cc8
movb $0x0, %al
callq 0x1080
cmpl $0x6, -0x4(%rbp)
jl 0x3491
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x4(%rbp), %edx
callq 0x31e0
cmpl $0x0, -0x4(%rbp)
setne %dl
xorb $-0x1, %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/rsa/genrsa.c
// Function: genprime
__uint64_t		genprime(int bits, int out)
{
	__uint64_t			p;
	__uint64_t			min;
	__uint64_t			max;
	unsigned int		i;

	min = 1ULL << (abs(bits - 1));
	max = (1ULL << bits) - 1;
	i = 0;
	while (1)
	{
		if (i % (bits * 2) == 0)
		{
			p = genrand(min, max) | 1;
			p |= 1ULL << (bits - 1);
			out ? 0 : ft_putchar_fd('.', 2);
		}
		if (ft_is_primary(p, out))
			break ;
		out ? 0 : ft_putchar_fd('.', 2);
		p -= 2;
		i++;
	}
	DEBUG ? ft_printf("\nSUCCESS\tprime --> [%llb]", p) : 0;
	out ? 0 : ft_putchar_fd('\n', 2);
	return (p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x4(%rbp), %ecx
shll %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x0, %edx
jne 0x3550
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5d90
orq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x353f
jmp 0x354e
movl $0x2e, %edi
movl $0x2, %esi
callq 0xb200
jmp 0x3550
movq -0x10(%rbp), %rdi
cvtsi2ssl -0x8(%rbp), %xmm0
callq 0x4b80
cmpl $0x0, %eax
je 0x3565
jmp 0x3596
cmpl $0x0, -0x8(%rbp)
je 0x356d
jmp 0x357c
movl $0x2e, %edi
movl $0x2, %esi
callq 0xb200
movq -0x10(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x10(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x34f7
cmpl $0x0, -0x8(%rbp)
je 0x359e
jmp 0x35ad
movl $0xa, %edi
movl $0x2, %esi
callq 0xb200
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/rsa/genrsa.c
// Function: valid_modulus
__uint64_t		valid_modulus(t_rsa gg, int bits)
{
	__uint64_t	n;

	n = gg.p * gg.q;
	if ((n / gg.p == gg.q) && n & 1ULL << (bits - 1) &&\
	n <= (bits == 64 ? UINT64_MAX : (1ULL << bits)))
		return (n);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rcx
movl %edi, -0xc(%rbp)
movq (%rcx), %rax
imulq 0x8(%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
xorl %edx, %edx
divq (%rcx)
cmpq 0x8(%rcx), %rax
jne 0x3649
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x3649
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x40, -0xc(%rbp)
jne 0x3621
movq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3632
movl -0xc(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq %rcx, %rax
ja 0x3649
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3651
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/hash/hash.c
// Function: copy_free
void			copy_free(char *buf, char **acontents)
{
	char		*tmp;
	char		*contents;
	int			len;

	buf[PAGESIZE] = 0;
	tmp = NULL;
	contents = *acontents;
	tmp = ft_strjoin(contents, buf);
	len = ft_strlen(tmp);
	ft_strdel(&contents);
	contents = ft_strdup(tmp);
	ft_strdel(&tmp);
	*acontents = contents;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x1000(%rax)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xbc60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbf10
movl %eax, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xbc20
movq -0x18(%rbp), %rdi
callq 0xc1d0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xbc20
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/hash/hash.c
// Function: get_hash
char			*get_hash(char **to_hash, char **input, t_ssl *ssl, int i)
{
	char		buf[PAGESIZE + 1];
	char		*contents;
	char		*tmp;
	static char	*(*hasher[6])(char *, char *) = {
				md5, sha224, sha256, sha384, sha512, sha1};

	ft_bzero(buf, PAGESIZE);
	contents = NULL;
	tmp = NULL;
	*input = *to_hash;
	if (ssl->fd[i] > 2)
	{
		contents = ft_strdup("");
		while (read(ssl->fd[i], buf, PAGESIZE) > 0)
		{
			copy_free(buf, &contents);
			ft_bzero(buf, PAGESIZE);
		}
		close(ssl->fd[i]);
		*to_hash = ft_strdup(contents);
		ft_strdel(&contents);
	}
	else
		*to_hash = ft_strdup(*to_hash);
	return ((*hasher[ssl->type - 1])(buf, *to_hash));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq -0x1020(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0xa600
movq $0x0, -0x1028(%rbp)
movq $0x0, -0x1030(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x2, 0xc(%rax,%rcx,4)
jle 0x39e3
leaq 0x1032a(%rip), %rdi     # 0x13c83
callq 0xc1d0
movq %rax, -0x1028(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl 0xc(%rax,%rcx,4), %edi
leaq -0x1020(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x10a0
cmpq $0x0, %rax
jle 0x39ae
leaq -0x1020(%rbp), %rdi
leaq -0x1028(%rbp), %rsi
callq 0x3870
leaq -0x1020(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0xa600
jmp 0x3965
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl 0xc(%rax,%rcx,4), %edi
callq 0x1070
movq -0x1028(%rbp), %rdi
callq 0xc1d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
leaq -0x1028(%rbp), %rdi
callq 0xbc20
jmp 0x39f9
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xc1d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x14743(%rip), %rax     # 0x18150
movq (%rax,%rcx,8), %rax
leaq -0x1020(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/hash/hash.c
// Function: string_input
char			string_input(char **av, int *i, int *j, t_ssl *ssl)
{
	char	p_flag;

	p_flag = 0;
	if (ssl->flag & P_FLAG)
		p_flag = 1;
	if (!(ssl->flag & R_FLAG))
		ssl->flag |= S_FLAG;
	if (av[*i][++(*j)])
	{
		ssl->flag &= ~P_FLAG;
		hash(av[1], &av[*i][*j], ssl, 0);
		if (p_flag)
			ssl->flag |= P_FLAG;
		return (1);
	}
	if (av[++(*i)] && av[*i][0])
	{
		ssl->flag &= ~P_FLAG;
		hash(av[1], &av[*i][0], ssl, 0);
		if (p_flag)
			ssl->flag |= P_FLAG;
		return (1);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x3ce1
movb $0x1, -0x29(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x20000, %eax          # imm = 0x20000
cmpl $0x0, %eax
jne 0x3d02
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
orl $0x40000, %ecx          # imm = 0x40000
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rdx
movl (%rdx), %ecx
addl $0x1, %ecx
movl %ecx, (%rdx)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x3d80
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
andl $0xffff7fff, %ecx       # imm = 0xFFFF7FFF
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x20(%rbp), %rax
movslq (%rax), %rax
addq %rax, %rsi
movq -0x28(%rbp), %rdx
xorl %ecx, %ecx
callq 0x3a30
cmpb $0x0, -0x29(%rbp)
je 0x3d77
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
orl $0x8000, %ecx           # imm = 0x8000
movl %ecx, 0x4(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3e02
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdx
movl (%rdx), %ecx
addl $0x1, %ecx
movl %ecx, (%rdx)
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x3dfe
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x3dfe
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
andl $0xffff7fff, %ecx       # imm = 0xFFFF7FFF
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x28(%rbp), %rdx
xorl %ecx, %ecx
callq 0x3a30
cmpb $0x0, -0x29(%rbp)
je 0x3df8
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
orl $0x8000, %ecx           # imm = 0x8000
movl %ecx, 0x4(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3e02
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/inputs.c
// Function: get_inputs
int				get_inputs(int *ac, char ***av)
{
	char	**replace;

	*ac += 1;
	replace = malloc(sizeof(*replace) * (*ac + 1));
	replace[0] = ft_strdup(**av);
	replace[1] = ft_strdup("\0");
	while (replace[1][0] == '\n' || replace[1][0] == '\0')
	{
		ft_printf("ft_ssl> ");
		ft_strdel(&replace[1]);
		get_stdin(&(replace[1]), 0, 0, 0);
		if (!replace[1])
		{
			ft_strdel(&replace[0]);
			free(replace);
			return (1);
		}
		if (check_for_spaces(replace, av, ac))
			return (0);
	}
	replace[*ac] = 0;
	*av = replace;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x10c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0xc1d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
leaq 0xfbf7(%rip), %rdi      # 0x13d3b
callq 0xc1d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x21(%rbp)
je 0x417d
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x4186
jmp 0x4200
leaq 0xfbb0(%rip), %rdi      # 0x13d3d
movb $0x0, %al
callq 0xad50
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0xbc20
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x9f00
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x41dc
movq -0x20(%rbp), %rdi
callq 0xbc20
movq -0x20(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
jmp 0x4225
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x4230
cmpl $0x0, %eax
je 0x41fb
movl $0x0, -0x4(%rbp)
jmp 0x4225
jmp 0x4154
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%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/inputs.c
// Function: check_for_spaces
static int		check_for_spaces(char **input, char ***av, int *ac)
{
	char		**replace;
	char		**split;
	int			i;

	if (ft_countwords(input[1], ' ') > 1)
	{
		*ac += (ft_countwords(input[1], ' ') - 1);
		replace = (char **)malloc(sizeof(*replace) * (*ac + 1));
		split = ft_strsplit(input[1], ' ');
		replace[0] = ft_strdup(input[0]);
		ft_pipewrench("-s-s", &input[0], &input[1]);
		free(input);
		i = -1;
		while (++i < (*ac) - 1)
		{
			replace[i + 1] = ft_strdup(split[i]);
			free(split[i]);
		}
		free(split);
		replace[*ac] = 0;
		*av = replace;
		return (1);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x20, %esi
callq 0xc310
cmpl $0x1, %eax
jle 0x436b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x20, %esi
callq 0xc310
movl %eax, %ecx
subl $0x1, %ecx
movq -0x20(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x10c0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x20, %esi
callq 0xc3e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xc1d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
leaq 0xfa7a(%rip), %rdi      # 0x13d50
movb $0x0, %al
callq 0xa8d0
movq -0x10(%rbp), %rdi
callq 0x1030
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x433b
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xc1d0
movq %rax, %rdx
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
jmp 0x42ed
movq -0x30(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4372
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/inputs.c
// Function: handle_inputs
int				handle_inputs(int *ac, char ***av, t_ssl *ssl)
{
	static void	(*choose[5])(char **, t_ssl *) = {
				ssl_md5, ssl_b64, ssl_des, ssl_rsa, ssl_standard};
	char		**pv;

	if (*ac < 2 && (ssl->stdin = 1))
		if (get_inputs(ac, av))
			return (0);
	pv = *av;
	if (!ft_strcmp(pv[1], "quit") || !ft_strcmp(pv[1], "exit"))
		return (clean_exit(0, pv));
	if (valid_command(pv[1], ssl))
		return (ft_error(1, pv[1], ssl));
	if (ssl->type > 10)
	{
		choose[ssl->type / 10](pv, ssl);
		return (1);
	}
	if (parse_av(*(av), ssl, 1, 0))
		return (ft_error(3, pv[1], ssl));
	if (!read_files(pv, ssl, ssl->file_index[0], 0))
		if ((ssl->type < 10) &&
		!(ssl->flag & 0x38000) && ssl->flag && !ssl->file_index[0])
			return (DEBUG ? ft_printf("Here I AM\n") : 1);
	choose[0](pv, ssl);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jge 0x45cf
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movb $0x1, %al
testb $0x1, %al
jne 0x45af
jmp 0x45cf
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x40f0
cmpl $0x0, %eax
je 0x45cd
movl $0x0, -0x4(%rbp)
jmp 0x473a
jmp 0x45cf
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xf75d(%rip), %rsi      # 0x13d46
callq 0xb8e0
cmpl $0x0, %eax
je 0x460c
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xf749(%rip), %rsi      # 0x13d4b
callq 0xb8e0
cmpl $0x0, %eax
jne 0x461f
movq -0x28(%rbp), %rsi
xorl %edi, %edi
callq 0x4dc0
movl %eax, -0x4(%rbp)
jmp 0x473a
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x6770
cmpl $0x0, %eax
je 0x4653
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %edi
callq 0x33a0
movl %eax, -0x4(%rbp)
jmp 0x473a
movq -0x20(%rbp), %rax
cmpl $0xa, 0x8(%rax)
jle 0x4690
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movslq %eax, %rcx
leaq 0x13b0a(%rip), %rax     # 0x18180
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x473a
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x4380
cmpl $0x0, %eax
je 0x46c7
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
movl $0x3, %edi
callq 0x33a0
movl %eax, -0x4(%rbp)
jmp 0x473a
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movl 0x408(%rax), %edx
xorl %ecx, %ecx
callq 0x9d80
cmpl $0x0, %eax
jne 0x4722
movq -0x20(%rbp), %rax
cmpl $0xa, 0x8(%rax)
jge 0x4720
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x38000, %eax          # imm = 0x38000
cmpl $0x0, %eax
jne 0x4720
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x4720
movq -0x20(%rbp), %rax
cmpl $0x0, 0x408(%rax)
jne 0x4720
movl $0x1, -0x4(%rbp)
jmp 0x473a
jmp 0x4722
movq 0x13a57(%rip), %rax     # 0x18180
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/rsa/is_primary.c
// Function: array_make
__uint64_t		*array_make(int len, ...)
{
	va_list		ap;
	__uint64_t	*a;
	int			i;

	a = malloc(sizeof(__uint64_t) * (len + 1));
	i = 0;
	va_start(ap, len);
	while (i < len)
	{
		a[i] = va_arg(ap, int);
		i++;
	}
	a[len] = 0;
	va_end(ap);
	return (a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x4788
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x10c0
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movl -0x2c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x4873
leaq -0x20(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0xe4(%rbp)
cmpl $0x28, %eax
ja 0x4832
movq -0xf0(%rbp), %rcx
movl -0xe4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0xf8(%rbp)
jmp 0x484f
movq -0xf0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movslq (%rax), %rdx
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x47ef
movq -0x28(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/rsa/is_primary.c
// Function: ft_is_primary
int				ft_is_primary(__uint64_t number, float probability)
{
	t_primary	checks;
	int			ret;

	if (number == 2 || number == 3)
		return (1);
	if (number == 1 || !(number & 0x1))
		return (0);
	checks.d = number - 1;
	checks.r = 0;
	while (!(checks.d & 0x1) && ++checks.r)
		checks.d /= 2;
	checks.a = get_a(number);
	ret = witness(number, &checks, (int)probability);
	free(checks.a);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
cmpq $0x2, -0x10(%rbp)
je 0x4b9f
cmpq $0x3, -0x10(%rbp)
jne 0x4bab
movl $0x1, -0x4(%rbp)
jmp 0x4c50
cmpq $0x1, -0x10(%rbp)
je 0x4bc0
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x4bcc
movl $0x0, -0x4(%rbp)
jmp 0x4c50
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rcx
andq $0x1, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x3d(%rbp)
jne 0x4c09
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x4c12
jmp 0x4c1f
movq -0x38(%rbp), %rax
shrq %rax
movq %rax, -0x38(%rbp)
jmp 0x4be0
movq -0x10(%rbp), %rdi
callq 0x4890
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
cvttss2si -0x14(%rbp), %edx
leaq -0x38(%rbp), %rsi
callq 0x4c60
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/rsa/is_primary.c
// Function: witness
static int		witness(__uint64_t n, t_primary *checks, int prob)
{
	__uint64_t	tmp;
	int			i;

	tmp = checks->r;
	i = -1;
	while (checks->a[++i] != 0)
	{
		checks->r = tmp;
		checks->x = powmod(checks->a[i], checks->d, n);
		if (checks->x == 1 || checks->x == n - 1)
			break ;
		while (checks->r - 1)
		{
			checks->x = (checks->x * checks->x) % n;
			if (checks->x == n - 1)
				break ;
			--checks->r;
		}
		if (!(checks->r - 1) && !(checks->a[i + 1]))
			return (0);
	}
	prob ? 0 : ft_putchar_fd('+', 2);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x2c(%rbp)
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x4d97
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x50e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
cmpq $0x1, 0x10(%rax)
je 0x4cfc
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x4d01
jmp 0x4d97
jmp 0x4d03
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
cmpq $0x0, %rax
je 0x4d5f
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
imulq 0x10(%rcx), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rdx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x4d4d
jmp 0x4d5f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x4d03
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
cmpq $0x0, %rax
jne 0x4d92
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x4d92
movl $0x0, -0x4(%rbp)
jmp 0x4db5
jmp 0x4c86
cmpl $0x0, -0x1c(%rbp)
je 0x4d9f
jmp 0x4dae
movl $0x2b, %edi
movl $0x2, %esi
callq 0xb200
movl $0x1, -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/main.c
// Function: clean_exit
int				clean_exit(int ac, char **av)
{
	int		i;

	i = 0;
	while (ac ? i < ac : av[i] != 0)
	{
		ft_strdel(&av[i]);
		i++;
	}
	ft_memdel((void**)&av);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x4def
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x18(%rbp)
jmp 0x4e07
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl $0x0, %eax
je 0x4e2e
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0xbc20
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4dd6
leaq -0x10(%rbp), %rdi
callq 0xbbe0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/main.c
// Function: main
int				main(int ac, char **av)
{
	t_ssl	ssl;
	char	**tmp;

	ft_bzero(&ssl, (sizeof(t_ssl)));
	tmp = av;
	while (handle_inputs(&ac, &av, &ssl))
	{
		if (!ssl.stdin)
			break ;
		clean_exit(ac, av);
		ft_bzero(&ssl, (sizeof(t_ssl)));
		ac = 1;
		av = tmp;
	}
	DEBUG ? system("leaks ft_ssl") : 0;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x820, %rsp            # imm = 0x820
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x814(%rbp), %rdi
movl $0x804, %esi            # imm = 0x804
callq 0xa600
movq -0x10(%rbp), %rax
movq %rax, -0x820(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x814(%rbp), %rdx
callq 0x4580
cmpl $0x0, %eax
je 0x4eca
cmpl $0x0, -0x814(%rbp)
jne 0x4e99
jmp 0x4eca
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x4dc0
leaq -0x814(%rbp), %rdi
movl $0x804, %esi            # imm = 0x804
callq 0xa600
movl $0x1, -0x8(%rbp)
movq -0x820(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x4e75
xorl %eax, %eax
addq $0x820, %rsp            # imm = 0x820
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/util/maths.c
// Function: mod_inverse
__uint64_t		mod_inverse(__uint64_t a, __uint64_t b)
{
	__uint64_t	b0;
	__int64_t	t;
	__uint64_t	q;
	__int64_t	x0;
	__int64_t	x1;

	b0 = b;
	x0 = 0;
	x1 = 1;
	if (a == b)
		return (0);
	while (a > 1)
	{
		!b ? ft_putendl_fd("Error divide by 0", 2) : 0;
		if (!b)
			exit(0);
		q = a / b;
		t = b;
		b = a % b;
		a = t;
		t = x0;
		x0 = x1 - q * x0;
		x1 = t;
	}
	return (x1 < 0 ? x1 += b0 : x1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x1, -0x40(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x4f1f
movq $0x0, -0x8(%rbp)
jmp 0x4fd8
jmp 0x4f21
cmpq $0x1, -0x10(%rbp)
jbe 0x4faf
cmpq $0x0, -0x18(%rbp)
jne 0x4f46
leaq 0xee1b(%rip), %rdi      # 0x13d55
movl $0x2, %esi
callq 0xb330
jmp 0x4f48
jmp 0x4f48
cmpq $0x0, -0x18(%rbp)
jne 0x4f56
xorl %edi, %edi
callq 0x10e0
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
imulq -0x38(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x4f21
cmpq $0x0, -0x40(%rbp)
jge 0x4fc8
movq -0x20(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rax, -0x48(%rbp)
jmp 0x4fd0
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/util/maths.c
// Function: mulmod
__uint64_t		mulmod(__uint64_t a, __uint64_t b, __uint64_t m)
{
	__uint64_t	res;
	__uint64_t	temp_b;

	res = 0;
	if (b >= m)
		b = (m > UINT64_MAX >> 1) ? b - m : b % m;
	while (a)
	{
		if (a & 1)
		{
			if (b >= m - res)
				res -= m;
			res += b;
		}
		a >>= 1;
		temp_b = b;
		if (b >= m - b)
			temp_b -= m;
		b += temp_b;
	}
	return (res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x5048
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x18(%rbp)
jbe 0x5030
movq -0x10(%rbp), %rdx
subq -0x18(%rbp), %rdx
movq %rdx, -0x30(%rbp)
jmp 0x5040
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x504a
cmpq $0x0, -0x8(%rbp)
je 0x50cf
movq -0x8(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x508b
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jb 0x507f
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
shrq %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jb 0x50be
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x504a
movq -0x20(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/util/maths.c
// Function: powmod
__uint64_t		powmod(__uint64_t num, __uint64_t exp, __uint64_t mod)
{
	__uint64_t	x;

	if (mod < 2 || num == 0)
	{
		if (mod == 0)
			write(2, "Cannot take modpow with modulus 0\n", 34);
		return (0);
	}
	if (exp == 0)
		return (1);
	x = 1;
	num = num % mod;
	while (exp)
	{
		if (exp & 1)
			x = mulmod(x, num, mod);
		num = mulmod(num, num, mod);
		exp >>= 1;
	}
	return (x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x2, -0x20(%rbp)
jb 0x5102
cmpq $0x0, -0x10(%rbp)
jne 0x5129
cmpq $0x0, -0x20(%rbp)
jne 0x511f
movl $0x2, %edi
leaq 0xec52(%rip), %rsi      # 0x13d67
movl $0x22, %edx
callq 0x1050
movq $0x0, -0x8(%rbp)
jmp 0x51a6
cmpq $0x0, -0x18(%rbp)
jne 0x513a
movq $0x1, -0x8(%rbp)
jmp 0x51a6
movq $0x1, -0x28(%rbp)
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x20(%rbp)
movq %rdx, -0x10(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x519e
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x517c
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4ff0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4ff0
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
shrq %rax
movq %rax, -0x18(%rbp)
jmp 0x5152
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq