LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: brandoncanaday[P]1730sh/1730sh.cpp
// Function: do_redirects(int, int, int)
void do_redirects(int STDIN, int STDOUT, int STDERR) {
  if(STDIN >= 0) {
    if(dup2(STDIN, STDIN_FILENO) == -1) nope_out("dup2");
  } // if
  if(STDOUT >= 0) {
    if(dup2(STDOUT, STDOUT_FILENO) == -1) nope_out("dup2");
  } // if
  if(STDERR >= 0) {
    if(dup2(STDERR, STDERR_FILENO) == -1) nope_out("dup2");
  } // if
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x7028
movl -0x4(%rbp), %edi
xorl %esi, %esi
callq 0x32c0
cmpl $-0x1, %eax
jne 0x7026
leaq -0x31(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3590
movq -0xa0(%rbp), %rdx
leaq 0xd120(%rip), %rsi      # 0x140eb
leaq -0x30(%rbp), %rdi
callq 0x3440
jmp 0x6fd6
leaq -0x30(%rbp), %rdi
callq 0xb4d0
jmp 0x6fe1
leaq -0x30(%rbp), %rdi
callq 0x31e0
leaq -0x31(%rbp), %rdi
callq 0x3340
jmp 0x7026
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7018
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31e0
leaq -0x31(%rbp), %rdi
callq 0x3340
jmp 0x7175
jmp 0x7028
cmpl $0x0, -0x8(%rbp)
jl 0x70bf
movl -0x8(%rbp), %edi
movl $0x1, %esi
callq 0x32c0
cmpl $-0x1, %eax
jne 0x70bd
leaq -0x69(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3590
movq -0xa8(%rbp), %rdx
leaq 0xd089(%rip), %rsi      # 0x140eb
leaq -0x68(%rbp), %rdi
callq 0x3440
jmp 0x706d
leaq -0x68(%rbp), %rdi
callq 0xb4d0
jmp 0x7078
leaq -0x68(%rbp), %rdi
callq 0x31e0
leaq -0x69(%rbp), %rdi
callq 0x3340
jmp 0x70bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x70af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x31e0
leaq -0x69(%rbp), %rdi
callq 0x3340
jmp 0x7175
jmp 0x70bf
cmpl $0x0, -0xc(%rbp)
jl 0x716c
movl -0xc(%rbp), %edi
movl $0x2, %esi
callq 0x32c0
cmpl $-0x1, %eax
jne 0x716a
leaq -0x91(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x3590
movq -0xb0(%rbp), %rdx
leaq 0xcfeb(%rip), %rsi      # 0x140eb
leaq -0x90(%rbp), %rdi
callq 0x3440
jmp 0x710e
leaq -0x90(%rbp), %rdi
callq 0xb4d0
jmp 0x711c
leaq -0x90(%rbp), %rdi
callq 0x31e0
leaq -0x91(%rbp), %rdi
callq 0x3340
jmp 0x716a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x715c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x31e0
leaq -0x91(%rbp), %rdi
callq 0x3340
jmp 0x7175
jmp 0x716c
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3580
nop
// File: brandoncanaday[P]1730sh/1730sh.cpp
// Function: close_redirects(int, int, int)
void close_redirects(int STDIN, int STDOUT, int STDERR) {
  if(STDIN != STDIN_FILENO) {
    if(close(STDIN) == -1) nope_out("close");
  } // if
  if(STDOUT != STDOUT_FILENO) {
    if(close(STDOUT) == -1) nope_out("close");
  } // if
  if(STDERR != STDERR_FILENO) {
    if(close(STDERR) == -1) nope_out("close");
  } // if
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x7226
movl -0x4(%rbp), %edi
callq 0x35f0
cmpl $-0x1, %eax
jne 0x7224
leaq -0x31(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3590
movq -0xa0(%rbp), %rdx
leaq 0xceba(%rip), %rsi      # 0x14083
leaq -0x30(%rbp), %rdi
callq 0x3440
jmp 0x71d4
leaq -0x30(%rbp), %rdi
callq 0xb4d0
jmp 0x71df
leaq -0x30(%rbp), %rdi
callq 0x31e0
leaq -0x31(%rbp), %rdi
callq 0x3340
jmp 0x7224
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7216
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31e0
leaq -0x31(%rbp), %rdi
callq 0x3340
jmp 0x7369
jmp 0x7226
cmpl $0x1, -0x8(%rbp)
je 0x72b8
movl -0x8(%rbp), %edi
callq 0x35f0
cmpl $-0x1, %eax
jne 0x72b6
leaq -0x69(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3590
movq -0xa8(%rbp), %rdx
leaq 0xce28(%rip), %rsi      # 0x14083
leaq -0x68(%rbp), %rdi
callq 0x3440
jmp 0x7266
leaq -0x68(%rbp), %rdi
callq 0xb4d0
jmp 0x7271
leaq -0x68(%rbp), %rdi
callq 0x31e0
leaq -0x69(%rbp), %rdi
callq 0x3340
jmp 0x72b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x72a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x31e0
leaq -0x69(%rbp), %rdi
callq 0x3340
jmp 0x7369
jmp 0x72b8
cmpl $0x2, -0xc(%rbp)
je 0x7360
movl -0xc(%rbp), %edi
callq 0x35f0
cmpl $-0x1, %eax
jne 0x735e
leaq -0x91(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x3590
movq -0xb0(%rbp), %rdx
leaq 0xcd8f(%rip), %rsi      # 0x14083
leaq -0x90(%rbp), %rdi
callq 0x3440
jmp 0x7302
leaq -0x90(%rbp), %rdi
callq 0xb4d0
jmp 0x7310
leaq -0x90(%rbp), %rdi
callq 0x31e0
leaq -0x91(%rbp), %rdi
callq 0x3340
jmp 0x735e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7350
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x31e0
leaq -0x91(%rbp), %rdi
callq 0x3340
jmp 0x7369
jmp 0x7360
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3580
nopw %cs:(%rax,%rax)
// File: brandoncanaday[P]1730sh/1730sh.cpp
// Function: close_pipe(int*, bool)
void close_pipe(int pipefd[2], bool exit_on_failure) {
  if(close(pipefd[0]) == -1) {
    if(exit_on_failure) { nope_out("close"); } // if
  } // if
  if(close(pipefd[1]) == -1) {
    if(exit_on_failure) { nope_out("close"); } // if
  } // if
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x35f0
cmpl $-0x1, %eax
jne 0x7d92
testb $0x1, -0x9(%rbp)
je 0x7d90
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3590
movq -0x78(%rbp), %rdx
leaq 0xc34e(%rip), %rsi      # 0x14083
leaq -0x30(%rbp), %rdi
callq 0x3440
jmp 0x7d40
leaq -0x30(%rbp), %rdi
callq 0xb4d0
jmp 0x7d4b
leaq -0x30(%rbp), %rdi
callq 0x31e0
leaq -0x31(%rbp), %rdi
callq 0x3340
jmp 0x7d90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7d82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31e0
leaq -0x31(%rbp), %rdi
callq 0x3340
jmp 0x7e24
jmp 0x7d92
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x35f0
cmpl $-0x1, %eax
jne 0x7e1b
testb $0x1, -0x9(%rbp)
je 0x7e19
leaq -0x69(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3590
movq -0x80(%rbp), %rdx
leaq 0xc2c2(%rip), %rsi      # 0x14083
leaq -0x68(%rbp), %rdi
callq 0x3440
jmp 0x7dcc
leaq -0x68(%rbp), %rdi
callq 0xb4d0
jmp 0x7dd7
leaq -0x68(%rbp), %rdi
callq 0x31e0
leaq -0x69(%rbp), %rdi
callq 0x3340
jmp 0x7e19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7e0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x31e0
leaq -0x69(%rbp), %rdi
callq 0x3340
jmp 0x7e24
jmp 0x7e1b
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3580
nopl (%rax)
// File: brandoncanaday[P]1730sh/1730sh.cpp
// Function: deletePipes(int**, int)
void deletePipes(int** pipes, int numPipes) {
  if(pipes != nullptr) {
    for(int i = 0; i < numPipes; i++) {
      delete[] pipes[i];
    } // for
    delete[] pipes;
  } // if
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7e9a
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7e81
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x7e74
movq -0x18(%rbp), %rdi
callq 0x33f0
jmp 0x7e76
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7e4d
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x7e98
movq -0x20(%rbp), %rdi
callq 0x33f0
jmp 0x7e9a
addq $0x20, %rsp
popq %rbp
retq
// File: brandoncanaday[P]1730sh/1730sh.cpp
// Function: put_job_in_foreground(Input*, bool)
void put_job_in_foreground(Input * job, bool cont) {
  if(job != nullptr) {
    // makes JID the foreground pgrp of the terminal
    if(tcsetpgrp(shell_terminal, job->getJID()) == -1) { nope_out("tcsetpgrp"); } 
    // Send the job a continue signal, if necessary
    if(cont) {
      if(kill(-job->getJID(), SIGCONT) < 0) {
	nope_out("kill(SIGCONT)");
      } // if
    } // if
    // wait for job to finish
    wait_for_job(job); 
    // makes the shell the foreground pgrp again
    if(tcsetpgrp(shell_terminal, shell_pgid) == -1) { nope_out("tcsetpgrp"); }
  } // if
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x80b3
movl 0x14490(%rip), %eax     # 0x1c358
movl %eax, -0x98(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb500
movl -0x98(%rbp), %edi
movl %eax, %esi
callq 0x3460
cmpl $-0x1, %eax
jne 0x7f62
leaq -0x31(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3590
movq -0xa0(%rbp), %rdx
leaq 0xc10d(%rip), %rsi      # 0x14014
leaq -0x30(%rbp), %rdi
callq 0x3440
jmp 0x7f12
leaq -0x30(%rbp), %rdi
callq 0xb4d0
jmp 0x7f1d
leaq -0x30(%rbp), %rdi
callq 0x31e0
leaq -0x31(%rbp), %rdi
callq 0x3340
jmp 0x7f62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7f54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31e0
leaq -0x31(%rbp), %rdi
callq 0x3340
jmp 0x80bc
testb $0x1, -0x9(%rbp)
je 0x8003
movq -0x8(%rbp), %rdi
callq 0xb500
xorl %edi, %edi
subl %eax, %edi
movl $0x12, %esi
callq 0x3470
cmpl $0x0, %eax
jge 0x8001
leaq -0x69(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3590
movq -0xa8(%rbp), %rdx
leaq 0xc16d(%rip), %rsi      # 0x14113
leaq -0x68(%rbp), %rdi
callq 0x3440
jmp 0x7fb1
leaq -0x68(%rbp), %rdi
callq 0xb4d0
jmp 0x7fbc
leaq -0x68(%rbp), %rdi
callq 0x31e0
leaq -0x69(%rbp), %rdi
callq 0x3340
jmp 0x8001
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7ff3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x31e0
leaq -0x69(%rbp), %rdi
callq 0x3340
jmp 0x80bc
jmp 0x8003
movq -0x8(%rbp), %rdi
callq 0x8480
movl 0x14346(%rip), %edi     # 0x1c358
movl 0x14344(%rip), %esi     # 0x1c35c
callq 0x3460
cmpl $-0x1, %eax
jne 0x80b1
leaq -0x91(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x3590
movq -0xb0(%rbp), %rdx
leaq 0xbfcd(%rip), %rsi      # 0x14014
leaq -0x90(%rbp), %rdi
callq 0x3440
jmp 0x8055
leaq -0x90(%rbp), %rdi
callq 0xb4d0
jmp 0x8063
leaq -0x90(%rbp), %rdi
callq 0x31e0
leaq -0x91(%rbp), %rdi
callq 0x3340
jmp 0x80b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x80a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x31e0
leaq -0x91(%rbp), %rdi
callq 0x3340
jmp 0x80bc
jmp 0x80b3
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3580
nopw %cs:(%rax,%rax)
// File: brandoncanaday[P]1730sh/1730sh.cpp
// Function: put_job_in_background(Input*, bool)
void put_job_in_background(Input * job, bool cont) {
  if(job != nullptr) {
    if(cont) {
      if(kill(-job->getJID(), SIGCONT) < 0) {
	nope_out("kill(SIGCONT)");  
      } // if
    } // if
  } // if
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8189
testb $0x1, -0x9(%rbp)
je 0x8187
movq -0x8(%rbp), %rdi
callq 0xb500
xorl %edi, %edi
subl %eax, %edi
movl $0x12, %esi
callq 0x3470
cmpl $0x0, %eax
jge 0x8185
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3590
movq -0x50(%rbp), %rdx
leaq 0xbfe6(%rip), %rsi      # 0x14113
leaq -0x30(%rbp), %rdi
callq 0x3440
jmp 0x8138
leaq -0x30(%rbp), %rdi
callq 0xb4d0
jmp 0x8143
leaq -0x30(%rbp), %rdi
callq 0x31e0
leaq -0x31(%rbp), %rdi
callq 0x3340
jmp 0x8185
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x817a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31e0
leaq -0x31(%rbp), %rdi
callq 0x3340
jmp 0x818f
jmp 0x8187
jmp 0x8189
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3580
nopl (%rax,%rax)
// File: brandoncanaday[P]1730sh/1730sh.cpp
// Function: mk_cstrvec(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
vector<char *> mk_cstrvec(vector<string> & strvec) {
  vector<char *> cstrvec;
  for (unsigned int i = 0, s = strvec.size(); i < s; i++) {
    cstrvec.push_back(new char [strvec.at(i).size() + 1]);
    strcpy(cstrvec.at(i), strvec.at(i).c_str());
  } // for
  cstrvec.push_back(nullptr);
  return cstrvec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xb7c0
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb7a0
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x8298
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0xb810
movq %rax, -0x58(%rbp)
jmp 0x81fa
movq -0x58(%rbp), %rdi
callq 0x3210
movq %rax, %rdi
incq %rdi
callq 0x3030
movq %rax, -0x60(%rbp)
jmp 0x8214
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0xb7e0
jmp 0x822b
movq -0x50(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0xb850
movq %rax, -0x68(%rbp)
jmp 0x823f
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0xb810
movq %rax, -0x70(%rbp)
jmp 0x825e
movq -0x70(%rbp), %rdi
callq 0x3130
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x32d0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x81da
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xb890
jmp 0x82cf
movq -0x50(%rbp), %rdi
movq $0x0, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0xb7e0
jmp 0x82af
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x82c2
movq -0x50(%rbp), %rdi
callq 0xb890
movq -0x48(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3580
nopl (%rax,%rax)
// File: brandoncanaday[P]1730sh/1730sh.cpp
// Function: delete_from_current_jobs(Input*)
void delete_from_current_jobs(Input * job) {
  if(job != nullptr) {
    for(unsigned int i = 0, s = current_jobs.size(); i < s; i++) {
      if(current_jobs[i] != nullptr) {
	if(job->getJID() == current_jobs[i]->getJID()) { 
	  delete job; 
	  current_jobs[i] = nullptr; 
	  break;
	} // if
      } // if
    } // for
  } // if
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8781
movl $0x0, -0xc(%rbp)
leaq 0x13c8b(%rip), %rdi     # 0x1c360
callq 0xb910
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x877f
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq 0x13c6b(%rip), %rdi     # 0x1c360
callq 0xb930
cmpq $0x0, (%rax)
je 0x876f
movq -0x8(%rbp), %rdi
callq 0xb500
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq 0x13c48(%rip), %rdi     # 0x1c360
callq 0xb930
movq (%rax), %rdi
callq 0xb500
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jne 0x876d
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8753
movq -0x20(%rbp), %rdi
callq 0xb3c0
movq -0x20(%rbp), %rdi
movl $0xe8, %esi
callq 0x3300
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq 0x13c01(%rip), %rdi     # 0x1c360
callq 0xb930
movq $0x0, (%rax)
jmp 0x877f
jmp 0x876f
jmp 0x8771
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x86dd
jmp 0x8781
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: brandoncanaday[P]1730sh/Input.cpp
// Function: Input::Input(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Input::Input(string input) {
  setShellInput(input); 
  set_foreground();
  setSTDIN();
  setSTDOUT();
  setSTDERR();
  this->processes = inputToProcesses();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
leaq 0x4315(%rip), %rax      # 0x14101
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3450
movq -0x70(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x98(%rbp)
callq 0x123b0
movq -0x70(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x90(%rbp)
callq 0x3450
movq -0x70(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x88(%rbp)
callq 0x3450
movq -0x70(%rbp), %rdi
addq $0x88, %rdi
movq %rdi, -0x80(%rbp)
callq 0x3450
movq -0x70(%rbp), %rdi
addq $0xa8, %rdi
movq %rdi, -0x78(%rbp)
callq 0x3450
movq -0x70(%rbp), %rdi
addq $0xc8, %rdi
movq %rdi, -0x68(%rbp)
callq 0x3450
movq -0x60(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3140
jmp 0xfe87
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xff80
jmp 0xfe96
leaq -0x30(%rbp), %rdi
callq 0x31e0
movq -0x70(%rbp), %rdi
callq 0x10030
jmp 0xfeaa
movq -0x70(%rbp), %rdi
callq 0x10080
jmp 0xfeb5
movq -0x70(%rbp), %rdi
callq 0x10380
jmp 0xfec0
movq -0x70(%rbp), %rdi
callq 0x10750
jmp 0xfecb
movq -0x70(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x10b30
jmp 0xfeda
movq -0x70(%rbp), %rdi
addq $0x30, %rdi
leaq -0x58(%rbp), %rsi
callq 0x123d0
leaq -0x58(%rbp), %rdi
callq 0xc090
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xff20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31e0
movq -0x68(%rbp), %rdi
callq 0x31e0
movq -0x78(%rbp), %rdi
callq 0x31e0
movq -0x80(%rbp), %rdi
callq 0x31e0
movq -0x88(%rbp), %rdi
callq 0x31e0
movq -0x90(%rbp), %rdi
callq 0x31e0
movq -0x98(%rbp), %rdi
callq 0xc090
movq -0xa0(%rbp), %rdi
callq 0x31e0
movq -0x38(%rbp), %rdi
callq 0x3580
nopw %cs:(%rax,%rax)
// File: brandoncanaday[P]1730sh/Input.cpp
// Function: Input::setShellInput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Input::setShellInput(string input) {
  const char * ws = " \t"; // chars to trim
  input = input.erase(input.find_last_not_of(ws) + 1); // trims end 
  input = input.erase(0, input.find_first_not_of(ws)); // trims beginning  
  this->shellInput = input;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x5b1e(%rip), %rax      # 0x15acc
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq $-0x1, %rdx
callq 0x35c0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
movq $-0x1, %rdx
callq 0x3090
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x3050
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3190
movq -0x20(%rbp), %rdi
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x3090
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x3050
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rdi
callq 0x3050
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: brandoncanaday[P]1730sh/Input.cpp
// Function: Input::setJID(int)
void Input::setJID(pid_t pgid) {
  this->JID = pgid;
  for(int i = 0, s = processes.size(); i < s; i++) {
    processes[i].PGID = pgid;
  } // for
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
movl $0x0, -0x10(%rbp)
addq $0x30, %rdi
callq 0xb460
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x11b8f
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
addq $0x30, %rdi
movslq -0x10(%rbp), %rsi
callq 0xb490
movl -0x24(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x11b5f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: brandoncanaday[P]1730sh/Input.cpp
// Function: Input::getNumPipes() const
const int Input::getNumPipes() const {
  int pipes = 0;
  for(unsigned int i = 0; i < processes.size(); i++) {
    if(processes[i].hasPipe) { // if not the last process in input
      pipes++;
    } // if
  } // for
  return pipes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movq %rax, -0x20(%rbp)
addq $0x30, %rdi
callq 0xb460
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x11c10
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x12400
testb $0x1, 0xa(%rax)
je 0x11c03
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x11c05
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x11bc2
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: brandoncanaday[P]1730sh/Input.cpp
// Function: Input::isStopped() const
const bool Input::isStopped() const {
  for(unsigned int i = 0, s = processes.size(); i < s; i++) {
    if(!processes[i].stopped && !processes[i].completed) {
      return false;
    } // if
  } // for
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
addq $0x30, %rdi
callq 0xb460
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x11cb2
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x12400
testb $0x1, 0x8(%rax)
jne 0x11ca5
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x12400
testb $0x1, 0x9(%rax)
jne 0x11ca5
movb $0x0, -0x1(%rbp)
jmp 0x11cb6
jmp 0x11ca7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11c67
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: brandoncanaday[P]1730sh/Input.cpp
// Function: Input::isCompleted() const
const bool Input::isCompleted() const {
  for(unsigned int i = 0, s = processes.size(); i < s; i++) {
    if(!processes[i].completed) {
      return false;
    } // if
  } // for
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
addq $0x30, %rdi
callq 0xb460
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x11d2a
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x12400
testb $0x1, 0x9(%rax)
jne 0x11d1d
movb $0x0, -0x1(%rbp)
jmp 0x11d2e
jmp 0x11d1f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11cf7
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: brandoncanaday[P]1730sh/Input.cpp
// Function: Input::operator=(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Input& Input::operator=(string input) {
  setShellInput(input); 
  set_foreground();
  setSTDIN();
  setSTDOUT();
  setSTDERR();
  this->processes = inputToProcesses();
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3140
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0xff80
jmp 0x11d74
leaq -0x30(%rbp), %rdi
callq 0x31e0
movq -0x68(%rbp), %rdi
callq 0x10030
movq -0x68(%rbp), %rdi
callq 0x10080
movq -0x68(%rbp), %rdi
callq 0x10380
movq -0x68(%rbp), %rdi
callq 0x10750
movq -0x68(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x10b30
movq -0x68(%rbp), %rdi
addq $0x30, %rdi
leaq -0x58(%rbp), %rsi
callq 0x123d0
leaq -0x58(%rbp), %rdi
callq 0xc090
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31e0
movq -0x38(%rbp), %rdi
callq 0x3580
// File: brandoncanaday[P]1730sh/Input.cpp
// Function: operator<<(std::ostream&, Input&)
ostream& operator<<(ostream& output, Input& rhs) { 
  output << "JID = " << rhs.getJID() << ", In foreground? " << rhs.isForeground() << endl;
  for(unsigned int i = 0, s = rhs.getProcesses().size(); i < s; i++) {
    output << "Process " << i << " (PID/PGID = " << rhs.getProcesses()[i].PID << "/" << rhs.getProcesses()[i].PGID << ") argv: ";
    for(unsigned int j = 0; j < rhs.getProcesses()[i].args.size(); j++) {
      output << rhs.getProcesses()[i].args[j] << " ";
    } // for
    if(i != s-1) { output << endl; } // if not last iter
  } // for
  return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3cc4(%rip), %rsi      # 0x15acf
callq 0x32e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb500
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x3570
movq %rax, %rdi
leaq 0x3ca4(%rip), %rsi      # 0x15ad6
callq 0x32e0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb510
movq -0x28(%rbp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x35b0
movq %rax, %rdi
movq 0xa14b(%rip), %rsi      # 0x1bfa8
callq 0x3330
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb440
movq %rax, %rdi
callq 0xb460
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x11fdd
movq -0x8(%rbp), %rdi
leaq 0x3c54(%rip), %rsi      # 0x15ae8
callq 0x32e0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x3410
movq %rax, %rdi
leaq 0x3c43(%rip), %rsi      # 0x15af1
callq 0x32e0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb440
movq %rax, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0xb490
movq -0x40(%rbp), %rdi
movl (%rax), %esi
callq 0x3570
movq %rax, %rdi
leaq 0x3a12(%rip), %rsi      # 0x158f4
callq 0x32e0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb440
movq %rax, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0xb490
movq -0x38(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x3570
movq %rax, %rdi
leaq 0x3be8(%rip), %rsi      # 0x15aff
callq 0x32e0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb440
movq %rax, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0xb490
movq %rax, %rdi
addq $0x10, %rdi
callq 0xb7a0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x11fb0
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb440
movq %rax, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0xb490
movq %rax, %rdi
addq $0x10, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0xb4b0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x32a0
movq %rax, %rdi
leaq 0x2785(%rip), %rsi      # 0x14722
callq 0x32e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11f23
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x11fcd
movq -0x8(%rbp), %rdi
movq 0x9fe0(%rip), %rsi      # 0x1bfa8
callq 0x3330
jmp 0x11fcf
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11e7d
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: brandoncanaday[P]1730sh/Input.cpp
// Function: trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string trim(string input) {
  string s = input;
  const char * ws = " \t"; // chars to trim
  s = s.erase(s.find_last_not_of(ws) + 1); // trims end 
  s = s.erase(0, s.find_first_not_of(ws)); // trims beginning  
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3140
movq -0x48(%rbp), %rdi
leaq 0x3aad(%rip), %rax      # 0x15acc
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq $-0x1, %rdx
movq %rdx, -0x40(%rbp)
callq 0x35c0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq %rax, %rsi
incq %rsi
callq 0x3090
movq %rax, -0x38(%rbp)
jmp 0x12050
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x3050
jmp 0x1205f
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x60(%rbp)
callq 0x3190
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0x3090
movq %rax, -0x58(%rbp)
jmp 0x1208a
movq -0x58(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x3050
jmp 0x12099
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x120c5
jmp 0x120bc
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x31e0
jmp 0x120cf
movq -0x48(%rbp), %rdi
callq 0x31e0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3580
nopl (%rax,%rax)
// File: brandoncanaday[P]1730sh/Input.cpp
// Function: sanitize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string sanitize(string input, string charsToRemove) {
  const string unwanted = charsToRemove ;
  std::string sanitized_str = "";
  for(char c : input) {
    if(unwanted.find(c) == string::npos) {
      sanitized_str += c;
    } // if
  } // for
  return sanitized_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x98(%rbp)
movq %rsi, %rax
movq -0x98(%rbp), %rsi
movq %rax, -0x90(%rbp)
movq %rdi, -0x80(%rbp)
movq %rdi, %rcx
movq %rcx, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3140
movb $0x0, -0x39(%rbp)
leaq -0x3a(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3590
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rdx
leaq 0x3988(%rip), %rsi      # 0x15ace
callq 0x3440
jmp 0x1214d
leaq -0x3a(%rbp), %rdi
callq 0x3340
movq -0x90(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x3280
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x31a0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x124d0
testb $0x1, %al
jne 0x1218e
jmp 0x12202
leaq -0x60(%rbp), %rdi
callq 0x12510
movb (%rax), %al
movb %al, -0x69(%rbp)
leaq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl -0x69(%rbp), %esi
callq 0x3400
cmpq $-0x1, %rax
jne 0x121f2
movq -0x80(%rbp), %rdi
movsbl -0x69(%rbp), %esi
callq 0x31f0
jmp 0x121c2
jmp 0x121f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x3a(%rbp), %rdi
callq 0x3340
jmp 0x1222e
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x31e0
jmp 0x1222e
jmp 0x121f4
leaq -0x60(%rbp), %rdi
callq 0x12530
jmp 0x1217b
movb $0x1, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x12215
movq -0x80(%rbp), %rdi
callq 0x31e0
leaq -0x38(%rbp), %rdi
callq 0x31e0
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x31e0
movq -0x48(%rbp), %rdi
callq 0x3580
// File: brandoncanaday[P]1730sh/Input.cpp
// Function: hasQuotes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool hasQuotes(string input) {
  for(unsigned int i = 0; i < input.length(); i++) {
    if(i == 0) {
      if(input[i] == '"') return true;
    } else {
      if(input[i] == '"' && input[i-1] != '\\') return true;
    } // if/else
  } // for
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x34d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x122e0
cmpl $0x0, -0x14(%rbp)
jne 0x12297
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3610
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x12295
movb $0x1, -0x1(%rbp)
jmp 0x122e4
jmp 0x122d0
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3610
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x122ce
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x3610
movsbl (%rax), %eax
cmpl $0x5c, %eax
je 0x122ce
movb $0x1, -0x1(%rbp)
jmp 0x122e4
jmp 0x122d0
jmp 0x122d2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12257
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: brandoncanaday[P]1730sh/Input.cpp
// Function: pos_of_first_quote(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
unsigned int pos_of_first_quote(string input) {
  int pos = 0;
  for(unsigned int i = 0; i < input.length(); i++) {
    if(i == 0) {
      if(input[i] == '"') {
	pos = i; 
	break;
      } // if
    } else {
      if(input[i] == '"' && input[i-1] != '\\') {
	pos = i;
	break;
      } // if
    } // if/else
  } // for
  return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movq %rax, -0x20(%rbp)
callq 0x34d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x1239b
cmpl $0x0, -0x10(%rbp)
jne 0x12350
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x3610
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x1234e
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x1239b
jmp 0x1238b
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x3610
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x12389
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x3610
movsbl (%rax), %eax
cmpl $0x5c, %eax
je 0x12389
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x1239b
jmp 0x1238b
jmp 0x1238d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1230e
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: luisremis[P]SDFS/main.cpp
// Function: main
int main (int argc, char* argv[])
{
    srand (time(NULL));

    system("rm files/*");
    system("clear");

    std::cout << std::endl << "CS425 - MP3: Distributed File System" ;
    std::cout << std::endl << std::endl;

    logFile.open("log.log");
    logFile << "Inicializing! " << std::endl;

    int port = atoi(argv[1]);
    bool isIntroducer = atoi(argv[2]);

    Membership m(isIntroducer, port);
    FileSystem fs (port + 21, m);

    std::thread cinListening(listeningCin, &m, &fs);
    cinListening.join();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x720, %rsp            # imm = 0x720
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x43a0
movl %eax, %edi
callq 0x43d0
leaq 0x16d4d(%rip), %rdi     # 0x1c2dd
callq 0x4350
leaq 0x16ca5(%rip), %rdi     # 0x1c241
callq 0x4350
movq 0x21a18(%rip), %rdi     # 0x26fc0
movq %rdi, -0x720(%rbp)
movq 0x219f2(%rip), %rsi     # 0x26fa8
movq %rsi, -0x710(%rbp)
callq 0x4410
movq %rax, %rdi
leaq 0x16d1c(%rip), %rsi     # 0x1c2e8
callq 0x43f0
movq -0x720(%rbp), %rdi
movq -0x710(%rbp), %rsi
callq 0x4410
movq -0x710(%rbp), %rsi
movq %rax, %rdi
callq 0x4410
leaq 0x21dde(%rip), %rdi     # 0x273d8
movq %rdi, -0x718(%rbp)
leaq 0x16d05(%rip), %rsi     # 0x1c30d
movl $0x10, %edx
callq 0x4070
movq -0x718(%rbp), %rdi
leaq 0x16cf5(%rip), %rsi     # 0x1c315
callq 0x43f0
movq -0x710(%rbp), %rsi
movq %rax, %rdi
callq 0x4410
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x45c0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x45c0
testl %eax, %eax
setne -0x15(%rbp)
movl -0x14(%rbp), %edx
movzbl -0x15(%rbp), %esi
andl $0x1, %esi
leaq -0x3e0(%rbp), %rdi
movq %rdi, -0x708(%rbp)
callq 0x6100
movq -0x708(%rbp), %rdx
movl -0x14(%rbp), %esi
addl $0x15, %esi
leaq -0x6d8(%rbp), %rdi
callq 0x10630
jmp 0x568f
leaq -0x3e0(%rbp), %rax
movq %rax, -0x6f8(%rbp)
leaq -0x6d8(%rbp), %rax
movq %rax, -0x700(%rbp)
leaq -0xca2(%rip), %rsi      # 0x4a10
leaq -0x6f0(%rbp), %rdi
leaq -0x6f8(%rbp), %rdx
leaq -0x700(%rbp), %rcx
callq 0x5780
jmp 0x56ce
leaq -0x6f0(%rbp), %rdi
callq 0x4650
jmp 0x56dc
movl $0x0, -0x4(%rbp)
leaq -0x6f0(%rbp), %rdi
callq 0x5840
leaq -0x6d8(%rbp), %rdi
callq 0x10f90
leaq -0x3e0(%rbp), %rdi
callq 0x8080
movl -0x4(%rbp), %eax
addq $0x720, %rsp            # imm = 0x720
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x6e0(%rbp)
movl %eax, -0x6e4(%rbp)
jmp 0x5765
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x6e0(%rbp)
movl %eax, -0x6e4(%rbp)
jmp 0x5759
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x6e0(%rbp)
movl %eax, -0x6e4(%rbp)
leaq -0x6f0(%rbp), %rdi
callq 0x5840
leaq -0x6d8(%rbp), %rdi
callq 0x10f90
leaq -0x3e0(%rbp), %rdi
callq 0x8080
movq -0x6e0(%rbp), %rdi
callq 0x46a0
nopl (%rax)
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::join()
void Membership::join()
{
	bool joined = firstJoin();
    while( !isIntroducer && !joined)
    {   //introducer will firstJoin() once. Other node will keep firstJoin() until it enter the group.
        joined = firstJoin();
        //usleep( 1000*1000 );
    }


    MemberUpdateMsg msg( MSG_JOIN_FINISH , members[0]);
    pushMsgToFileSysQueue(msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x8250
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0xc0(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x2cc(%rcx)
movb %al, -0xc1(%rbp)
jne 0x6a57
movb -0x9(%rbp), %al
xorb $-0x1, %al
movb %al, -0xc1(%rbp)
movb -0xc1(%rbp), %al
testb $0x1, %al
jne 0x6a63
jmp 0x6a76
movq -0xc0(%rbp), %rdi
callq 0x8250
andb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x6a34
movq -0xc0(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
xorl %eax, %eax
movl %eax, %esi
callq 0xb8d0
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xb8f0
movq -0xd0(%rbp), %rdx
leaq -0x48(%rbp), %rdi
movl $0x8, %esi
callq 0xb160
jmp 0x6ab7
leaq -0x70(%rbp), %rdi
callq 0xb7f0
leaq -0xb8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xb1d0
jmp 0x6ad2
movq -0xc0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x8840
jmp 0x6ae7
leaq -0xb8(%rbp), %rdi
callq 0xb930
leaq -0x48(%rbp), %rdi
callq 0xb930
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xb7f0
jmp 0x6b4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x6b42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0xb930
leaq -0x48(%rbp), %rdi
callq 0xb930
movq -0x78(%rbp), %rdi
callq 0x46a0
nopw %cs:(%rax,%rax)
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::~Membership()
Membership::~Membership()
{
	//Kill threads
	killListeningThread = true;
	killDetectingThread = true;

	listening.join();
	detecting.join();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movb $0x1, 0x350(%rdi)
movb $0x1, 0x351(%rdi)
addq $0x338, %rdi            # imm = 0x338
callq 0x4650
jmp 0x80b0
movq -0x20(%rbp), %rdi
addq $0x340, %rdi            # imm = 0x340
callq 0x4650
jmp 0x80c2
movq -0x20(%rbp), %rdi
addq $0x398, %rdi            # imm = 0x398
callq 0x46e0
movq -0x20(%rbp), %rdi
addq $0x358, %rdi            # imm = 0x358
callq 0xb730
movq -0x20(%rbp), %rdi
addq $0x348, %rdi            # imm = 0x348
callq 0x5840
movq -0x20(%rbp), %rdi
addq $0x340, %rdi            # imm = 0x340
callq 0x5840
movq -0x20(%rbp), %rdi
addq $0x338, %rdi            # imm = 0x338
callq 0x5840
movq -0x20(%rbp), %rdi
addq $0x2f8, %rdi            # imm = 0x2F8
callq 0xb790
movq -0x20(%rbp), %rdi
addq $0x2d8, %rdi            # imm = 0x2D8
callq 0x42a0
movq -0x20(%rbp), %rdi
addq $0x270, %rdi            # imm = 0x270
callq 0xb7f0
movq -0x20(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
callq 0xb810
movq -0x20(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
callq 0xb810
movq -0x20(%rbp), %rdi
addq $0x200, %rdi            # imm = 0x200
callq 0xb870
movq -0x20(%rbp), %rdi
callq 0x4768
addq $0x20, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
addq $0x398, %rdi            # imm = 0x398
callq 0x46e0
movq -0x20(%rbp), %rdi
addq $0x358, %rdi            # imm = 0x358
callq 0xb730
movq -0x20(%rbp), %rdi
addq $0x348, %rdi            # imm = 0x348
callq 0x5840
movq -0x20(%rbp), %rdi
addq $0x340, %rdi            # imm = 0x340
callq 0x5840
movq -0x20(%rbp), %rdi
addq $0x338, %rdi            # imm = 0x338
callq 0x5840
movq -0x20(%rbp), %rdi
addq $0x2f8, %rdi            # imm = 0x2F8
callq 0xb790
movq -0x20(%rbp), %rdi
addq $0x2d8, %rdi            # imm = 0x2D8
callq 0x42a0
movq -0x20(%rbp), %rdi
addq $0x270, %rdi            # imm = 0x270
callq 0xb7f0
movq -0x20(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
callq 0xb810
movq -0x20(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
callq 0xb810
movq -0x20(%rbp), %rdi
addq $0x200, %rdi            # imm = 0x200
callq 0xb870
movq -0x20(%rbp), %rdi
callq 0x4768
movq -0x10(%rbp), %rdi
callq 0x44a0
nop
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::pushMsgToFileSysQueue(MemberUpdateMsg)
void Membership::pushMsgToFileSysQueue(MemberUpdateMsg msg){
    std::unique_lock<std::mutex> locker( fileSysMsgQueueLock );

    this->fileSysMsgQueue.push_back(msg);

    this->fileSysMsgQueueCV.notify_all();
    usleep(5000);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x40(%rbp)
addq $0x370, %rsi            # imm = 0x370
leaq -0x20(%rbp), %rdi
callq 0xbf30
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x358, %rdi            # imm = 0x358
callq 0xbf70
jmp 0x8882
movq -0x40(%rbp), %rdi
addq $0x398, %rdi            # imm = 0x398
callq 0x4640
movl $0x1388, %edi           # imm = 0x1388
callq 0x4540
jmp 0x889e
leaq -0x20(%rbp), %rdi
callq 0xbfe0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xbfe0
movq -0x28(%rbp), %rdi
callq 0x46a0
nopl (%rax,%rax)
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::leave()
void Membership::leave()
{
    membersLock.lock();
    Message msg;
    msg.type = MSG_LEAVE;
    msg.TTL = 1; // Just in case
    ipString2Char4(members.at(0).ip_str, msg.carrierAdd);
    msg.timeStamp = members.at(0).timeStamp;
    membersLock.unlock();
    spreadMessage(msg); // this method wants the lock!
    
    while(members.size()!=0){
        failMember(members[0].ip_str, members[0].timeStamp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x230, %rdi            # imm = 0x230
callq 0xb5f0
movq -0x90(%rbp), %rdi
movl $0x7, -0x1c(%rbp)
movb $0x1, -0xc(%rbp)
addq $0x258, %rdi            # imm = 0x258
xorl %eax, %eax
movl %eax, %esi
callq 0xb950
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x41e0
movq -0x88(%rbp), %rdi
leaq -0x17(%rbp), %rsi
callq 0x1a2b0
jmp 0x893d
leaq -0x40(%rbp), %rdi
callq 0x42a0
movq -0x90(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
xorl %eax, %eax
movl %eax, %esi
callq 0xb950
movq -0x90(%rbp), %rdi
movl 0x20(%rax), %eax
movl %eax, -0x10(%rbp)
addq $0x230, %rdi            # imm = 0x230
callq 0xb620
movq -0x90(%rbp), %rdi
movq -0x1c(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x14(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x50(%rbp)
leaq -0x60(%rbp), %rax
xorl %esi, %esi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x10(%rsp)
callq 0x8a90
movq -0x90(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
callq 0xb990
cmpq $0x0, %rax
je 0x8a71
movq -0x90(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
movq %rdi, -0xa8(%rbp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0xa0(%rbp)
callq 0xb8d0
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x41e0
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0xb8d0
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
movl 0x20(%rax), %edx
callq 0x8f40
jmp 0x8a35
leaq -0x80(%rbp), %rdi
callq 0x42a0
jmp 0x89b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x42a0
jmp 0x8a7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x42a0
jmp 0x8a7a
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x46a0
nopw %cs:(%rax,%rax)
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::broadcastJoin(Message, int)
int Membership::broadcastJoin(Message income, int i)
{
	income.TTL = 0;
	int connectionToServer;
    //TCP connect to members of introducer
    logFile<<"broadcastJoin: Introducer trying to broadcast join to "<<members[i].ip_str << std::endl;
    int ret = connect_to_server(members[i].ip_str.c_str(), port + 1, &connectionToServer);
    if(ret!=0){
        logFile<<"broadcastJoin: cannot connect to "<<members[i].ip_str << std::endl;
        return 1;
    }
    else{
    	ret = write(connectionToServer, &income, sizeof(Message) );
    	close(connectionToServer);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movb $0x0, 0x10(%rax)
leaq 0x12d1c(%rip), %rsi     # 0x1c4d6
callq 0x43f0
movq -0x28(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x258, %rdi            # imm = 0x258
movslq -0x14(%rbp), %rsi
callq 0xb8d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x4370
movq %rax, %rdi
movq 0x1d7bb(%rip), %rsi     # 0x26fa8
callq 0x4410
movq -0x28(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
movslq -0x14(%rbp), %rsi
callq 0xb8d0
movq %rax, %rdi
callq 0x41d0
movq %rax, %rdi
movq -0x28(%rbp), %rax
movl 0x298(%rax), %esi
addl $0x1, %esi
leaq -0x18(%rbp), %rdx
callq 0x1aaf0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x987c
movq -0x28(%rbp), %rdi
leaq 0x12cd2(%rip), %rsi     # 0x1c50d
callq 0x43f0
movq -0x28(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x258, %rdi            # imm = 0x258
movslq -0x14(%rbp), %rsi
callq 0xb8d0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x4370
movq %rax, %rdi
movq 0x1d73a(%rip), %rsi     # 0x26fa8
callq 0x4410
movl $0x1, -0x4(%rbp)
jmp 0x989f
movq -0x38(%rbp), %rsi
movl -0x18(%rbp), %edi
movl $0x14, %edx
callq 0x4190
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %edi
callq 0x4740
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::piggyMsg(Message, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Membership::piggyMsg( Message msg, std::string sender )
{
    std::string target = char42String(msg.carrierAdd);
    msg.type = MSG_PIGGY_PING;

    ipString2Char4(sender, msg.carrierAdd); //Original Sender as carrier

    sendUDP( sockfd,  target, port, (char*)&msg, sizeof(Message) );
    logFile << "Weired!: " << sender << " says that " << target << " did not responde..." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, %rax
movq %rax, -0x68(%rbp)
leaq 0x10(%rbp), %rsi
movq %rsi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x5, %rsi
leaq -0x30(%rbp), %rdi
callq 0x1a480
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rsi
movl $0x3, (%rax)
leaq -0x50(%rbp), %rdi
callq 0x41e0
jmp 0x99c0
movq -0x70(%rbp), %rsi
addq $0x5, %rsi
leaq -0x50(%rbp), %rdi
callq 0x1a2b0
jmp 0x99d3
leaq -0x50(%rbp), %rdi
callq 0x42a0
movq -0x78(%rbp), %rax
movq -0x70(%rbp), %rcx
movl 0x298(%rax), %edx
movl 0x29c(%rax), %edi
leaq -0x30(%rbp), %rsi
movl $0x14, %r8d
callq 0x1a870
jmp 0x9a01
movq -0x78(%rbp), %rdi
leaq 0x12d85(%rip), %rsi     # 0x1c791
callq 0x43f0
movq %rax, -0x80(%rbp)
jmp 0x9a17
movq -0x68(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0x4370
movq %rax, -0x88(%rbp)
jmp 0x9a2d
movq -0x88(%rbp), %rdi
leaq 0x12d60(%rip), %rsi     # 0x1c79b
callq 0x43f0
movq %rax, -0x90(%rbp)
jmp 0x9a49
movq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4370
movq %rax, -0x98(%rbp)
jmp 0x9a62
movq -0x98(%rbp), %rdi
leaq 0x12d37(%rip), %rsi     # 0x1c7a7
callq 0x43f0
movq %rax, -0xa0(%rbp)
jmp 0x9a7e
movq -0xa0(%rbp), %rdi
movq 0x1d51c(%rip), %rsi     # 0x26fa8
callq 0x4410
jmp 0x9a93
leaq -0x30(%rbp), %rdi
callq 0x42a0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x9ac8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x42a0
leaq -0x30(%rbp), %rdi
callq 0x42a0
movq -0x58(%rbp), %rdi
callq 0x46a0
nopw (%rax,%rax)