LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/hash/sha512.c
// Function: sha64_cycle
void			sha64_cycle(int count, t_sha64bit *s, __uint64_t *w, int i)
{
	while (++i < 16)
		w[i] = s->message[count][i];
	i = 15;
	while (++i < 80)
		w[i] = w[i - 16] + s0(w[i - 15]) + w[i - 7] + s1(w[i - 2]);
	s->a = s->hash[0];
	s->b = s->hash[1];
	s->c = s->hash[2];
	s->d = s->hash[3];
	s->e = s->hash[4];
	s->f = s->hash[5];
	s->g = s->hash[6];
	s->h = s->hash[7];
	i = -1;
	while (++i < 80)
		sha512_loop(s, i, w);
	s->hash[0] += s->a;
	s->hash[1] += s->b;
	s->hash[2] += s->c;
	s->hash[3] += s->d;
	s->hash[4] += s->e;
	s->hash[5] += s->f;
	s->hash[6] += s->g;
	s->hash[7] += s->h;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r13
movq %rsi, %rbx
cmpl $0xe, %ecx
jg 0x64eb
movq 0x88(%rbx), %rax
movslq %edi, %rdx
movq (%rax,%rdx,8), %rax
movslq %ecx, %rcx
incq %rcx
movq (%rax,%rcx,8), %rdx
movq %rdx, (%r13,%rcx,8)
incq %rcx
cmpq $0x10, %rcx
jne 0x64d9
xorl %r14d, %r14d
movq (%r13,%r14,8), %r12
movq 0x8(%r13,%r14,8), %rdi
callq 0x2f34
movq %rax, %r15
addq %r12, %r15
addq 0x48(%r13,%r14,8), %r15
movq 0x70(%r13,%r14,8), %rdi
callq 0x2f4c
addq %r15, %rax
movq %rax, 0x80(%r13,%r14,8)
incq %r14
cmpq $0x40, %r14
jne 0x64ee
movq (%rbx), %rax
movdqu (%rbx), %xmm1
movdqu 0x10(%rbx), %xmm2
movups 0x20(%rbx), %xmm0
movdqu %xmm1, 0x48(%rbx)
movdqu %xmm2, 0x58(%rbx)
movq 0x20(%rbx), %r15
movups %xmm0, 0x68(%rbx)
movq 0x30(%rbx), %rcx
movq %rcx, 0x78(%rbx)
movq 0x38(%rbx), %rdx
movq %rdx, 0x80(%rbx)
movdqu 0x28(%rbx), %xmm0
pshufd $0xee, %xmm1, %xmm1     # xmm1 = xmm1[2,3,2,3]
punpcklqdq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0]
xorl %ebp, %ebp
movq %r13, (%rsp)
movq %rdx, 0x10(%rsp)
movq %xmm0, %r13
pshufd $0xee, %xmm0, %xmm0     # xmm0 = xmm0[2,3,2,3]
movq %xmm0, 0x8(%rsp)
movq %xmm1, %rcx
pshufd $0xee, %xmm1, %xmm0     # xmm0 = xmm1[2,3,2,3]
movq %xmm0, %r14
movq %r14, %rdx
xorq %rcx, %rdx
andq %rax, %rdx
andq %rcx, %r14
xorq %rdx, %r14
movq %r15, %rdi
callq 0x2f1b
movq %rax, %r12
movq 0x8(%rsp), %rax
xorq %rax, %r13
andq %r15, %r13
xorq %rax, %r13
addq 0x10(%rsp), %r12
addq %r13, %r12
movq (%rsp), %r13
leaq 0x6ff2(%rip), %rax      # 0xd5c0
addq (%rbp,%rax), %r12
addq (%r13,%rbp), %r12
movq 0x48(%rbx), %rdi
callq 0x2f02
movq 0x78(%rbx), %rdx
movq %rdx, 0x80(%rbx)
movdqu 0x68(%rbx), %xmm0
movdqu %xmm0, 0x70(%rbx)
movq 0x60(%rbx), %r15
addq %r12, %r15
movq %r15, 0x68(%rbx)
movq 0x58(%rbx), %rcx
movq %rcx, 0x60(%rbx)
movdqu 0x48(%rbx), %xmm1
movdqu %xmm1, 0x50(%rbx)
addq %r14, %rax
addq %r12, %rax
movq %rax, 0x48(%rbx)
addq $0x8, %rbp
cmpq $0x280, %rbp            # imm = 0x280
jne 0x656f
addq %rax, (%rbx)
movdqu 0x8(%rbx), %xmm2
movdqu 0x28(%rbx), %xmm3
paddq %xmm1, %xmm2
movdqu %xmm2, 0x8(%rbx)
addq %rcx, 0x18(%rbx)
addq %r15, 0x20(%rbx)
paddq %xmm0, %xmm3
movdqu %xmm3, 0x28(%rbx)
addq %rdx, 0x38(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/hash/sha512.c
// Function: sha64_start
void			sha64_start(char *to_hash, t_sha64bit *s)
{
	int			i;
	__uint64_t	len;

	i = -1;
	len = (ft_strlen(to_hash) * 8) + 1;
	while (len % 1024 != 896)
		len++;
	s->multiples = (len += 128) / 1024;
	s->message = (__uint64_t**)malloc(sizeof(__uint64_t*) * s->multiples);
	while (++i < s->multiples)
	{
		s->message[i] = (__uint64_t*)malloc(sizeof(__uint64_t) * 16);
		ft_bzero(s->message[i], sizeof(__uint64_t) * 16);
	}
	sha_pad(to_hash, s, ft_strlen(to_hash));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x8082
leaq 0x80(,%rax,8), %r15
shlq $0x19, %rax
addq $0x20000000, %rax       # imm = 0x20000000
leal -0x7f(%r15), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
addq $0x400000, %rax         # imm = 0x400000
incq %r15
cmpl $0x380, %ecx            # imm = 0x380
jne 0x668a
shrq $0xa, %r15
movl %r15d, 0x40(%rbx)
sarq $0x1d, %rax
movq %rax, %rdi
callq 0x10d0
movq %rax, 0x88(%rbx)
testl %r15d, %r15d
jle 0x66fe
xorl %r15d, %r15d
movl $0x80, %edi
callq 0x10d0
movq 0x88(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x88(%rbx), %rax
movq (%rax,%r15,8), %rdi
movl $0x80, %esi
callq 0x7370
incq %r15
movslq 0x40(%rbx), %rax
cmpq %rax, %r15
jl 0x66c8
movq %r14, %rdi
callq 0x8082
xorl %r8d, %r8d
movq 0x88(%rbx), %rdi
testq %rax, %rax
je 0x6777
movl $0x38, %r9d
xorl %r10d, %r10d
movl $0x38, %edx
movl %r10d, %esi
andl $0x7, %esi
addl $-0x8, %edx
testq %rsi, %rsi
cmovel %r9d, %edx
movsbq (%r14,%r10), %r11
movl %edx, %ecx
shlq %cl, %r11
shll $0x3, %esi
movl %esi, %ecx
shlq %cl, %r11
shrq %cl, %r11
movl %r8d, %ecx
movq (%rdi,%rcx,8), %rcx
movl %r10d, %esi
andl $0x78, %esi
orq %r11, (%rcx,%rsi)
incq %r10
movl %r10d, %ecx
andl $0x7f, %ecx
cmpq $0x1, %rcx
adcl $0x0, %r8d
cmpq %r10, %rax
jne 0x6723
addl $-0x8, %edx
movl %r8d, %r8d
jmp 0x677c
movl $0x30, %edx
movl $0x80, %esi
movl %edx, %ecx
shlq %cl, %rsi
testb $0x7, %al
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmovneq %rsi, %rcx
movq (%rdi,%r8,8), %rdx
movl %eax, %esi
andl $0x78, %esi
orq %rcx, (%rdx,%rsi)
shlq $0x3, %rax
movq %rax, %rcx
shrq $0x38, %rcx
movslq 0x40(%rbx), %rdx
movq -0x8(%rdi,%rdx,8), %rdx
movq %rcx, 0x70(%rdx)
movq %rax, 0x78(%rdx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/hash/sha512.c
// Function: sha512
char			*sha512(char *buf, char *to_hash)
{
	t_sha64bit	s;
	__uint64_t	w[80];
	int			i;

	i = -1;
	ft_bzero(&s, sizeof(t_sha64bit));
	sha64_start(to_hash, &s);
	s.hash[0] = 0x6a09e667f3bcc908;
	s.hash[1] = 0xbb67ae8584caa73b;
	s.hash[2] = 0x3c6ef372fe94f82b;
	s.hash[3] = 0xa54ff53a5f1d36f1;
	s.hash[4] = 0x510e527fade682d1;
	s.hash[5] = 0x9b05688c2b3e6c1f;
	s.hash[6] = 0x1f83d9abfb41bd6b;
	s.hash[7] = 0x5be0cd19137e2179;
	while (++i < (s.multiples))
		sha64_cycle(i, &s, w, -1);
	to_hash = buf;
	ft_sprintf(to_hash,
		"%.16llx%.16llx%.16llx%.16llx%.16llx%.16llx%.16llx%.16llx",
		s.hash[0], s.hash[1], s.hash[2], s.hash[3],
		s.hash[4], s.hash[5], s.hash[6], s.hash[7]);
	free_message(s.multiples, s.message);
	free(s.message);
	return (to_hash);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x328, %rsp            # imm = 0x328
movq %rsi, %rbp
movq %rdi, 0x8(%rsp)
movabsq $0x6a09e667f3bcc908, %r12 # imm = 0x6A09E667F3BCC908
movabsq $0x5be0cd19137e2179, %r14 # imm = 0x5BE0CD19137E2179
movabsq $0x3c6ef372fe94f82b, %r13 # imm = 0x3C6EF372FE94F82B
movabsq $0x1f83d9abfb41bd6b, %r15 # imm = 0x1F83D9ABFB41BD6B
leaq 0x10(%rsp), %rbx
movl $0x90, %esi
movq %rbx, %rdi
callq 0x7370
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x6668
movabsq $-0x5ab00ac5a0e2c90f, %r9 # imm = 0xA54FF53A5F1D36F1
movabsq $-0x4498517a7b3558c5, %rcx # imm = 0xBB67AE8584CAA73B
movabsq $0x510e527fade682d1, %r11 # imm = 0x510E527FADE682D1
movabsq $-0x64fa9773d4c193e1, %r10 # imm = 0x9B05688C2B3E6C1F
movq %r12, (%rbx)
movq %rcx, 0x8(%rbx)
movq %r13, 0x10(%rbx)
movq %r9, 0x18(%rbx)
movq %r11, 0x20(%rbx)
movq %r10, 0x28(%rbx)
movq %r15, 0x30(%rbx)
movq %r14, 0x38(%rbx)
cmpl $0x0, 0x40(%rbx)
jle 0x68c1
xorl %ebp, %ebp
leaq 0x10(%rsp), %r14
leaq 0xa0(%rsp), %r15
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x64ac
incl %ebp
cmpl 0x50(%rsp), %ebp
jl 0x687f
movq 0x10(%rsp), %r12
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r13
movq 0x28(%rsp), %r9
movq 0x30(%rsp), %r11
movq 0x38(%rsp), %r10
movq 0x40(%rsp), %r15
movq 0x48(%rsp), %r14
leaq 0x6cb8(%rip), %rsi      # 0xd580
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rdx
movq %r13, %r8
xorl %eax, %eax
pushq %r14
pushq %r15
pushq %r10
pushq %r11
callq 0x7a1c
addq $0x20, %rsp
movl 0x50(%rsp), %edi
movq 0x98(%rsp), %rsi
callq 0x7128
movq 0x98(%rsp), %rdi
callq 0x1030
movq %rbx, %rax
addq $0x328, %rsp            # imm = 0x328
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/rsa/ssl_rsa.c
// Function: check_utl_arg
int				check_utl_arg(t_rsa_out *rsa, char *arg)
{
	if (!ft_strcmp(arg, "pubin"))
		rsa->flag |= R_PUBIN;
	else if (!ft_strcmp(arg, "encrypt"))
		rsa->flag |= R_ENCRYPT;
	else if (!ft_strcmp(arg, "decrypt"))
		rsa->flag |= R_DECRYPT;
	else if (!ft_strcmp(arg, "hexdump"))
		rsa->flag |= R_HEXDUMP;
	else
		return (1);
	return (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6f13(%rip), %rsi      # 0xd840
movq %r14, %rdi
callq 0x7d58
testl %eax, %eax
je 0x6980
leaq 0x6f06(%rip), %rsi      # 0xd846
movq %r14, %rdi
callq 0x7d58
testl %eax, %eax
je 0x6987
leaq 0x6efb(%rip), %rsi      # 0xd84e
movq %r14, %rdi
callq 0x7d58
testl %eax, %eax
je 0x698e
leaq 0x6ef0(%rip), %rsi      # 0xd856
movq %r14, %rdi
callq 0x7d58
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x6997
movl $0x400, %eax            # imm = 0x400
jmp 0x6993
movl $0x20, %eax
jmp 0x6993
movl $0x100, %eax            # imm = 0x100
jmp 0x6993
movl $0x200, %eax            # imm = 0x200
orl %eax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/rsa/ssl_rsa.c
// Function: check_rsa_arg
int				check_rsa_arg(t_rsa_out *rsa, char *arg)
{
	if (!ft_strcmp(arg, "text"))
		rsa->flag |= R_TEXT;
	else if (!ft_strcmp(arg, "noout"))
		rsa->flag |= R_NOOUT;
	else if (!ft_strcmp(arg, "check"))
		rsa->flag |= R_CHECK;
	else if (!ft_strcmp(arg, "pubin"))
		rsa->flag |= R_PUBIN;
	else if (!ft_strcmp(arg, "pubout"))
		rsa->flag |= R_PUBOUT;
	else if (!ft_strcmp(arg, "modulus"))
		rsa->flag |= R_MODULUS;
	else
		return (1);
	return (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6eae(%rip), %rsi      # 0xd85e
movq %r14, %rdi
callq 0x7d58
testl %eax, %eax
je 0x6a29
leaq 0x6ea0(%rip), %rsi      # 0xd863
movq %r14, %rdi
callq 0x7d58
testl %eax, %eax
je 0x6a30
leaq 0x6e93(%rip), %rsi      # 0xd869
movq %r14, %rdi
callq 0x7d58
testl %eax, %eax
je 0x6a37
leaq 0x6e57(%rip), %rsi      # 0xd840
movq %r14, %rdi
callq 0x7d58
testl %eax, %eax
je 0x6a3e
leaq 0x6e73(%rip), %rsi      # 0xd86f
movq %r14, %rdi
callq 0x7d58
testl %eax, %eax
je 0x6a45
leaq 0x6e67(%rip), %rsi      # 0xd876
movq %r14, %rdi
callq 0x7d58
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x6a4e
movl $0x80, %eax
jmp 0x6a4a
movl $0x4, %eax
jmp 0x6a4a
movl $0x8, %eax
jmp 0x6a4a
movl $0x10, %eax
jmp 0x6a4a
movl $0x20, %eax
jmp 0x6a4a
movl $0x40, %eax
orl %eax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/rsa/ssl_rsa.c
// Function: ssl_rsa
void			ssl_rsa(char **av, t_ssl *ssl)
{
	t_rsa_out	rsa;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x68(%rsp), %r15
movl $0x18, %esi
movq %r15, %rdi
callq 0x7370
movabsq $0x100000040, %rax      # imm = 0x100000040
movq %rax, 0x8(%r15)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x6a56
testl %eax, %eax
je 0x6d42
cmpl $-0x1, 0x70(%rsp)
jne 0x6d69
leaq 0x6b46(%rip), %rdi      # 0xd87e
movl $0x2, %esi
callq 0x7941
movl 0x8(%rbx), %eax
cmpl $0x1f, %eax
jne 0x6d76
cmpl $0x10, 0x70(%rsp)
jl 0x6d76
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x68(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x2950
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x24, %eax
je 0x6dc8
cmpl $0x21, %eax
je 0x6da6
cmpl $0x20, %eax
jne 0x6d69
movl 0x68(%rsp), %eax
testb $0x4, %al
jne 0x6dd5
andl $0x20, %eax
xorl %edi, %edi
cmpl $0x1, %eax
adcl $0x17, %edi
movq 0x8(%r14), %rsi
movq %rbx, %rdx
callq 0x2738
jmp 0x6d69
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x68(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x80(%rsp), %rdi
callq 0x4d2a
jmp 0x6d69
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3ff6
jmp 0x6d69
movl $0x1, 0x6c(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x68(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0xc8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4d2a
leaq 0x18(%rsp), %rdi
movl $0x9, %ecx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x68(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x5425
jmp 0x6d69
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/util/utils.c
// Function: open_file_to_fd
int				open_file_to_fd(int *fd, char *fname, int type)
{
	int		tmp;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
testl %edx, %edx
je 0x6fb3
movl %edx, %ebp
movq %rdi, %r15
movq %rcx, (%rsp)
movslq %edx, %rax
movq (%rdi,%rax,8), %rdi
testq %rdi, %rdi
je 0x6fbb
leaq (%r15,%rax,8), %rbx
leaq 0x69da(%rip), %r12      # 0xd8b2
movq %r15, 0x10(%rsp)
callq 0x1060
movq %rax, %r14
callq 0x1040
movq %rax, %r13
movl (%rax), %edi
callq 0x1100
movl $0x1a, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x7d80
testl %eax, %eax
je 0x6f2b
testq %r14, %r14
je 0x6f6d
movq 0x8(%r15), %rsi
movq (%rbx), %rdx
leaq 0x69b1(%rip), %rdi      # 0xd8cc
leaq 0x69b6(%rip), %rcx      # 0xd8d8
xorl %eax, %eax
callq 0x7698
jmp 0x6f63
movq 0x8(%r15), %r12
movq (%rbx), %r15
movl (%r13), %edi
callq 0x1100
leaq 0x698a(%rip), %rdi      # 0xd8cc
movq %r12, %rsi
leaq 0x6966(%rip), %r12      # 0xd8b2
movq %r15, %rdx
movq 0x10(%rsp), %r15
movq %rax, %rcx
xorl %eax, %eax
callq 0x7698
testq %r14, %r14
je 0x6f96
movq %r14, %rdi
callq 0x10a0
jmp 0x6f96
movq (%rbx), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10e0
movq (%rsp), %rcx
movslq %ecx, %rcx
movq 0x8(%rsp), %rdx
movl %eax, 0xc(%rdx,%rcx,4)
movl %ebp, 0x408(%rdx,%rcx,4)
incl %ecx
movq %rcx, (%rsp)
movl $0x0, (%r13)
movq 0x8(%rbx), %rdi
addq $0x8, %rbx
incl %ebp
testq %rdi, %rdi
jne 0x6edd
jmp 0x6fbb
movq $0x0, (%rsp)
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/srcs/util/utils.c
// Function: get_stdin
int				get_stdin(char **line, char *str, int x, int i)
{
	char	buf[PAGESIZE + 1];
	char	*tmp;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1028, %rsp           # imm = 0x1028
movl %edx, %ebx
movq %rdi, 0x18(%rsp)
movq %rsi, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
xorl %edi, %edi
callq 0x10b0
movq %rax, %r14
testl %r14d, %r14d
je 0x70a2
leaq 0x5cc2(%rip), %r15      # 0xccda
leaq 0x20(%rsp), %r12
leaq 0x8(%rsp), %r13
leaq 0x10(%rsp), %rbp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0x7041
movq %r15, %rdi
callq 0x81d4
movq %rax, %rdi
movq %rax, 0x8(%rsp)
movslq %r14d, %rax
movb $0x0, 0x20(%rsp,%rax)
movq %r12, %rsi
callq 0x7ef0
movq %rax, 0x10(%rsp)
movq %r13, %rdi
callq 0x7ecf
testl %ebx, %ebx
jne 0x7074
movq %r12, %rdi
movl $0xa, %esi
callq 0x7cac
testq %rax, %rax
jne 0x70dc
movq 0x10(%rsp), %rdi
callq 0x81d4
movq %rax, 0x8(%rsp)
movq %rbp, %rdi
callq 0x7ecf
movl $0x1000, %edx           # imm = 0x1000
xorl %edi, %edi
movq %r12, %rsi
callq 0x10b0
movq %rax, %r14
testl %r14d, %r14d
jne 0x7027
leaq 0x10(%rsp), %rdi
callq 0x7ecf
movq 0x8(%rsp), %rdi
callq 0x81d4
movq 0x18(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x8(%rsp), %rdi
callq 0x7ecf
movl %ebx, %eax
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rsp), %r14
movq (%r14), %rdi
callq 0x8082
movq %rax, %r15
movq (%r14), %rax
leal -0x1(%r15), %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq (%r14), %rdi
callq 0x81d4
movq %rax, 0x8(%rsp)
movq %r14, %rdi
callq 0x7ecf
cmpl $0x1, %r15d
jne 0x70ac
movq 0x8(%rsp), %rdi
leaq 0x5bb8(%rip), %rsi      # 0xccd9
callq 0x7ef0
jmp 0x70b6
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_atoi.c
// Function: ft_atoi
int					ft_atoi(const char *str)
{
	int		i;
	int		res;
	int		neg;

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

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x71cd
movb (%rdi,%rax), %cl
movzbl %cl, %edx
leal -0x9(%rdx), %esi
cmpl $0x5, %esi
jae 0x716e
incq %rax
jmp 0x715b
cmpl $0x20, %edx
je 0x7169
cmpl $0x2b, %edx
je 0x717d
cmpl $0x2d, %edx
jne 0x7191
xorl %edx, %edx
cmpb $0x2d, %cl
setne %dl
leal -0x1(,%rdx,2), %ecx
incq %rax
jmp 0x7196
movl $0x1, %ecx
movslq %eax, %rsi
movb (%rdi,%rsi), %dl
leal -0x30(%rdx), %r8d
xorl %eax, %eax
cmpb $0x9, %r8b
ja 0x71ca
addq %rdi, %rsi
incq %rsi
xorl %eax, %eax
leal (%rax,%rax,4), %eax
addb $-0x30, %dl
movzbl %dl, %edx
leal (%rdx,%rax,2), %eax
movb (%rsi), %dl
leal -0x30(%rdx), %edi
incq %rsi
cmpb $0xa, %dil
jb 0x71b0
imull %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_atoi.c
// Function: ft_atoull
unsigned long long	ft_atoull(const char *str)
{
	int					i;
	unsigned long long	n;

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

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

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

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

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

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

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

// Assembly:
testq %rsi, %rsi
je 0x73cc
movq %rdi, %rax
testq %rdx, %rdx
je 0x73cb
xorl %ecx, %ecx
movb (%rsi,%rcx), %dil
movb %dil, (%rax,%rcx)
incq %rcx
cmpq %rcx, %rdx
jne 0x73bb
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_pipewrench.c
// Function: ft_pipewrench
int				ft_pipewrench(char *str, ...)
{
	int		freed;
	va_list ap;

	freed = 0;
	va_start(ap, str);
	while (*str && freed >= 0)
	{
		if (*str != PIPE_KEY)
		{
			freed = -1;
			break ;
		}
		else
		{
			freed += pipe_cutter(&str, ap);
			if (freed == 0)
			{
				ft_putendl_fd("No valid pointers were freed", 2);
			}
		}
	}
	va_end(ap);
	return (freed);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x74a4
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)
movq %rdi, 0x10(%rsp)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
movb (%rbx), %al
xorl %r14d, %r14d
testb %al, %al
je 0x7681
leaq 0x640f(%rip), %r15      # 0xd8e7
leaq 0x6425(%rip), %r12      # 0xd904
cmpb $0x2d, %al
jne 0x767b
incq %rbx
xorl %r13d, %r13d
movb $0x2d, %al
cmpb $0x2d, %al
jne 0x74fd
incl %r13d
movb (%rbx), %al
incq %rbx
jmp 0x74ef
movzbl %al, %ecx
testl %ecx, %ecx
jne 0x7509
decq %rbx
jmp 0x751c
cmpl $0x3, %r13d
jb 0x7545
movq %r12, %rdi
movl $0x2, %esi
callq 0x79c4
xorl %r13d, %r13d
addl %r13d, %r14d
jne 0x7531
movq %r15, %rdi
movl $0x2, %esi
callq 0x79c4
testl %r14d, %r14d
js 0x7681
movb (%rbx), %al
testb %al, %al
jne 0x74df
jmp 0x7681
cmpb $0x69, %al
je 0x756d
cmpl $0x73, %ecx
jne 0x751f
cmpl $0x2, %r13d
jne 0x7593
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x75c7
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x75d5
cmpl $0x2, %r13d
jne 0x7593
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x7617
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x7625
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x75ac
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x75ba
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdi
callq 0x7eb0
jmp 0x751f
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rbp
movq %rbp, 0x18(%rsp)
xorl %r13d, %r13d
testq %rbp, %rbp
je 0x751f
cmpq $0x0, (%rbp)
je 0x751f
movl $0x1, %r13d
movq %rbp, %rdi
callq 0x7ecf
incl %r13d
cmpq $0x0, 0x8(%rbp)
leaq 0x8(%rbp), %rbp
jne 0x75fa
leaq 0x18(%rsp), %rdi
jmp 0x75bd
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq %r12, %r15
movq (%rax), %rbp
movq %rbp, 0x18(%rsp)
xorl %r13d, %r13d
movq %r13, %rax
incq %r13
cmpq $0x0, (%rbp,%rax,8)
jne 0x7633
cmpq $0x1, %r13
je 0x7662
movl %eax, %r12d
cmpq $0x0, (%rbp)
je 0x7662
movq %rbp, %rdi
callq 0x7eb0
addq $0x8, %rbp
decq %r12
jne 0x764a
leaq 0x18(%rsp), %rdi
callq 0x7eb0
movq %r15, %r12
leaq 0x6271(%rip), %r15      # 0xd8e7
jmp 0x751f
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_strchr.c
// Function: ft_strrchr
char	*ft_strrchr(const char *s, int c)
{
	size_t	i;

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

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

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

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

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

// Assembly:
movb (%rdi), %al
xorl %ecx, %ecx
testb %al, %al
je 0x7d77
cmpb (%rsi,%rcx), %al
jne 0x7d72
movb 0x1(%rdi,%rcx), %al
incq %rcx
testb %al, %al
jne 0x7d60
xorl %eax, %eax
movzbl %al, %eax
jmp 0x7d79
xorl %eax, %eax
movzbl (%rsi,%rcx), %ecx
subl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_strcmp.c
// Function: ft_strncmp
int		ft_strncmp(const char *s1, const char *s2, size_t n)
{
	int		i;

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

// Assembly:
movb (%rdi), %r8b
xorl %eax, %eax
testb %r8b, %r8b
je 0x7dab
movslq %edx, %r9
xorl %ecx, %ecx
cmpq %r9, %rcx
jge 0x7db4
cmpb (%rsi,%rcx), %r8b
jne 0x7db4
movb 0x1(%rdi,%rcx), %r8b
incq %rcx
testb %r8b, %r8b
jne 0x7d8f
xorl %edi, %edi
jmp 0x7db8
xorl %r8d, %r8d
xorl %ecx, %ecx
xorl %edi, %edi
jmp 0x7dbb
movzbl %r8b, %edi
movl %ecx, %r8d
cmpl %edx, %r8d
je 0x7dc8
movzbl (%rsi,%rcx), %eax
subl %eax, %edi
movl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_strcpy.c
// Function: ft_strcpy
char	*ft_strcpy(char *dst, const char *src)
{
	int		i;

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x7e8c
movq %rdx, %rbx
movq %rsi, %r15
xorl %edi, %edi
movb (%r15,%rdi), %al
testb %al, %al
je 0x7e6f
movb %al, (%r14,%rdi)
jmp 0x7e84
movq %rbx, %rdx
subq %rdi, %rdx
jbe 0x7e84
addq %r14, %rdi
xorl %esi, %esi
callq 0x1070
movq %rbx, %rdi
incq %rdi
cmpq %rbx, %rdi
jb 0x7e61
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_strjoin.c
// Function: ft_strjoin
char	*ft_strjoin(char const *s1, char const *s2)
{
	char	*new_str;
	size_t	i;
	size_t	j;
	size_t	s1_len;
	size_t	s2_len;

	if (!s1 || !s2)
		return (s1 ? ft_strdup(s1) : ft_strdup(s2));
	s1_len = ft_strlen(s1);
	s2_len = ft_strlen(s2);
	if (!(new_str = ft_strnew(s1_len + s2_len)))
		return (NULL);
	i = -1;
	while (++i < s1_len)
		new_str[i] = s1[i];
	j = -1;
	while (++j < s2_len)
		new_str[i++] = s2[j];
	return (new_str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
je 0x7f67
movq %r14, %rdi
callq 0x8082
movq %rax, %r12
movq %rbx, %rdi
callq 0x8082
movq %rax, %r15
leaq (%rax,%r12), %rdi
callq 0x811c
testq %rax, %rax
je 0x7f71
testq %r12, %r12
je 0x7f48
xorl %ecx, %ecx
movb (%r14,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq %rcx, %r12
jne 0x7f39
testq %r15, %r15
je 0x7f73
movq %rax, %rcx
addq %r12, %rcx
xorl %edx, %edx
movb (%rbx,%rdx), %sil
movb %sil, (%rcx,%rdx)
incq %rdx
cmpq %rdx, %r15
jne 0x7f55
jmp 0x7f73
testq %r14, %r14
je 0x7f7f
movq %r14, %rdi
jmp 0x7f82
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x81d4
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_strjoin.c
// Function: str_3join
char	*str_3join(char const *s1, char const *s2, char const *s3)
{
	char	*new_str;
	size_t	i[3];
	size_t	len[3];

	if (!s1 || !s2 || !s3)
		return (NULL);
	len[0] = ft_strlen(s1);
	len[1] = ft_strlen(s2);
	len[2] = ft_strlen(s3);
	if (!(new_str = ft_strnew(len[0] + len[1] + len[2])))
		return (NULL);
	i[0] = -1;
	i[1] = -1;
	i[2] = -1;
	while (++i[0] < len[0])
		new_str[i[0]] = s1[i[0]];
	while (++i[1] < len[1])
		new_str[i[0]++] = s2[i[1]];
	while (++i[2] < len[2])
		new_str[i[0]++] = s3[i[2]];
	new_str[i[0]] = '\0';
	return (new_str);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %al
orb %cl, %al
jne 0x803c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %rbp
callq 0x8082
movq %rax, %r14
movq %r12, %rdi
callq 0x8082
movq %rax, %r13
movq %rbx, %rdi
callq 0x8082
movq %rax, %r15
leaq (%r14,%r13), %rdi
addq %rax, %rdi
callq 0x811c
testq %rax, %rax
je 0x803f
testq %r14, %r14
je 0x8007
xorl %ecx, %ecx
movb (%rbp,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq %rcx, %r14
jne 0x7ff8
testq %r13, %r13
je 0x801f
movb (%r12), %cl
movb %cl, (%rax,%r14)
incq %r14
incq %r12
decq %r13
jne 0x800c
testq %r15, %r15
je 0x8035
movb (%rbx), %cl
movb %cl, (%rax,%r14)
incq %r14
incq %rbx
decq %r15
jne 0x8024
movb $0x0, (%rax,%r14)
jmp 0x8041
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_strlen.c
// Function: ft_intlen
int		ft_intlen(int num)
{
	int		n;

	n = 1;
	while (num /= 10)
		n++;
	return (n);
}

// Assembly:
leal 0x9(%rdi), %ecx
movl $0x1, %eax
cmpl $0x13, %ecx
jb 0x8081
movslq %edi, %rcx
imulq $0x66666667, %rcx, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
leal (%rcx,%rdx), %edi
incl %eax
addl %edx, %ecx
addl $0x9, %ecx
cmpl $0x12, %ecx
ja 0x805d
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_strlen.c
// Function: ft_strlen
size_t	ft_strlen(const char *str)
{
	size_t	i;

	i = 0;
	if (str && *str)
		while (str[i])
			i++;
	return (i);
}

// Assembly:
testq %rdi, %rdi
je 0x80a2
cmpb $0x0, (%rdi)
je 0x80a2
movq $-0x1, %rcx
leaq 0x1(%rcx), %rax
cmpb $0x0, 0x1(%rdi,%rcx)
movq %rax, %rcx
jne 0x8093
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_strlen.c
// Function: ft_striter
void	ft_striter(char *s, void (*f)(char *))
{
	int		i;

	i = 0;
	if (s && f)
		while (*(s + i))
			f(s + i++);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x80db
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x80d4
movq %rsi, %rbx
movq %r14, %rdi
callq *%rbx
cmpb $0x0, 0x1(%r14)
leaq 0x1(%r14), %r14
jne 0x80c4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_strlen.c
// Function: ft_striteri
void	ft_striteri(char *s, void (*f)(unsigned int, char *))
{
	int		i;

	i = -1;
	if (s && f)
		while (*(s + ++i))
			f(i, s + i);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x8119
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x8114
movq %rsi, %rbx
xorl %r15d, %r15d
leaq (%r14,%r15), %rsi
movl %r15d, %edi
callq *%rbx
cmpb $0x0, 0x1(%r14,%r15)
leaq 0x1(%r15), %r15
jne 0x80ff
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_strnew.c
// Function: ft_strsub
char	*ft_strsub(char const *s, unsigned int start, size_t len)
{
	char	*new_str;
	size_t	i;

	if (!s)
		return (NULL);
	if (!(new_str = ft_strnew(len)))
		return (NULL);
	i = 0;
	while (i < len && *s)
		new_str[i++] = s[start++];
	return (new_str);
}

// Assembly:
testq %rdi, %rdi
je 0x81ca
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rdi
callq 0x811c
testq %rax, %rax
je 0x81cd
testq %rbx, %rbx
je 0x81cf
movl %ebp, %ecx
xorl %edx, %edx
cmpb $0x0, (%r14)
je 0x81cf
leaq (%rcx,%rdx), %rsi
movl %esi, %esi
movb (%r14,%rsi), %sil
movb %sil, (%rax,%rdx)
incq %rdx
cmpq %rdx, %rbx
jne 0x81ac
jmp 0x81cf
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_strnew.c
// Function: ft_strdup
char	*ft_strdup(const char *s1)
{
	char	*dup;
	size_t	i;

	if (!s1)
		return (NULL);
	i = ft_strlen(s1) + 1;
	if (!(dup = (char *)malloc(i)))
		return (NULL);
	dup[--i] = '\0';
	while (i-- > 0)
		dup[i] = s1[i];
	return (dup);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8215
movq %rdi, %rbx
callq 0x8082
movq %rax, %r14
leaq 0x1(%rax), %rdi
callq 0x10d0
testq %rax, %rax
je 0x8215
movb $0x0, (%rax,%r14)
testq %r14, %r14
je 0x8217
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_strnew.c
// Function: ft_strndup
char	*ft_strndup(const char *s, size_t len)
{
	char	*dup;

	if (!s)
		return (NULL);
	if (!(dup = (char *)malloc(len + 1)))
		return (NULL);
	dup[len] = '\0';
	while (len-- > 0)
		dup[len] = s[len];
	return (dup);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x825a
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rsi), %rdi
callq 0x10d0
testq %rax, %rax
je 0x825a
movb $0x0, (%rax,%rbx)
testq %rbx, %rbx
je 0x825c
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_strsplit.c
// Function: ft_countwords
int				ft_countwords(char const *str, char c)
{
	int count;
	int	i;

	i = 0;
	count = 0;
	while (str[i])
	{
		while (str[i] == c)
			i++;
		if (str[i] != c && str[i] != '\0')
			count++;
		while (str[i] != c && str[i] != '\0')
			i++;
	}
	return (count);
}

// Assembly:
cmpb $0x0, (%rdi)
je 0x82d8
pushq %rbx
xorl %r8d, %r8d
movabsq $0x100000000, %rcx      # imm = 0x100000000
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
xorl %eax, %eax
movslq %r8d, %r10
decq %r10
shlq $0x20, %r8
addq %rdx, %r8
movq %r8, %rbx
movq %r10, %r8
movq %rbx, %r9
movb 0x1(%rdi,%r10), %r11b
incq %r10
addq %rcx, %rbx
cmpb %sil, %r11b
je 0x8293
xorl %r10d, %r10d
testb %r11b, %r11b
setne %r10b
movb 0x1(%rdi,%r8), %r11b
addq %rcx, %r9
incq %r8
cmpb %sil, %r11b
je 0x82c8
testb %r11b, %r11b
jne 0x82b3
addl %r10d, %eax
sarq $0x20, %r9
cmpb $0x0, (%rdi,%r9)
jne 0x8283
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_strsplit.c
// Function: ft_strsplit
char			**ft_strsplit(char const *s, char c)
{
	char	**arr;
	int		i;
	int		j;

	if (!s || !(arr = (char **)malloc(sizeof(*arr) * ft_countwords(s, c) + 1)))
		return (NULL);
	i = -1;
	j = 0;
	while (++i < ft_countwords(s, c))
	{
		while (s[j] == c)
			j++;
		if (!(arr[i] = ft_strsub(s, j, word_len(&s[j], c))))
			arr[i] = NULL;
		j += (int)word_len(&s[j], c);
	}
	arr[i] = 0;
	return (arr);
}

// Assembly:
testq %rdi, %rdi
je 0x8423
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movsbl %bpl, %esi
movl %esi, 0x14(%rsp)
callq 0x8264
movl %eax, %r12d
cltq
leaq 0x1(,%rax,8), %rdi
callq 0x10d0
testq %rax, %rax
je 0x8426
xorl %r13d, %r13d
testl %r12d, %r12d
jle 0x8419
movq %rax, 0x18(%rsp)
leaq 0x1(%rbx), %rax
movq %rax, 0x20(%rsp)
xorl %r12d, %r12d
movq %rbx, 0x8(%rsp)
movslq %r13d, %rax
addq %rax, %rbx
addq 0x20(%rsp), %rax
xorl %r15d, %r15d
movq %r15, %rcx
movq %rax, %r14
incq %r15
incq %rax
cmpb %bpl, (%rbx,%rcx)
je 0x834f
addq %r15, %rbx
movq $-0x1, %rcx
movq %r14, %rsi
movq %rsi, %rax
movb (%rbx,%rcx), %dl
incq %rcx
incq %rsi
cmpb %bpl, %dl
je 0x836e
testb %dl, %dl
je 0x8398
xorl %edx, %edx
incq %rdx
movb (%rax), %cl
cmpb %bpl, %cl
je 0x839a
incq %rax
testb %cl, %cl
jne 0x8385
jmp 0x839a
xorl %edx, %edx
leal -0x1(%r13), %esi
addq %r15, %rsi
movq 0x8(%rsp), %rdi
callq 0x8185
movq 0x18(%rsp), %rcx
movq %rax, (%rcx,%r12,8)
movq $-0x1, %rcx
movq %r14, %rax
movb (%rbx,%rcx), %dl
incq %rcx
incq %r14
cmpb %bpl, %dl
je 0x83bb
xorl %ecx, %ecx
testb %dl, %dl
je 0x83e9
movq 0x8(%rsp), %rbx
incl %ecx
movb (%rax), %dl
cmpb %bpl, %dl
je 0x83ee
incq %rax
testb %dl, %dl
jne 0x83d7
jmp 0x83ee
movq 0x8(%rsp), %rbx
addl %ecx, %r13d
addl %r15d, %r13d
decl %r13d
incq %r12
movq %rbx, %rdi
movl 0x14(%rsp), %esi
callq 0x8264
cltq
cmpq %rax, %r12
jl 0x8341
movslq %r12d, %r13
movq 0x18(%rsp), %rax
movq $0x0, (%rax,%r13,8)
jmp 0x8428
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_strsplit.c
// Function: ft_strtrim
char			*ft_strtrim(char const *s)
{
	char	*new;
	size_t	start;
	size_t	end;
	size_t	new_len;

	if (!s)
		return (NULL);
	start = 0;
	end = ft_strlen(s) - 1;
	if (!has_whitespace((char *)s, &start, &end))
		return (ft_strdup(s));
	new_len = (start == ft_strlen(s)) ? 0 : ft_strlen(s) - start - \
											(ft_strlen(s) - end);
	if (!(new = ft_strnew(new_len + 1)))
		return (NULL);
	ft_strncpy(new, &s[start], new_len + 1);
	return (new);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x8518
movq %rdi, %rbx
callq 0x8082
movq %rax, %r14
xorl %r13d, %r13d
movabsq $0x100003600, %r15      # imm = 0x100003600
movzbl (%rbx,%r13), %eax
cmpq $0x20, %rax
ja 0x8477
btq %rax, %r15
jae 0x8477
incq %r13
jmp 0x8461
movq %rbx, %rdi
callq 0x8082
cmpq %rax, %r13
ja 0x8472
leaq (%rbx,%r13), %r15
movzbl (%rbx,%r13), %eax
leaq -0x1(%r14), %r12
subq %r13, %r14
movl %eax, %ecx
movabsq $0x100003200, %rdx      # imm = 0x100003200
cmpl $0x20, %eax
ja 0x84b3
btq %rcx, %rdx
jae 0x84b3
decq %r14
decq %r12
jmp 0x84a0
cmpb $0xa, (%rbx,%r12)
je 0x84ab
testq %r13, %r13
jne 0x84cc
movq %rbx, %rdi
callq 0x8082
cmpq %rax, %r12
jae 0x8527
movq %rbx, %rdi
callq 0x8082
movl $0x1, %r12d
cmpq %r13, %rax
je 0x84f8
movq %rbx, %rdi
callq 0x8082
movq %rax, %r12
movq %rbx, %rdi
callq 0x8082
subq %rax, %r12
addq %r14, %r12
movq %r12, %rdi
callq 0x811c
testq %rax, %rax
je 0x8518
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7e4c
jmp 0x851a
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x81d4
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_printf/finders.c
// Function: get_type_specifier
int		get_type_specifier(char x)
{
	char	*str;
	int		i;

	i = -1;
	str = "%dcspouxfb";
	while (str[++i])
		if (x == str[i])
			return (i + 1);
	str = ".i...OUXFB";
	while (--i >= 0)
		if (x == str[i])
			return (i + 11);
	return (0);
}

// Assembly:
xorl %ecx, %ecx
leaq 0x5426(%rip), %rdx      # 0xd9ac
cmpq $0xa, %rcx
je 0x859a
leaq 0x1(%rcx), %rax
cmpb %dil, (%rcx,%rdx)
movq %rax, %rcx
jne 0x8586
retq
movl $0xa, %edx
movl $0x15, %eax
leaq 0x540c(%rip), %rcx      # 0xd9b7
movl $0xa, %esi
subq $0x1, %rsi
jb 0x85c4
decl %eax
cmpb %dil, -0x1(%rdx,%rcx)
movq %rsi, %rdx
jne 0x85b0
jmp 0x8599
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_printf/do_things.c
// Function: set_flags
void		set_flags(t_flag *fl, char c)
{
	if (c == ' ')
		fl->space = 1;
	else if (c == '#')
		fl->pound = 1;
	else if (c == '+')
		fl->fplus = 1;
	else if (c == '-')
		fl->minus = 1;
	else if (c == '0')
		fl->fzero = 1;
}

// Assembly:
cmpl $0x2a, %esi
jle 0x864d
cmpl $0x2b, %esi
je 0x865d
cmpl $0x2d, %esi
je 0x8663
cmpl $0x30, %esi
jne 0x866d
addq $0x10, %rdi
jmp 0x8667
cmpl $0x20, %esi
je 0x8667
cmpl $0x23, %esi
jne 0x866d
addq $0x4, %rdi
jmp 0x8667
addq $0xc, %rdi
jmp 0x8667
addq $0x8, %rdi
movl $0x1, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_printf/do_things.c
// Function: num_string_u_base
char		*num_string_u_base(unsigned long long num, int base)
{
	unsigned long long	tmp;
	int					len;
	char				*str;

	len = 0;
	tmp = num;
	if (tmp == 0)
		return ((str = ft_strdup("0")));
	while (tmp > 0)
	{
		len++;
		tmp /= base;
	}
	if (!(str = ft_strnew(len)))
		return (NULL);
	len--;
	while (num > 0)
	{
		str[len] = g_base[(num % base)];
		num /= base;
		len--;
	}
	return (str);
}

// Assembly:
testq %rdi, %rdi
je 0x86d2
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq %esi, %r15
xorl %r14d, %r14d
movq %rdi, %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %r15
incq %r14
cmpq %r15, %rcx
movq %rax, %rcx
jae 0x8684
movq %r14, %rdi
callq 0x811c
testq %rax, %rax
je 0x86de
movq %rax, %rcx
movslq %r14d, %rax
leaq (%rcx,%rax), %rsi
decq %rsi
leaq 0x5328(%rip), %rdi      # 0xd9e0
movq %rbx, %rax
xorl %edx, %edx
divq %r15
movb (%rdx,%rdi), %dl
movb %dl, (%rsi)
decq %rsi
cmpq %r15, %rbx
movq %rax, %rbx
jae 0x86b8
jmp 0x86e0
leaq 0x46e3(%rip), %rdi      # 0xcdbc
jmp 0x81d4
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_printf/do_things.c
// Function: num_string_base
char		*num_string_base(long long num, int base)
{
	long long	tmp;
	int			len;
	char		*str;

	len = 0;
	tmp = num;
	if ((tmp + 1) * -1 == 9223372036854775807)
		return ((str = ft_strdup("9223372036854775808")));
	if (tmp == 0)
		return ((str = ft_strdup("0")));
	while (tmp > 0)
	{
		len++;
		tmp /= base;
	}
	if (!(str = ft_strnew(len)))
		return (NULL);
	len--;
	while (num > 0)
	{
		str[len] = g_base[(num % base)];
		num /= base;
		len--;
	}
	return (str);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rax
negq %rax
jo 0x8709
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x871f
leaq 0x46b5(%rip), %rdi      # 0xcdbc
jmp 0x8710
leaq 0x52b2(%rip), %rdi      # 0xd9c2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x81d4
jle 0x878c
movslq %esi, %r14
movq $-0x1, %r15
movq %rbx, %rax
cqto
idivq %r14
incq %r15
testq %rax, %rax
jg 0x872e
testq %rbx, %rbx
setle %bpl
leaq 0x1(%r15), %rdi
callq 0x811c
movq %rax, %rcx
testq %rax, %rax
sete %al
orb %bpl, %al
jne 0x877e
movq %rcx, %rsi
addq %r15, %rsi
leaq 0x527a(%rip), %rdi      # 0xd9e0
movq %rbx, %rax
cqto
idivq %r14
movb (%rdx,%rdi), %dl
movb %dl, (%rsi)
decq %rsi
movq %rax, %rbx
testq %rax, %rax
jg 0x8766
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x811c
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_b.c
// Function: pad_width
static int		pad_width(t_mods mod, int len, int nbyte, char *num)
{
	char	*pad_char;

	if ((pad_char = " ") && (len > mod.prcsn || mod.prcsn == -1))
	{
		if (mod.width > len)
		{
			mod.fl.fzero && mod.prcsn == -1 ? pad_char = "0" : 0;
			if (mod.fl.space && mod.fl.fzero && !nbyte)
				nbyte += write(1, " ", 1);
			if (mod.fl.pound && !nbyte && num[0] != '0')
				len += 2;
			while (mod.width - len > nbyte)
				nbyte += (int)write(1, pad_char, 1);
		}
	}
	else
	{
		if (mod.fl.pound && !nbyte && num[0] == '\0')
			;
		else if (mod.fl.pound && !nbyte)
			mod.prcsn += 2;
		while (mod.width - mod.prcsn > nbyte)
			nbyte += (int)write(1, pad_char, 1);
	}
	return (nbyte);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl %esi, %ebx
leaq 0x40(%rsp), %r13
movl 0x18(%r13), %eax
cmpl %edi, %eax
setge %cl
cmpl $-0x1, %eax
setne %dl
testb %dl, %cl
jne 0x8ded
movl %edi, %r15d
movl 0x14(%r13), %ebp
cmpl %edi, %ebp
jle 0x8e2e
movl 0x10(%r13), %ecx
testl %ecx, %ecx
leaq 0x4041(%rip), %r14      # 0xcdbc
leaq 0x4678(%rip), %rdx      # 0xd3fa
cmoveq %rdx, %r14
cmpl $-0x1, %eax
cmovneq %rdx, %r14
testl %ebx, %ebx
jne 0x8db5
cmpl $0x0, (%r13)
je 0x8db5
testl %ecx, %ecx
je 0x8db5
leaq 0x4657(%rip), %rsi      # 0xd3fa
movl $0x1, %edx
movl $0x1, %edi
callq 0x1050
movq %rax, %rbx
testl %ebx, %ebx
jne 0x8dd0
cmpl $0x0, 0x4(%r13)
je 0x8dd0
cmpb $0x30, (%r12)
leal 0x2(%r15), %eax
cmovel %r15d, %eax
movl %eax, %r15d
subl %r15d, %ebp
cmpl %ebx, %ebp
jle 0x8e2e
movl $0x1, %edx
movl $0x1, %edi
movq %r14, %rsi
callq 0x1050
addl %eax, %ebx
jmp 0x8dd3
testl %ebx, %ebx
jne 0x8e05
cmpl $0x0, 0x4(%r13)
je 0x8e05
cmpb $0x0, (%r12)
leal 0x2(%rax), %ecx
cmovel %eax, %ecx
movl %ecx, %eax
movl 0x14(%r13), %ebp
subl %eax, %ebp
cmpl %ebx, %ebp
jle 0x8e2e
leaq 0x45e4(%rip), %r14      # 0xd3fa
movl $0x1, %edx
movl $0x1, %edi
movq %r14, %rsi
callq 0x1050
addl %eax, %ebx
cmpl %ebx, %ebp
jg 0x8e16
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop