LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tylerkaraszewski[P]Argyle/Logger.cpp
// Function: Logger::close()
void Logger::close()
{
  if (m_accessFile != NULL)
  {
    fclose(m_accessFile);
    m_accessFile = NULL;
  }
  if (m_errorFile != NULL)
  {
    fclose(m_errorFile);
    m_errorFile = NULL;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rax)
je 0x10cd5
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x43a0
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x10cfc
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x43a0
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tylerkaraszewski[P]Argyle/Logger.cpp
// Function: Logger::log(_IO_FILE*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Logger::log(FILE* file, const string& msg)
{
  if (file != NULL)
  {
    string logline = Utils::llToString(time(NULL)) + "\t" + msg + "\n";
    size_t bytesWritten = fwrite(logline.c_str(), 1, logline.size(), file);
    if (bytesWritten != logline.size())
    {
      // This wont actually go anywhere.
      printf("Log writing error %d (%s).\n", errno, strerror(errno));
    }
    else
    {
      fflush(file); // Can take this out for performance reasons if required.
    }
  }
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
cmpq $0x0, 0xd8(%rsp)
je 0x10f2c
xorl %eax, %eax
movl %eax, %edi
callq 0x4380
movq %rax, %rsi
leaq 0x50(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x10f70
movq 0x30(%rsp), %rsi
leaq 0x23aa(%rip), %rdx      # 0x1313f
leaq 0x70(%rsp), %rdi
callq 0x61e0
jmp 0x10da1
movq 0xd0(%rsp), %rdx
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x9760
jmp 0x10dbd
leaq 0x2453(%rip), %rdx      # 0x13217
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x61e0
jmp 0x10ddb
leaq 0x90(%rsp), %rdi
callq 0x4788
leaq 0x70(%rsp), %rdi
callq 0x4788
leaq 0x50(%rsp), %rdi
callq 0x4788
leaq 0xb0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x4190
movq 0x18(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x42a0
movq 0x20(%rsp), %rdi
movq %rax, %rdx
movq 0xd8(%rsp), %rcx
movl $0x1, %esi
callq 0x4730
movq %rax, 0x28(%rsp)
jmp 0x10e3e
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x42a0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x10f0e
callq 0x4060
movl (%rax), %eax
movl %eax, 0xc(%rsp)
callq 0x4060
movl (%rax), %edi
callq 0x4150
movl 0xc(%rsp), %esi
movq %rax, %rdx
leaq 0x2c9f(%rip), %rdi      # 0x13b34
xorl %eax, %eax
callq 0x4070
jmp 0x10e9e
jmp 0x10f1f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x10ee5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x10edb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x4788
leaq 0x70(%rsp), %rdi
callq 0x4788
leaq 0x50(%rsp), %rdi
callq 0x4788
jmp 0x10f34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x4788
jmp 0x10f34
movq 0xd8(%rsp), %rdi
callq 0x4470
jmp 0x10f1d
jmp 0x10f1f
leaq 0xb0(%rsp), %rdi
callq 0x4788
addq $0xe8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x46b0
nop
// File: tylerkaraszewski[P]Argyle/Utils.cpp
// Function: Utils::llToString[abi:cxx11](long long)
string Utils::llToString(long long i)
{
  string s;
  char str[32] = {0};
  size_t strLen = snprintf(str, 31, "%lli", i);
  s.append(str, strLen);
  return s;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movb $0x0, 0x57(%rsp)
callq 0x4570
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq 0x58(%rsp), %rcx
leaq 0x2ba3(%rip), %rdx      # 0x13b50
xorl %eax, %eax
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x1f, %esi
callq 0x4620
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
cltq
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdx
callq 0x40a0
jmp 0x10fe0
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x11012
jmp 0x11008
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x4788
jmp 0x1101b
movq 0x8(%rsp), %rdi
callq 0x4788
movq (%rsp), %rax
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
// File: tylerkaraszewski[P]Argyle/Utils.cpp
// Function: Utils::parseHttpDate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
time_t Utils::parseHttpDate(const string& dateStr)
{
  // strptime onmy ubuntu box ignores the timezone parameter at the end of the format string.
  // This isn't the case on OS X, so we keep it for that platform.
  #ifdef __linux__
    #define REQ_INPUT_LEN 26
  #else
    #define REQ_INPUT_LEN 29
  #endif

  struct tm date;
  const char* in = dateStr.c_str();
  char* parsed = strptime(in, "%a, %d %b %Y %T %Z", &date);
  if (parsed != (in + REQ_INPUT_LEN))
  {
    return 0;
  }
  return timegm(&date);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4190
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x28da(%rip), %rsi      # 0x13b5e
leaq 0x10(%rsp), %rdx
callq 0x4090
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
addq $0x1a, %rcx
cmpq %rcx, %rax
je 0x112af
movq $0x0, 0x50(%rsp)
jmp 0x112be
leaq 0x10(%rsp), %rdi
callq 0x4680
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: tylerkaraszewski[P]Argyle/Utils.cpp
// Function: Utils::getHttpDate[abi:cxx11](long)
string Utils::getHttpDate(time_t secondsSinceEpoch)
{
  char buffer[30] = {0};
  struct tm* date = gmtime(&secondsSinceEpoch);
  strftime(buffer, 30,  "%a, %d %b %Y %T %Z", date);
  return buffer;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x4e(%rsp)
movaps %xmm0, 0x40(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x4340
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rcx
leaq 0x284c(%rip), %rdx      # 0x13b5e
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x1e, %esi
callq 0x4300
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x46c0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x6450
jmp 0x1134b
leaq 0x37(%rsp), %rdi
callq 0x4400
movq (%rsp), %rax
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x4400
movq 0x28(%rsp), %rdi
callq 0x46b0
// File: tylerkaraszewski[P]Argyle/Config.cpp
// Function: Config::getString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
string Config::getString(const string& key) const
{
  std::multimap<std::string, std::string>::const_iterator it = m_configValues.find(key);
  if (it == m_configValues.end())
  {
    return "";
  }
  return it->second;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x20, %rdi
movq 0x50(%rsp), %rsi
callq 0xba10
movq 0x20(%rsp), %rdi
movq %rax, 0x48(%rsp)
addq $0x20, %rdi
callq 0xba60
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xba40
testb $0x1, %al
jne 0x11cc5
jmp 0x11d12
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x46c0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x145b(%rip), %rsi      # 0x13140
callq 0x6450
jmp 0x11cec
leaq 0x3f(%rsp), %rdi
callq 0x4400
jmp 0x11d2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x4400
jmp 0x11d37
leaq 0x48(%rsp), %rdi
callq 0xb910
movq 0x10(%rsp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x41b0
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: PrzemekWirkus[P]functional-workshop/src/testconf.cpp
// Function: 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>>>> AddressBook::findMatchingAddresses<findAddressesFromOrgs[abi:cxx11]()::$_0>(findAddressesFromOrgs[abi:cxx11]()::$_0)
vector<string> findMatchingAddresses (Func func)
    {
        vector<string> results;
        for ( auto itr = _addresses.begin(), end = _addresses.end(); itr != end; ++itr )
        {
            // call the function passed into findMatchingAddresses and see if it matches
            if ( func( *itr ) )
            {
                results.push_back( *itr );
            }
        }
        return results;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x1a40
movq -0x48(%rbp), %rdi
callq 0x1980
movq -0x48(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x19b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2610
testb $0x1, %al
jne 0x1489
jmp 0x14e9
leaq -0x28(%rbp), %rdi
callq 0x2650
movq %rax, %rsi
leaq -0x9(%rbp), %rdi
callq 0x18d0
movb %al, -0x59(%rbp)
jmp 0x14a3
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x14ac
jmp 0x14dc
leaq -0x28(%rbp), %rdi
callq 0x2650
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x1b10
jmp 0x14c3
jmp 0x14dc
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x19e0
jmp 0x1506
jmp 0x14de
leaq -0x28(%rbp), %rdi
callq 0x2670
jmp 0x1476
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x14fc
movq -0x58(%rbp), %rdi
callq 0x19e0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1170
nop
// File: girdhari9[P]TEXPLORER/projectfile.cpp
// Function: main
int main(){
	getcwd(root_path,1000);
	home_path = (string)root_path;
	screen_point(0,0,1);
	list_print(home_path,1,0);
	pointer_move();
	return 0;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x14757(%rip), %rdi     # 0x18330
movq %rdi, -0x70(%rbp)
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x3180
leaq -0x29(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3540
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x3cd0
jmp 0x3c07
leaq 0x14b0a(%rip), %rdi     # 0x18718
movq %rdi, -0x88(%rbp)
leaq -0x28(%rbp), %rsi
movq %rsi, -0x90(%rbp)
callq 0x33e0
movq -0x90(%rbp), %rdi
callq 0x35c8
leaq -0x29(%rbp), %rdi
callq 0x3350
xorl %esi, %esi
movl %esi, -0x74(%rbp)
movl $0x1, %edx
movl %edx, -0x78(%rbp)
movl %esi, %edi
callq 0x4020
movq -0x88(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3130
movq -0x80(%rbp), %rdi
movl -0x78(%rbp), %esi
movl -0x74(%rbp), %edx
callq 0x4360
jmp 0x3c73
leaq -0x60(%rbp), %rdi
callq 0x35c8
callq 0x6bc0
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x3350
jmp 0x3cb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x35c8
movq -0x38(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: girdhari9[P]TEXPLORER/screen_point.cpp
// Function: clear_scr(int)
void clear_scr(int start){
	gotoxy(start,1);
	for(int i=start;i<=vertical;i++){
		for(int i=1;i<=horizontal;i++){
			cout<<" ";
		}
	}
	gotoxy(start,1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x13d5e(%rip), %rdi     # 0x17fd0
leaq 0xcdb5(%rip), %rsi      # 0x1102e
callq 0x32d0
movq %rax, %rdi
movl -0x4(%rbp), %esi
callq 0x3520
movq %rax, %rdi
leaq 0xcd9e(%rip), %rsi      # 0x11031
callq 0x32d0
movq %rax, %rdi
movl $0x1, %esi
callq 0x3520
movq %rax, %rdi
leaq 0xcd84(%rip), %rsi      # 0x11033
callq 0x32d0
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x14481(%rip), %eax     # 0x18744
jg 0x4302
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x1446b(%rip), %eax     # 0x18740
jg 0x42f5
movq 0x13cf2(%rip), %rdi     # 0x17fd0
leaq 0xd139(%rip), %rsi      # 0x1141e
callq 0x32d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x42cc
jmp 0x42f7
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x42ba
movq 0x13cc7(%rip), %rdi     # 0x17fd0
leaq 0xcd1e(%rip), %rsi      # 0x1102e
callq 0x32d0
movq %rax, %rdi
movl -0x4(%rbp), %esi
callq 0x3520
movq %rax, %rdi
leaq 0xcd07(%rip), %rsi      # 0x11031
callq 0x32d0
movq %rax, %rdi
movl $0x1, %esi
callq 0x3520
movq %rax, %rdi
leaq 0xcced(%rip), %rsi      # 0x11033
callq 0x32d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: girdhari9[P]TEXPLORER/list_print.cpp
// Function: trim_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
string trim_name(string name,int size,int flag){
	string t;
	for(int i=0;i<size;i++){
		t += name[i];
	}
	if(flag)	
		t += "...";
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x3460
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5216
movq -0x48(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x35b0
movq %rax, -0x50(%rbp)
jmp 0x51e0
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rax
movsbl (%rax), %esi
callq 0x31e0
jmp 0x51f2
jmp 0x51f4
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x51c5
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x35c8
jmp 0x524d
cmpl $0x0, -0x18(%rbp)
je 0x5230
movq -0x40(%rbp), %rdi
leaq 0xbe48(%rip), %rsi      # 0x1106f
callq 0x32c0
jmp 0x522e
jmp 0x5230
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x5243
movq -0x40(%rbp), %rdi
callq 0x35c8
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: girdhari9[P]TEXPLORER/pointer_move.cpp
// Function: init_setting()
void init_setting(){
    tcgetattr(0, &initialrsettings);
    newrsettings = initialrsettings;
    newrsettings.c_lflag &= ~ECHO;
    newrsettings.c_lflag &= ~ICANON;
    // newrsettings.c_lflag &= ~ISIG;
    tcsetattr(0, TCSANOW, &newrsettings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
leaq 0x11523(%rip), %rsi     # 0x18830
callq 0x3380
leaq 0x11553(%rip), %rdi     # 0x1886c
leaq 0x11510(%rip), %rsi     # 0x18830
movl $0x3c, %edx
callq 0x3260
movl 0x11548(%rip), %eax     # 0x18878
andl $-0x9, %eax
movl %eax, 0x1153f(%rip)     # 0x18878
movl 0x11539(%rip), %eax     # 0x18878
andl $-0x3, %eax
movl %eax, 0x11530(%rip)     # 0x18878
xorl %esi, %esi
leaq 0x1151b(%rip), %rdx     # 0x1886c
movl %esi, %edi
callq 0x3430
popq %rbp
retq
nopw (%rax,%rax)
// File: girdhari9[P]TEXPLORER/pointer_move.cpp
// Function: my_handler(int)
void my_handler(int s){
    map<string,string>::iterator it;
    clear_scr(1);
    re_init_setting();
    for(it = trace_map.begin();it != trace_map.end(); it++){
        string file_path = home_path + "/Trash/" + it->first;
        unlink(file_path.c_str());
    }
    trace_map.erase(trace_map.begin(),trace_map.end());
    exit(0); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x4(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7580
movl $0x1, %edi
callq 0x4260
callq 0x74d0
leaq 0x11583(%rip), %rdi     # 0x18910
callq 0x75a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x1156b(%rip), %rdi     # 0x18910
callq 0x7600
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x75d0
testb $0x1, %al
jne 0x73c4
jmp 0x744e
leaq 0x1134d(%rip), %rsi     # 0x18718
leaq 0x9d09(%rip), %rdx      # 0x110db
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x5490
leaq -0x10(%rbp), %rdi
callq 0x7630
movq -0xa8(%rbp), %rsi
movq %rax, %rdx
leaq -0x40(%rbp), %rdi
callq 0x5370
jmp 0x7400
leaq -0x60(%rbp), %rdi
callq 0x35c8
leaq -0x40(%rbp), %rdi
callq 0x3110
movq %rax, %rdi
callq 0x3170
leaq -0x40(%rbp), %rdi
callq 0x35c8
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x7660
movq %rax, -0x78(%rbp)
jmp 0x739e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x35c8
jmp 0x74bc
leaq 0x114bb(%rip), %rdi     # 0x18910
callq 0x75a0
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x76f0
leaq 0x11498(%rip), %rdi     # 0x18910
callq 0x7600
movq %rax, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x76f0
movq -0x80(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq 0x11467(%rip), %rdi     # 0x18910
callq 0x76a0
movq %rax, -0xa0(%rbp)
xorl %edi, %edi
callq 0x33d0
movq -0x68(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: girdhari9[P]TEXPLORER/cmd_functions.cpp
// Function: copy_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void copy_file(string file_name, string dir_name){
    int source_file, dest_file, read_size;
    char buffer[1024];
    source_file = open(file_name.c_str(), O_RDONLY);
    dest_file = open(dir_name.c_str(), O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR);
    while((read_size = read(source_file,buffer,sizeof(buffer))) > 0)
        write(dest_file,buffer,read_size);
    return; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rsi, -0x428(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x3110
movq %rax, %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x3230
movq -0x428(%rbp), %rdi
movl %eax, -0x14(%rbp)
callq 0x3110
movq %rax, %rdi
movl $0x41, %esi
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x3230
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %edi
leaq -0x420(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x34a0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jle 0x7fd2
movl -0x18(%rbp), %edi
leaq -0x420(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x30d0
jmp 0x7fa1
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopl (%rax,%rax)
// File: girdhari9[P]TEXPLORER/cmd_functions.cpp
// Function: rename_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void rename_file(string file_old_name, string file_new_name){
    int source_file, dest_file, read_size;
    char buffer[1024];
    source_file = open(file_old_name.c_str(), O_RDONLY);
    dest_file = open(file_new_name.c_str(), O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR);
    while((read_size = read(source_file,buffer,sizeof(buffer))) > 0)
        write(dest_file,buffer,read_size);
    remove(file_old_name.c_str());
    return; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x430(%rbp)
movq %rsi, -0x428(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x3110
movq %rax, %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x3230
movq -0x428(%rbp), %rdi
movl %eax, -0x14(%rbp)
callq 0x3110
movq %rax, %rdi
movl $0x41, %esi
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x3230
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %edi
leaq -0x420(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x34a0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jle 0x8539
movl -0x18(%rbp), %edi
leaq -0x420(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x30d0
jmp 0x8508
movq -0x430(%rbp), %rdi
callq 0x3110
movq %rax, %rdi
callq 0x3560
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: girdhari9[P]TEXPLORER/cmd_functions.cpp
// Function: delete_dir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void delete_dir(string dir_path){
    flag++;
    if(flag > 100) return;
    struct dirent ** dir_namelist;
    int n = scandir(dir_path.c_str(),&dir_namelist,NULL, alphasort);
    while(n--){
        if(n < 2) break;
        if(dir_namelist[n]->d_type == 4){
            string new_dir_path = dir_path + "/" + dir_namelist[n]->d_name;
            // rmdir(new_dir_path.c_str()); //If it will not work then open it
            delete_dir(new_dir_path);
            rmdir(new_dir_path.c_str());
        }
        else{
            string file_name = dir_path + "/" + dir_namelist[n]->d_name;
            remove(file_name.c_str());
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movl 0x10338(%rip), %eax     # 0x188b4
addl $0x1, %eax
movl %eax, 0x1032f(%rip)     # 0x188b4
cmpl $0x64, 0x10328(%rip)    # 0x188b4
jle 0x8593
jmp 0x8766
movq -0xd0(%rbp), %rdi
callq 0x3110
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movq 0xfa17(%rip), %rcx      # 0x17fc8
callq 0x3060
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0x8766
cmpl $0x2, -0x14(%rbp)
jge 0x85d8
jmp 0x8766
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movzbl 0x12(%rax), %eax
cmpl $0x4, %eax
jne 0x86d3
movq -0xd0(%rbp), %rsi
leaq 0x8ae2(%rip), %rdx      # 0x110e1
leaq -0x58(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x5490
movq -0xd8(%rbp), %rsi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x13, %rdx
leaq -0x38(%rbp), %rdi
callq 0x5440
jmp 0x8631
leaq -0x58(%rbp), %rdi
callq 0x35c8
leaq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3130
jmp 0x864c
leaq -0x88(%rbp), %rdi
callq 0x8560
jmp 0x865a
leaq -0x88(%rbp), %rdi
callq 0x35c8
leaq -0x38(%rbp), %rdi
callq 0x3110
movq %rax, %rdi
callq 0x3120
leaq -0x38(%rbp), %rdi
callq 0x35c8
jmp 0x8761
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x35c8
jmp 0x876f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x86c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x35c8
leaq -0x38(%rbp), %rdi
callq 0x35c8
jmp 0x876f
movq -0xd0(%rbp), %rsi
leaq 0x8a00(%rip), %rdx      # 0x110e1
leaq -0xc8(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x5490
movq -0xe0(%rbp), %rsi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x13, %rdx
leaq -0xa8(%rbp), %rdi
callq 0x5440
jmp 0x8719
leaq -0xc8(%rbp), %rdi
callq 0x35c8
leaq -0xa8(%rbp), %rdi
callq 0x3110
movq %rax, %rdi
callq 0x3560
leaq -0xa8(%rbp), %rdi
callq 0x35c8
jmp 0x8761
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x35c8
jmp 0x876f
jmp 0x85b9
addq $0xe0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3530
nopl (%rax,%rax)
// File: girdhari9[P]TEXPLORER/cmd_functions.cpp
// Function: search_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void search_file(string current_path,string file_name){
    struct dirent ** dir_namelist;
    int n = scandir(current_path.c_str(),&dir_namelist,NULL, alphasort);
    while(n--){
        if(n < 2) break;
        if(dir_namelist[n]->d_type == 4){
            string new_current_path = current_path + "/" + dir_namelist[n]->d_name;
            search_file(new_current_path,file_name);
        }
        else if(dir_namelist[n]->d_name == file_name){
            search_v.push_back(current_path);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rsi, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x3110
movq %rax, %rdi
leaq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movq 0xf810(%rip), %rcx      # 0x17fc8
callq 0x3060
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x8944
cmpl $0x2, -0x1c(%rbp)
jge 0x87df
jmp 0x8944
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movzbl 0x12(%rax), %eax
cmpl $0x4, %eax
jne 0x8908
movq -0xc0(%rbp), %rsi
leaq 0x88db(%rip), %rdx      # 0x110e1
leaq -0x60(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x5490
movq -0xc8(%rbp), %rsi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x13, %rdx
leaq -0x40(%rbp), %rdi
callq 0x5440
jmp 0x8838
leaq -0x60(%rbp), %rdi
callq 0x35c8
leaq -0x90(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3130
jmp 0x8853
movq -0xb8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x3130
jmp 0x8868
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x8780
jmp 0x887d
leaq -0xb0(%rbp), %rdi
callq 0x35c8
leaq -0x90(%rbp), %rdi
callq 0x35c8
leaq -0x40(%rbp), %rdi
callq 0x35c8
jmp 0x893f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x35c8
jmp 0x894d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x88fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x88f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x35c8
leaq -0x90(%rbp), %rdi
callq 0x35c8
leaq -0x40(%rbp), %rdi
callq 0x35c8
jmp 0x894d
movq -0xb8(%rbp), %rsi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x13, %rdi
callq 0x8dc0
testb $0x1, %al
jne 0x892a
jmp 0x893d
movq -0xc0(%rbp), %rsi
leaq 0xff80(%rip), %rdi      # 0x188b8
callq 0x8df0
jmp 0x893f
jmp 0x87c0
addq $0xd0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: girdhari9[P]TEXPLORER/cmd_functions.cpp
// Function: snapshot(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, _IO_FILE*)
void snapshot(string current_path,FILE *file_pointer){
    struct dirent ** dir_namelist;
    int n = scandir(current_path.c_str(),&dir_namelist,NULL, alphasort);
    int x = n;
    fprintf(file_pointer,"%s\n\n",current_path.c_str());
    while(n--){
        if(n<2) break;
        fprintf(file_pointer,"%s\t",dir_namelist[n]->d_name);
    }
    fprintf(file_pointer,"\n\n\n");
    while(x--){
        if(x<2) break;
        else if(dir_namelist[x]->d_type == 4){
            string new_current_path = current_path + "/" + dir_namelist[x]->d_name;
            snapshot(new_current_path,file_pointer);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x3110
movq %rax, %rdi
leaq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movq 0xf637(%rip), %rcx      # 0x17fc8
callq 0x3060
movq -0xa0(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x3110
movq -0x98(%rbp), %rdi
movq %rax, %rdx
leaq 0x871c(%rip), %rsi      # 0x110e3
movb $0x0, %al
callq 0x3490
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x8a0a
cmpl $0x2, -0x1c(%rbp)
jge 0x89e6
jmp 0x8a0a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x13, %rdx
leaq 0x86e7(%rip), %rsi      # 0x110e8
movb $0x0, %al
callq 0x3490
jmp 0x89ce
movq -0x10(%rbp), %rdi
leaq 0x86d7(%rip), %rsi      # 0x110ec
movb $0x0, %al
callq 0x3490
movl -0x20(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x20(%rbp)
cmpl $0x0, %eax
je 0x8b27
cmpl $0x2, -0x20(%rbp)
jge 0x8a3b
jmp 0x8b27
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movzbl 0x12(%rax), %eax
cmpl $0x4, %eax
jne 0x8b20
movq -0xa0(%rbp), %rsi
leaq 0x867f(%rip), %rdx      # 0x110e1
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x5490
movq -0xa8(%rbp), %rsi
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x13, %rdx
leaq -0x40(%rbp), %rdi
callq 0x5440
jmp 0x8a94
leaq -0x60(%rbp), %rdi
callq 0x35c8
leaq -0x90(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3130
jmp 0x8aaf
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x8960
jmp 0x8ac1
leaq -0x90(%rbp), %rdi
callq 0x35c8
leaq -0x40(%rbp), %rdi
callq 0x35c8
jmp 0x8b20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x35c8
jmp 0x8b30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x8b15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x35c8
leaq -0x40(%rbp), %rdi
callq 0x35c8
jmp 0x8b30
jmp 0x8b22
jmp 0x8a1c
addq $0xb0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3530
nopl (%rax)
// File: girdhari9[P]TEXPLORER/cmd_functions.cpp
// Function: print_search_file(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>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void print_search_file(vector<string> &v,string file_name){
    screen_point(0,0,1);
    for(unsigned int i = 0; i < 13 && i < v.size(); i++){
        string new_name = v[i];
        if(file_name.size() > 20)
            file_name = file_name.substr(1,19) + "...";
        cout<<"\033[21;35m "<<file_name<<"\033[0m";
        screen_point(i,30,0);
        cout<<v[i]<<"\n";
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %esi, %esi
movl $0x1, %edx
movl %esi, %edi
callq 0x4020
movl $0x0, -0x14(%rbp)
xorl %eax, %eax
cmpl $0xd, -0x14(%rbp)
movb %al, -0x91(%rbp)
jae 0x8ba6
movl -0x14(%rbp), %eax
movq %rax, -0xa0(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8e60
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
setb %al
movb %al, -0x91(%rbp)
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x8bb5
jmp 0x8d27
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x8e80
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x3130
movq -0x90(%rbp), %rdi
callq 0x3210
cmpq $0x14, %rax
jbe 0x8c6c
movq -0x90(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movl $0x1, %edx
movl $0x13, %ecx
callq 0x3310
jmp 0x8c01
leaq 0x8467(%rip), %rdx      # 0x1106f
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x5440
jmp 0x8c17
movq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x33e0
leaq -0x58(%rbp), %rdi
callq 0x35c8
leaq -0x78(%rbp), %rdi
callq 0x35c8
jmp 0x8c6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x8d1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x35c8
jmp 0x8d1c
movq 0xf35d(%rip), %rdi      # 0x17fd0
leaq 0x8476(%rip), %rsi      # 0x110f0
callq 0x32d0
movq %rax, -0xa8(%rbp)
jmp 0x8c88
movq -0x90(%rbp), %rsi
movq -0xa8(%rbp), %rdi
callq 0x3290
movq %rax, -0xb0(%rbp)
jmp 0x8ca4
movq -0xb0(%rbp), %rdi
leaq 0x83cb(%rip), %rsi      # 0x1107d
callq 0x32d0
jmp 0x8cb9
movl -0x14(%rbp), %edi
movl $0x1e, %esi
xorl %edx, %edx
callq 0x4020
jmp 0x8cca
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x8e80
movq %rax, %rsi
movq 0xf2ee(%rip), %rdi      # 0x17fd0
callq 0x3290
movq %rax, -0xb8(%rbp)
jmp 0x8cf0
movq -0xb8(%rbp), %rdi
leaq 0x83f0(%rip), %rsi      # 0x110ee
callq 0x32d0
jmp 0x8d05
leaq -0x38(%rbp), %rdi
callq 0x35c8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8b6f
leaq -0x38(%rbp), %rdi
callq 0x35c8
jmp 0x8d30
addq $0xc0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x3530
nopl (%rax)
// File: andersonfernandes[P]sm-chat/src/client.cpp
// Function: main
int main() {
  init();
  create_user();

  system("clear");
  cout << endl << "> Welcome " << current_user.name <<  endl;
  cout << endl << "The chat started. To quit the app type :q" << endl << endl;

  thread receive_messages_thread(receive_messages);
  receive_messages_thread.detach();
  send_messages();

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
callq 0x2860
callq 0x28c0
leaq 0x1884(%rip), %rdi      # 0x4004
callq 0x20f0
movq 0x4844(%rip), %rdi      # 0x6fd0
movq %rdi, -0x38(%rbp)
movq 0x4821(%rip), %rsi      # 0x6fb8
movq %rsi, -0x30(%rbp)
callq 0x2180
movq %rax, %rdi
leaq 0x1860(%rip), %rsi      # 0x400a
callq 0x2160
movq %rax, %rdi
leaq 0x4997(%rip), %rsi      # 0x7150
callq 0x2160
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x2180
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2180
movq %rax, %rdi
leaq 0x1834(%rip), %rsi      # 0x4015
callq 0x2160
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x2180
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x2180
leaq 0x1ab(%rip), %rsi       # 0x29b0
leaq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x2fc0
movq -0x28(%rbp), %rdi
callq 0x2200
jmp 0x281d
callq 0x2a30
jmp 0x2824
movl $0x0, -0x4(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3070
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3070
movq -0x18(%rbp), %rdi
callq 0x2210
nopl (%rax,%rax)
// File: andersonfernandes[P]sm-chat/src/client.cpp
// Function: init()
void init() {
  srand(time(NULL));

  if ((users_shmid < 0) || (users_count_shmid < 0)) {
    perror("shmget");
    cout << "Unable to connect with the server!" << endl;

    exit(1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl %eax, %edi
callq 0x2120
movl %eax, %edi
callq 0x2150
cmpl $0x0, 0x48c9(%rip)      # 0x7144
jl 0x2886
cmpl $0x0, 0x48c4(%rip)      # 0x7148
jge 0x28be
leaq 0x17b2(%rip), %rdi      # 0x403f
callq 0x20e0
movq 0x4737(%rip), %rdi      # 0x6fd0
leaq 0x17a6(%rip), %rsi      # 0x4046
callq 0x2160
movq %rax, %rdi
movq 0x4709(%rip), %rsi      # 0x6fb8
callq 0x2180
movl $0x1, %edi
callq 0x21a0
popq %rbp
retq
// File: andersonfernandes[P]sm-chat/src/client.cpp
// Function: create_user()
void create_user() {
  User *users = att_users(users_shmid);
  int *users_count = att_users_count(users_count_shmid);

  User *new_user = new User();

  cout << "Username: ";
  cin.getline(new_user->name, 50);
  new_user->shmq_id = create_shmq();

  memcpy(&users[(*users_count)], new_user, sizeof(User));
  memcpy(users_count, &++(*users_count), sizeof(int));
  memcpy(&current_user, new_user, sizeof(User));

  shmdt(users);
  shmdt(users_count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x4876(%rip), %edi      # 0x7144
callq 0x2720
movq %rax, -0x8(%rbp)
movl 0x486b(%rip), %edi      # 0x7148
callq 0x2740
movq %rax, -0x10(%rbp)
movl $0x38, %edi
callq 0x2170
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
xorl %esi, %esi
movl $0x38, %edx
callq 0x20a0
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x46be(%rip), %rdi      # 0x6fd0
leaq 0x1750(%rip), %rsi      # 0x4069
callq 0x2160
movq -0x18(%rbp), %rsi
addq $0x4, %rsi
movq 0x46b3(%rip), %rdi      # 0x6fe0
movl $0x32, %edx
callq 0x2050
callq 0x2cf0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rax
imulq $0x38, %rax, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movl $0x38, %edx
callq 0x20d0
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %edx
addl $0x1, %edx
movl %edx, (%rcx)
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rsi
leaq 0x47ca(%rip), %rdi      # 0x714c
movl $0x38, %edx
callq 0x20d0
movq -0x8(%rbp), %rdi
callq 0x2220
movq -0x10(%rbp), %rdi
callq 0x2220
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: andersonfernandes[P]sm-chat/src/client.cpp
// Function: receive_messages()
void receive_messages() {
  while(true) {
    ShmQueue* shmq = att_shmq(current_user.shmq_id);
    if(!empty(shmq)) {
      Message* message = new Message();

      if(dequeue(shmq, message)) print_message(message);
    }
    shmdt(shmq);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x478e(%rip), %edi      # 0x714c
callq 0x2700
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2560
testb $0x1, %al
jne 0x2a17
movl $0x108, %edi            # imm = 0x108
callq 0x2170
movq %rax, %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x108, %edx            # imm = 0x108
callq 0x20a0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2650
testb $0x1, %al
jne 0x2a0c
jmp 0x2a15
movq -0x10(%rbp), %rdi
callq 0x2ef0
jmp 0x2a17
movq -0x8(%rbp), %rdi
callq 0x2220
jmp 0x29b8
nopw %cs:(%rax,%rax)
// File: andersonfernandes[P]sm-chat/src/client.cpp
// Function: create_shmq()
int create_shmq() {
  key_t key = rand();
  int shmq_id = shmget(key, sizeof(ShmQueue), 0666|IPC_CREAT);

  ShmQueue* shmq = att_shmq(shmq_id);
  memcpy(shmq, create_queue(), sizeof(ShmQueue));
  shmdt(shmq);

  return shmq_id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x2030
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl $0x18, %esi
movl $0x3b6, %edx            # imm = 0x3B6
callq 0x20b0
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x2700
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x24b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x2220
movl -0x8(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: andersonfernandes[P]sm-chat/src/client.cpp
// Function: select_user(User*)
void select_user(User* user_to_chat) {
  User *users = att_users(users_shmid);
  int *users_count = att_users_count(users_count_shmid);

  if(*users_count == 1) {
    cout << endl << "0 Users online!" << endl;
  } else {
    users = att_users(users_shmid);

    cout << endl << "Online users:" << endl;
    for (int i = 0; i < (*users_count); i++) {
      if (users[i].shmq_id == current_user.shmq_id) continue;
      cout << i << " - " << users[i].name << endl;
    }

    int user_to_chat_index;
    cout << endl << "Select the user to chat: ";
    cin >> user_to_chat_index;

    memcpy(user_to_chat, &users[user_to_chat_index], sizeof(User));
  }

  shmdt(users);
  shmdt(users_count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl 0x43d2(%rip), %edi      # 0x7144
callq 0x2720
movq %rax, -0x10(%rbp)
movl 0x43c7(%rip), %edi      # 0x7148
callq 0x2740
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x2dc9
movq 0x4236(%rip), %rdi      # 0x6fd0
movq 0x4217(%rip), %rsi      # 0x6fb8
callq 0x2180
movq %rax, %rdi
leaq 0x12c4(%rip), %rsi      # 0x4074
callq 0x2160
movq %rax, %rdi
movq 0x41f9(%rip), %rsi      # 0x6fb8
callq 0x2180
jmp 0x2ed8
movl 0x4375(%rip), %edi      # 0x7144
callq 0x2720
movq %rax, -0x10(%rbp)
movq 0x41f1(%rip), %rdi      # 0x6fd0
movq 0x41d2(%rip), %rsi      # 0x6fb8
callq 0x2180
movq %rax, %rdi
leaq 0x128f(%rip), %rsi      # 0x4084
callq 0x2160
movq %rax, %rdi
movq 0x41b4(%rip), %rsi      # 0x6fb8
callq 0x2180
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x2e89
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl 0x431a(%rip), %eax      # 0x714c
jne 0x2e36
jmp 0x2e7e
movl -0x1c(%rbp), %esi
movq 0x4190(%rip), %rdi      # 0x6fd0
callq 0x21f0
movq %rax, %rdi
leaq 0x1243(%rip), %rsi      # 0x4092
callq 0x2160
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rsi
addq $0x4, %rsi
callq 0x2160
movq %rax, %rdi
movq 0x413f(%rip), %rsi      # 0x6fb8
callq 0x2180
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2e10
movq 0x4140(%rip), %rdi      # 0x6fd0
movq 0x4121(%rip), %rsi      # 0x6fb8
callq 0x2180
movq %rax, %rdi
leaq 0x11f0(%rip), %rsi      # 0x4096
callq 0x2160
movq 0x412e(%rip), %rdi      # 0x6fe0
leaq -0x20(%rbp), %rsi
callq 0x20c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x20(%rbp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rsi
movl $0x38, %edx
callq 0x20d0
movq -0x10(%rbp), %rdi
callq 0x2220
movq -0x18(%rbp), %rdi
callq 0x2220
addq $0x20, %rsp
popq %rbp
retq
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::Reader::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Json::Value&, bool)
bool
Reader::parse(const std::string& document, Value& root, bool collectComments) {
  document_.assign(document.begin(), document.end());
  const char* begin = document_.c_str();
  const char* end = begin + document_.length();
  return parse(begin, end, root, collectComments);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0xa0, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5430
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5800
movq -0x58(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1e390
movq -0x50(%rbp), %rdi
addq $0xa0, %rdi
callq 0x5170
movq -0x50(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0xa0, %rdi
callq 0x56c0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x18(%rbp), %rcx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x5f40
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::Reader::parse(std::istream&, Json::Value&, bool)
bool Reader::parse(std::istream& sin, Value& root, bool collectComments) {
  // std::istream_iterator<char> begin(sin);
  // std::istream_iterator<char> end;
  // Those would allow streamed input from a file, if parse() were a
  // template function.

  // Since JSONCPP_STRING is reference-counted, this at least does not
  // create an extra copy.
  JSONCPP_STRING doc;
  std::getline(sin, doc, (char)EOF);
  return parse(doc.data(), doc.data() + doc.size(), root, collectComments);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x5680
movq -0x58(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x57f0
jmp 0x61d7
leaq -0x40(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x55f0
movq -0x80(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x55f0
movq -0x80(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x5360
movq -0x78(%rbp), %rdx
movq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rsi
addq %rax, %rdx
movq -0x18(%rbp), %rcx
movzbl -0x19(%rbp), %r8d
andl $0x1, %r8d
callq 0x5f40
movb %al, -0x61(%rbp)
jmp 0x6224
leaq -0x40(%rbp), %rdi
callq 0x52c0
movb -0x61(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x52c0
movq -0x48(%rbp), %rdi
callq 0x5780
nopl (%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::Reader::decodeString(Json::Reader::Token&)
bool Reader::decodeString(Token& token) {
  JSONCPP_STRING decoded_string;
  if (!decodeString(token, decoded_string))
    return false;
  Value decoded(decoded_string);
  currentValue().swapPayload(decoded);
  currentValue().setOffsetStart(token.start_ - begin_);
  currentValue().setOffsetLimit(token.end_ - begin_);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x5680
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rdx
movq -0x18(%rbp), %rsi
callq 0x8430
movb %al, -0x71(%rbp)
jmp 0x7804
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x782e
jmp 0x780d
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x7909
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7920
leaq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x12570
jmp 0x783d
movq -0x88(%rbp), %rdi
callq 0x6b40
movq %rax, -0x90(%rbp)
jmp 0x7852
movq -0x90(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x7940
jmp 0x7864
movq -0x88(%rbp), %rdi
callq 0x6b40
movq %rax, -0x98(%rbp)
jmp 0x7879
movq -0x98(%rbp), %rdi
movq -0x88(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq 0xc0(%rax), %rax
subq %rax, %rsi
callq 0x7a30
jmp 0x78a0
movq -0x88(%rbp), %rdi
callq 0x6b40
movq %rax, -0xa0(%rbp)
jmp 0x78b5
movq -0xa0(%rbp), %rdi
movq -0x88(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rsi
movq 0xc0(%rax), %rax
subq %rax, %rsi
callq 0x7300
jmp 0x78dc
movb $0x1, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x12a50
jmp 0x7909
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x12a50
jmp 0x7920
leaq -0x38(%rbp), %rdi
callq 0x52c0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x52c0
movq -0x40(%rbp), %rdi
callq 0x5780
nopw %cs:(%rax,%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::Reader::addComment(char const*, char const*, Json::CommentPlacement)
void
Reader::addComment(Location begin, Location end, CommentPlacement placement) {
  assert(collectComments_);
  const JSONCPP_STRING& normalized = normalizeEOL(begin, end);
  if (placement == commentAfterOnSameLine) {
    assert(lastValue_ != 0);
    lastValue_->setComment(normalized, placement);
  } else {
    commentsBefore_ += normalized;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
testb $0x1, 0x10c(%rax)
je 0x825a
jmp 0x8279
leaq 0x2faa0(%rip), %rdi     # 0x37d01
leaq 0x2faaa(%rip), %rsi     # 0x37d12
movl $0x26d, %edx            # imm = 0x26D
leaq 0x2fab2(%rip), %rcx     # 0x37d26
callq 0x5320
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x8330
leaq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x82f9
movq -0x60(%rbp), %rax
cmpq $0x0, 0xe0(%rax)
je 0x82a8
jmp 0x82c7
leaq 0x2fabb(%rip), %rdi     # 0x37d6a
leaq 0x2fa5c(%rip), %rsi     # 0x37d12
movl $0x270, %edx            # imm = 0x270
leaq 0x2fa64(%rip), %rcx     # 0x37d26
callq 0x5320
movq -0x60(%rbp), %rax
movq 0xe0(%rax), %rdi
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x6990
jmp 0x82e0
jmp 0x8311
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x52c0
jmp 0x8320
movq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0xe8, %rdi
callq 0x55d0
jmp 0x830f
jmp 0x8311
leaq -0x48(%rbp), %rdi
callq 0x52c0
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x5780
nopl (%rax)