LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::FtpWrite(void*, int, ftphandle*)
int ftplib::FtpWrite(void *buf, int len, ftphandle *nData)
{
	int i;

	if (nData->dir != FTPLIB_WRITE) 
        return 0;
	if (nData->buf) 
        i = writeline(static_cast<char*>(buf), len, nData);
	else
	{
		socket_wait(nData);
#ifndef NOSSL
		if (nData->tlsdata) 
            i = SSL_write(nData->ssl, buf, len);
		else 
            i = net_write(nData->handle, buf, len);
#else
		i = net_write(nData->handle, buf, len);
#endif
	}
	if (i == -1) 
        return 0;
	nData->xfered += i;

	if (nData->xfercb && nData->cbbytes) {
		nData->xfered1 += i;
		if (nData->xfered1 > nData->cbbytes) {
			if (nData->xfercb(nData->xfered, nData->cbarg) == 0) 
                return 0;
			nData->xfered1 = 0;
		}
	}
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x2, 0x28(%rax)
je 0x18975
movl $0x0, -0x4(%rbp)
jmp 0x18a5f
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x18999
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x16a50
movl %eax, -0x2c(%rbp)
jmp 0x189bd
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16530
movq -0x28(%rbp), %rax
movl 0x10(%rax), %edi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x4160
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x189cf
movl $0x0, -0x4(%rbp)
jmp 0x18a5f
movslq -0x2c(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x70(%rax), %rcx
movq %rcx, 0x70(%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x18a59
movq -0x28(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x18a59
movslq -0x2c(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x80(%rax), %rcx
movq %rcx, 0x80(%rax)
movq -0x28(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jle 0x18a57
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x70(%rcx), %rdi
movq -0x28(%rbp), %rcx
movq 0x68(%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x18a48
movl $0x0, -0x4(%rbp)
jmp 0x18a5f
movq -0x28(%rbp), %rax
movq $0x0, 0x80(%rax)
jmp 0x18a59
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::Site(char const*)
int ftplib::Site(const char *cmd)
{
	char buf[256];

	if ((strlen(cmd) + 7) > sizeof(buf)) 
        return 0;
	sprintf(buf,"SITE %s",cmd);
	if (!FtpSendCmd(buf,'2',mp_ftphandle)) 
        return 0;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41d0
addq $0x7, %rax
cmpq $0x100, %rax            # imm = 0x100
jbe 0x18aac
movl $0x0, -0x4(%rbp)
jmp 0x18af5
leaq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x4f1b(%rip), %rsi      # 0x1d9d9
movb $0x0, %al
callq 0x40d0
movq -0x128(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq (%rdi), %rcx
movl $0x32, %edx
callq 0x171c0
cmpl $0x0, %eax
jne 0x18aee
movl $0x0, -0x4(%rbp)
jmp 0x18af5
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::Raw(char const*)
int ftplib::Raw(const char *cmd)
{
	char buf[256];
	strncpy(buf, cmd, 256);
	if (!FtpSendCmd(buf,'2',mp_ftphandle)) 
        return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x4230
movq -0x128(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq (%rdi), %rcx
movl $0x32, %edx
callq 0x171c0
cmpl $0x0, %eax
jne 0x18b6c
movl $0x0, -0x4(%rbp)
jmp 0x18b73
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nop
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::SysType(char*, int)
int ftplib::SysType(char *buf, int max)
{
	int l = max;
	char *b = buf;
	char *s;
	if (!FtpSendCmd("SYST",'2',mp_ftphandle)) 
        return 0;
	s = &mp_ftphandle->response[4];
	while ((--l) && (*s != ' ')) 
        *b++ = *s++;
	*b++ = '\0';
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rdi), %rcx
leaq 0x4e2e(%rip), %rsi      # 0x1d9e1
movl $0x32, %edx
callq 0x171c0
cmpl $0x0, %eax
jne 0x18bcb
movl $0x0, -0x4(%rbp)
jmp 0x18c49
movq -0x38(%rbp), %rax
movq (%rax), %rax
addq $0x88, %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movl -0x20(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0x18c03
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x18c0c
jmp 0x18c30
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb (%rax), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
jmp 0x18be0
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x0, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::Mkdir(char const*)
int ftplib::Mkdir(const char *path)
{
	char buf[256];

	if ((strlen(path) + 6) > sizeof(buf)) 
        return 0;
	sprintf(buf,"MKD %s",path);
	if (!FtpSendCmd(buf,'2', mp_ftphandle)) 
        return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41d0
addq $0x6, %rax
cmpq $0x100, %rax            # imm = 0x100
jbe 0x18c9c
movl $0x0, -0x4(%rbp)
jmp 0x18ce5
leaq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x4d38(%rip), %rsi      # 0x1d9e6
movb $0x0, %al
callq 0x40d0
movq -0x128(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq (%rdi), %rcx
movl $0x32, %edx
callq 0x171c0
cmpl $0x0, %eax
jne 0x18cde
movl $0x0, -0x4(%rbp)
jmp 0x18ce5
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::Chdir(char const*)
int ftplib::Chdir(const char *path)
{
	char buf[256];

	if ((strlen(path) + 6) > sizeof(buf)) 
        return 0;
	sprintf(buf,"CWD %s",path);
	if (!FtpSendCmd(buf,'2',mp_ftphandle))
        return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41d0
addq $0x6, %rax
cmpq $0x100, %rax            # imm = 0x100
jbe 0x18d3c
movl $0x0, -0x4(%rbp)
jmp 0x18d85
leaq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x4c9f(%rip), %rsi      # 0x1d9ed
movb $0x0, %al
callq 0x40d0
movq -0x128(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq (%rdi), %rcx
movl $0x32, %edx
callq 0x171c0
cmpl $0x0, %eax
jne 0x18d7e
movl $0x0, -0x4(%rbp)
jmp 0x18d85
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::Rmdir(char const*)
int ftplib::Rmdir(const char *path)
{
	char buf[256];

	if ((strlen(path) + 6) > sizeof(buf)) 
        return 0;
	sprintf(buf,"RMD %s",path);
	if (!FtpSendCmd(buf,'2',mp_ftphandle)) 
        return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41d0
addq $0x6, %rax
cmpq $0x100, %rax            # imm = 0x100
jbe 0x18e2c
movl $0x0, -0x4(%rbp)
jmp 0x18e75
leaq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x4bbb(%rip), %rsi      # 0x1d9f9
movb $0x0, %al
callq 0x40d0
movq -0x128(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq (%rdi), %rcx
movl $0x32, %edx
callq 0x171c0
cmpl $0x0, %eax
jne 0x18e6e
movl $0x0, -0x4(%rbp)
jmp 0x18e75
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::Pwd(char*, int)
int ftplib::Pwd(char *path, int max)
{
	int l = max;
	char *b = path;
	char *s;

 	if (!FtpSendCmd("PWD",'2',mp_ftphandle)) 
        return 0;
	s = strchr(mp_ftphandle->response, '"');
	if (s == NULL) 
        return 0;
   s++;
	while ((--l) && (*s) && (*s != '"'))
        *b++ = *s++;
	*b = '\0';
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rdi), %rcx
leaq 0x4b3d(%rip), %rsi      # 0x1da00
movl $0x32, %edx
callq 0x171c0
cmpl $0x0, %eax
jne 0x18ede
movl $0x0, -0x4(%rbp)
jmp 0x18f82
movq -0x38(%rbp), %rax
movq (%rax), %rdi
addq $0x88, %rdi
movl $0x22, %esi
callq 0x4180
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x18f0a
movl $0x0, -0x4(%rbp)
jmp 0x18f82
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movl -0x20(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0x18f47
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x39(%rbp)
je 0x18f47
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x18f50
jmp 0x18f74
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb (%rax), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
jmp 0x18f16
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::Size(char const*, int*, ftplib::transfermode)
int ftplib::Size(const char *path, int *size, transfermode mode)
{
   char cmd[256];
   int resp,sz,rv=1;

   if ((strlen(path) + 7) > sizeof(cmd)) 
        return 0;

	sprintf(cmd, "TYPE %c", mode);
   if (!FtpSendCmd(cmd, '2', mp_ftphandle)) 
        return 0;

	sprintf(cmd,"SIZE %s",path);
   if (!FtpSendCmd(cmd,'2',mp_ftphandle)) 
    rv = 0;
   else  {
		if (sscanf(mp_ftphandle->response, "%d %d", &resp, &sz) == 2) 
            *size = sz;
		else 
            rv = 0;
   }
   return rv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x148(%rbp)
movl $0x1, -0x13c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41d0
addq $0x7, %rax
cmpq $0x100, %rax            # imm = 0x100
jbe 0x19360
movl $0x0, -0x4(%rbp)
jmp 0x1943e
leaq -0x130(%rbp), %rdi
movl -0x24(%rbp), %edx
leaq 0x4553(%rip), %rsi      # 0x1d8c4
movb $0x0, %al
callq 0x40d0
movq -0x148(%rbp), %rdi
leaq -0x130(%rbp), %rsi
movq (%rdi), %rcx
movl $0x32, %edx
callq 0x171c0
cmpl $0x0, %eax
jne 0x193a4
movl $0x0, -0x4(%rbp)
jmp 0x1943e
leaq -0x130(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x46b0(%rip), %rsi      # 0x1da66
movb $0x0, %al
callq 0x40d0
movq -0x148(%rbp), %rdi
leaq -0x130(%rbp), %rsi
movq (%rdi), %rcx
movl $0x32, %edx
callq 0x171c0
cmpl $0x0, %eax
jne 0x193e9
movl $0x0, -0x13c(%rbp)
jmp 0x19435
movq -0x148(%rbp), %rax
movq (%rax), %rdi
addq $0x88, %rdi
leaq 0x466d(%rip), %rsi      # 0x1da6e
leaq -0x134(%rbp), %rdx
leaq -0x138(%rbp), %rcx
movb $0x0, %al
callq 0x4480
cmpl $0x2, %eax
jne 0x19429
movl -0x138(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x19433
movl $0x0, -0x13c(%rbp)
jmp 0x19435
movl -0x13c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopw (%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::ModDate(char const*, char*, int)
int ftplib::ModDate(const char *path, char *dt, int max)
{
	char buf[256];
	int rv = 1;

	if ((strlen(path) + 7) > sizeof(buf)) 
        return 0;
	sprintf(buf,"MDTM %s",path);
    if (!FtpSendCmd(buf,'2',mp_ftphandle)) 
        rv = 0;
	else 
        strncpy(dt, &mp_ftphandle->response[4], max);
	return rv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x140(%rbp)
movl $0x1, -0x134(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41d0
addq $0x7, %rax
cmpq $0x100, %rax            # imm = 0x100
jbe 0x1949d
movl $0x0, -0x4(%rbp)
jmp 0x1950d
leaq -0x130(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x45c5(%rip), %rsi      # 0x1da74
movb $0x0, %al
callq 0x40d0
movq -0x140(%rbp), %rdi
leaq -0x130(%rbp), %rsi
movq (%rdi), %rcx
movl $0x32, %edx
callq 0x171c0
cmpl $0x0, %eax
jne 0x194e2
movl $0x0, -0x134(%rbp)
jmp 0x19504
movq -0x140(%rbp), %rax
movq -0x20(%rbp), %rdi
movq (%rax), %rsi
addq $0x88, %rsi
addq $0x4, %rsi
movslq -0x24(%rbp), %rdx
callq 0x4230
movl -0x134(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopl (%rax)
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::Get(char const*, char const*, ftplib::transfermode, long)
int ftplib::Get(const char *outputfile, const char *path, transfermode mode, off64_t offset)
{
	mp_ftphandle->offset = offset;
	if (offset == 0) 
        return FtpXfer(outputfile, path, mp_ftphandle, ftplib::fileread, mode);
	else 
        return FtpXfer(outputfile, path, mp_ftphandle, ftplib::filereadappend, mode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x1b0(%rax)
cmpq $0x0, -0x30(%rbp)
jne 0x1957b
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq (%rdi), %rcx
movl -0x24(%rbp), %r9d
movl $0x3, %r8d
callq 0x18f90
movl %eax, -0x4(%rbp)
jmp 0x1959c
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq (%rdi), %rcx
movl -0x24(%rbp), %r9d
movl $0x5, %r8d
callq 0x18f90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::Put(char const*, char const*, ftplib::transfermode, long)
int ftplib::Put(const char *inputfile, const char *path, transfermode mode, off64_t offset)
{
	mp_ftphandle->offset = offset;
	if (offset == 0) 
        return FtpXfer(inputfile, path, mp_ftphandle, ftplib::filewrite, mode);
	else 
        return FtpXfer(inputfile, path, mp_ftphandle, ftplib::filewriteappend, mode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x1b0(%rax)
cmpq $0x0, -0x30(%rbp)
jne 0x1960b
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq (%rdi), %rcx
movl -0x24(%rbp), %r9d
movl $0x4, %r8d
callq 0x18f90
movl %eax, -0x4(%rbp)
jmp 0x1962c
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq (%rdi), %rcx
movl -0x24(%rbp), %r9d
movl $0x6, %r8d
callq 0x18f90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::Rename(char const*, char const*)
int ftplib::Rename(const char *src, const char *dst)
{
	char cmd[256];

	if (((strlen(src) + 7) > sizeof(cmd)) || ((strlen(dst) + 7) > sizeof(cmd))) 
        return 0;
	sprintf(cmd,"RNFR %s",src);
	if (!FtpSendCmd(cmd,'3',mp_ftphandle)) 
        return 0;
	sprintf(cmd,"RNTO %s",dst);
	if (!FtpSendCmd(cmd,'2',mp_ftphandle)) 
        return 0;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41d0
addq $0x7, %rax
cmpq $0x100, %rax            # imm = 0x100
ja 0x1968c
movq -0x20(%rbp), %rdi
callq 0x41d0
addq $0x7, %rax
cmpq $0x100, %rax            # imm = 0x100
jbe 0x19698
movl $0x0, -0x4(%rbp)
jmp 0x19723
leaq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x43d2(%rip), %rsi      # 0x1da7c
movb $0x0, %al
callq 0x40d0
movq -0x128(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq (%rdi), %rcx
movl $0x33, %edx
callq 0x171c0
cmpl $0x0, %eax
jne 0x196da
movl $0x0, -0x4(%rbp)
jmp 0x19723
leaq -0x120(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x4398(%rip), %rsi      # 0x1da84
movb $0x0, %al
callq 0x40d0
movq -0x128(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq (%rdi), %rcx
movl $0x32, %edx
callq 0x171c0
cmpl $0x0, %eax
jne 0x1971c
movl $0x0, -0x4(%rbp)
jmp 0x19723
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nop
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::Delete(char const*)
int ftplib::Delete(const char *path)
{
	char cmd[256];

	if ((strlen(path) + 7) > sizeof(cmd)) 
        return 0;
   	sprintf(cmd,"DELE %s",path);
   	if (!FtpSendCmd(cmd,'2', mp_ftphandle)) 
        return 0;
   	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41d0
addq $0x7, %rax
cmpq $0x100, %rax            # imm = 0x100
jbe 0x1976c
movl $0x0, -0x4(%rbp)
jmp 0x197b5
leaq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x430e(%rip), %rsi      # 0x1da8c
movb $0x0, %al
callq 0x40d0
movq -0x128(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq (%rdi), %rcx
movl $0x32, %edx
callq 0x171c0
cmpl $0x0, %eax
jne 0x197ae
movl $0x0, -0x4(%rbp)
jmp 0x197b5
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lianxings[P]ftp_benchmark/ftplib.cc
// Function: ftplib::Quit()
int ftplib::Quit()
{
	if (mp_ftphandle->dir != FTPLIB_CONTROL) 
        return 0;
	if (mp_ftphandle->handle == 0)
	{
		strcpy(mp_ftphandle->response, "error: no anwser from server\n");
		return 0;
	}
	if (!FtpSendCmd("QUIT",'2',mp_ftphandle))
	{
		net_close(mp_ftphandle->handle);
		return 0;
	} else	{
		net_close(mp_ftphandle->handle);
		return 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
cmpl $0x0, 0x28(%rax)
je 0x197f6
movl $0x0, -0x4(%rbp)
jmp 0x19871
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jne 0x19826
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x88, %rdi
leaq 0x427c(%rip), %rsi      # 0x1da94
callq 0x4430
movl $0x0, -0x4(%rbp)
jmp 0x19871
movq -0x18(%rbp), %rdi
movq (%rdi), %rcx
leaq 0x427e(%rip), %rsi      # 0x1dab2
movl $0x32, %edx
callq 0x171c0
cmpl $0x0, %eax
jne 0x1985b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %edi
callq 0x48b0
movl $0x0, -0x4(%rbp)
jmp 0x19871
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %edi
callq 0x48b0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lianxings[P]ftp_benchmark/WjCryptLib_Md5.cc
// Function: Md5Initialise(Md5Context*)
void Md5Initialise (
        Md5Context*         Context         // [out]
) {
    Context->a = 0x67452301;
    Context->b = 0xefcdab89;
    Context->c = 0x98badcfe;
    Context->d = 0x10325476;

    Context->lo = 0;
    Context->hi = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x67452301, 0x8(%rax)  # imm = 0x67452301
movq -0x8(%rbp), %rax
movl $0xefcdab89, 0xc(%rax)  # imm = 0xEFCDAB89
movq -0x8(%rbp), %rax
movl $0x98badcfe, 0x10(%rax) # imm = 0x98BADCFE
movq -0x8(%rbp), %rax
movl $0x10325476, 0x14(%rax) # imm = 0x10325476
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: lianxings[P]ftp_benchmark/WjCryptLib_Md5.cc
// Function: Md5Update(Md5Context*, void const*, unsigned int)
void Md5Update (
        Md5Context*         Context,        // [in out]
        void const*         Buffer,         // [in]
        uint32_t            BufferSize      // [in]
) {
    uint32_t    saved_lo;
    uint32_t    used;
    uint32_t    free;

    saved_lo = Context->lo;
    if( (Context->lo = (saved_lo + BufferSize) & 0x1fffffff) < saved_lo )
    {
        Context->hi++;
    }
    Context->hi += (uint32_t)( BufferSize >> 29 );

    used = saved_lo & 0x3f;

    if( used )
    {
        free = 64 - used;

        if( BufferSize < free )
        {
            memcpy( &Context->buffer[used], Buffer, BufferSize );
            return;
        }

        memcpy( &Context->buffer[used], Buffer, free );
        Buffer = (uint8_t*)Buffer + free;
        BufferSize -= free;
        TransformFunction(Context, Context->buffer, 64);
    }

    if( BufferSize >= 64 )
    {
        Buffer = TransformFunction( Context, Buffer, BufferSize & ~(unsigned long)0x3f );
        BufferSize &= 0x3f;
    }

    memcpy( Context->buffer, Buffer, BufferSize );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
andl $0x1fffffff, %eax       # imm = 0x1FFFFFFF
movq -0x8(%rbp), %rcx
movl %eax, (%rcx)
cmpl -0x18(%rbp), %eax
jae 0x1a25f
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
shrl $0x1d, %ecx
movq -0x8(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl -0x18(%rbp), %eax
andl $0x3f, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1a2fd
movl $0x40, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x1a2b2
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movl -0x1c(%rbp), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x4380
jmp 0x1a33c
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movl -0x1c(%rbp), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x20(%rbp), %eax
movl %eax, %edx
callq 0x4380
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
movl $0x40, %edx
callq 0x1a350
cmpl $0x40, -0x14(%rbp)
jb 0x1a326
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
andq $-0x40, %rdx
callq 0x1a350
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
andl $0x3f, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x4380
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lianxings[P]ftp_benchmark/WjCryptLib_Md5.cc
// Function: Md5Calculate(void const*, unsigned int, MD5_HASH*)
void Md5Calculate (
        void  const*        Buffer,         // [in]
        uint32_t            BufferSize,     // [in]
        MD5_HASH*           Digest          // [in]
) {
    Md5Context context;

    Md5Initialise( &context );
    Md5Update( &context, Buffer, BufferSize );
    Md5Finalise( &context, Digest );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x1a1d0
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0xb0(%rbp), %rdi
callq 0x1a220
movq -0x18(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x1b700
addq $0xb0, %rsp
popq %rbp
retq
// File: rachit31[P]CubeSatADCS/KalmanPi.cpp
// Function: main
int main(int argc, char* argv[])
 {
	 i2c.initialize();
	 
	 // Initialize Gyro
	 initializeGyros();
	 
	 // Initialize Accelerometer
	 initializeAccel();
	 
	 // Initialize Magnetometer
	 initializeMag();
	 
	 ThreadManager threadManager;
	 threadManager.create(readGyros);
	 threadManager.create(readAccel);
	 threadManager.create(readMag);
	 threadManager.create(sendFunction);
	 threadManager.create(propagateANDupdate);
	 
	 threadManager.wait();
	 
	 return EXIT_SUCCESS;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xed08(%rip), %rdi      # 0x124f8
callq 0x40d0
callq 0x38e0
callq 0x3b60
callq 0x3de0
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x5d60
movq -0xc0(%rbp), %rdi
leaq 0x1feb(%rip), %rsi      # 0x5810
callq 0x5e80
jmp 0x382c
leaq 0x21bd(%rip), %rsi      # 0x59f0
leaq -0xa8(%rbp), %rdi
callq 0x5e80
jmp 0x3841
leaq 0x22f8(%rip), %rsi      # 0x5b40
leaq -0xa8(%rbp), %rdi
callq 0x5e80
jmp 0x3856
leaq 0x2433(%rip), %rsi      # 0x5c90
leaq -0xa8(%rbp), %rdi
callq 0x5e80
jmp 0x386b
leaq 0x61ce(%rip), %rsi      # 0x9a40
leaq -0xa8(%rbp), %rdi
callq 0x5e80
jmp 0x3880
leaq -0xa8(%rbp), %rdi
callq 0x63a0
jmp 0x388e
movl $0x0, -0x4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x5dc0
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x5dc0
movq -0xb0(%rbp), %rdi
callq 0x3420
nopw (%rax,%rax)
// File: rachit31[P]CubeSatADCS/i2c.cpp
// Function: I2C::initialize()
const char* I2C::initialize()
{
  std::stringstream error;

  // Open the I2C Bus
  m_busFd = open("/dev/i2c-1", O_RDWR);
  if (m_busFd == -1)
  {
    error << "open(): " << std::strerror(errno);
    return error.str().c_str();
  }

  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d8(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3190
leaq 0x9080(%rip), %rdi      # 0xd17d
xorl %eax, %eax
movl $0x2, %esi
callq 0x31c0
movl %eax, -0x1d0(%rbp)
jmp 0x4111
movq -0x1d8(%rbp), %rax
movl -0x1d0(%rbp), %ecx
movl %ecx, (%rax)
cmpl $-0x1, (%rax)
jne 0x41bf
leaq -0x188(%rbp), %rdi
leaq 0x9051(%rip), %rsi      # 0xd188
callq 0x3270
movq %rax, -0x1e0(%rbp)
jmp 0x4145
callq 0x3040
movl (%rax), %edi
callq 0x30d0
movq -0x1e0(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
jmp 0x4162
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3260
jmp 0x4177
leaq -0x1c8(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x3160
movl $0x1, -0x1cc(%rbp)
jmp 0x41d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31d0
jmp 0x41ea
movq $0x0, -0x8(%rbp)
movl $0x1, -0x1cc(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31d0
movq -0x8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: rachit31[P]CubeSatADCS/i2c.cpp
// Function: I2C::writeByte(unsigned char, unsigned char, unsigned char)
const char* I2C::writeByte(uint8_t busAddr, uint8_t dataAddr, uint8_t data)
{
  std::stringstream error;

  union i2c_smbus_data smbus_data;
  smbus_data.byte = data;

  struct i2c_smbus_ioctl_data args;

  args.read_write = 0;
  args.command = dataAddr;
  args.size = 2;
  args.data = &smbus_data;

  m_mutex.lock();
  if (ioctl(m_busFd, I2C_SLAVE, busAddr) == -1)
  {
    m_mutex.unlock();
    error << "ioctl(): " << std::strerror(errno);
    return error.str().c_str();
  }

  if (ioctl(m_busFd,I2C_SMBUS,&args) == -1)
  {
    m_mutex.unlock();
    error << "ioctl(): " << std::strerror(errno);
    return error.str().c_str();
  }
  m_mutex.unlock();

  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x10(%rbp)
movb %dl, -0x11(%rbp)
movb %cl, -0x12(%rbp)
movb %al, -0x13(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x238(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x3190
movq -0x238(%rbp), %rdi
movb -0x13(%rbp), %al
movb %al, -0x1c2(%rbp)
movb $0x0, -0x1d8(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x1d7(%rbp)
movl $0x2, -0x1d4(%rbp)
leaq -0x1c2(%rbp), %rax
movq %rax, -0x1d0(%rbp)
addq $0x8, %rdi
callq 0x49e0
jmp 0x4279
movq -0x238(%rbp), %rax
movl (%rax), %edi
movzbl -0x11(%rbp), %edx
movl $0x703, %esi            # imm = 0x703
movb $0x0, %al
callq 0x3360
cmpl $-0x1, %eax
jne 0x4349
movq -0x238(%rbp), %rdi
addq $0x8, %rdi
callq 0x4b30
jmp 0x42ad
leaq -0x190(%rbp), %rdi
leaq 0x8ed6(%rip), %rsi      # 0xd191
callq 0x3270
movq %rax, -0x240(%rbp)
jmp 0x42c9
callq 0x3040
movl (%rax), %edi
callq 0x30d0
movq -0x240(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
jmp 0x42e6
leaq -0x208(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x3260
jmp 0x42fb
leaq -0x208(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x3160
movl $0x1, -0x20c(%rbp)
jmp 0x441a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e0(%rbp)
movl %eax, -0x1e4(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31d0
jmp 0x4433
movq -0x238(%rbp), %rax
movl (%rax), %edi
movl $0x720, %esi            # imm = 0x720
leaq -0x1d8(%rbp), %rdx
movb $0x0, %al
callq 0x3360
cmpl $-0x1, %eax
jne 0x43f6
movq -0x238(%rbp), %rdi
addq $0x8, %rdi
callq 0x4b30
jmp 0x4380
leaq -0x190(%rbp), %rdi
leaq 0x8e03(%rip), %rsi      # 0xd191
callq 0x3270
movq %rax, -0x248(%rbp)
jmp 0x439c
callq 0x3040
movl (%rax), %edi
callq 0x30d0
movq -0x248(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
jmp 0x43b9
leaq -0x230(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x3260
jmp 0x43ce
leaq -0x230(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x3160
movl $0x1, -0x20c(%rbp)
jmp 0x441a
movq -0x238(%rbp), %rdi
addq $0x8, %rdi
callq 0x4b30
jmp 0x4408
movq $0x0, -0x8(%rbp)
movl $0x1, -0x20c(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31d0
movq -0x8(%rbp), %rax
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x1e0(%rbp), %rdi
callq 0x3420
nop
// File: rachit31[P]CubeSatADCS/i2c.cpp
// Function: I2C::readByte(unsigned char, unsigned char)
uint8_t I2C::readByte(uint8_t busAddr, uint8_t dataAddr)
{
  std::stringstream error;

  union i2c_smbus_data smbus_data;

  struct i2c_smbus_ioctl_data args;

  args.read_write = 1;
  args.command = dataAddr;
  args.size = 2;
  args.data = &smbus_data;

  m_mutex.lock();
  if (ioctl(m_busFd, I2C_SLAVE, busAddr) == -1)
  {
    m_mutex.unlock();
    return -1;
  }

  if (ioctl(m_busFd,I2C_SMBUS,&args) == -1)
  {
    m_mutex.unlock();
    return -1;
  }
  m_mutex.unlock();

  return 0xFF & smbus_data.byte;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1f0(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x3190
movq -0x1f0(%rbp), %rdi
movb $0x1, -0x1d8(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x1d7(%rbp)
movl $0x2, -0x1d4(%rbp)
leaq -0x1c2(%rbp), %rax
movq %rax, -0x1d0(%rbp)
addq $0x8, %rdi
callq 0x49e0
jmp 0x44ab
movq -0x1f0(%rbp), %rax
movl (%rax), %edi
movzbl -0x11(%rbp), %edx
movl $0x703, %esi            # imm = 0x703
movb $0x0, %al
callq 0x3360
cmpl $-0x1, %eax
jne 0x4511
movq -0x1f0(%rbp), %rdi
addq $0x8, %rdi
callq 0x4b30
jmp 0x44db
movb $-0x1, -0x1(%rbp)
movl $0x1, -0x1e8(%rbp)
jmp 0x457f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e0(%rbp)
movl %eax, -0x1e4(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31d0
jmp 0x4597
movq -0x1f0(%rbp), %rax
movl (%rax), %edi
movl $0x720, %esi            # imm = 0x720
leaq -0x1d8(%rbp), %rdx
movb $0x0, %al
callq 0x3360
cmpl $-0x1, %eax
jne 0x4554
movq -0x1f0(%rbp), %rdi
addq $0x8, %rdi
callq 0x4b30
jmp 0x4544
movb $-0x1, -0x1(%rbp)
movl $0x1, -0x1e8(%rbp)
jmp 0x457f
movq -0x1f0(%rbp), %rdi
addq $0x8, %rdi
callq 0x4b30
jmp 0x4566
movzbl -0x1c2(%rbp), %eax
andl $0xff, %eax
movb %al, -0x1(%rbp)
movl $0x1, -0x1e8(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31d0
movb -0x1(%rbp), %al
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1e0(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: rachit31[P]CubeSatADCS/mutex.cpp
// Function: Mutex::lock()
const char* Mutex::lock()
{
  std::stringstream error;
  int retVal;

  // Lock the thread Mutex (TLPI pg 636)
  retVal = pthread_mutex_lock(&m_pthread_mutex);
  if (retVal != 0)
  {
    error << "pthread_mutex_lock(): " << std::strerror(retVal);
    return error.str().c_str();
  }
  m_locked = true;

  return error.str().c_str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x200(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3190
movq -0x200(%rbp), %rdi
addq $0x8, %rdi
callq 0x3390
movl %eax, -0x19c(%rbp)
cmpl $0x0, -0x19c(%rbp)
je 0x4abe
leaq -0x188(%rbp), %rdi
leaq 0x8780(%rip), %rsi      # 0xd1b7
callq 0x3270
movq %rax, -0x208(%rbp)
jmp 0x4a45
movl -0x19c(%rbp), %edi
callq 0x30d0
movq -0x208(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
jmp 0x4a61
leaq -0x1d0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3260
jmp 0x4a76
leaq -0x1d0(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x3160
movl $0x1, -0x1d4(%rbp)
jmp 0x4b03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31d0
jmp 0x4b1c
movq -0x200(%rbp), %rax
movb $0x1, (%rax)
leaq -0x1f8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3260
jmp 0x4add
leaq -0x1f8(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x3160
movl $0x1, -0x1d4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31d0
movq -0x8(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0x3420
nopl (%rax,%rax)
// File: rachit31[P]CubeSatADCS/mutex.cpp
// Function: Mutex::unlock()
const char* Mutex::unlock()
{
  std::stringstream error;
  int retVal;

  // Unlock the thread Mutex (TLPI pg 636)
  retVal = pthread_mutex_unlock(&m_pthread_mutex);
  if (retVal != 0)
  {
    error << "pthread_mutex_unlock(): " << std::strerror(retVal);
    return error.str().c_str();
  }
  m_locked = false;

  return error.str().c_str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x200(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3190
movq -0x200(%rbp), %rdi
addq $0x8, %rdi
callq 0x31e0
movl %eax, -0x19c(%rbp)
cmpl $0x0, -0x19c(%rbp)
je 0x4c0e
leaq -0x188(%rbp), %rdi
leaq 0x8647(%rip), %rsi      # 0xd1ce
callq 0x3270
movq %rax, -0x208(%rbp)
jmp 0x4b95
movl -0x19c(%rbp), %edi
callq 0x30d0
movq -0x208(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
jmp 0x4bb1
leaq -0x1d0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3260
jmp 0x4bc6
leaq -0x1d0(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x3160
movl $0x1, -0x1d4(%rbp)
jmp 0x4c53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31d0
jmp 0x4c6c
movq -0x200(%rbp), %rax
movb $0x0, (%rax)
leaq -0x1f8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3260
jmp 0x4c2d
leaq -0x1f8(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x3160
movl $0x1, -0x1d4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31d0
movq -0x8(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0x3420
nopl (%rax,%rax)
// File: rachit31[P]CubeSatADCS/mutex.cpp
// Function: Mutex::wait()
const char* Mutex::wait()
{
  std::stringstream error;
  int retVal;

  // Lock the thread Mutex (TLPI pg 636)
  retVal = pthread_mutex_lock(&m_pthread_mutex);
  if (retVal != 0)
  {
    error << "pthread_mutex_lock(): " << std::strerror(retVal);
    return error.str().c_str();
  }
  m_locked = true;

  // If the cond_wait is successful the mutex will be unlocked
  m_locked = false;

  // Wait for Thread Conditional Variable (TLPI pg 644)
  retVal = pthread_cond_wait(&m_pthread_cond, &m_pthread_mutex);
  if (retVal != 0)
  {
    m_locked = true;
    error << "pthread_cond_wait(): " << std::strerror(retVal);
    return error.str().c_str();
  }

  // The mutex is now relocked
  m_locked = true;

  return error.str().c_str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x220(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3190
movq -0x220(%rbp), %rdi
addq $0x8, %rdi
callq 0x3390
movl %eax, -0x19c(%rbp)
cmpl $0x0, -0x19c(%rbp)
je 0x4d64
leaq -0x188(%rbp), %rdi
leaq 0x84e0(%rip), %rsi      # 0xd1b7
callq 0x3270
movq %rax, -0x228(%rbp)
jmp 0x4ce5
movl -0x19c(%rbp), %edi
callq 0x30d0
movq -0x228(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
jmp 0x4d01
leaq -0x1d0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3260
jmp 0x4d16
leaq -0x1d0(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x3160
movl $0x1, -0x1d4(%rbp)
jmp 0x4e62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31d0
jmp 0x4e7b
movq -0x220(%rbp), %rsi
movb $0x1, (%rsi)
movb $0x0, (%rsi)
movq %rsi, %rdi
addq $0x30, %rdi
addq $0x8, %rsi
callq 0x33a0
movl %eax, -0x22c(%rbp)
jmp 0x4d89
movl -0x22c(%rbp), %eax
movl %eax, -0x19c(%rbp)
cmpl $0x0, -0x19c(%rbp)
je 0x4e1d
movq -0x220(%rbp), %rax
movb $0x1, (%rax)
leaq -0x188(%rbp), %rdi
leaq 0x8431(%rip), %rsi      # 0xd1e7
callq 0x3270
movq %rax, -0x238(%rbp)
jmp 0x4dc4
movl -0x19c(%rbp), %edi
callq 0x30d0
movq -0x238(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
jmp 0x4de0
leaq -0x1f8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3260
jmp 0x4df5
leaq -0x1f8(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x3160
movl $0x1, -0x1d4(%rbp)
jmp 0x4e62
movq -0x220(%rbp), %rax
movb $0x1, (%rax)
leaq -0x218(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3260
jmp 0x4e3c
leaq -0x218(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x3160
movl $0x1, -0x1d4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31d0
movq -0x8(%rbp), %rax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0x3420
nopw (%rax,%rax)
// File: rachit31[P]CubeSatADCS/mutex.cpp
// Function: Mutex::signal()
const char* Mutex::signal()
{
  std::stringstream error;
  int retVal;

  // Signal the conditional variable (TLPI pg 644)
  retVal = pthread_cond_signal(&m_pthread_cond);
  if (retVal != 0)
  {
    error << "pthread_cond_signal(): " << std::strerror(retVal);
    return error.str().c_str();
  }
  return error.str().c_str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x200(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3190
movq -0x200(%rbp), %rdi
addq $0x30, %rdi
callq 0x3030
movl %eax, -0x19c(%rbp)
cmpl $0x0, -0x19c(%rbp)
je 0x4f6e
leaq -0x188(%rbp), %rdi
leaq 0x8316(%rip), %rsi      # 0xd1fd
callq 0x3270
movq %rax, -0x208(%rbp)
jmp 0x4ef5
movl -0x19c(%rbp), %edi
callq 0x30d0
movq -0x208(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
jmp 0x4f11
leaq -0x1d0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3260
jmp 0x4f26
leaq -0x1d0(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x3160
movl $0x1, -0x1d4(%rbp)
jmp 0x4fa9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31d0
jmp 0x4fc2
leaq -0x1f8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3260
jmp 0x4f83
leaq -0x1f8(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x3160
movl $0x1, -0x1d4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31d0
movq -0x8(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0x3420
nop
// File: rachit31[P]CubeSatADCS/sleepTimer.cpp
// Function: SleepTimer::sleep()
void SleepTimer::sleep()
{
  m_wakeTime.tv_sec += m_durSec;
  m_wakeTime.tv_nsec += m_durNan;

  if (m_wakeTime.tv_nsec >= 1000000000)
  {
    m_wakeTime.tv_sec++;
    m_wakeTime.tv_nsec -= 1000000000;
  }

  clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &m_wakeTime, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x10(%rax), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x18(%rax), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x3b9aca00, 0x8(%rax)  # imm = 0x3B9ACA00
jl 0x50e1
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rcx
subq $0x3b9aca00, %rcx       # imm = 0x3B9ACA00
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdx
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %ecx
movl %esi, %edi
callq 0x3490
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rachit31[P]CubeSatADCS/sendUdp.cpp
// Function: SendUdp::sendDoubles(double const*, int) const
const char* SendUdp::sendDoubles(const double* buffer, const int number) const
{
  if (m_socketFd == -1)
  {
    return "sendUdp class has not been initialized";
  }

  std::stringstream error;
  int size = 8*number;

  // Send datagrams to socket (TLPI PG 1161)
  if (sendto(m_socketFd, buffer, size, 0, (struct sockaddr*)&m_sockaddr_in, m_len) != size)
  {
    error << "sendto(): " << std::strerror(errno);
    return error.str().c_str();
  }

  return error.str().c_str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x210(%rbp)
cmpl $-0x1, (%rax)
jne 0x56b6
leaq 0x7be5(%rip), %rax      # 0xd292
movq %rax, -0x8(%rbp)
jmp 0x57f1
leaq -0x1a8(%rbp), %rdi
callq 0x3190
movq -0x210(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, -0x1ac(%rbp)
movq -0x18(%rbp), %rsi
movslq -0x1ac(%rbp), %rdx
movq %rax, %r8
addq $0x4, %r8
movl (%rax), %edi
movl 0x14(%rax), %r9d
xorl %ecx, %ecx
callq 0x3060
movq %rax, -0x218(%rbp)
jmp 0x56fd
movq -0x218(%rbp), %rax
movslq -0x1ac(%rbp), %rcx
cmpq %rcx, %rax
je 0x57aa
leaq -0x198(%rbp), %rdi
leaq 0x7b97(%rip), %rsi      # 0xd2b9
callq 0x3270
movq %rax, -0x220(%rbp)
jmp 0x5730
callq 0x3040
movl (%rax), %edi
callq 0x30d0
movq -0x220(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
jmp 0x574d
leaq -0x1e0(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x3260
jmp 0x5762
leaq -0x1e0(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x3160
movl $0x1, -0x1e4(%rbp)
jmp 0x57e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x31d0
jmp 0x57fe
leaq -0x208(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x3260
jmp 0x57bf
leaq -0x208(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x3160
movl $0x1, -0x1e4(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x31d0
movq -0x8(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x3420
nopw (%rax,%rax)
// File: rachit31[P]CubeSatADCS/sendFunction.cpp
// Function: sendFunction(void*)
void* sendFunction(void *pArg)
{
  // Push Cleanup Handler to cleanup thread
  pthread_cleanup_push(&Thread::cleanup,pArg);

  // Create a SendUdp Class
  SendUdp sendUdp;
  
  // Initialize the SendUdp Class
  sendUdp.initialize(LOCALIP, REMOTEIP, SNDPORT);

  // Create a buffer to dump the data in  
  double localBuffer[SNDNUM];
  
  // Loop and send data
  while(true)  
	  {
		  sendMutex.wait(); // Wait until gets access to mutex
	  
          std::memcpy(localBuffer, sendBuffer, sizeof(localBuffer)); // (Copy to, Copy from, Copy Number of Bytes)
	  
          sendMutex.unlock(); // Now anyone can access send buffer
	  
          sendUdp.sendDoubles(localBuffer, SNDNUM); // Send the specified number of doubles from the localBuffer to Simulink
	  }

  // Run clean up handler to cleanup thread (TLPI pg 676)
  pthread_cleanup_pop(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
leaq 0x3d79(%rip), %rsi      # 0x9a20
leaq -0x20(%rbp), %rdi
callq 0x5980
leaq -0x38(%rbp), %rdi
callq 0x5150
jmp 0x5cbb
leaq 0x7602(%rip), %rsi      # 0xd2c4
leaq 0x7606(%rip), %rdx      # 0xd2cf
leaq -0x38(%rbp), %rdi
movl $0x303a, %ecx           # imm = 0x303A
callq 0x51b0
jmp 0x5cd9
jmp 0x5cdb
jmp 0x5cdd
leaq 0xc75c(%rip), %rdi      # 0x12440
callq 0x4c80
jmp 0x5ceb
leaq 0xc72e(%rip), %rax      # 0x12420
movaps (%rax), %xmm0
movaps 0x10(%rax), %xmm1
movaps %xmm1, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
leaq 0xc738(%rip), %rdi      # 0x12440
callq 0x4b30
jmp 0x5d0f
leaq -0x38(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x4, %edx
callq 0x5680
jmp 0x5d23
jmp 0x5cdb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5d48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5170
leaq -0x20(%rbp), %rdi
callq 0x59b0
movq -0x40(%rbp), %rdi
callq 0x3420
nopw (%rax,%rax)
// File: rachit31[P]CubeSatADCS/threadManager.cpp
// Function: ThreadManager::~ThreadManager()
ThreadManager::~ThreadManager()
{
  // Iterate over map and free memory
  std::map<unsigned int, Thread*>::iterator it = m_threadMap.begin();
  for (it = m_threadMap.begin(); it != m_threadMap.end(); ++it)
  {
    delete it->second;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x8, %rdi
callq 0x6c90
movq -0x28(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x8, %rdi
callq 0x6c90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x6cf0
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6cc0
testb $0x1, %al
jne 0x5e1e
jmp 0x5e59
leaq -0x10(%rbp), %rdi
callq 0x6d20
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x5e4c
movq -0x30(%rbp), %rdi
callq 0x9960
movq -0x30(%rbp), %rdi
movl $0x20, %esi
callq 0x3290
jmp 0x5e4e
leaq -0x10(%rbp), %rdi
callq 0x6d40
jmp 0x5dfa
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
callq 0x4990
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x6c70
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)