LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
movslq %edi, %rax
movslq %ecx, %rcx
cmpq $0xf, %rcx
jge 0x59a6
movq 0x88(%rbx), %rdx
movq (%rdx,%rax,8), %rdx
movq 0x8(%rdx,%rcx,8), %rdx
movq %rdx, 0x8(%r13,%rcx,8)
incq %rcx
jmp 0x5986
xorl %r14d, %r14d
cmpq $0x40, %r14
je 0x59e3
movq (%r13,%r14,8), %r12
movq 0x8(%r13,%r14,8), %rdi
callq 0x2d60
movq %rax, %r15
addq %r12, %r15
addq 0x48(%r13,%r14,8), %r15
movq 0x70(%r13,%r14,8), %rdi
callq 0x2d78
addq %r15, %rax
movq %rax, 0x80(%r13,%r14,8)
incq %r14
jmp 0x59a9
movq %r13, 0x8(%rsp)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rax, 0x48(%rbx)
movq %rcx, 0x50(%rbx)
movq 0x10(%rbx), %r13
movq %r13, 0x58(%rbx)
movq 0x18(%rbx), %rdx
movq %rdx, 0x60(%rbx)
movq 0x20(%rbx), %r15
movq %r15, 0x68(%rbx)
movq 0x28(%rbx), %r14
movq %r14, 0x70(%rbx)
movq 0x30(%rbx), %rdi
movq %rdi, 0x78(%rbx)
movq 0x38(%rbx), %r12
movq %r12, 0x80(%rbx)
xorl %ebp, %ebp
cmpq $0x280, %rbp            # imm = 0x280
je 0x5ade
movq %r13, %rdx
xorq %rcx, %rdx
andq %rax, %rdx
andq %rcx, %r13
xorq %rdx, %r13
movq %rbp, 0x10(%rsp)
movq %rdi, %rbp
movq %r15, %rdi
callq 0x2d47
xorq %rbp, %r14
andq %r15, %r14
xorq %rbp, %r14
movq 0x10(%rsp), %rbp
addq %rax, %r12
addq %r14, %r12
leaq 0x6aad(%rip), %rax      # 0xc520
addq (%rbp,%rax), %r12
movq 0x8(%rsp), %rax
addq (%rax,%rbp), %r12
movq 0x48(%rbx), %rdi
callq 0x2d2e
movq 0x78(%rbx), %rsi
movq %rsi, 0x80(%rbx)
movq 0x70(%rbx), %rdi
movq %rdi, 0x78(%rbx)
movq 0x68(%rbx), %r14
movq %r14, 0x70(%rbx)
movq 0x60(%rbx), %r15
addq %r12, %r15
movq %r15, 0x68(%rbx)
movq 0x58(%rbx), %rdx
movq %rdx, 0x60(%rbx)
movq 0x48(%rbx), %rcx
addq %r13, %rax
movq 0x50(%rbx), %r13
movq %r13, 0x58(%rbx)
movq %rcx, 0x50(%rbx)
addq %r12, %rax
movq %rax, 0x48(%rbx)
addq $0x8, %rbp
movq %rsi, %r12
jmp 0x5a2c
addq %rax, (%rbx)
addq %rcx, 0x8(%rbx)
addq %r13, 0x10(%rbx)
addq %rdx, 0x18(%rbx)
addq %r15, 0x20(%rbx)
addq %r14, 0x28(%rbx)
addq %rdi, 0x30(%rbx)
addq %r12, 0x38(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x739e
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 0x5b31
shrq $0xa, %r15
movl %r15d, 0x40(%rbx)
sarq $0x1d, %rax
movq %rax, %rdi
callq 0x10b0
movq %rax, 0x88(%rbx)
xorl %r12d, %r12d
movslq %r15d, %rax
cmpq %rax, %r12
jge 0x5ba5
movl $0x80, %edi
callq 0x10b0
movq 0x88(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
movq 0x88(%rbx), %rax
movq (%rax,%r12,8), %rdi
movl $0x80, %esi
callq 0x6720
movl 0x40(%rbx), %r15d
incq %r12
jmp 0x5b6a
movq %r14, %rdi
callq 0x739e
pushq $0x38
popq %rdi
xorl %r8d, %r8d
movl %edi, %edx
xorl %r9d, %r9d
addl $-0x8, %edx
movl %r8d, %r10d
cmpq %r9, %rax
je 0x5c09
movl %r9d, %esi
andl $0x7, %esi
cmovel %edi, %edx
movsbq (%r14,%r9), %r11
movl %edx, %ecx
shlq %cl, %r11
shll $0x3, %esi
movl %esi, %ecx
shlq %cl, %r11
shrq %cl, %r11
movq 0x88(%rbx), %rcx
movq (%rcx,%r10,8), %rcx
movl %r9d, %esi
andl $0x78, %esi
orq %r11, (%rcx,%rsi)
incq %r9
movl %r9d, %ecx
andl $0x7f, %ecx
cmpq $0x1, %rcx
adcl $0x0, %r8d
jmp 0x5bb8
movl $0x80, %esi
movl %edx, %ecx
shlq %cl, %rsi
testb $0x7, %al
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmovneq %rsi, %rcx
movq 0x88(%rbx), %rdx
movq (%rdx,%r10,8), %rsi
movl %eax, %edi
andl $0x78, %edi
orq %rcx, (%rsi,%rdi)
shlq $0x3, %rax
movq %rax, %rcx
shrq $0x38, %rcx
movslq 0x40(%rbx), %rsi
movq -0x8(%rdx,%rsi,8), %rdx
movq %rcx, 0x70(%rdx)
movq %rax, 0x78(%rdx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x330, %rsp            # imm = 0x330
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movl $0x90, %esi
movq %r14, %rdi
callq 0x6720
movq %r15, %rdi
movq %r14, %rsi
callq 0x5b0c
movabsq $0x6a09e667f3bcc908, %rax # imm = 0x6A09E667F3BCC908
movq %rax, (%r14)
movabsq $-0x4498517a7b3558c5, %rax # imm = 0xBB67AE8584CAA73B
movq %rax, 0x8(%r14)
movabsq $0x3c6ef372fe94f82b, %rax # imm = 0x3C6EF372FE94F82B
movq %rax, 0x10(%r14)
movabsq $-0x5ab00ac5a0e2c90f, %rax # imm = 0xA54FF53A5F1D36F1
movq %rax, 0x18(%r14)
movabsq $0x510e527fade682d1, %rax # imm = 0x510E527FADE682D1
movq %rax, 0x20(%r14)
movabsq $-0x64fa9773d4c193e1, %rax # imm = 0x9B05688C2B3E6C1F
movq %rax, 0x28(%r14)
movabsq $0x1f83d9abfb41bd6b, %rax # imm = 0x1F83D9ABFB41BD6B
movq %rax, 0x30(%r14)
movabsq $0x5be0cd19137e2179, %rax # imm = 0x5BE0CD19137E2179
movq %rax, 0x38(%r14)
xorl %ebp, %ebp
leaq 0xb0(%rsp), %r15
pushq $-0x1
popq %r12
cmpl 0x60(%rsp), %ebp
jge 0x5d28
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
movl %r12d, %ecx
callq 0x596c
incl %ebp
jmp 0x5d0e
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x38(%rsp), %r9
movups 0x40(%rsp), %xmm0
movups 0x50(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x678a(%rip), %rsi      # 0xc4e0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6dd0
movl 0x60(%rsp), %edi
movq 0xa8(%rsp), %rsi
callq 0x6525
movq 0xa8(%rsp), %rdi
callq 0x1030
movq %rbx, %rax
addq $0x330, %rsp            # imm = 0x330
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x69fb(%rip), %rsi      # 0xc7a0
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x5def
leaq 0x69ee(%rip), %rsi      # 0xc7a6
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x5df4
leaq 0x69e3(%rip), %rsi      # 0xc7ae
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x5dfb
leaq 0x69d8(%rip), %rsi      # 0xc7b6
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x5e02
pushq $0x1
popq %rax
jmp 0x5e0b
pushq $0x20
popq %rax
jmp 0x5e07
movl $0x100, %eax            # imm = 0x100
jmp 0x5e07
movl $0x200, %eax            # imm = 0x200
jmp 0x5e07
movl $0x400, %eax            # imm = 0x400
orl %eax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x699a(%rip), %rsi      # 0xc7be
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x5e94
leaq 0x698c(%rip), %rsi      # 0xc7c3
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x5e98
leaq 0x697f(%rip), %rsi      # 0xc7c9
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x5e9c
leaq 0x6943(%rip), %rsi      # 0xc7a0
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x5ea0
leaq 0x695f(%rip), %rsi      # 0xc7cf
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x5ea4
leaq 0x6953(%rip), %rsi      # 0xc7d6
movq %r14, %rdi
callq 0x70f4
testl %eax, %eax
je 0x5eb3
pushq $0x1
popq %rax
jmp 0x5eab
pushq $0x4
jmp 0x5ea6
pushq $0x8
jmp 0x5ea6
pushq $0x10
jmp 0x5ea6
pushq $0x20
jmp 0x5ea6
pushq $0x40
popq %rax
orl %eax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x80, %eax
jmp 0x5ea7
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x6720
movabsq $0x100000040, %rax      # imm = 0x100000040
movq %rax, 0x8(%r15)
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x5eba
testl %eax, %eax
je 0x617b
cmpl $-0x1, 0x70(%rsp)
jne 0x61a2
leaq 0x666b(%rip), %rdi      # 0xc7de
pushq $0x2
popq %rsi
callq 0x6d07
movl 0x8(%rbx), %eax
cmpl $0x1f, %eax
jne 0x61af
cmpl $0x10, 0x70(%rsp)
jl 0x61af
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x68(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x27d3
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x24, %eax
je 0x6201
cmpl $0x21, %eax
je 0x61df
cmpl $0x20, %eax
jne 0x61a2
movl 0x68(%rsp), %eax
testb $0x4, %al
jne 0x620e
andl $0x20, %eax
xorl %edi, %edi
cmpl $0x1, %eax
adcl $0x17, %edi
movq 0x8(%r14), %rsi
movq %rbx, %rdx
callq 0x2608
jmp 0x61a2
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x68(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x80(%rsp), %rdi
callq 0x4919
jmp 0x61a2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c9b
jmp 0x61a2
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 0x4919
leaq 0x18(%rsp), %rdi
pushq $0x9
popq %rcx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x68(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x4fec
jmp 0x61a2
// File: /workspace/github_c_makefile_star2_O2/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 0x6288
movl $0x242, %esi            # imm = 0x242
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x10c0
jmp 0x6291
xorl %esi, %esi
xorl %eax, %eax
callq 0x10c0
testl %eax, %eax
js 0x629c
movl %eax, (%r14)
xorl %ebp, %ebp
jmp 0x62c4
pushq $0x1
popq %rbp
testq %rbx, %rbx
je 0x62c4
callq 0x1040
movl (%rax), %edi
callq 0x10e0
leaq 0x6579(%rip), %rdi      # 0xc830
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x6a50
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x10(%rsp)
testl %edx, %edx
je 0x63dd
movl %edx, %ebp
movq %rdi, %r15
movq %rcx, (%rsp)
movslq %edx, %rax
leaq (%rdi,%rax,8), %rbx
leaq 0x6515(%rip), %r13      # 0xc812
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x63d7
callq 0x1060
movq %rax, %r12
callq 0x1040
movq %rax, %r14
movl (%rax), %edi
callq 0x10e0
movq %rax, %rdi
movq %r13, %rsi
pushq $0x1a
popq %rdx
callq 0x7110
testl %eax, %eax
je 0x6355
testq %r12, %r12
je 0x639f
movq 0x8(%r15), %rsi
movq (%rbx), %rdx
leaq 0x64e7(%rip), %rdi      # 0xc82c
leaq 0x64ec(%rip), %rcx      # 0xc838
xorl %eax, %eax
callq 0x6a50
jmp 0x6395
movq 0x8(%r15), %r13
movl %ebp, 0xc(%rsp)
movq %r15, %rbp
movq (%rbx), %r15
movl (%r14), %edi
callq 0x10e0
leaq 0x64ba(%rip), %rdi      # 0xc82c
movq %r13, %rsi
leaq 0x6496(%rip), %r13      # 0xc812
movq %r15, %rdx
movq %rbp, %r15
movl 0xc(%rsp), %ebp
movq %rax, %rcx
xorl %eax, %eax
callq 0x6a50
testq %r12, %r12
je 0x63c8
movq %r12, %rdi
callq 0x1090
jmp 0x63c8
movq (%rbx), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10c0
movq (%rsp), %rcx
movslq %ecx, %rcx
movq 0x10(%rsp), %rdx
movl %eax, 0xc(%rdx,%rcx,4)
movl %ebp, 0x408(%rdx,%rcx,4)
incl %ecx
movq %rcx, (%rsp)
andl $0x0, (%r14)
incl %ebp
addq $0x8, %rbx
jmp 0x62fd
movq (%rsp), %rax
jmp 0x63df
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_O2/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)
leaq 0x8(%rsp), %r15
leaq 0x10(%rsp), %r12
andq $0x0, (%r12)
movq %rsi, (%r15)
leaq 0x20(%rsp), %r13
pushq $0xa
popq %r14
movl $0x1000, %edx           # imm = 0x1000
xorl %edi, %edi
movq %r13, %rsi
callq 0x10a0
movq %rax, %rbp
testl %ebp, %ebp
je 0x649f
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0x6455
leaq 0x5892(%rip), %rdi      # 0xbcda
callq 0x74dc
movq %rax, %rdi
movq %rax, 0x8(%rsp)
movslq %ebp, %rax
movb $0x0, 0x20(%rsp,%rax)
movq %r13, %rsi
callq 0x7228
movq %rax, 0x10(%rsp)
movq %r15, %rdi
callq 0x720c
testl %ebx, %ebx
jne 0x6486
movq %r13, %rdi
movl %r14d, %esi
callq 0x7050
testq %rax, %rax
jne 0x64d9
movq 0x10(%rsp), %rdi
callq 0x74dc
movq %rax, 0x8(%rsp)
movq %r12, %rdi
callq 0x720c
jmp 0x6421
leaq 0x10(%rsp), %rdi
callq 0x720c
movq 0x8(%rsp), %rdi
callq 0x74dc
movq 0x18(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x8(%rsp), %rdi
callq 0x720c
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 0x739e
movq %rax, %r15
movq (%r14), %rax
leal -0x1(%r15), %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq (%r14), %rdi
callq 0x74dc
movq %rax, 0x8(%rsp)
movq %r14, %rdi
callq 0x720c
cmpl $0x1, %r15d
jne 0x64a9
movq 0x8(%rsp), %rdi
leaq 0x57bb(%rip), %rsi      # 0xbcd9
callq 0x7228
jmp 0x64b3
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x659e
xorl %eax, %eax
movabsq $0x100003e00, %rcx      # imm = 0x100003E00
movzbl (%rdi,%rax), %edx
cmpq $0x2d, %rdx
ja 0x65a1
btq %rdx, %rcx
jae 0x657a
incq %rax
jmp 0x6565
movabsq $0x280000000000, %rcx   # imm = 0x280000000000
btq %rdx, %rcx
jae 0x65a1
xorl %ecx, %ecx
cmpb $0x2d, %dl
setne %cl
leal -0x1(,%rcx,2), %ecx
incq %rax
jmp 0x65a4
xorl %eax, %eax
retq
pushq $0x1
popq %rcx
cltq
addq %rax, %rdi
xorl %eax, %eax
movb (%rdi), %dl
addb $-0x30, %dl
cmpb $0x9, %dl
ja 0x65c2
imull $0xa, %eax, %esi
movzbl %dl, %eax
addl %esi, %eax
incq %rdi
jmp 0x65ab
imull %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x661b
movq %rdi, %rbx
incq %rbx
movabsq $0x100003e00, %rcx      # imm = 0x100003E00
movzbl -0x1(%rbx), %eax
cmpq $0x20, %rax
ja 0x65f4
btq %rax, %rcx
jae 0x65f4
incq %rbx
jmp 0x65df
xorl %r14d, %r14d
movsbl %al, %edi
callq 0x66c8
testl %eax, %eax
je 0x661e
imulq $0xa, %r14, %rax
movsbq -0x1(%rbx), %rcx
leaq (%rax,%rcx), %r14
addq $-0x30, %r14
movb (%rbx), %al
incq %rbx
jmp 0x65f7
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x6670
movq %rbx, %r14
movsbl (%r14), %edi
testl %edi, %edi
je 0x6670
callq 0x6638
movb %al, (%r14)
incq %r14
jmp 0x665b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, %r14
movsbl (%r14), %edi
testl %edi, %edi
je 0x66bb
callq 0x6688
movb %al, (%r14)
incq %r14
jmp 0x66a6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x70ac
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x739e
movq %rax, %rcx
movsbl %bpl, %edx
xorl %eax, %eax
cmpq $-0x1, %rcx
je 0x70a5
movsbl (%rbx,%rcx), %esi
decq %rcx
cmpl %esi, %edx
jne 0x708d
leaq (%rbx,%rcx), %rax
incq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x70ee
movsbl %sil, %ecx
xorl %edx, %edx
xorl %eax, %eax
movsbl (%rdi,%rdx), %esi
testl %esi, %esi
je 0x70f0
incq %rdx
cmpl %esi, %ecx
cmovel %edx, %eax
jmp 0x70dc
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %edx, %edx
movzbl (%rdi,%rdx), %eax
movzbl (%rsi,%rdx), %ecx
testl %eax, %eax
je 0x710b
incq %rdx
cmpb %cl, %al
je 0x70f6
jmp 0x710d
xorl %eax, %eax
subl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movslq %edx, %rax
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %r8d
testl %r8d, %r8d
je 0x712f
cmpq %rax, %rcx
jge 0x712f
cmpb (%rsi,%rcx), %r8b
jne 0x712f
incq %rcx
jmp 0x7115
xorl %eax, %eax
cmpl %ecx, %edx
je 0x713f
movzbl (%rsi,%rcx), %eax
subl %eax, %r8d
movl %r8d, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %ecx, %ecx
movb (%rsi,%rcx), %dl
testb %dl, %dl
je 0x71a4
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x7195
movb $0x0, (%rax,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rdi, %rax
pushq $-0x1
popq %rcx
incq %rcx
cmpq %rdx, %rcx
jae 0x71d4
movb (%rsi,%rcx), %dil
testb %dil, %dil
je 0x71cd
movb %dil, (%rax,%rcx)
jmp 0x71af
movb $0x0, (%rax,%rcx)
incq %rcx
cmpq %rdx, %rcx
jb 0x71c6
jmp 0x71af
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x727d
movq %r14, %rdi
callq 0x739e
movq %rax, %r12
movq %rbx, %rdi
callq 0x739e
movq %rax, %r15
leaq (%rax,%r12), %rdi
callq 0x7428
testq %rax, %rax
je 0x72a1
xorl %ecx, %ecx
cmpq %rcx, %r12
je 0x7287
movb (%r14,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x726c
testq %r14, %r14
je 0x72af
movq %r14, %rdi
jmp 0x72b2
movq %rax, %rcx
addq %r12, %rcx
xorl %edx, %edx
cmpq %rdx, %r15
je 0x72a3
movb (%rbx,%rdx), %sil
movb %sil, (%rcx,%rdx)
incq %rdx
jmp 0x728f
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 0x74dc
// File: /workspace/github_c_makefile_star2_O2/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 0x7332
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x739e
movq %rax, %rbp
movq %r14, %rdi
callq 0x739e
movq %rax, %r13
movq %rbx, %rdi
callq 0x739e
movq %rax, %r15
movq %r13, %rdi
addq %rbp, %rdi
addq %rax, %rdi
callq 0x7428
testq %rax, %rax
je 0x7370
xorl %ecx, %ecx
cmpq %rcx, %rbp
je 0x7335
movb (%r12,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x7321
xorl %eax, %eax
retq
movq %rax, %rcx
addq %rbp, %rcx
xorl %edx, %edx
cmpq %rdx, %r13
je 0x734f
movb (%r14,%rdx), %sil
movb %sil, (%rcx,%rdx)
incq %rdx
jmp 0x733d
xorl %esi, %esi
cmpq %rsi, %r15
je 0x7367
movb (%rbx,%rsi), %dil
leaq (%rcx,%rsi), %r8
movb %dil, (%rdx,%r8)
incq %rsi
jmp 0x7351
addq %rsi, %rcx
movb $0x0, (%rdx,%rcx)
jmp 0x7372
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
movl %edi, %eax
pushq $0x1
popq %rcx
pushq $0xa
popq %rsi
leal 0x9(%rax), %edx
cmpl $0x13, %edx
jb 0x739b
cltd
idivl %esi
incl %ecx
jmp 0x738c
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x73ba
cmpb $0x0, (%rdi)
je 0x73ba
pushq $-0x1
popq %rcx
leaq 0x1(%rcx), %rax
cmpb $0x0, 0x1(%rdi,%rcx)
movq %rax, %rcx
jne 0x73ab
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x73ee
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, (%r14)
je 0x73e7
movq %r14, %rdi
callq *%rbx
incq %r14
jmp 0x73d7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7427
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
cmpb $0x0, (%r14,%r15)
je 0x7422
leaq (%r14,%r15), %rsi
movl %r15d, %edi
callq *%rbx
incq %r15
jmp 0x740d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/libft/srcs/ft_strnew.c
// Function: ft_strcnew
char	*ft_strcnew(size_t len, char c)
{
	char	*new;
	size_t	i;

	if (len)
		if (!(new = (char *)malloc(sizeof(char) * len + 1)))
			return (NULL);
	i = -1;
	while (++i < len)
		new[i] = c;
	new[i] = '\0';
	return (new);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testq %rdi, %rdi
je 0x7477
leaq 0x1(%rbx), %rdi
callq 0x10b0
testq %rax, %rax
jne 0x7477
xorl %eax, %eax
jmp 0x748b
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x7487
movb %bpl, (%rax,%rcx)
incq %rcx
jmp 0x7479
movb $0x0, (%rax,%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x74d2
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rdi
callq 0x7428
testq %rax, %rax
je 0x74d5
movl %ebp, %ecx
xorl %edx, %edx
cmpq %rdx, %rbx
je 0x74d7
cmpb $0x0, (%r14)
je 0x74d7
leaq (%rcx,%rdx), %rsi
movl %esi, %esi
movb (%r14,%rsi), %sil
movb %sil, (%rax,%rdx)
incq %rdx
jmp 0x74b4
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x7517
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x739e
movq %rax, %r14
leaq 0x1(%rax), %rdi
callq 0x10b0
testq %rax, %rax
je 0x751a
xorl %edx, %edx
movq %r14, %rcx
movb %dl, (%rax,%r14)
subq $0x1, %rcx
jb 0x751c
movb -0x1(%rbx,%r14), %dl
movq %rcx, %r14
jmp 0x7503
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x755a
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1(%rsi), %rdi
callq 0x10b0
testq %rax, %rax
je 0x755d
xorl %edx, %edx
movq %r14, %rcx
movb %dl, (%rax,%r14)
subq $0x1, %rcx
jb 0x755f
movb -0x1(%rbx,%r14), %dl
movq %rcx, %r14
jmp 0x7546
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
xorl %ecx, %ecx
movslq %ecx, %rdx
cmpb $0x0, (%rdi,%rdx)
je 0x75a6
decq %rdx
movq %rdx, %rcx
movb 0x1(%rdi,%rdx), %r8b
incq %rdx
cmpb %sil, %r8b
je 0x7578
xorl %edx, %edx
testb %r8b, %r8b
setne %dl
movb 0x1(%rdi,%rcx), %r8b
incq %rcx
cmpb %sil, %r8b
je 0x75a2
testb %r8b, %r8b
jne 0x7590
addl %edx, %eax
jmp 0x756c
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7670
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
movsbl %bl, %ebp
movl %ebp, %esi
callq 0x7568
cltq
leaq 0x1(,%rax,8), %rdi
callq 0x10b0
testq %rax, %rax
je 0x7673
movq %rax, 0x8(%rsp)
leaq -0x1(%r14), %rax
movq %rax, 0x10(%rsp)
pushq $-0x1
popq %r15
xorl %r13d, %r13d
incq %r15
movq %r14, %rdi
movl %ebp, %esi
callq 0x7568
cltq
cmpq %rax, %r15
jge 0x765e
movslq %r13d, %r12
movq 0x10(%rsp), %rax
leaq (%rax,%r12), %r13
decq %r12
movq %r13, %rax
incq %r13
incq %r12
cmpb %bl, 0x1(%rax)
je 0x761d
movq %r13, %rdi
movl %ebp, %esi
callq 0x7684
movq %r14, %rdi
movl %r12d, %esi
movq %rax, %rdx
callq 0x7492
movq 0x8(%rsp), %rcx
movq %rax, (%rcx,%r15,8)
movq %r13, %rdi
movl %ebp, %esi
callq 0x7684
movq %rax, %r13
addq %r12, %r13
jmp 0x75fa
movslq %r15d, %rax
movq 0x8(%rsp), %rcx
andq $0x0, (%rcx,%rax,8)
movq %rcx, %rax
jmp 0x7675
xorl %eax, %eax
retq
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_O2/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 0x7783
movq %rdi, %rbx
callq 0x739e
movq %rax, %r14
xorl %r12d, %r12d
movabsq $0x100003600, %r15      # imm = 0x100003600
movzbl (%rbx,%r12), %eax
cmpq $0x20, %rax
ja 0x76e2
btq %rax, %r15
jae 0x76e2
incq %r12
jmp 0x76cc
movq %rbx, %rdi
callq 0x739e
cmpq %rax, %r12
ja 0x76dd
leaq (%rbx,%r12), %r15
movzbl (%rbx,%r12), %eax
leaq -0x1(%r14), %r13
subq %r12, %r14
movl %eax, %ecx
movabsq $0x100003200, %rdx      # imm = 0x100003200
cmpl $0x20, %eax
ja 0x771e
btq %rcx, %rdx
jae 0x771e
decq %r14
decq %r13
jmp 0x770b
cmpb $0xa, (%rbx,%r13)
je 0x7716
testq %r12, %r12
jne 0x7737
movq %rbx, %rdi
callq 0x739e
cmpq %rax, %r13
jae 0x7792
movq %rbx, %rdi
callq 0x739e
cmpq %r12, %rax
jne 0x774a
pushq $0x1
popq %r12
jmp 0x7763
movq %rbx, %rdi
callq 0x739e
movq %rax, %r12
movq %rbx, %rdi
callq 0x739e
subq %rax, %r12
addq %r14, %r12
movq %r12, %rdi
callq 0x7428
testq %rax, %rax
je 0x7783
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x71a9
jmp 0x7785
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 0x74dc
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x511e(%rip), %rdx      # 0xc90c
cmpq $0xa, %rcx
je 0x7802
leaq 0x1(%rcx), %rax
cmpb %dil, (%rcx,%rdx)
movq %rax, %rcx
jne 0x77ee
retq
pushq $0xa
popq %rdx
pushq $0x15
popq %rax
leaq 0x5108(%rip), %rcx      # 0xc917
movq %rdx, %rsi
subq $0x1, %rsi
jb 0x7826
decl %eax
cmpb %dil, -0x1(%rdx,%rcx)
movq %rsi, %rdx
jne 0x7812
jmp 0x7801
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 $0x20, %esi
je 0x78c6
cmpl $0x30, %esi
je 0x78b6
cmpl $0x2b, %esi
je 0x78c2
cmpl $0x2d, %esi
je 0x78bc
cmpl $0x23, %esi
jne 0x78cc
addq $0x4, %rdi
jmp 0x78c6
addq $0x10, %rdi
jmp 0x78c6
addq $0x8, %rdi
jmp 0x78c6
addq $0xc, %rdi
movl $0x1, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7929
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq %esi, %r14
pushq $-0x1
popq %r15
movq %rdi, %rax
testq %rax, %rax
je 0x78f3
xorl %edx, %edx
divq %r14
incq %r15
jmp 0x78e4
leaq 0x1(%r15), %rdi
callq 0x7428
testq %rax, %rax
je 0x7935
movq %rax, %rcx
addq %rax, %r15
leaq 0x5032(%rip), %rsi      # 0xc940
testq %rbx, %rbx
je 0x7937
movq %rbx, %rax
xorl %edx, %edx
divq %r14
movb (%rdx,%rsi), %dl
movb %dl, (%r15)
decq %r15
movq %rax, %rbx
jmp 0x790e
leaq 0x448c(%rip), %rdi      # 0xbdbc
jmp 0x74dc
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rdi, %rax
negq %rax
jo 0x7956
jb 0x7962
leaq 0x446b(%rip), %rdi      # 0xbdbc
jmp 0x74dc
leaq 0x4fc5(%rip), %rdi      # 0xc922
jmp 0x74dc
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq %esi, %r14
pushq $-0x1
popq %r15
movq %rdi, %rax
testq %rax, %rax
jle 0x7983
cqto
idivq %r14
incq %r15
jmp 0x7974
leaq 0x1(%r15), %rdi
callq 0x7428
testq %rax, %rax
je 0x79b9
movq %rax, %rcx
addq %rax, %r15
leaq 0x4fa2(%rip), %rsi      # 0xc940
testq %rbx, %rbx
jle 0x79bb
movq %rbx, %rax
cqto
idivq %r14
movb (%rdx,%rsi), %dl
movb %dl, (%r15)
decq %r15
movq %rax, %rbx
jmp 0x799e
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rbp
movl 0x18(%rbp), %eax
cmpl %edi, %eax
setge %cl
cmpl $-0x1, %eax
setne %dl
testb %dl, %cl
jne 0x7feb
movl %edi, %r15d
movl 0x14(%rbp), %r13d
cmpl %edi, %r13d
jle 0x802d
movl 0x10(%rbp), %ecx
testl %ecx, %ecx
leaq 0x3e40(%rip), %r14      # 0xbdbc
leaq 0x43bf(%rip), %rdx      # 0xc342
cmoveq %rdx, %r14
cmpl $-0x1, %eax
cmovneq %rdx, %r14
testl %ebx, %ebx
jne 0x7fb1
cmpl $0x0, (%rbp)
je 0x7fb1
testl %ecx, %ecx
je 0x7fb1
leaq 0x439f(%rip), %rsi      # 0xc342
pushq $0x1
popq %rdi
pushq $0x1
popq %rdx
callq 0x1050
movq %rax, %rbx
testl %ebx, %ebx
jne 0x7fcb
cmpl $0x0, 0x4(%rbp)
je 0x7fcb
cmpb $0x30, (%r12)
leal 0x2(%r15), %eax
cmovel %r15d, %eax
movl %eax, %r15d
subl %r15d, %r13d
pushq $0x1
popq %rbp
pushq $0x1
popq %r15
cmpl %ebx, %r13d
jle 0x802d
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
addl %eax, %ebx
jmp 0x7fd5
testl %ebx, %ebx
jne 0x8002
cmpl $0x0, 0x4(%rbp)
je 0x8002
cmpb $0x0, (%r12)
leal 0x2(%rax), %ecx
cmovel %eax, %ecx
movl %ecx, %eax
movl 0x14(%rbp), %r12d
subl %eax, %r12d
leaq 0x4332(%rip), %r14      # 0xc342
pushq $0x1
popq %rbp
pushq $0x1
popq %r15
cmpl %ebx, %r12d
jle 0x802d
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
addl %eax, %ebx
jmp 0x8017
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_c.c
// Function: convert_c
int				convert_c(t_mods modifiers, va_list ap)
{
	unsigned char	c;

	c = va_arg(ap, int);
	if (modifiers.fl.minus == 1)
	{
		return (left_justify(modifiers.width, c));
	}
	if (modifiers.width > 1)
	{
		return (right_justify(modifiers.width, modifiers.fl.fzero, c));
	}
	return ((int)write(1, &c, 1));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x40(%rsp), %rax
movl (%rdi), %edx
cmpq $0x28, %rdx
ja 0x8067
movq %rdx, %rcx
addq 0x10(%rdi), %rcx
addl $0x8, %edx
movl %edx, (%rdi)
jmp 0x8073
movq 0x8(%rdi), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rdi)
movb (%rcx), %cl
movb %cl, 0xd(%rsp)
movl 0x14(%rax), %r12d
cmpl $0x1, 0x8(%rax)
jne 0x80c9
leaq 0xf(%rsp), %rsi
movb %cl, (%rsi)
pushq $0x1
popq %rdi
pushq $0x1
popq %rdx
callq 0x1050
movq %rax, %rbx
cmpl %ebx, %r12d
jle 0x815c
leaq 0x429a(%rip), %r14      # 0xc342
pushq $0x1
popq %rbp
pushq $0x1
popq %r15
cmpl %r12d, %ebx
jge 0x815c
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
addl %eax, %ebx
jmp 0x80af
cmpl $0x2, %r12d
jl 0x8105
cmpl $0x0, 0x10(%rax)
movb %cl, 0xe(%rsp)
je 0x811a
xorl %r15d, %r15d
leaq 0x3cd9(%rip), %rbx      # 0xbdbc
pushq $0x1
popq %rbp
pushq $0x1
popq %r14
cmpl $0x2, %r12d
jl 0x8146
decl %r12d
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1050
addl %eax, %r15d
jmp 0x80ea
pushq $0x1
popq %rdi
leaq 0xd(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x1050
movq %rax, %rbx
jmp 0x815c
xorl %r15d, %r15d
leaq 0x421e(%rip), %rbx      # 0xc342
pushq $0x1
popq %rbp
pushq $0x1
popq %r14
cmpl $0x2, %r12d
jl 0x8146
decl %r12d
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1050
addl %eax, %r15d
jmp 0x812b
pushq $0x1
popq %rdi
leaq 0xe(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x1050
movq %rax, %rbx
addl %r15d, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_i.c
// Function: pad_width
static int		pad_width(t_mods mod, int len, int nbyte, int neg)
{
	char	*pad_char;

	pad_char = " ";
	if (len > mod.prcsn || mod.prcsn == -1)
	{
		if (mod.width > len)
		{
			mod.fl.fzero && mod.prcsn == -1 ? pad_char = "0" : 0;
			if (nbyte == 0)
			{
				if (mod.fl.space && mod.fl.fzero)
					nbyte += write(1, " ", 1);
				while (mod.width - len - neg > nbyte)
					nbyte += (int)write(1, pad_char, 1);
			}
			else
				while (mod.width - len > nbyte)
					nbyte += (int)write(1, pad_char, 1);
		}
	}
	else
		while (mod.width - mod.prcsn - neg > 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
movl %edx, %ebp
movl %esi, %ebx
movl 0x54(%rsp), %r12d
movl 0x58(%rsp), %eax
cmpl %edi, %eax
setl %cl
cmpl $-0x1, %eax
sete %dl
orb %cl, %dl
je 0x85d1
movl %edi, %r15d
movl %r12d, %r13d
subl %edi, %r13d
jle 0x8646
leaq 0x40(%rsp), %rcx
movl 0x10(%rcx), %edx
testl %edx, %edx
leaq 0x3822(%rip), %r14      # 0xbdbc
leaq 0x3da1(%rip), %rsi      # 0xc342
cmoveq %rsi, %r14
cmpl $-0x1, %eax
cmovneq %rsi, %r14
testl %ebx, %ebx
je 0x85fa
pushq $0x1
popq %rbp
pushq $0x1
popq %r15
cmpl %ebx, %r13d
jle 0x8646
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
addl %eax, %ebx
jmp 0x85b7
addl %ebp, %eax
subl %eax, %r12d
leaq 0x3d65(%rip), %r14      # 0xc342
pushq $0x1
popq %rbp
pushq $0x1
popq %r15
cmpl %ebx, %r12d
jle 0x8646
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
addl %eax, %ebx
jmp 0x85e4
testl %edx, %edx
setne %al
cmpl $0x0, (%rcx)
setne %cl
andb %al, %cl
xorl %ebx, %ebx
cmpb $0x1, %cl
jne 0x8623
leaq 0x3d2d(%rip), %rsi      # 0xc342
pushq $0x1
popq %rdi
pushq $0x1
popq %rdx
callq 0x1050
movq %rax, %rbx
addl %r15d, %ebp
subl %ebp, %r12d
pushq $0x1
popq %rbp
pushq $0x1
popq %r15
cmpl %ebx, %r12d
jle 0x8646
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
addl %eax, %ebx
jmp 0x8630
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_p.c
// Function: pad_width
static int		pad_width(t_mods mod, int len, int nbyte, int neg)
{
	char	*pad_char;

	pad_char = " ";
	if (len > mod.prcsn || mod.prcsn == -1)
	{
		if (mod.width > len)
		{
			mod.fl.fzero && mod.prcsn == -1 ? pad_char = "0" : 0;
			if (nbyte == 0)
			{
				while (mod.width - len - neg > nbyte)
					nbyte += (int)write(1, pad_char, 1);
			}
			else
				while (mod.width - len > nbyte)
					nbyte += (int)write(1, pad_char, 1);
		}
	}
	else
		while (mod.width - mod.prcsn - neg > 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
movl %esi, %ebx
movl 0x54(%rsp), %r12d
movl 0x58(%rsp), %eax
cmpl %edi, %eax
setl %cl
cmpl $-0x1, %eax
sete %sil
orb %cl, %sil
je 0x8cc4
movl %r12d, %r13d
subl %edi, %r13d
jle 0x8d11
leaq 0x40(%rsp), %rcx
cmpl $0x0, 0x10(%rcx)
leaq 0x312b(%rip), %r14      # 0xbdbc
leaq 0x36aa(%rip), %rcx      # 0xc342
cmoveq %rcx, %r14
cmpl $-0x1, %eax
cmovneq %rcx, %r14
testl %ebx, %ebx
je 0x8ced
pushq $0x1
popq %rbp
pushq $0x1
popq %r15
cmpl %ebx, %r13d
jle 0x8d11
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
addl %eax, %ebx
jmp 0x8cae
addl %edx, %eax
subl %eax, %r12d
leaq 0x3672(%rip), %r14      # 0xc342
pushq $0x1
popq %rbp
pushq $0x1
popq %r15
cmpl %ebx, %r12d
jle 0x8d11
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
addl %eax, %ebx
jmp 0x8cd7
addl %edi, %edx
subl %edx, %r12d
xorl %ebx, %ebx
pushq $0x1
popq %rbp
pushq $0x1
popq %r15
cmpl %ebx, %r12d
jle 0x8d11
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
addl %eax, %ebx
jmp 0x8cfb
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop