LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/PARKINHYO[P]BlackjackGame/shm/./common.h
// Function: display_state
int display_state(int hand_values[], int hand_suits[], int ncards)
{
	int i;
	int sum = calc_sum(hand_values, ncards);
	for (i = 0; i < ncards; ++i)
	{
		if (i > 0)
			printf(", ");
		printf("%s-%s", values[hand_values[i]], suits[hand_suits[i]]);
	}
	printf(" Sum: %d", sum);
	if (sum > 21){
		printf("; BUSTED");
		printf("\n");
		return 1;
		}
	else if (sum == 21){
		printf("\n");
		return 1;
	}
	printf("\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %esi
callq 0x144b
movl %eax, -0x2c(%rbp)
testl %r12d, %r12d
jle 0x1516
movl %r12d, %ebx
leaq 0x1b81(%rip), %r12      # 0x3051
xorl %r13d, %r13d
testq %r13, %r13
je 0x14e6
leaq 0x1b6f(%rip), %rdi      # 0x304e
xorl %eax, %eax
callq 0x10a0
movslq (%r15,%r13,4), %rax
leaq 0x3c2f(%rip), %rcx      # 0x5120
movq (%rcx,%rax,8), %rsi
movslq (%r14,%r13,4), %rax
leaq 0x3c00(%rip), %rcx      # 0x5100
movq (%rcx,%rax,8), %rdx
movq %r12, %rdi
xorl %eax, %eax
callq 0x10a0
incq %r13
cmpq %r13, %rbx
jne 0x14d3
leaq 0x1b3a(%rip), %rdi      # 0x3057
movl -0x2c(%rbp), %ebx
movl %ebx, %esi
xorl %eax, %eax
callq 0x10a0
cmpl $0x16, %ebx
jl 0x154e
leaq 0x1b2b(%rip), %rdi      # 0x3060
xorl %eax, %eax
callq 0x10a0
movl $0xa, %edi
callq 0x1040
movl $0x1, %r14d
jmp 0x1562
xorl %r14d, %r14d
cmpl $0x15, %ebx
sete %r14b
movl $0xa, %edi
callq 0x1040
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/PARKINHYO[P]BlackjackGame/shm/shm_server.c
// Function: set_shutdown
void *set_shutdown ()
{
        printf("[SIGNAL] : Got shutdown signal\n");
        shmctl( gnShmID1, IPC_RMID, 0 );
        printf("[SIGNAL] : Shared meory segment marked for deletion\n");;
        semctl( gnSemID1, IPC_RMID, 0 );
        printf("[SIGNAL] : Semapore segment marked for deletion\n");
        exit (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1c81(%rip), %rdi      # 0x3200
callq 0x1080
movl 0x3c16(%rip), %edi      # 0x51a0
xorl %esi, %esi
xorl %edx, %edx
callq 0x1110
leaq 0x1c85(%rip), %rdi      # 0x321f
callq 0x1080
movl 0x3bff(%rip), %edi      # 0x51a4
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x1130
leaq 0x1c9c(%rip), %rdi      # 0x3253
callq 0x1080
movl $0x1, %edi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O1/PARKINHYO[P]BlackjackGame/shm/shm_server.c
// Function: init_cards
void init_cards()
{
	int i;

	for (i = 0; i < 52; ++i)
	{
		card_values[i] = (i % 13) + 1;
		card_suits[i] = i / 13;
	}

	srand(time(NULL));
	/* srand(1); */
	for (i = 0; i < 52; ++i)
	{
		int cv, cs;
		int j = rand() % 52;

		cv = card_values[i];
		card_values[i] = card_values[j];
		card_values[j] = cv;

		cs = card_suits[i];
		card_suits[i] = card_suits[j];
		card_suits[j] = cs;
	}

	ncard = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x1, %eax
xorl %ecx, %ecx
leaq 0x3bd2(%rip), %rbx      # 0x51b0
leaq 0x3c9b(%rip), %r14      # 0x5280
xorl %edx, %edx
movl %edx, %esi
imulq $0x4ec4ec4f, %rsi, %rsi # imm = 0x4EC4EC4F
shrq $0x22, %rsi
leal (%rsi,%rsi,2), %edi
leal (%rsi,%rdi,4), %edi
movl %eax, %r8d
subl %edi, %r8d
movl %r8d, (%rcx,%rbx)
movl %esi, (%rcx,%r14)
incq %rdx
incl %eax
addq $0x4, %rcx
cmpq $0x34, %rdx
jne 0x15e7
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x10e0
movl %eax, %edi
callq 0x10b0
callq 0x11c0
cltq
imulq $0x4ec4ec4f, %rax, %rcx # imm = 0x4EC4EC4F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x24, %rcx
addl %edx, %ecx
imull $0x34, %ecx, %ecx
subl %ecx, %eax
movl (%r15,%rbx), %ecx
cltq
movl (%rbx,%rax,4), %edx
movl %edx, (%r15,%rbx)
movl %ecx, (%rbx,%rax,4)
movl (%r15,%r14), %ecx
movl (%r14,%rax,4), %edx
movl %edx, (%r15,%r14)
movl %ecx, (%r14,%rax,4)
addq $0x4, %r15
cmpq $0xd0, %r15
jne 0x1628
movl $0x0, 0x3cd1(%rip)      # 0x5350
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/robertdavidgraham[P]wc2/wcstream.c
// Function: main
int main()
{
    for (;;) {
        char buf[65536];
        size_t length;
        size_t i;

        length = read(STDIN_FILENO, buf, sizeof(buf));
        if (length <= 0)
            break;
        for (i=0; i<length; i++) {
            size_t count;

            count = write(STDOUT_FILENO, buf+i, 1);
            if (count <= 0)
                exit(1);
        }
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10000, %rsp          # imm = 0x10000
movq %rsp, %rsi
movl $0x10000, %edx          # imm = 0x10000
xorl %edi, %edi
callq 0x1040
testq %rax, %rax
je 0x11bc
movq %rax, %r14
movq %rsp, %rbx
xorl %r15d, %r15d
leaq (%rsp,%r15), %rsi
movl $0x1, %edx
movl $0x1, %edi
callq 0x1030
testq %rax, %rax
je 0x11cb
incq %r15
cmpq %r15, %r14
jne 0x1185
movl $0x10000, %edx          # imm = 0x10000
xorl %edi, %edi
movq %rbx, %rsi
callq 0x1040
movq %rax, %r14
testq %rax, %rax
jne 0x1182
xorl %eax, %eax
addq $0x10000, %rsp          # imm = 0x10000
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %edi
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/antonblanchard[P]will-it-scale/tests/pipe1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	int fd[2];

	assert(pipe(fd) == 0);

	while (1) {
		char c = 0;
		int ret;

		do {
			ret = write(fd[WRITE], &c, 1);
		} while (ret != 1 && errno == EINTR);

		do {
			ret = read(fd[READ], &c, 1);
		} while (ret != 1 && errno == EINTR);

		(*iterations)++;
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2140
testl %eax, %eax
jne 0x2c43
leaq 0xf(%rsp), %r14
movb $0x0, 0xf(%rsp)
movl 0x14(%rsp), %edi
movl $0x1, %edx
movq %r14, %rsi
callq 0x20d0
cmpl $0x1, %eax
je 0x2c1e
callq 0x2070
cmpl $0x4, (%rax)
je 0x2bfe
movl 0x10(%rsp), %edi
movl $0x1, %edx
movq %r14, %rsi
callq 0x2150
cmpl $0x1, %eax
je 0x2c3e
callq 0x2070
cmpl $0x4, (%rax)
je 0x2c1e
incq (%rbx)
jmp 0x2bf9
leaq 0x62e(%rip), %rdi       # 0x3278
leaq 0x635(%rip), %rsi       # 0x3286
leaq 0x63c(%rip), %rcx       # 0x3294
movl $0xf, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/rsa/asn1.c
// Function: asn1_pub
void			asn1_pub(t_rsa gg, uint8_t *buf, uint8_t *buf2, int *len)
{
	uint8_t		copy[PAGESIZE];
	int			index;

	dump_to_buf(buf, INT, NULL, len);
	dump_to_buf(buf, byte_string(buf2, gg.n)[0] == 0xFF ?
	byte_len(gg.n) + 1 : byte_len(gg.n), NULL, len);
	dump_to_buf(buf, 0, byte_string(buf2, gg.n), len);
	dump_to_buf(buf, INT, NULL, len);
	dump_to_buf(buf, byte_len(gg.e), NULL, len);
	dump_to_buf(buf, 0, byte_string(buf2, gg.e), len);
	ft_memcpy(copy, buf, *len);
	ft_bzero(buf, PAGESIZE);
	index = 2;
	dump_to_buf(buf, SEQUENCE, NULL, &index);
	dump_to_buf(buf, 0, (uint8_t*)PKCS_1, &index);
	dump_to_buf(buf, BIT, NULL, &index);
	dump_to_buf(buf, (char)(*len) + 3, NULL, &index);
	dump_to_buf(buf, V1, NULL, &index);
	dump_to_buf(buf, SEQUENCE, NULL, &index);
	dump_to_buf(buf, (char)(*len), NULL, &index);
	ft_memcpy(&buf[index], copy, *len);
	*len += index;
	buf[0] = SEQUENCE;
	buf[1] = (uint8_t)*len - 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1010, %rsp           # imm = 0x1010
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x2, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x1823
movq 0x1050(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x179d
cmpb $-0x1, (%rax)
sete %bpl
movq %r12, %rdi
callq 0x1780
addb %bpl, %al
movsbl %al, %esi
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x1823
movq %r15, %rdi
movq %r12, %rsi
callq 0x179d
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %r14, %rcx
callq 0x1823
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x1823
movq 0x1078(%rsp), %r12
movq %r12, %rdi
callq 0x1780
movsbl %al, %esi
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x1823
movq %r15, %rdi
movq %r12, %rsi
callq 0x179d
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %r14, %rcx
callq 0x1823
movslq (%r14), %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6c88
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
callq 0x6c50
leaq 0xc(%rsp), %r12
movl $0x2, (%r12)
movq %rbx, %rdi
movl $0x30, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x1823
leaq 0xa924(%rip), %rdx      # 0xc004
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rcx
callq 0x1823
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x1823
movb (%r14), %al
addb $0x3, %al
movsbl %al, %esi
movq %rbx, %rdi
xorl %edx, %edx
movq %r12, %rcx
callq 0x1823
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
movq %r12, %rcx
callq 0x1823
movq %rbx, %rdi
movl $0x30, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x1823
movsbl (%r14), %esi
movq %rbx, %rdi
xorl %edx, %edx
movq %r12, %rcx
callq 0x1823
movslq (%r12), %rdi
addq %rbx, %rdi
movslq (%r14), %rdx
movq %r15, %rsi
callq 0x6c88
movl (%r12), %eax
addl %eax, (%r14)
movb $0x30, (%rbx)
movb (%r14), %al
addb $-0x2, %al
movb %al, 0x1(%rbx)
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0xa, %esi
callq 0x6c50
xorl %edx, %edx
movl $0x38, %ecx
xorl %eax, %eax
testl %edx, %edx
jne 0x17d1
movl $0xff, %esi
shlq %cl, %rsi
andq %r14, %rsi
shrq %cl, %rsi
testq %rsi, %rsi
je 0x1814
movl $0xff, %esi
shlq %cl, %rsi
andq %r14, %rsi
shrq %cl, %rsi
movslq %eax, %rdi
movb %sil, (%rbx,%rdi)
testl %edx, %edx
jne 0x1801
movl %esi, %edx
andl $0x80, %edx
je 0x1801
leaq 0x1(%rdi), %rax
movb %sil, 0x1(%rbx,%rdi)
movb $-0x1, (%rbx,%rdi)
incl %eax
movl $0x1, %edx
addq $-0x8, %rcx
cmpq $-0x8, %rcx
jne 0x17ba
jmp 0x1818
xorl %edx, %edx
jmp 0x1808
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x1876
movq %rdx, %r15
movq %rdx, %rdi
callq 0x7952
cmpl $0x1, %eax
jne 0x1854
xorl %eax, %eax
cmpb $0x1, 0x2(%r15)
sete %al
leal 0x1(,%rax,2), %eax
cltq
xorl %ecx, %ecx
cmpq %rax, %rcx
jl 0x1864
cmpb $0x0, (%r15,%rax)
je 0x187f
movb (%r15,%rcx), %dl
movslq (%rbx), %rsi
movb %dl, (%r14,%rsi)
incl (%rbx)
incq %rcx
jmp 0x1858
movslq (%rbx), %rax
movb %sil, (%r14,%rax)
incl (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/encode/base64.c
// Function: base64_decode
int				base64_decode(uint8_t *enc, uint8_t *dec, int len)
{
	int		i;

	i = 0;
	while (i < len)
	{
		if ((i + 4) % 64 == 0)
		{
			if (len != 65)
				i++;
			if (i == len)
				return (i - 1);
		}
		dec[3 * (i / 4)] |= (g_base64_decode[enc[i]]) << 2;
		dec[3 * (i / 4)] |= ((g_base64_decode[enc[i + 1]] & 0x30) >> 4);
		dec[3 * (i / 4) + 1] |= ((g_base64_decode[enc[i + 1]] & 0x0F) << 4);
		dec[3 * (i / 4) + 1] |= (g_base64_decode[enc[i + 2]] >> 2);
		dec[3 * (i / 4) + 2] |= (g_base64_decode[enc[i + 2]] << 6);
		dec[3 * (i / 4) + 2] |= g_base64_decode[enc[i + 3]];
		i += 4;
	}
	return (i);
}

// Assembly:
testl %edx, %edx
jle 0x1b4d
xorl %ecx, %ecx
cmpl $0x41, %edx
setne %cl
xorl %eax, %eax
leaq 0x1064d(%rip), %r8      # 0x120e0
leal 0x4(%rax), %r9d
testb $0x3f, %r9b
jne 0x1aa7
addl %ecx, %eax
cmpl %edx, %eax
je 0x1b50
cltq
movzbl (%rdi,%rax), %r9d
movb (%r9,%r8), %r10b
shlb $0x2, %r10b
leal 0x3(%rax), %r9d
testl %eax, %eax
cmovnsl %eax, %r9d
sarl $0x2, %r9d
movslq %r9d, %r9
leaq (%r9,%r9,2), %r9
orb (%rsi,%r9), %r10b
movb %r10b, (%rsi,%r9)
movzbl 0x1(%rdi,%rax), %r11d
movb (%r11,%r8), %r11b
shrb $0x4, %r11b
andb $0x3, %r11b
orb %r10b, %r11b
movb %r11b, (%rsi,%r9)
movzbl 0x1(%rdi,%rax), %r10d
movb (%r10,%r8), %r10b
shlb $0x4, %r10b
orb 0x1(%rsi,%r9), %r10b
movb %r10b, 0x1(%rsi,%r9)
movzbl 0x2(%rdi,%rax), %r11d
movb (%r11,%r8), %r11b
shrb $0x2, %r11b
orb %r10b, %r11b
movb %r11b, 0x1(%rsi,%r9)
movzbl 0x2(%rdi,%rax), %r10d
movb (%r10,%r8), %r10b
shlb $0x6, %r10b
orb 0x2(%rsi,%r9), %r10b
movb %r10b, 0x2(%rsi,%r9)
movzbl 0x3(%rdi,%rax), %r11d
orb (%r11,%r8), %r10b
movb %r10b, 0x2(%rsi,%r9)
addl $0x4, %eax
cmpl %edx, %eax
jl 0x1a93
retq
xorl %eax, %eax
retq
decl %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movl $0x42, %esi
movq %r14, %rdi
callq 0x6c50
movq %rsp, %rdi
movl $0x32, %esi
callq 0x6c50
movl (%rbx), %edi
movl $0x41, %edx
movq %r14, %rsi
callq 0x10b0
movq %rax, %r12
cmpl $0x41, %r12d
jne 0x1c0c
leaq 0x40(%rsp), %r14
xorl %ebp, %ebp
movq %rsp, %r15
movq %r14, %rdi
movl $0xa, %esi
callq 0x75f7
cltq
movb %bpl, 0x40(%rsp,%rax)
movq %r14, %rdi
movq %r15, %rsi
movl $0x41, %edx
callq 0x1a7a
movb %bpl, 0x30(%rsp)
movl 0x4(%rbx), %esi
movq %r15, %rdi
callq 0x7225
movl $0x41, %esi
movq %r14, %rdi
callq 0x6c50
movl $0x31, %esi
movq %r15, %rdi
callq 0x6c50
movl (%rbx), %edi
movl $0x41, %edx
movq %r14, %rsi
callq 0x10b0
movq %rax, %r12
cmpl $0x41, %r12d
je 0x1ba6
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x75f7
cltq
xorl %ebp, %ebp
movb %bpl, 0x40(%rsp,%rax)
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x1a7a
addl %r12d, %r12d
cvtsi2ss %r12d, %xmm0
cvtss2sd %xmm0, %xmm0
divsd 0xa3cc(%rip), %xmm0     # 0xc018
cvttsd2si %xmm0, %eax
cltq
movb %bpl, (%rsp,%rax)
movl 0x4(%rbx), %esi
movq %r15, %rdi
callq 0x7225
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/choose.c
// Function: ssl_md5
void			ssl_md5(char **av, t_ssl *ssl)
{
	int		i;
	char	*line;

	i = -1;
	line = NULL;
	if (!(ssl->flag & 0x38000) && !ssl->flag && ssl->file_index[0])
		;
	else if (!(ssl->flag & S_FLAG) && (!*(ssl->fd) || ssl->flag & P_FLAG))
	{
		get_stdin(&line, 0, 1, 0);
		line = (!line) ? ft_strdup("") : line;
		ssl->flag &= ~0x40000;
		if (ssl->flag || (ssl->flag && !(ssl->flag & 0x10000)))
			ssl->flag |= 0x8000;
		hash(av[1], line, ssl, 0);
		ft_pipewrench("-s", &line) ? ssl->flag &= ~0x1000 : 0;
	}
	ssl->flag &= ~P_FLAG;
	while (ssl->fd[++i])
	{
		ssl->flag &= ~0x40000;
		hash(av[1], av[ssl->file_index[i]], ssl, i);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, 0x8(%rsp)
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x1eee
btl $0x12, %eax
jae 0x1ef7
jmp 0x1f76
cmpl $0x0, 0x408(%rbx)
jne 0x1f76
testw %ax, %ax
js 0x1f02
cmpl $0x0, 0xc(%rbx)
jne 0x1f76
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x68ad
movq (%r15), %rsi
testq %rsi, %rsi
jne 0x1f2f
leaq 0xadb3(%rip), %rdi      # 0xccda
callq 0x7ab8
movq %rax, %rsi
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
movl $0xfffbffff, %eax       # imm = 0xFFFBFFFF
andl 0x4(%rbx), %eax
movl %eax, %ecx
orl $0x8000, %ecx           # imm = 0x8000
testl %eax, %eax
cmovel %eax, %ecx
movl %ecx, 0x4(%rbx)
movq 0x8(%r14), %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x2c3a
leaq 0xae45(%rip), %rdi      # 0xcda9
movq %r15, %rsi
xorl %eax, %eax
callq 0x6d18
testl %eax, %eax
je 0x1f76
andb $-0x11, 0x5(%rbx)
andb $0x7f, 0x5(%rbx)
cmpl $0x0, 0xc(%rbx)
je 0x1fae
xorl %r15d, %r15d
andb $-0x5, 0x6(%rbx)
movq 0x8(%r14), %rdi
movslq 0x408(%rbx,%r15,4), %rax
movq (%r14,%rax,8), %rsi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x2c3a
cmpl $0x0, 0x10(%rbx,%r15,4)
leaq 0x1(%r15), %r15
jne 0x1f83
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4(%rsp), %r15
movl $0xc, %esi
movq %r15, %rdi
callq 0x6c50
leaq 0x10(%rsp), %rdi
movl $0x40, %esi
callq 0x6c50
movl $0x1, 0x4(%r15)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x1c71
testl %eax, %eax
jne 0x208f
movl $0x0, (%rsp)
testb $0x8, 0xc(%rsp)
jne 0x2085
movl 0x4(%rsp), %edi
leaq 0x10(%rsp), %rsi
movl $0x3f, %edx
callq 0x10b0
cmpl $0x3f, %eax
jne 0x2070
leaq 0x10(%rsp), %rbx
movq %rsp, %r14
movl 0x8(%rsp), %edx
movq %rbx, %rdi
movl $0x3f, %esi
movq %r14, %rcx
callq 0x1888
movl $0x40, %esi
movq %rbx, %rdi
callq 0x6c50
movl 0x4(%rsp), %edi
movl $0x3f, %edx
movq %rbx, %rsi
callq 0x10b0
cmpl $0x3f, %eax
je 0x2039
movl 0x8(%rsp), %edx
leaq 0x10(%rsp), %rdi
movq %rsp, %rcx
movl %eax, %esi
callq 0x1888
jmp 0x208f
leaq 0x4(%rsp), %rdi
callq 0x1b53
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x29, 0x8(%rsi)
jne 0x20db
leaq 0xa575(%rip), %rdi      # 0xc637
leaq 0x9fe1(%rip), %rsi      # 0xc0aa
leaq 0xa010(%rip), %rdx      # 0xc0e0
xorl %eax, %eax
callq 0x6f7c
testl %eax, %eax
jne 0x20fc
movl 0x8(%rbx), %eax
cmpl $0x2b, %eax
je 0x2104
cmpl $0x2a, %eax
jne 0x20fc
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x447f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x2b, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a8
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movq %rsi, %rax
movslq (%rsi), %rsi
movq (%rdi,%rsi,8), %r8
movslq (%rdx), %r9
leaq 0x1(%r9), %rsi
movl %esi, (%rdx)
cmpb $0x0, 0x1(%r8,%r9)
movslq (%rax), %r8
je 0x2158
movq (%rdi,%r8,8), %rax
addq %rax, %rsi
movsbl (%rax,%r9), %edx
leaq 0x9fc5(%rip), %rdi      # 0xc10f
xorl %eax, %eax
callq 0x6f7c
movl $0x1, %eax
jmp 0x2187
leaq 0x1(%r8), %rsi
movl %esi, (%rax)
movq 0x8(%rdi,%r8,8), %rsi
testq %rsi, %rsi
je 0x217b
cmpb $0x0, (%rsi)
je 0x217b
movq (%rdi,%r8,8), %rax
movslq (%rdx), %rcx
movsbl -0x1(%rax,%rcx), %edx
jmp 0x2143
movl $0x0, 0x1ac(%rcx)
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xa54d(%rip), %rsi      # 0xca13
leaq 0x9d8a(%rip), %rdx      # 0xc257
leaq 0x9d8b(%rip), %rcx      # 0xc25f
movl $0x2, %edi
xorl %eax, %eax
callq 0x1090
cmpl $0x9, %ebp
jg 0x2501
leaq 0xa533(%rip), %rsi      # 0xca1f
movl $0x2, %edi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1090
cmpl $0x1d, %ebp
jg 0x2535
leaq 0xa535(%rip), %rsi      # 0xca42
movl $0x2, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1090
leaq 0xa551(%rip), %rsi      # 0xca74
movl $0x2, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1090
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl %edi, %ebx
cmpl $0x13, %edi
je 0x25a9
cmpl $0x14, %ebx
jne 0x255a
leaq 0xa548(%rip), %rdi      # 0xca98
movl $0x2, %esi
callq 0x7225
cmpl $0x17, %ebx
jl 0x2570
leaq 0xa580(%rip), %rdi      # 0xcae6
movl $0x2, %esi
callq 0x7225
leaq 0xa585(%rip), %rdi      # 0xcafc
movl $0x2, %esi
callq 0x7225
testb $0x1, %bl
leaq 0xa589(%rip), %rax      # 0xcb14
leaq 0xa579(%rip), %rdi      # 0xcb0b
cmoveq %rax, %rdi
movl $0x2, %esi
callq 0x7225
leaq 0xa577(%rip), %rdi      # 0xcb1e
jmp 0x25b0
leaq 0xa50a(%rip), %rdi      # 0xcaba
movl $0x2, %esi
callq 0x7225
cmpl $0x9, %ebx
jge 0x25c8
leaq 0xa55d(%rip), %rdi      # 0xcb23
jmp 0x25f0
cmpl $0xb, %ebx
jge 0x25d6
leaq 0xa57c(%rip), %rdi      # 0xcb50
jmp 0x25f0
cmpl $0xd, %ebx
jge 0x25e4
leaq 0xa597(%rip), %rdi      # 0xcb79
jmp 0x25f0
cmpl $0xe, %ebx
jg 0x25fb
leaq 0xa5b1(%rip), %rdi      # 0xcba1
movl $0x2, %esi
popq %rbx
jmp 0x7225
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
cmpl $0x6, %edx
jne 0x26b8
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa609(%rip), %rsi      # 0xcc21
callq 0x7644
testl %eax, %eax
je 0x2676
leaq 0xa5fe(%rip), %rsi      # 0xcc26
movq %r14, %rdi
callq 0x7644
testl %eax, %eax
je 0x2676
leaq 0xb168(%rip), %rsi      # 0xd7a3
movq %r14, %rdi
callq 0x7644
testl %eax, %eax
je 0x2676
leaq 0xa5da(%rip), %rsi      # 0xcc28
movq %r14, %rdi
callq 0x7644
testl %eax, %eax
je 0x2676
cmpl $-0x2a, 0x4(%rbx)
je 0x2676
leaq 0xa5c7(%rip), %rsi      # 0xcc2e
movl $0x2, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1090
movl 0x8(%rbx), %eax
addl $-0x1f, %eax
cmpl $0x2, %eax
ja 0x26ab
movl %eax, %eax
leaq 0x9b12(%rip), %rcx      # 0xc19c
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq 0x9bbf(%rip), %rdx      # 0xc257
leaq 0x9bc0(%rip), %rcx      # 0xc25f
movl $0x2, %edi
xorl %eax, %eax
callq 0x1090
movl 0x8(%rbx), %edi
popq %rbx
popq %r14
popq %r15
jmp 0x21a8
movl %edx, %r15d
leal -0x15(%r15), %eax
cmpl $0x1, %eax
ja 0x271c
leaq 0xa505(%rip), %rdi      # 0xcbd0
movl $0x2, %esi
callq 0x7225
leaq 0xa509(%rip), %rdi      # 0xcbe5
movl $0x2, %esi
callq 0x7225
testb $0x1, %r15b
leaq 0xa51a(%rip), %rax      # 0xcc0b
leaq 0xa50b(%rip), %rdi      # 0xcc03
cmoveq %rax, %rdi
movl $0x2, %esi
callq 0x7225
leaq 0xa506(%rip), %rdi      # 0xcc13
movl $0x2, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x7225
movl %r15d, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x253c
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebx
leal -0x1(%rbx), %eax
cmpl $0x4, %eax
ja 0x27f3
leaq 0x9a3f(%rip), %rcx      # 0xc188
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xa555(%rip), %rsi      # 0xccae
movl $0x2, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1090
callq 0x4817
jmp 0x27f3
movl 0x8(%r14), %esi
movq %r15, %rdi
callq 0x24b7
cmpl $0x0, 0x4(%r14)
je 0x278e
movl 0x8(%r14), %edi
callq 0x21a8
cmpl $0x5, %ebx
je 0x27b9
cmpl $0x4, %ebx
jne 0x27f3
movsbl (%r15), %edx
cmpl $0x68, %edx
je 0x27b4
leaq 0xa561(%rip), %rsi      # 0xcd09
movl $0x2, %edi
xorl %eax, %eax
callq 0x1090
cmpl $0x5, %ebx
jne 0x27f3
leaq 0xa55f(%rip), %rsi      # 0xcd1f
movl $0x2, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1090
jmp 0x27f3
movl 0x4(%r14), %ecx
leaq 0xa4ff(%rip), %rsi      # 0xccdb
movl $0x2, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1090
movl $0x0, 0x4(%r14)
cmpl $0x6, %ebx
jl 0x2805
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x25fd
xorl %eax, %eax
negl %ebx
sbbl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
leal -0x1(%rbx), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, 0x10(%rsp)
movq $-0x1, %r15
movl %ebx, %ecx
shlq %cl, %r15
movl %esi, %ebp
movl $0x1, %r14d
notq %r15
addl %ebx, %ebx
movl %eax, %ecx
shlq %cl, %r14
cvtsi2ss %esi, %xmm0
movss %xmm0, 0xc(%rsp)
xorl %r13d, %r13d
movl %r13d, %eax
xorl %edx, %edx
divl %ebx
testl %edx, %edx
jne 0x289b
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x4114
movq %rax, %r12
orq %r14, %r12
orq $0x1, %r12
testl %ebp, %ebp
jne 0x289b
movl $0x2e, %edi
movl $0x2, %esi
callq 0x720c
movq %r12, %rdi
movss 0xc(%rsp), %xmm0
callq 0x3654
testl %eax, %eax
jne 0x28c9
testl %ebp, %ebp
jne 0x28c0
movl $0x2e, %edi
movl $0x2, %esi
callq 0x720c
addq $-0x2, %r12
incl %r13d
jmp 0x2866
testl %ebp, %ebp
jne 0x28dc
movl $0xa, %edi
movl $0x2, %esi
callq 0x720c
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/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:
movq 0x8(%rsp), %rax
mulq 0x10(%rsp)
jo 0x2923
leal -0x1(%rdi), %ecx
movzbl %cl, %ecx
btq %rcx, %rax
jae 0x2923
cmpl $0x40, %edi
setne %dl
movl $0x1, %esi
movl %edi, %ecx
shlq %cl, %rsi
cmpq %rax, %rsi
setb %cl
andb %dl, %cl
cmpb $0x1, %cl
jne 0x2928
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/rsa/genrsa.c
// Function: genrsa
__uint64_t		genrsa(t_rsa_out rsa)
{
	t_rsa		gg;
	char		buf[80];

	ft_bzero(buf, 80);
	ft_bzero(&gg, sizeof(gg));
	ft_sprintf(buf, "%s, %d bit long modulus\n", GEN_PRV, rsa.bits);
	ft_putstr_fd(buf, 2);
	while (1)
	{
		gg.p = genprime((rsa.bits / 2), (int)gg.n);
		gg.q = genprime((rsa.bits / 2) + 1, (int)gg.n);
		if ((gg.n = valid_modulus(gg, rsa.bits)) != 1)
			break ;
	}
	gg.e = 65537;
	gg.phi = (gg.p - 1) * (gg.q - 1);
	gg.d = mod_inverse(gg.e, gg.phi);
	gg.dmp1 = gg.d % (gg.p - 1);
	gg.dmq1 = gg.d % (gg.q - 1);
	gg.iqmp = mod_inverse(gg.q, gg.p);
	ft_bzero(buf, 80);
	ft_sprintf(buf, "e is %llu (%#x)\n", gg.e, gg.e);
	ft_putstr_fd(buf, 2);
	rsa_encode_out(rsa, gg);
	return (gg.n);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
leaq 0x120(%rsp), %r15
leaq 0xb0(%rsp), %rbx
movl $0x50, %esi
movq %rbx, %rdi
callq 0x6c50
leaq 0x68(%rsp), %rdi
movl $0x48, %esi
callq 0x6c50
movl 0x8(%r15), %ecx
leaq 0xa3d2(%rip), %rsi      # 0xcd3e
leaq 0xa3e4(%rip), %rdx      # 0xcd57
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7300
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7225
movl 0x8(%r15), %eax
movl %eax, %edi
shrl $0x1f, %edi
addl %eax, %edi
sarl %edi
movl 0x78(%rsp), %esi
callq 0x2814
movq %rax, 0x68(%rsp)
movl 0x8(%r15), %eax
movl %eax, %edi
shrl $0x1f, %edi
addl %eax, %edi
sarl %edi
incl %edi
movl 0x78(%rsp), %esi
callq 0x2814
movq %rax, %rsi
movq %rax, 0x70(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, %rax
mulq %rsi
jo 0x29f5
movl 0x8(%r15), %ecx
leal -0x1(%rcx), %edx
movzbl %dl, %edx
btq %rdx, %rax
jae 0x29f5
movl $0x1, %edx
shlq %cl, %rdx
cmpq $0x40, %rcx
je 0x29fa
cmpq %rax, %rdx
jae 0x29fa
movl $0x1, %eax
movq %rax, 0x78(%rsp)
cmpq $0x1, %rax
je 0x298a
leaq 0x68(%rsp), %rbx
movq $0x10001, 0x38(%rbx)    # imm = 0x10001
decq %rdi
decq %rsi
imulq %rdi, %rsi
movq %rsi, 0x18(%rbx)
movl $0x10001, %edi          # imm = 0x10001
callq 0x38a4
movq %rax, %rcx
movq %rax, 0x40(%rbx)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdi
leaq -0x1(%rsi), %r8
xorl %edx, %edx
divq %r8
movq %rdx, 0x20(%rbx)
leaq -0x1(%rdi), %r8
movq %rcx, %rax
xorl %edx, %edx
divq %r8
movq %rdx, 0x28(%rbx)
callq 0x38a4
movq %rax, 0x30(%rbx)
leaq 0xb0(%rsp), %r14
movl $0x50, %esi
movq %r14, %rdi
callq 0x6c50
movq 0x38(%rbx), %rcx
leaq 0xa2f4(%rip), %rsi      # 0xcd72
movq %r14, %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x7300
movq %r14, %rdi
movl $0x2, %esi
callq 0x7225
leaq 0x18(%rsp), %rdi
movl $0x9, %ecx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x50bd
movq 0x10(%rbx), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movb $0x0, 0x1000(%rdi)
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movq (%rbx), %rdi
movq %rsp, %r15
movq %rdi, (%r15)
callq 0x77bc
movq %rax, (%r14)
movq %rax, %rdi
callq 0x7952
movq %r15, %rdi
callq 0x779b
movq (%r14), %rdi
callq 0x7ab8
movq %rax, (%r15)
movq %r14, %rdi
callq 0x779b
movq (%r15), %rax
movq %rax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1018, %rsp           # imm = 0x1018
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x6c50
movq $0x0, 0x8(%rsp)
movq (%rbx), %rax
movq %rax, (%r15)
movslq %ebp, %r13
cmpl $0x3, 0xc(%r14,%r13,4)
jl 0x2c06
leaq 0xa154(%rip), %rdi      # 0xccda
callq 0x7ab8
movq %rax, 0x8(%rsp)
movl 0xc(%r14,%r13,4), %edi
leaq 0x10(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x10b0
testq %rax, %rax
jle 0x2be2
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2ad0
movl $0x1000, %esi           # imm = 0x1000
movq %r15, %rdi
callq 0x6c50
movl 0xc(%r14,%r13,4), %edi
movl $0x1000, %edx           # imm = 0x1000
movq %r15, %rsi
callq 0x10b0
testq %rax, %rax
jg 0x2bb3
movl 0xc(%r14,%r13,4), %edi
callq 0x1080
leaq 0x8(%rsp), %r15
movq (%r15), %rdi
callq 0x7ab8
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x779b
jmp 0x2c11
movq (%rbx), %rdi
callq 0x7ab8
movq %rax, (%rbx)
movslq 0x8(%r14), %rax
leaq 0xf184(%rip), %rcx      # 0x11da0
movq (%rbx), %rsi
leaq 0x10(%rsp), %rdi
callq *-0x8(%rcx,%rax,8)
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/hash/hash.c
// Function: hash
void			hash(char *input, char *to_hash, t_ssl *ssl, int i)
{
	if ((!(ssl->flag & 0x38000) &&
	(ssl->flag & S_FLAG || (i >= 0 && ssl->fd[i]))))
	{
		ft_printf("%s (", ft_strtoupper(input));
		ssl->fd[i] < 1 ? ft_putchar('\"') : 0;
		ft_printf("%s", to_hash);
		ssl->fd[i] < 1 ? ft_putchar('\"') : 0;
		ft_printf(") = ");
	}
	!(ssl->flag & 0x70000) && (ssl->flag & P_FLAG || (ssl->fd[i] && ssl->flag))
	? ft_printf("%s", to_hash) : 0;
	ft_printf("%s%c", get_hash(&to_hash, &input, ssl, i),
	((!(ssl->flag & R_FLAG) || ssl->flag & Q_FLAG) || (ssl->flag & R_FLAG &&
	!(ssl->flag & Q_FLAG) && (ssl->flag & P_FLAG)) ? '\n' : ' '));
	if (ssl->flag & R_FLAG && !(ssl->flag & 0x18000))
	{
		ssl->fd[i] < 1 ? ft_putchar('\"') : 0;
		(ssl->fd[i] || ssl->flag & R_FLAG) ? ft_printf("%s", input) : 0;
		ssl->fd[i] < 1 ? ft_putchar('\"') : 0;
		ft_putchar('\n');
	}
	ft_strdel(&to_hash);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl 0x4(%rdx), %eax
testl $0x38000, %eax          # imm = 0x38000
jne 0x2cce
btl $0x12, %eax
jb 0x2c70
testl %ebp, %ebp
js 0x2cce
movl %ebp, %eax
cmpl $0x0, 0xc(%rbx,%rax,4)
je 0x2cce
callq 0x6bb4
leaq 0xa107(%rip), %rdi      # 0xcd83
movq %rax, %rsi
xorl %eax, %eax
callq 0x6f7c
movslq %ebp, %r14
cmpl $0x0, 0xc(%rbx,%r14,4)
jg 0x2c9b
movl $0x22, %edi
callq 0x724b
movq 0x8(%rsp), %rsi
leaq 0x9992(%rip), %rdi      # 0xc639
xorl %eax, %eax
callq 0x6f7c
cmpl $0x0, 0xc(%rbx,%r14,4)
jg 0x2cc0
movl $0x22, %edi
callq 0x724b
leaq 0xa0c1(%rip), %rdi      # 0xcd88
xorl %eax, %eax
callq 0x6f7c
movl 0x4(%rbx), %eax
testl $0x70000, %eax          # imm = 0x70000
jne 0x2cfe
testw %ax, %ax
js 0x2ceb
testl %eax, %eax
je 0x2cfe
movslq %ebp, %rax
cmpl $0x0, 0xc(%rbx,%rax,4)
je 0x2cfe
movq 0x8(%rsp), %rsi
leaq 0x9942(%rip), %rdi      # 0xc639
xorl %eax, %eax
callq 0x6f7c
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x2b36
movl $0x38000, %r14d         # imm = 0x38000
movl 0x4(%rbx), %ecx
andl %r14d, %ecx
movl $0x20000, %r15d         # imm = 0x20000
cmpl %r15d, %ecx
movl $0x20, %ecx
movl $0xa, %edx
cmovel %ecx, %edx
leaq 0xa052(%rip), %rdi      # 0xcd8d
movq %rax, %rsi
xorl %eax, %eax
callq 0x6f7c
andl 0x4(%rbx), %r14d
cmpl %r15d, %r14d
jne 0x2da0
movslq %ebp, %r14
cmpl $0x0, 0xc(%rbx,%r14,4)
jg 0x2d63
movl $0x22, %edi
callq 0x724b
cmpl $0x0, 0xc(%rbx,%r14,4)
jne 0x2d71
testb $0x2, 0x6(%rbx)
je 0x2d84
movq 0x10(%rsp), %rsi
leaq 0x98bc(%rip), %rdi      # 0xc639
xorl %eax, %eax
callq 0x6f7c
cmpl $0x0, 0xc(%rbx,%r14,4)
jg 0x2d96
movl $0x22, %edi
callq 0x724b
movl $0xa, %edi
callq 0x724b
leaq 0x8(%rsp), %rdi
callq 0x779b
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl 0x4(%rcx), %ebp
btl $0x11, %ebp
jb 0x2dce
movl %ebp, %eax
orl $0x40000, %eax          # imm = 0x40000
movl %eax, 0x4(%rbx)
movslq (%rsi), %rax
movq (%rdi,%rax,8), %rax
movslq (%rdx), %rcx
leaq 0x1(%rcx), %r8
movl %r8d, (%rdx)
cmpb $0x0, 0x1(%rax,%rcx)
je 0x2e14
andb $0x7f, 0x5(%rbx)
movq 0x8(%rdi), %rax
movslq (%rsi), %rcx
movslq (%rdx), %rsi
addq (%rdi,%rcx,8), %rsi
movq %rax, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x2c3a
movb $0x1, %al
testw %bp, %bp
jns 0x2e3f
orb $-0x80, 0x5(%rbx)
movb $0x1, %al
jmp 0x2e3f
movslq (%rsi), %rax
leaq 0x1(%rax), %rcx
movl %ecx, (%rsi)
movq 0x8(%rdi,%rax,8), %rax
testq %rax, %rax
je 0x2e3d
cmpb $0x0, (%rax)
je 0x2e3d
andb $0x7f, 0x5(%rbx)
movq 0x8(%rdi), %rax
movslq (%rsi), %rcx
movq (%rdi,%rcx,8), %rsi
jmp 0x2df8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movslq (%rdi), %rax
leal 0x1(%rax), %ecx
movl %ecx, (%rdi)
leaq 0x10(,%rax,8), %rdi
callq 0x10d0
movq %rax, %r12
movq %rbx, 0x10(%rsp)
movq (%rbx), %rax
movq (%rax), %rdi
callq 0x7ab8
movq %rax, (%r12)
leaq 0x9e43(%rip), %rdi      # 0xcd92
callq 0x7ab8
movq %rax, 0x8(%r12)
movq %r12, 0x8(%rsp)
addq $0x8, %r12
leaq 0x9e2b(%rip), %rbx      # 0xcd94
movq (%r12), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0x2f7d
testl %eax, %eax
jne 0x309b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6f7c
movq %r12, %rdi
callq 0x779b
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x68ad
movq (%r12), %rdi
testq %rdi, %rdi
je 0x307f
movl $0x20, %esi
callq 0x7b48
cmpl $0x2, %eax
jl 0x2f69
movl %eax, %ebp
movq 0x8(%rsp), %r15
movq 0x8(%r15), %rdi
movl $0x20, %esi
callq 0x7b48
movl (%r14), %ecx
leal (%rcx,%rax), %edx
addl %ecx, %eax
decl %eax
movl %eax, (%r14)
movslq %edx, %rdi
shlq $0x3, %rdi
callq 0x10d0
movq %rax, %rbx
movq 0x8(%r15), %rdi
movl $0x20, %esi
callq 0x7bbf
movq %rax, %r13
movq (%r15), %rdi
callq 0x7ab8
movq %rax, (%rbx)
leaq 0x9d9a(%rip), %rdi      # 0xcda7
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x6d18
movq %r15, %rdi
callq 0x1030
cmpl $0x2, (%r14)
jl 0x3052
xorl %r15d, %r15d
movq (%r13,%r15,8), %rdi
callq 0x7ab8
movq %rax, 0x8(%rbx,%r15,8)
movq (%r13,%r15,8), %rdi
callq 0x1030
incq %r15
movslq (%r14), %rax
decq %rax
cmpq %rax, %r15
jl 0x302b
movq %r13, %rdi
callq 0x1030
movslq (%r14), %rax
movq $0x0, (%rbx,%rax,8)
movq 0x10(%rsp), %rax
movq %rbx, (%rax)
cmpl $0x2, %ebp
leaq 0x9d1d(%rip), %rbx      # 0xcd94
jl 0x2f69
jmp 0x30b3
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x779b
movq %rbx, %rdi
callq 0x1030
movl $0x1, %eax
jmp 0x30b5
movslq (%r14), %rax
movq 0x8(%rsp), %rcx
movq $0x0, (%rcx,%rax,8)
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/srcs/inputs.c
// Function: parse_av
int				parse_av(char **av, t_ssl *ssl, int i, int j)
{
	while ((av[++i]) && av[i][0] == '-' && !(j = 0))
	{
		if (av[i][1])
			while (av[i][++j])
			{
				if (valid_flags(ssl, av[i][j]))
					return ((ssl->flag = av[i][j] == HELP_KEY ? 1 : 0) + 1);
				if (ssl->type < 10 && av[i][j] == 's')
				{
					if (ssl->type < 10 && string_input(av, &i, &j, ssl))
						break ;
					ssl->flag = av[--i][--j] ? av[i][j] : 0;
					return (ft_error(2, ft_strtolower(av[1]), ssl));
				}
			}
		else
			break ;
	}
	av[i] ? ssl->file_index[0] += i : 0;
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, 0x8(%rsp)
leal 0x1(%rdx), %eax
movl %eax, 0xc(%rsp)
movslq %edx, %rcx
movq 0x8(%rdi,%rcx,8), %rdx
xorl %ebp, %ebp
testq %rdx, %rdx
sete %cl
je 0x31c1
movq %rsi, %rbx
cmpb $0x2d, (%rdx)
jne 0x3197
movq %rdi, %r14
leaq 0xc(%rsp), %r15
leaq 0x8(%rsp), %r12
movl $0x0, 0x8(%rsp)
cmpb $0x0, 0x1(%rdx)
je 0x3197
movslq 0xc(%rsp), %rax
movq (%r14,%rax,8), %rax
movslq 0x8(%rsp), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x8(%rsp)
movb 0x1(%rax,%rcx), %al
testb %al, %al
je 0x3174
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4510
testl %eax, %eax
jne 0x31a4
cmpl $0x9, 0x8(%rbx)
jg 0x3118
movslq 0xc(%rsp), %rax
movq (%r14,%rax,8), %rax
movslq 0x8(%rsp), %rcx
cmpb $0x73, (%rax,%rcx)
jne 0x3118
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2db5
testb %al, %al
je 0x31d0
movslq 0xc(%rsp), %rcx
leaq 0x1(%rcx), %rax
movl %eax, 0xc(%rsp)
movq 0x8(%r14,%rcx,8), %rdx
testq %rdx, %rdx
sete %cl
je 0x31c1
cmpb $0x2d, (%rdx)
je 0x310a
testb $0x1, %cl
jne 0x31c1
addl %eax, 0x408(%rbx)
jmp 0x31c1
movslq 0xc(%rsp), %rax
movq (%r14,%rax,8), %rax
movslq 0x8(%rsp), %rcx
xorl %ebp, %ebp
cmpb $0x68, (%rax,%rcx)
sete %bpl
movl %ebp, 0x4(%rbx)
incl %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movslq 0xc(%rsp), %rax
leaq -0x1(%rax), %rcx
movl %ecx, 0xc(%rsp)
movq -0x8(%r14,%rax,8), %rax
movslq 0x8(%rsp), %rcx
leaq -0x1(%rcx), %rdx
movl %edx, 0x8(%rsp)
movsbl -0x1(%rax,%rcx), %eax
movl %eax, 0x4(%rbx)
movq 0x8(%r14), %rdi
callq 0x6b4c
movl $0x2, %edi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x2729
movl %eax, %ebp
jmp 0x31c1
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
cmpl $0x1, (%rdi)
jg 0x3240
movl $0x1, (%rbx)
movq %r15, %rsi
callq 0x2f08
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x3240
popq %rbx
popq %r14
popq %r15
retq
movq (%r15), %r14
movq 0x8(%r14), %rdi
leaq 0x9b4f(%rip), %rsi      # 0xcd9d
callq 0x7644
testl %eax, %eax
je 0x3291
movq 0x8(%r14), %rdi
leaq 0x9b40(%rip), %rsi      # 0xcda2
callq 0x7644
testl %eax, %eax
je 0x3291
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x4721
testl %eax, %eax
je 0x32a0
movq 0x8(%r14), %rsi
movl $0x1, %edi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2729
xorl %edi, %edi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3798
movl 0x8(%rbx), %eax
cmpl $0xb, %eax
jl 0x32cc
movl %eax, %eax
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
imulq %rax, %rcx
shrq $0x20, %rcx
andl $-0x8, %ecx
leaq 0xeb0f(%rip), %rax      # 0x11dd0
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rcx,%rax)
jmp 0x3332
movq (%r15), %rdi
movq %rbx, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x30c4
testl %eax, %eax
je 0x32ed
movq 0x8(%r14), %rsi
movl $0x3, %edi
jmp 0x3284
movl 0x408(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x6781
testl %eax, %eax
jne 0x3327
cmpl $0x9, 0x8(%rbx)
jg 0x3327
movl 0x4(%rbx), %eax
testl $0x38000, %eax          # imm = 0x38000
setne %cl
testl %eax, %eax
sete %al
orb %cl, %al
jne 0x3327
cmpl $0x0, 0x408(%rbx)
je 0x3332
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ec4
movl $0x1, %eax
jmp 0x323a
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movl %edi, %ebx
leaq 0x20(%rsp), %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0x339e
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movslq %edi, %r14
leaq 0x8(,%r14,8), %rdi
callq 0x10d0
movabsq $0x3000000008, %rcx     # imm = 0x3000000008
movq %rcx, (%rsp)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq %r15, 0x10(%rsp)
testl %r14d, %r14d
jle 0x3415
movl (%rsp), %ecx
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %r8
movl %ebx, %esi
xorl %edi, %edi
cmpl $0x28, %ecx
ja 0x33fa
movq %r8, %r9
movl %ecx, %r8d
addq %rdx, %r8
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x3403
leaq 0x8(%r8), %r9
movq %r9, 0x8(%rsp)
movslq (%r8), %r8
movq %r8, (%rax,%rdi,8)
incq %rdi
movq %r9, %r8
cmpq %rdi, %rsi
jne 0x33e4
movq $0x0, (%rax,%r14,8)
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq