LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/shell.c
// Function: count
int count(struct cmdline cmd)
{
	int i = 0;
	while (cmd.seq[i] != NULL)
		i++;
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x4(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x4(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x2911
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x28f3
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/shell.c
// Function: runPipes
void runPipes(struct cmdline cmd)
{

	/*------------------------------- Definitions ------------------------------ */
	char ***commands = cmd.seq;
	int pipes[2];
	int fd_input = 0;	// a special fd that is being used to chain the execution of the commands

	/*------------------------ Traverse all the commands ----------------------- */
	while (*commands != NULL)
	{

		/*------------------------------ Define pipes ------------------------------ */
		pipe(pipes);

		switch (fork())
		{
			case -1:
				/*---------------------- FORK() has failed ---------------------- */
				exit(1);
				break;
			case 0:
				/*------------------------------ FORKED CHILD PROCESS ----------------------------- */
				dup2(fd_input, STDIN);	//input pipe < STDIN
				if (*(commands + 1) != NULL)
					dup2(pipes[1], STDOUT);	//Redirect the output of the current command (to be executed) if it is not the last one.
				close(pipes[0]);
				if (execvp((*commands)[0], *commands) == -1)
				{
					printf("%s : command not found.\n", (*commands)[0]);
				}
				exit(1);
				break;
			default:
				/*--------------------------------- Parent --------------------------------- */
				if (cmd.in_background == 0)
				{
					wait(NULL);
				}

				close(pipes[1]);
				fd_input = pipes[0];	//UPDATE : input pipe uses the previous one in order to keep a relevant sequence of executions
				commands++;
				break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2a13
leaq -0x10(%rbp), %rdi
callq 0x21e0
callq 0x25a0
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
subl $-0x1, %eax
je 0x2970
jmp 0x2967
movl -0x24(%rbp), %eax
testl %eax, %eax
je 0x297a
jmp 0x29e1
movl $0x1, %edi
callq 0x24e0
movl -0x14(%rbp), %edi
xorl %esi, %esi
callq 0x2160
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x299c
movl -0xc(%rbp), %edi
movl $0x1, %esi
callq 0x2160
movl -0x10(%rbp), %edi
callq 0x21d0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x2490
cmpl $-0x1, %eax
jne 0x29d7
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
leaq 0x368b(%rip), %rdi      # 0x605b
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x24e0
movq -0x20(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x29f4
xorl %eax, %eax
movl %eax, %edi
callq 0x2580
movl -0xc(%rbp), %edi
callq 0x21d0
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x293f
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/shell.c
// Function: handle_stp
void handle_stp(int sig)
{
	waitpid(-1, &status, WNOHANG);
	if (((child_pid != 0) && (kill(child_pid, 0) == 0)))
	{
		Kill(child_pid, SIGTSTP);
		push(child_pid);
		suspendedJobs = 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
leaq 0x6899(%rip), %rsi      # 0x9320
movl $0x1, %edx
callq 0x2410
cmpl $0x0, 0x706c(%rip)      # 0x9b04
je 0x2ad1
movl 0x7064(%rip), %edi      # 0x9b04
xorl %esi, %esi
callq 0x2300
cmpl $0x0, %eax
jne 0x2ad1
movl 0x7052(%rip), %edi      # 0x9b04
movl $0x14, %esi
callq 0x3c60
movl 0x7042(%rip), %edi      # 0x9b04
callq 0x2880
movl $0x1, 0x6853(%rip)      # 0x9324
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/shell.c
// Function: get_jobs
void get_jobs()
{

	int access = 0;
	while (access <= top)
	{
		printf("[%i] Arrêté \t %i\n", access + 1, stack[access]);
		access++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x680c(%rip), %eax      # 0x9304
jg 0x2b27
movl -0x4(%rbp), %esi
addl $0x1, %esi
movslq -0x4(%rbp), %rcx
leaq 0x6825(%rip), %rax      # 0x9330
movl (%rax,%rcx,4), %edx
leaq 0x355f(%rip), %rdi      # 0x6074
movb $0x0, %al
callq 0x2170
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2aef
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/shell.c
// Function: to_stop
void to_stop()
{
	if (isempty() != 1)
	{
		Kill(pop(), SIGTERM);
	}
	if (top == -1)
	{
		suspendedJobs = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x26e0
cmpl $0x1, %eax
je 0x2b4f
callq 0x2820
movl %eax, %edi
movl $0xf, %esi
callq 0x3c60
cmpl $-0x1, 0x67ae(%rip)     # 0x9304
jne 0x2b62
movl $0x0, 0x67c2(%rip)      # 0x9324
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/shell.c
// Function: quit
void quit()
{
	if (isempty() != 1)
	{
		puts("\n Il y a des processus arretés.");
		usleep(10000);
	}
	else
	{
		exit(0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x26e0
cmpl $0x1, %eax
je 0x2bb6
leaq 0x34e3(%rip), %rdi      # 0x6088
callq 0x20b0
movl $0x2710, %edi           # imm = 0x2710
callq 0x25b0
jmp 0x2bbd
xorl %edi, %edi
callq 0x24e0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/readcmd.c
// Function: readline
static char *readline(void)
{
	size_t buf_len = 16;
	char *buf = xmalloc(buf_len * sizeof(char));

	if (fgets(buf, buf_len, stdin) == NULL) {
		free(buf);
		return NULL;
	}
	
	if (feof(stdin)) { /* End of file (ctrl-d) */
	    fflush(stdout);
	    exit(0);
	}

	do {
		size_t l = strlen(buf);
		if ((l > 0) && (buf[l-1] == '\n')) {
			l--;
			buf[l] = 0;
			return buf;
		}
		if (buf_len >= (INT_MAX / 2)) memory_error();
		buf_len *= 2;
		buf = xrealloc(buf, buf_len * sizeof(char));
		if (fgets(buf + l, buf_len - l, stdin) == NULL) return buf;
	} while (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x10, -0x10(%rbp)
movq -0x10(%rbp), %rdi
shlq $0x0, %rdi
callq 0x36e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %esi
movq 0x5a76(%rip), %rax      # 0x8fd8
movq (%rax), %rdx
callq 0x2230
cmpq $0x0, %rax
jne 0x3586
movq -0x18(%rbp), %rdi
callq 0x2050
movq $0x0, -0x8(%rbp)
jmp 0x366b
movq 0x5a4b(%rip), %rax      # 0x8fd8
movq (%rax), %rdi
callq 0x22b0
cmpl $0x0, %eax
je 0x35b0
movq 0x5a2f(%rip), %rax      # 0x8fd0
movq (%rax), %rdi
callq 0x2360
xorl %edi, %edi
callq 0x24e0
jmp 0x35b2
movq -0x18(%rbp), %rdi
callq 0x2140
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x35fd
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x35fd
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x366b
cmpq $0x3fffffff, -0x10(%rbp) # imm = 0x3FFFFFFF
jb 0x360c
callq 0x39f0
movq -0x10(%rbp), %rax
shlq %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
shlq $0x0, %rsi
callq 0x3920
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
subq -0x20(%rbp), %rax
movl %eax, %esi
movq 0x5993(%rip), %rax      # 0x8fd8
movq (%rax), %rdx
callq 0x2230
cmpq $0x0, %rax
jne 0x365d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x366b
jmp 0x365f
movb $0x1, %al
testb $0x1, %al
jne 0x35b2
jmp 0x366b
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/readcmd.c
// Function: freeseq
static void freeseq(char ***seq)
{
	int i, j;

	for (i=0; seq[i]!=0; i++) {
		char **cmd = seq[i];

		for (j=0; cmd[j]!=0; j++) free(cmd[j]);
		free(cmd);
	}
	free(seq);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x39d8
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x39c4
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2050
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3999
movq -0x18(%rbp), %rdi
callq 0x2050
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3973
movq -0x8(%rbp), %rdi
callq 0x2050
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/csapp.c
// Function: Setpgid
void Setpgid(pid_t pid, pid_t pgid) {
    int rc;

    if ((rc = setpgid(pid, pgid)) < 0)
	unix_error("Setpgid error");
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x24b0
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jge 0x3d2d
leaq 0x24fc(%rip), %rdi      # 0x6224
callq 0x3a20
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/csapp.c
// Function: Signal
handler_t *Signal(int signum, handler_t *handler) 
{
    struct sigaction action, old_action;

    action.sa_handler = handler;  
    sigemptyset(&action.sa_mask); /* Block sigs of type being handled */
    action.sa_flags = SA_RESTART; /* Restart syscalls if possible */

    if (sigaction(signum, &action, &old_action) < 0)
	unix_error("Signal error");
    return (old_action.sa_handler);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0xa8(%rbp), %rdi
addq $0x8, %rdi
callq 0x22a0
movl $0x10000000, -0x20(%rbp) # imm = 0x10000000
movl -0x4(%rbp), %edi
leaq -0xa8(%rbp), %rsi
leaq -0x140(%rbp), %rdx
callq 0x20d0
cmpl $0x0, %eax
jge 0x3dab
leaq 0x248c(%rip), %rdi      # 0x6232
callq 0x3a20
movq -0x140(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/csapp.c
// Function: Sigsuspend
int Sigsuspend(const sigset_t *set)
{
    int rc = sigsuspend(set); /* always returns -1 */
    if (errno != EINTR)
        unix_error("Sigsuspend error");
    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2390
movl %eax, -0xc(%rbp)
callq 0x2060
cmpl $0x4, (%rax)
je 0x3f4e
leaq 0x235d(%rip), %rdi      # 0x62a6
callq 0x3a20
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/csapp.c
// Function: sio_strlen
static size_t sio_strlen(char s[])
{
    int i = 0;

    while (s[i] != '\0')
        ++i;
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3fcb
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3faf
movslq -0xc(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/csapp.c
// Function: sio_ltoa
static void sio_ltoa(long v, char s[], int b) 
{
    int c, i = 0;
    int neg = v < 0;

    if (neg)
	v = -v;

    do {  
        s[i++] = ((c = (v % b)) < 10)  ?  c + '0' : c - 10 + 'a';
    } while ((v /= b) > 0);

    if (neg)
	s[i++] = '-';

    s[i] = '\0';
    sio_reverse(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x405a
xorl %eax, %eax
subq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x405c
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cqto
idivq %rcx
movl %edx, %eax
movl %eax, -0x18(%rbp)
cmpl $0xa, %eax
jge 0x407e
movl -0x18(%rbp), %eax
addl $0x30, %eax
movl %eax, -0x24(%rbp)
jmp 0x408a
movl -0x18(%rbp), %eax
subl $0xa, %eax
addl $0x61, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movslq -0x14(%rbp), %rcx
movq -0x8(%rbp), %rax
cqto
idivq %rcx
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jg 0x405c
cmpl $0x0, -0x20(%rbp)
je 0x40d7
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
movb $0x2d, (%rax,%rcx)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
callq 0x5740
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/csapp.c
// Function: Opendir
DIR *Opendir(const char *name) 
{
    DIR *dirp = opendir(name); 

    if (!dirp)
        unix_error("opendir error");
    return dirp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2130
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x445c
leaq 0x1ee7(%rip), %rdi      # 0x633e
callq 0x3a20
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/csapp.c
// Function: Readdir
struct dirent *Readdir(DIR *dirp)
{
    struct dirent *dep;
    
    errno = 0;
    dep = readdir(dirp);
    if ((dep == NULL) && (errno != 0))
        unix_error("readdir error");
    return dep;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x2060
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x2320
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x44b1
callq 0x2060
cmpl $0x0, (%rax)
je 0x44b1
leaq 0x1ea0(%rip), %rdi      # 0x634c
callq 0x3a20
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/csapp.c
// Function: Getnameinfo
void Getnameinfo(const struct sockaddr *sa, socklen_t salen, char *host, 
                 size_t hostlen, char *serv, size_t servlen, int flags)
{
    int rc;

    if ((rc = getnameinfo(sa, salen, host, hostlen, serv, 
                          servlen, flags)) != 0) 
        gai_error(rc, "Getnameinfo error");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %rax
movl %eax, %r9d
movl 0x10(%rbp), %eax
movl %eax, (%rsp)
callq 0x21f0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x4ac0
movl -0x34(%rbp), %edi
leaq 0x19a8(%rip), %rsi      # 0x6463
callq 0x3ac0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/csapp.c
// Function: Inet_pton
void Inet_pton(int af, const char *src, void *dst) 
{
    int rc;

    rc = inet_pton(af, src, dst);
    if (rc == 0)
	app_error("inet_pton error: invalid dotted-decimal address");
    else if (rc < 0)
        unix_error("Inet_pton error");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x22f0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x4b7a
leaq 0x1912(%rip), %rdi      # 0x6485
callq 0x3b10
jmp 0x4b8e
cmpl $0x0, -0x1c(%rbp)
jge 0x4b8c
leaq 0x192e(%rip), %rdi      # 0x64b5
callq 0x3a20
jmp 0x4b8e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/csapp.c
// Function: rio_readn
ssize_t rio_readn(int fd, void *usrbuf, size_t n) 
{
    size_t nleft = n;
    ssize_t nread;
    char *bufp = usrbuf;

    while (nleft > 0) {
	if ((nread = read(fd, bufp, nleft)) < 0) {
	    if (errno == EINTR) /* Interrupted by sig handler return */
		nread = 0;      /* and call read() again */
	    else
		return -1;      /* errno set by read() */ 
	} 
	else if (nread == 0)
	    break;              /* EOF */
	nleft -= nread;
	bufp += nread;
    }
    return (n - nleft);         /* Return >= 0 */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x4ecc
movl -0xc(%rbp), %edi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2220
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jge 0x4ea4
callq 0x2060
cmpl $0x4, (%rax)
jne 0x4e98
movq $0x0, -0x30(%rbp)
jmp 0x4ea2
movq $-0x1, -0x8(%rbp)
jmp 0x4ed8
jmp 0x4eaf
cmpq $0x0, -0x30(%rbp)
jne 0x4ead
jmp 0x4ecc
jmp 0x4eaf
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x4e63
movq -0x20(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/csapp.c
// Function: rio_writen
ssize_t rio_writen(int fd, void *usrbuf, size_t n) 
{
    size_t nleft = n;
    ssize_t nwritten;
    char *bufp = usrbuf;

    while (nleft > 0) {
	if ((nwritten = write(fd, bufp, nleft)) <= 0) {
	    if (errno == EINTR)  /* Interrupted by sig handler return */
		nwritten = 0;    /* and call write() again */
	    else
		return -1;       /* errno set by write() */
	}
	nleft -= nwritten;
	bufp += nwritten;
    }
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x4f71
movl -0xc(%rbp), %edi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2100
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jg 0x4f54
callq 0x2060
cmpl $0x4, (%rax)
jne 0x4f48
movq $0x0, -0x30(%rbp)
jmp 0x4f52
movq $-0x1, -0x8(%rbp)
jmp 0x4f79
jmp 0x4f54
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x4f13
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/csapp.c
// Function: rio_readnb
ssize_t rio_readnb(rio_t *rp, void *usrbuf, size_t n) 
{
    size_t nleft = n;
    ssize_t nread;
    char *bufp = usrbuf;
    
    while (nleft > 0) {
	if ((nread = rio_read(rp, bufp, nleft)) < 0) 
            return -1;          /* errno set by read() */ 
	else if (nread == 0)
	    break;              /* EOF */
	nleft -= nread;
	bufp += nread;
    }
    return (n - nleft);         /* return >= 0 */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x5048
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x5060
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jge 0x5020
movq $-0x1, -0x8(%rbp)
jmp 0x5054
cmpq $0x0, -0x30(%rbp)
jne 0x5029
jmp 0x5048
jmp 0x502b
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x4ff4
movq -0x20(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/csapp.c
// Function: rio_read
static ssize_t rio_read(rio_t *rp, char *usrbuf, size_t n)
{
    int cnt;

    while (rp->rio_cnt <= 0) {  /* Refill if buf is empty */
	rp->rio_cnt = read(rp->rio_fd, rp->rio_buf, 
			   sizeof(rp->rio_buf));
	if (rp->rio_cnt < 0) {
	    if (errno != EINTR) /* Interrupted by sig handler return */
		return -1;
	}
	else if (rp->rio_cnt == 0)  /* EOF */
	    return 0;
	else 
	    rp->rio_bufptr = rp->rio_buf; /* Reset buffer ptr */
    }

    /* Copy min(n, rp->rio_cnt) bytes from internal buf to user buf */
    cnt = n;          
    if (rp->rio_cnt < n)   
	cnt = rp->rio_cnt;
    memcpy(usrbuf, rp->rio_bufptr, cnt);
    rp->rio_bufptr += cnt;
    rp->rio_cnt -= cnt;
    return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jg 0x50ea
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movl $0x2000, %edx           # imm = 0x2000
callq 0x2220
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jge 0x50c2
callq 0x2060
cmpl $0x4, (%rax)
je 0x50c0
movq $-0x1, -0x8(%rbp)
jmp 0x514a
jmp 0x50e8
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x50d6
movq $0x0, -0x8(%rbp)
jmp 0x514a
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x50e8
jmp 0x5074
movq -0x20(%rbp), %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
cmpq -0x20(%rbp), %rax
jae 0x5109
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x24(%rbp), %rdx
callq 0x22e0
movl -0x24(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movl -0x24(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x4(%rax)
movslq -0x24(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/csapp.c
// Function: rio_readlineb
ssize_t rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen) 
{
    int n, rc;
    char c, *bufp = usrbuf;

    for (n = 1; n < maxlen; n++) { 
        if ((rc = rio_read(rp, &c, 1)) == 1) {
	    *bufp++ = c;
	    if (c == '\n') {
                n++;
     		break;
            }
	} else if (rc == 0) {
	    if (n == 1)
		return 0; /* EOF, no data read */
	    else
		break;    /* EOF, some data was read */
	} else
	    return -1;	  /* Error */
    }
    *bufp = 0;
    return n-1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x1, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x5200
movq -0x10(%rbp), %rdi
leaq -0x29(%rbp), %rsi
movl $0x1, %edx
callq 0x5060
movl %eax, -0x28(%rbp)
cmpl $0x1, %eax
jne 0x51d1
movb -0x29(%rbp), %cl
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movb %cl, (%rax)
movsbl -0x29(%rbp), %eax
cmpl $0xa, %eax
jne 0x51cf
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5200
jmp 0x51f3
cmpl $0x0, -0x28(%rbp)
jne 0x51e9
cmpl $0x1, -0x24(%rbp)
jne 0x51e7
movq $0x0, -0x8(%rbp)
jmp 0x5213
jmp 0x5200
movq $-0x1, -0x8(%rbp)
jmp 0x5213
jmp 0x51f5
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5183
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movl -0x24(%rbp), %eax
subl $0x1, %eax
cltq
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/johanDa9u[P]MiniShell/src/csapp.c
// Function: sio_reverse
static void sio_reverse(char s[])
{
    int c, i, j;

    for (i = 0, j = strlen(s)-1; i < j; i++, j--) {
        c = s[i];
        s[i] = s[j];
        s[j] = c;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2140
subq $0x1, %rax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x57b4
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5763
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/teodorst[P]app-huffman/huffman_serial.c
// Function: open_file
FILE* open_file(char *filename, char *mode) {
	FILE* fp;
	fp = fopen(filename, mode);

    if (fp == NULL)
        exit(EXIT_FAILURE);

    return fp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1130
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x12c2
movl $0x1, %edi
callq 0x1160
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/teodorst[P]app-huffman/huffman_serial.c
// Function: free_codification_matrix
void free_codification_matrix(char** codification) {
    int i;
    for (i = 0; i < 128; i ++) {
        if (codification[i]) {
            free(codification[i]);
        }
    }
    free(codification);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x80, -0xc(%rbp)
jge 0x1319
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x130c
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
jmp 0x130e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x12e3
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/teodorst[P]app-huffman/huffman_serial.c
// Function: huffman_decompress
int huffman_decompress(char* input_filename, char* output_filename, char *codification_filename) {
    unsigned long long int nbits = 0;

    FILE* codification_fp = open_file(codification_filename, "r");

    char** codification = read_configuration(codification_fp, &nbits);

    fprintf(stderr, "got bits");

    /* for each codification find the leaf and save it into a buffer */
    node_t* root = build_huffman_tree_from_codification(codification);
    fprintf(stderr, "got tree");
    // int top = 0;
    // char path[MAX_BITS_CODE];
    // print_codes(root, path, top);
    /* read the bytes from the inputfile,  */

    FILE* input_fp = open_file(input_filename, "r");
    FILE* out_fp = open_file(output_filename, "w");

    /* decode the bytes using huffman tree */
    decode_bytes(input_fp, out_fp, root, nbits);

    free_codification_matrix(codification);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1a8d(%rip), %rsi      # 0x3004
callq 0x1290
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2690
movq %rax, -0x30(%rbp)
movq 0x3a60(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1a66(%rip), %rsi      # 0x3008
movb $0x0, %al
callq 0x10d0
movq -0x30(%rbp), %rdi
callq 0x2b10
movq %rax, -0x38(%rbp)
movq 0x3a3b(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1a4a(%rip), %rsi      # 0x3011
movb $0x0, %al
callq 0x10d0
movq -0x8(%rbp), %rdi
leaq 0x1a2b(%rip), %rsi      # 0x3004
callq 0x1290
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1a19(%rip), %rsi      # 0x3006
callq 0x1290
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1ee0
movq -0x30(%rbp), %rdi
callq 0x12d0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/teodorst[P]app-huffman/huffman_serial.c
// Function: main
int main (int argc, char* argv[]) {

	if (argc == 5 && strcmp(argv[OPERATION], "compress") == 0) {
		huffman_compress(argv[INPUT_FILE], argv[OUTPUT_FILE], argv[CODIFICATION]);
	}
	else if (argc == 5 && strcmp(argv[OPERATION], "decompress") == 0) {
		huffman_decompress(argv[INPUT_FILE], argv[OUTPUT_FILE], argv[CODIFICATION]);
	}
	else {
		printf("Bad arguments\n");
		printf("Usage huffman_serial operation[compress/decompress] input_file ouput_file codification_file_name\n");
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x5, -0x8(%rbp)
jne 0x1674
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x19d1(%rip), %rsi      # 0x301c
callq 0x10c0
cmpl $0x0, %eax
jne 0x1674
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x1330
jmp 0x16d9
cmpl $0x5, -0x8(%rbp)
jne 0x16b2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x1991(%rip), %rsi      # 0x301a
callq 0x10c0
cmpl $0x0, %eax
jne 0x16b2
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x1550
jmp 0x16d7
leaq 0x196c(%rip), %rdi      # 0x3025
movb $0x0, %al
callq 0x1080
leaq 0x196d(%rip), %rdi      # 0x3034
movb $0x0, %al
callq 0x1080
movl $0x1, -0x4(%rbp)
jmp 0x16e0
jmp 0x16d9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/teodorst[P]app-huffman/priority_queue.c
// Function: push
void push(heap_t *heap, node_t* new_node) {
	if (heap->len == heap->size) {
		heap->size = heap->size ? heap->size * 2 : 4;
		heap->nodes = (node_t **) realloc(heap->nodes, heap->size * sizeof(node_t*));
	}
	
	int i, j;
	i = heap->len;
	j = i / 2;
	if (heap->len > 0) {
		
		while (i >= 0 && heap->nodes[j]->priority > new_node->priority && i != j) {
			heap->nodes[i] = heap->nodes[j];
			i = j;
			j /= 2;
		}
	}
	heap->nodes[i] = new_node;
	heap->len ++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x178e
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x1758
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
shll %eax
movl %eax, -0x1c(%rbp)
jmp 0x1762
movl $0x4, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1762
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rsi
shlq $0x3, %rsi
callq 0x1120
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0x1826
jmp 0x17b2
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x1d(%rbp)
jl 0x17e7
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x1d(%rbp)
jle 0x17e7
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x17f0
jmp 0x1824
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
jmp 0x17b2
jmp 0x1826
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/teodorst[P]app-huffman/priority_queue.c
// Function: pop
node_t* pop(heap_t* heap) {
	if (heap->len == 0) {
		return NULL;
	}

	int i, j, k;
	node_t* old_node = heap->nodes[0];
	heap->nodes[0] = heap->nodes[heap->len - 1];
	heap->len --;
	
	i = 0;
	while (1) {
		k = i;
		j = 2 * i + 1;
		if (j < heap->len && heap->nodes[j]->priority < heap->nodes[k]->priority) {
			k = j;
		}
		if (j + 1 < heap->len && heap->nodes[j + 1]->priority < heap->nodes[k]->priority) {
			k = j + 1;
		}
		if (i == k) {
			break;
		}
		heap->nodes[i] = heap->nodes[k];
		i = k;
		heap->nodes[i] = heap->nodes[heap->len];
	}

	return old_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x186f
movq $0x0, -0x8(%rbp)
jmp 0x1998
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x18fa
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl (%rcx), %eax
jge 0x18fa
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x193b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl (%rcx), %eax
jge 0x193b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x1945
jmp 0x1990
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x18b3
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/teodorst[P]app-huffman/priority_queue.c
// Function: insert_values_in_queue
void insert_values_in_queue(unsigned long long int* frequecy, heap_t* h){
	int i;

	/* add all the letters into the heap */
	for (i = 0 ; i < 128 ; i++) {
		if (frequecy[i] > 0) {
			node_t* node = (node_t*) malloc (sizeof(struct node_t));
			node->left = node->right = NULL;
			node->priority = frequecy[i];
			node->data = i;
			push(h, node);
		}
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x80, -0x14(%rbp)
jge 0x1a2f
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jbe 0x1a22
movl $0x18, %edi
callq 0x10f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1720
jmp 0x1a24
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x19b7
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/teodorst[P]app-huffman/frequency.c
// Function: print_frequency
void print_frequency(int chunk_size, unsigned long long int* frequency){
	int i;
	
	for (i = 0 ; i < 128; i++){
		if (frequency[i] != 0)
			printf("%llu ", frequency[i]);
	}

	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x80, -0x14(%rbp)
jge 0x1a95
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1a88
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x1615(%rip), %rdi      # 0x3096
movb $0x0, %al
callq 0x1080
jmp 0x1a8a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1a56
leaq 0x1634(%rip), %rdi      # 0x30d0
movb $0x0, %al
callq 0x1080
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/teodorst[P]app-huffman/frequency.c
// Function: compute_frequency
unsigned long long int* compute_frequency(FILE *fp) {
	size_t nread = 0;
	int chunk_size = 0;
	char buf[CHUNK];
	unsigned long long int* frequency = (unsigned long long int*) calloc(128, sizeof(unsigned long long int));

	memset(buf, '\0', CHUNK);
	while((nread = fread(buf, 1, CHUNK, fp)) > 0) {
		chunk_size = CHUNK > nread ? nread : CHUNK;
		compute_frequency_for_chunk(buf, 0, chunk_size, frequency);
		memset(buf, '\0', CHUNK);
	}
	fseek(fp, 0, SEEK_SET);
	return frequency;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x6400030, %rsp        # imm = 0x6400030
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x80, %edi
movl $0x8, %esi
callq 0x10b0
movq %rax, -0x6400028(%rbp)
leaq -0x6400020(%rbp), %rdi
xorl %esi, %esi
movl $0x6400000, %edx        # imm = 0x6400000
callq 0x1090
leaq -0x6400020(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x1, %esi
movl $0x6400000, %edx        # imm = 0x6400000
callq 0x1050
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jbe 0x1bcb
movl $0x6400000, %eax        # imm = 0x6400000
cmpq -0x10(%rbp), %rax
jbe 0x1b83
movq -0x10(%rbp), %rax
movq %rax, -0x6400030(%rbp)
jmp 0x1b91
movl $0x6400000, %eax        # imm = 0x6400000
movq %rax, -0x6400030(%rbp)
jmp 0x1b91
movq -0x6400030(%rbp), %rax
movl %eax, -0x14(%rbp)
leaq -0x6400020(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x6400028(%rbp), %rcx
xorl %esi, %esi
callq 0x1ab0
leaq -0x6400020(%rbp), %rdi
xorl %esi, %esi
movl $0x6400000, %edx        # imm = 0x6400000
callq 0x1090
jmp 0x1b47
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1110
movq -0x6400028(%rbp), %rax
addq $0x6400030, %rsp        # imm = 0x6400030
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/teodorst[P]app-huffman/huffman.c
// Function: init_node
node_t* init_node(char data) {
    node_t* node = (node_t*) malloc(sizeof(node_t));
    node->data = data;
    node->left = node->right = NULL;
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl $0x18, %edi
callq 0x10f0
movq %rax, -0x10(%rbp)
movb -0x1(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/teodorst[P]app-huffman/huffman.c
// Function: decode_bytes_for_chunk
int decode_bytes_for_chunk(node_t *root, char *buffer, unsigned long long int nbits, node_t **remainig_node, char* out_buffer) {

    int i, j;
    node_t *node = *remainig_node;
    unsigned long long int nbytes = nbits % 8 == 0 ? nbits/8 : nbits/8 + 1;
    unsigned long long int count_bits = 0L;
    int bit;
    int length = 0;

    for (i = 0; i < nbytes; i++) {
        for (j = 7 ; j >= 0 && count_bits < nbits; j--) {

            /* get bit */
            bit = (buffer[i] >> j) & 1;

            if (bit == 0) {
                /* go left in tree*/
                node = node->left;
            } else {
                /* go right in tree */
                node = node->right;
            }

            /* depth search from the root */
            if (node->left == NULL && node->right == NULL) {
                out_buffer[length ++] = node->data;
                node = root;
            }

            count_bits ++;
        }
    }

    *remainig_node = node;
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x1c7f
movq -0x18(%rbp), %rax
shrq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0x1c8f
movq -0x18(%rbp), %rax
shrq $0x3, %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movl $0x0, -0x50(%rbp)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x1d82
movl $0x7, -0x30(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x30(%rbp)
movb %al, -0x59(%rbp)
jl 0x1cdb
movq -0x48(%rbp), %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x1ce7
jmp 0x1d72
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl -0x30(%rbp), %ecx
sarl %cl, %eax
andl $0x1, %eax
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
jne 0x1d12
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x1d1e
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1d58
movq -0x38(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1d58
movq -0x38(%rbp), %rax
movb 0x4(%rax), %dl
movq -0x28(%rbp), %rax
movl -0x50(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x50(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1cc2
jmp 0x1d74
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1cad
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x50(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/teodorst[P]app-huffman/huffman.c
// Function: decode_bytes_for_chunk_pthreads
int decode_bytes_for_chunk_pthreads(node_t *root, char *buffer, unsigned long long int nbits, char* out_buffer) {

    int i, j;
    node_t *node = root;
    unsigned long long int nbytes = nbits % 8 == 0 ? nbits/8 : nbits/8 + 1;
    unsigned long long int count_bits = 0L;
    int bit;
    int length = 0;
    for (i = 0; i < nbytes; i++) {
        for (j = 7 ; j >= 0 && count_bits < nbits; j--) {

            /* get bit */
            bit = (buffer[i] >> j) & 1;

            if (bit == 0) {
                /* go left in tree*/
                node = node->left;

            } else {
                /* go right in tree */
                node = node->right;
            }

            /* depth search from the root */
            if (node->left == NULL && node->right == NULL) {
                out_buffer[length ++] = node->data;
                node = root;
            }

            count_bits ++;
        }
    }

    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x1dd8
movq -0x18(%rbp), %rax
shrq $0x3, %rax
movq %rax, -0x50(%rbp)
jmp 0x1de8
movq -0x18(%rbp), %rax
shrq $0x3, %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movl $0x0, -0x48(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x1edb
movl $0x7, -0x28(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x28(%rbp)
movb %al, -0x51(%rbp)
jl 0x1e34
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x1e40
jmp 0x1ecb
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl -0x28(%rbp), %ecx
sarl %cl, %eax
andl $0x1, %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jne 0x1e6b
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x1e77
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1eb1
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1eb1
movq -0x30(%rbp), %rax
movb 0x4(%rax), %dl
movq -0x20(%rbp), %rax
movl -0x48(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x48(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1e1b
jmp 0x1ecd
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1e06
movl -0x48(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/teodorst[P]app-huffman/huffman.c
// Function: write_codification_for_input_file
unsigned long long int write_codification_for_input_file(char **codification, FILE* input_fp, FILE* output_fp) {
    size_t nread = 0;
    int chunk_size = 0;
    char *buf = calloc(CHUNK, sizeof(char));
    char *output_buffer = calloc(CHUNK, sizeof(char));
    char output_char = 0;
    int output_buffer_contor = 0;
    int contor = 7;
    unsigned long long int bits = 0L;

    while((nread = fread(buf, 1, CHUNK, input_fp)) > 0) {
        chunk_size = CHUNK > nread ? nread : CHUNK;
        write_codification_for_chunk(buf, chunk_size, codification, output_buffer, &output_buffer_contor, &output_char, &contor, &bits);
        fwrite(output_buffer, 1, output_buffer_contor, output_fp);
        memset(buf, '\0', CHUNK);
        memset(output_buffer, '\0', CHUNK);
        output_buffer_contor = 0;
    }

    // if there are some bits to write in the last byte.
    if (contor > 7 && contor > -1 ) {
        fwrite(&output_char, 1, 1, output_fp);
    }

    return bits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x6400000, %edi        # imm = 0x6400000
movl $0x1, %esi
callq 0x10b0
movq %rax, -0x30(%rbp)
movl $0x6400000, %edi        # imm = 0x6400000
movl $0x1, %esi
callq 0x10b0
movq %rax, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
movl $0x0, -0x40(%rbp)
movl $0x7, -0x44(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x6400000, %edx        # imm = 0x6400000
callq 0x1050
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jbe 0x21ce
movl $0x6400000, %eax        # imm = 0x6400000
cmpq -0x20(%rbp), %rax
jbe 0x214d
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x2158
movl $0x6400000, %eax        # imm = 0x6400000
movq %rax, -0x58(%rbp)
jmp 0x2158
movq -0x58(%rbp), %rax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x8(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq -0x40(%rbp), %r8
leaq -0x39(%rbp), %r9
leaq -0x44(%rbp), %r10
leaq -0x50(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2200
movq -0x38(%rbp), %rdi
movslq -0x40(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x1170
movq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x6400000, %edx        # imm = 0x6400000
callq 0x1090
movq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x6400000, %edx        # imm = 0x6400000
callq 0x1090
movl $0x0, -0x40(%rbp)
jmp 0x2113
cmpl $0x7, -0x44(%rbp)
jle 0x21ef
cmpl $-0x1, -0x44(%rbp)
jle 0x21ef
movq -0x18(%rbp), %rcx
leaq -0x39(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x1170
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)