LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Kingsford-Group[P]ghost2/include/./threadpool/./detail/pool_core.hpp
// Function: boost::threadpool::detail::pool_core<boost::function0<void>, boost::threadpool::fifo_scheduler, boost::threadpool::static_size, boost::threadpool::resize_controller, boost::threadpool::wait_for_all_tasks>::resize(unsigned long) volatile
bool resize(size_t const worker_count) volatile
    {
      locking_ptr<pool_type, recursive_mutex> lockedThis(*this, m_monitor); 

      if(!m_terminate_all_workers)
      {
        m_target_worker_count = worker_count;
      }
      else
      { 
        return false;
      }


      if(m_worker_count <= m_target_worker_count)
      { // increase worker count
        while(m_worker_count < m_target_worker_count)
        {
          try
          {
            worker_thread<pool_type>::create_and_attach(lockedThis->shared_from_this());
            m_worker_count++;
            m_active_worker_count++;	
          }
          catch(thread_resource_error)
          {
            return false;
          }
        }
      }
      else
      { // decrease worker count
        lockedThis->m_task_or_terminate_workers_event.notify_all();   // TODO: Optimize number of notified workers
      }

      return true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0xa0(%rdi), %rbx
movq %rbx, %rdi
callq 0x34b52
cmpb $0x0, 0x80(%r14)
je 0x35a8f
xorl %ebp, %ebp
jmp 0x35af3
movq %r15, 0x18(%r14)
movq 0x10(%r14), %rax
cmpq 0x18(%r14), %rax
jbe 0x35ab1
addq $0x120, %r14            # imm = 0x120
movq %r14, %rdi
callq 0x35770
movb $0x1, %bpl
jmp 0x35af3
movq 0x10(%r14), %rax
movb $0x1, %bpl
cmpq 0x18(%r14), %rax
jae 0x35af3
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x35c80
movq %r12, %rdi
callq 0x35b6e
movq %r15, %rdi
callq 0x21c42
incq 0x10(%r14)
incq 0x20(%r14)
movq 0x10(%r14), %rax
cmpq 0x18(%r14), %rax
jb 0x35ac6
movq %rbx, %rdi
callq 0x35340
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r12
movq %rax, %r14
jmp 0x35b20
movq %rdx, %r12
movq %rax, %r14
movq %r15, %rdi
callq 0x21c42
cmpl $0x1, %r12d
jne 0x35b56
movq %r14, %rdi
callq 0xc6e0
movq %rsp, %rdi
movq %rax, %rsi
callq 0x35cbe
movq %r14, %rdi
callq 0xc240
movq %rsp, %rdi
callq 0x35178
callq 0xc960
jmp 0x35a8b
movq %rax, %r14
movq %rbx, %rdi
callq 0x35340
movq %r14, %rdi
callq 0xc9c0
movq %rax, %rdi
callq 0x1c340
// File: /workspace/github_cpp_makefile_star2_O3/Kingsford-Group[P]ghost2/include/./threadpool/./detail/worker_thread.hpp
// Function: boost::threadpool::detail::worker_thread<boost::threadpool::detail::pool_core<boost::function0<void>, boost::threadpool::fifo_scheduler, boost::threadpool::static_size, boost::threadpool::resize_controller, boost::threadpool::wait_for_all_tasks>>::run()
void run()
	  { 
		  scope_guard notify_exception(bind(&worker_thread::died_unexpectedly, this));

		  while(m_pool->execute_task()) {}

		  notify_exception.disable();
		  m_pool->worker_destructed(this->shared_from_this());
	  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x411(%rip), %rax       # 0x3630a
leaq 0x38(%rsp), %rdi
movq %rax, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq %rbx, 0x18(%rdi)
leaq 0x40f1c(%rip), %rax     # 0x76e31
movq %rax, (%rdi)
movq %rax, 0x10(%rsp)
movq %rbx, 0x28(%rsp)
movq 0x8(%rdi), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movb $0x1, 0x30(%rsp)
callq 0x1d158
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x35f90
callq 0x3637c
testb %al, %al
jne 0x35f3e
movb $0x0, 0x30(%rsp)
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x35f90
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x364fa
movq %rsp, %rsi
movq %r14, %rdi
callq 0x3648e
leaq 0x8(%rsp), %rdi
callq 0x21c42
leaq 0x10(%rsp), %rdi
callq 0x36538
addq $0x58, %rsp
popq %rbx
popq %r14
retq
leaq 0x145c0(%rip), %rdi     # 0x4a557
leaq 0x145c1(%rip), %rsi     # 0x4a55f
leaq 0x22ca8(%rip), %rcx     # 0x58c4d
movl $0x2d8, %edx            # imm = 0x2D8
callq 0xc340
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x21c42
jmp 0x35fc3
jmp 0x35fc0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x36538
movq %rbx, %rdi
callq 0xc9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kingsford-Group[P]ghost2/include/./threadpool/./detail/pool_core.hpp
// Function: boost::threadpool::detail::pool_core<boost::function0<void>, boost::threadpool::fifo_scheduler, boost::threadpool::static_size, boost::threadpool::resize_controller, boost::threadpool::wait_for_all_tasks>::execute_task() volatile
bool execute_task() volatile
    {
      function0<void> task;

      { // fetch task
        pool_type* lockedThis = const_cast<pool_type*>(this);
        recursive_mutex::scoped_lock lock(lockedThis->m_monitor);

        // decrease number of threads if necessary
        if(m_worker_count > m_target_worker_count)
        {	
          return false;	// terminate worker
        }


        // wait for tasks
        while(lockedThis->m_scheduler.empty())
        {	
          // decrease number of workers if necessary
          if(m_worker_count > m_target_worker_count)
          {	
            return false;	// terminate worker
          }
          else
          {
            m_active_worker_count--;
            lockedThis->m_worker_idle_or_terminated_event.notify_all();	
            lockedThis->m_task_or_terminate_workers_event.wait(lock);
            m_active_worker_count++;
          }
        }

        task = lockedThis->m_scheduler.top();
        lockedThis->m_scheduler.pop();
      }

      // call task function
      if(task)
      {
        task();
      }
 
      //guard->disable();
      return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq $0x0, 0x18(%rsp)
leaq 0xa0(%rdi), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
callq 0x34a28
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
jbe 0x363b9
xorl %ebx, %ebx
jmp 0x3641d
movq 0x38(%rbx), %rsi
cmpq %rsi, 0x58(%rbx)
jne 0x36405
leaq 0xc8(%rbx), %r14
leaq 0x120(%rbx), %r15
leaq 0x8(%rsp), %r12
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
ja 0x363b5
decq 0x20(%rbx)
movq %r14, %rdi
callq 0x35770
movq %r15, %rdi
movq %r12, %rsi
callq 0x34926
incq 0x20(%rbx)
movq 0x38(%rbx), %rsi
cmpq %rsi, 0x58(%rbx)
je 0x363d6
leaq 0x18(%rsp), %rdi
callq 0x36872
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x36966
movb $0x1, %bl
cmpb $0x1, 0x10(%rsp)
jne 0x3642e
movq 0x8(%rsp), %rdi
callq 0x35340
cmpq $0x0, 0x18(%rsp)
setne %al
andb %bl, %al
cmpb $0x1, %al
jne 0x36447
leaq 0x18(%rsp), %rdi
callq 0x36912
leaq 0x18(%rsp), %rdi
callq 0x1d158
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x36468
jmp 0x36463
movq %rax, %rbx
jmp 0x3647c
movq %rax, %rbx
cmpb $0x1, 0x10(%rsp)
jne 0x3647c
movq 0x8(%rsp), %rdi
callq 0x35340
leaq 0x18(%rsp), %rdi
callq 0x1d158
movq %rbx, %rdi
callq 0xc9c0
// File: /workspace/github_cpp_makefile_star2_O3/Kingsford-Group[P]ghost2/include/./threadpool/./detail/pool_core.hpp
// Function: boost::threadpool::detail::pool_core<boost::function0<void>, boost::threadpool::fifo_scheduler, boost::threadpool::static_size, boost::threadpool::resize_controller, boost::threadpool::wait_for_all_tasks>::worker_destructed(boost::shared_ptr<boost::threadpool::detail::worker_thread<boost::threadpool::detail::pool_core<boost::function0<void>, boost::threadpool::fifo_scheduler, boost::threadpool::static_size, boost::threadpool::resize_controller, boost::threadpool::wait_for_all_tasks>>>) volatile
void worker_destructed(shared_ptr<worker_type> worker) volatile
    {
      locking_ptr<pool_type, recursive_mutex> lockedThis(*this, m_monitor);
      m_worker_count--;
      m_active_worker_count--;
      lockedThis->m_worker_idle_or_terminated_event.notify_all();	

      if(m_terminate_all_workers)
      {
        lockedThis->m_terminated_workers.push_back(worker);
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xa0(%rdi), %rbx
movq %rbx, %rdi
callq 0x34b52
decq 0x10(%r15)
decq 0x20(%r15)
leaq 0xc8(%r15), %rdi
callq 0x35770
movb 0x80(%r15), %al
cmpb $0x1, %al
jne 0x364d9
addq $0x88, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x36606
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x35340
movq %rax, %r14
movq %rbx, %rdi
callq 0x35340
movq %r14, %rdi
callq 0xc9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kingsford-Group[P]ghost2/include/./threadpool/./detail/pool_core.hpp
// Function: boost::threadpool::detail::pool_core<boost::function0<void>, boost::threadpool::fifo_scheduler, boost::threadpool::static_size, boost::threadpool::resize_controller, boost::threadpool::wait_for_all_tasks>::worker_died_unexpectedly(boost::shared_ptr<boost::threadpool::detail::worker_thread<boost::threadpool::detail::pool_core<boost::function0<void>, boost::threadpool::fifo_scheduler, boost::threadpool::static_size, boost::threadpool::resize_controller, boost::threadpool::wait_for_all_tasks>>>) volatile
void worker_died_unexpectedly(shared_ptr<worker_type> worker) volatile
    {
      locking_ptr<pool_type, recursive_mutex> lockedThis(*this, m_monitor);

      m_worker_count--;
      m_active_worker_count--;
      lockedThis->m_worker_idle_or_terminated_event.notify_all();	

      if(m_terminate_all_workers)
      {
        lockedThis->m_terminated_workers.push_back(worker);
      }
      else
      {
        lockedThis->m_size_policy->worker_died_unexpectedly(m_worker_count);
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0xa0(%rdi), %rbx
movq %rbx, %rdi
callq 0x34b52
decq 0x10(%r14)
decq 0x20(%r14)
leaq 0xc8(%r14), %rdi
callq 0x35770
movb 0x80(%r14), %al
cmpb $0x1, %al
jne 0x365af
addq $0x88, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x36606
jmp 0x365c7
movq 0x78(%r14), %rax
testq %rax, %rax
je 0x365d4
movq 0x10(%r14), %rsi
movq (%rax), %rdi
incq %rsi
callq 0x35a60
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x35340
leaq 0x13f7c(%rip), %rdi     # 0x4a557
leaq 0x218b6(%rip), %rsi     # 0x57e98
leaq 0x2245a(%rip), %rcx     # 0x58a43
movl $0x69, %edx
callq 0xc340
movq %rax, %r14
movq %rbx, %rdi
callq 0x35340
movq %r14, %rdi
callq 0xc9c0
// File: /workspace/github_cpp_makefile_star2_O3/Kingsford-Group[P]ghost2/include/./threadpool/./detail/pool_core.hpp
// Function: boost::threadpool::detail::pool_core<boost::function0<void>, boost::threadpool::fifo_scheduler, boost::threadpool::static_size, boost::threadpool::resize_controller, boost::threadpool::wait_for_all_tasks>::schedule(boost::function0<void> const&) volatile
bool schedule(task_type const & task) volatile
    {	
      locking_ptr<pool_type, recursive_mutex> lockedThis(*this, m_monitor); 
      
      if(lockedThis->m_scheduler.push(task))
      {
        lockedThis->m_task_or_terminate_workers_event.notify_one();
        return true;
      }
      else
      {
        return false;
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0xa0(%rdi), %rbx
movq %rbx, %rdi
callq 0x34b52
leaq 0x28(%r14), %rdi
movq %r15, %rsi
callq 0x37b72
addq $0x120, %r14            # imm = 0x120
movq %r14, %rdi
callq 0x37b1a
movq %rbx, %rdi
callq 0x35340
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x35340
movq %r14, %rdi
callq 0xc9c0
// File: /workspace/github_cpp_makefile_star2_O3/Kingsford-Group[P]ghost2/include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
// Function: void Eigen::internal::computeProductBlockingSizes<double, double, 1, long>(long&, long&, long&)
void computeProductBlockingSizes(SizeType& k, SizeType& m, SizeType& n)
{
  EIGEN_UNUSED_VARIABLE(n);
  // Explanations:
  // Let's recall the product algorithms form kc x nc horizontal panels B' on the rhs and
  // mc x kc blocks A' on the lhs. A' has to fit into L2 cache. Moreover, B' is processed
  // per kc x nr vertical small panels where nr is the blocking size along the n dimension
  // at the register level. For vectorization purpose, these small vertical panels are unpacked,
  // e.g., each coefficient is replicated to fit a packet. This small vertical panel has to
  // stay in L1 cache.
  std::ptrdiff_t l1, l2;

  typedef gebp_traits<LhsScalar,RhsScalar> Traits;
  enum {
    kdiv = KcFactor * 2 * Traits::nr
         * Traits::RhsProgress * sizeof(RhsScalar),
    mr = gebp_traits<LhsScalar,RhsScalar>::mr,
    mr_mask = (0xffffffff/mr)*mr
  };

  manage_caching_sizes(GetAction, &l1, &l2);
  k = std::min<SizeType>(k, l1/kdiv);
  SizeType _m = k>0 ? l2/(4 * sizeof(LhsScalar) * k) : 0;
  if(_m<m) m = _m & mr_mask;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x37e80(%rip), %rax     # 0x78600
testq %rax, %rax
jne 0x40800
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x14(%rsp), %r15
movl %ebp, (%r15)
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4084f
movl (%r15), %eax
testl %eax, %eax
movl $0x2000, %ecx           # imm = 0x2000
cmovgl %eax, %ecx
movslq %ecx, %rax
movq %rax, 0x37e37(%rip)     # 0x785f8
movl %ebp, (%r12)
movl %ebp, (%r13)
leaq 0x14(%rsp), %rdi
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0x4084f
movl (%r15), %eax
movl (%r12), %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
testl %ecx, %ecx
movl $0x100000, %eax         # imm = 0x100000
cmovgl %ecx, %eax
movq %rax, 0x37e00(%rip)     # 0x78600
movq 0x37df1(%rip), %rdx     # 0x785f8
leaq 0x7f(%rdx), %rcx
testq %rdx, %rdx
cmovnsq %rdx, %rcx
sarq $0x7, %rcx
movq (%r14), %rdx
cmpq %rdx, %rcx
cmovgeq %rdx, %rcx
movq %rcx, (%r14)
testq %rcx, %rcx
jle 0x40833
shlq $0x5, %rcx
xorl %edx, %edx
divq %rcx
jmp 0x40835
xorl %eax, %eax
cmpq (%rbx), %rax
jge 0x40840
andl $-0x4, %eax
movq %rax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/deanturpin[P]curly/./curly.h
// Function: find_token(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string find_token(const std::string &token, const std::string &s) noexcept {

  std::string token_value = "";

  const auto i = s.find('"' + token + '"');
  if (i != std::string::npos) {
    token_value = s.substr(i + 3 + token.size());

    // Refine token, try to find the end of the value definition
    const auto end = token_value.find_first_of("},");

    if (end != std::string::npos)
      token_value = token_value.substr(0, end);
  }

  return token_value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0x348d(%rip), %rdx      # 0x6104
movq %rdx, %rsi
callq 0x3fc4
leaq 0x20(%rsp), %rdi
movl $0x22, %esi
movq %r15, %rdx
callq 0x3ab3
leaq 0x20(%rsp), %rdi
movq 0x8(%rdi), %rsi
movl $0x1, %ecx
xorl %edx, %edx
movl $0x22, %r8d
callq 0x22c0
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rsi
movq %rax, %rdx
addq $0x10, %rdx
cmpq %rdx, %rsi
je 0x2cd2
movq %rsi, (%rsp)
movq (%rdx), %rcx
movq %rcx, 0x10(%rsp)
jmp 0x2cdd
movups (%rdx), %xmm0
movups %xmm0, (%r13)
movq %r13, %rsi
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq %rdx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rdi
xorl %edx, %edx
callq 0x2280
movq %rax, %r12
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2d18
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d33
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
cmpq $-0x1, %r12
je 0x2dd2
movq 0x8(%r15), %rax
leaq (%r12,%rax), %rdx
addq $0x3, %rdx
movq %rsp, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x2190
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21c0
movq (%r14), %rdi
leaq 0x10(%rsp), %r15
cmpq %r15, %rdi
je 0x2d83
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x332c(%rip), %rsi      # 0x60b6
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2200
cmpq $-0x1, %rax
je 0x2dd2
movq %rsp, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x2190
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21c0
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x2dd2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x3aa8
// File: /workspace/github_cpp_makefile_star2_O3/acherkaoui[P]HTOP/core/Core.cpp
// Function: Core::Core(int, char**)
Core::Core(int ac, char **av) : parser(Parser(ac, av))
{
	std::map<std::string, std::string> map = this->parser.getMap();
	this->updateActivate(this->parser.getMap());
	if (!parser.isGraphicMode()) {

		this->terminal =  new Curses(this->data);
		this->terminalInterface();
	} else {
		execve("graphic/myHpot", av, av);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rdi, %r15
leaq 0xd20c(%rip), %rax      # 0x11aa0
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x6818
leaq 0x68(%r15), %r14
movq %r14, %rdi
callq 0x5cd2
movq %rbx, %rdi
callq 0x76d8
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x606c
movq %rbx, %rdi
callq 0x76d8
movq %r15, %rdi
movq %rax, %rsi
callq 0x496e
movq %rbx, %rdi
callq 0x77ee
testb %al, %al
je 0x490b
leaq 0x8736(%rip), %rdi      # 0xd020
movq %r12, %rsi
movq %r12, %rdx
callq 0x4580
leaq 0x8(%rsp), %rdi
callq 0x6334
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x6d8, %edi            # imm = 0x6D8
callq 0x4340
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x9d5c
movq %r12, 0x700(%r15)
movq %r15, %rdi
callq 0x54f2
movq %rax, %r15
movq %r12, %rdi
callq 0x4320
jmp 0x494c
movq %rax, %r15
jmp 0x495e
movq %rax, %r15
jmp 0x4956
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x6334
movq %r14, %rdi
callq 0x5de8
movq %rbx, %rdi
callq 0x5e80
movq %r15, %rdi
callq 0x45c0
// File: /workspace/github_cpp_makefile_star2_O3/acherkaoui[P]HTOP/core/Core.cpp
// Function: Core::terminalInterface()
void Core::terminalInterface()
{
	std::map<std::string, std::string> map = this->parser.getMap();

	while(true) {
		(*terminal).clearTerminal();
		if(data.clock.isActive())
			(*terminal).printTime();
		if(data.cpu.isActive())
			(*terminal).printCpu();
		if(data.ram.isActive())
			(*terminal).printRam();
		if(data.user.isActive())
			(*terminal).printUser();
		if(data.network.isActive())
			(*terminal).printNet();
		(*terminal).refreshTerminal();
		usleep(30000);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x76d8
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x606c
leaq 0xa0(%rbx), %r14
leaq 0x70(%rbx), %r15
leaq 0x238(%rbx), %r12
leaq 0x2b0(%rbx), %r13
leaq 0xd0(%rbx), %rbp
movq 0x700(%rbx), %rdi
callq 0xc678
movq %r14, %rdi
callq 0x7c88
testb %al, %al
je 0x555d
movq 0x700(%rbx), %rdi
callq 0xc2da
movq %r15, %rdi
callq 0x7c88
testb %al, %al
je 0x5575
movq 0x700(%rbx), %rdi
callq 0xbb6a
movq %r12, %rdi
callq 0x7c88
testb %al, %al
je 0x558d
movq 0x700(%rbx), %rdi
callq 0xa532
movq %r13, %rdi
callq 0x7c88
testb %al, %al
je 0x55a5
movq 0x700(%rbx), %rdi
callq 0xb2c0
movq %rbp, %rdi
callq 0x7c88
testb %al, %al
je 0x55bd
movq 0x700(%rbx), %rdi
callq 0xb676
movq 0x700(%rbx), %rdi
callq 0xa108
movl $0x7530, %edi           # imm = 0x7530
callq 0x4490
jmp 0x5539
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6334
movq %rbx, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/acherkaoui[P]HTOP/core/Parser.cpp
// Function: Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Parser::parse(std::string file)
{
	std::ifstream input(file);
	std::string line;

	if (!input.is_open())
		return (1);
	while (!input.eof()) {
		getline(input, line);
		if (line.find('=') == std::string::npos)
			return (1);
		this->_map[line.substr(0, line.find('='))] =
		line.substr(line.find('=') + 1);
	}
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
movq %rdi, %rbx
leaq 0x60(%rsp), %rdi
movl $0x8, %edx
callq 0x4550
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0xd8(%rsp), %rdi
callq 0x40e0
movl $0x1, %ebp
testb %al, %al
je 0x6cd0
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
xorl %ebp, %ebp
testb $0x2, 0x80(%rsp,%rax)
jne 0x6cd0
leaq (%rsp,%rax), %rdi
addq $0x60, %rdi
addq $0x8, %rbx
leaq 0x50(%rsp), %rbp
leaq 0x60(%rsp), %r14
movq %rsp, %r15
leaq 0x20(%rsp), %r12
leaq 0x40(%rsp), %r13
movl $0xa, %esi
callq 0x4330
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x45f0
movq %r15, %rdi
movl $0x3d, %esi
xorl %edx, %edx
callq 0x4480
cmpq $-0x1, %rax
je 0x6cb8
movq %r15, %rdi
movl $0x3d, %esi
xorl %edx, %edx
callq 0x4480
leaq 0x1(%rax), %rdx
movq %r12, %rdi
movq %r15, %rsi
movq $-0x1, %rcx
callq 0x4370
movq %r15, %rdi
movl $0x3d, %esi
xorl %edx, %edx
callq 0x4480
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4370
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5eae
movq %rax, %rdi
movq %r12, %rsi
callq 0x4430
movq 0x40(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6c85
callq 0x4320
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x6c99
callq 0x4320
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x60, %rdi
testb $0x2, 0x20(%rdi)
je 0x6beb
xorl %ebp, %ebp
jmp 0x6cbd
movl $0x1, %ebp
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x6cd0
callq 0x4320
leaq 0x60(%rsp), %rdi
callq 0x4100
movl %ebp, %eax
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6d05
callq 0x4320
jmp 0x6d05
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x6d20
callq 0x4320
jmp 0x6d20
jmp 0x6d1d
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x6d33
callq 0x4320
leaq 0x60(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/acherkaoui[P]HTOP/core/Parser.cpp
// Function: Parser::setModuleActive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Parser::setModuleActive(std::string str) {
	if (str.find('=') == std::string::npos ||
		!isMandatoryModule(str.substr(0, str.find('='))))
		return (1);
	if (!this->isBool(str.substr(str.find('=') + 1)))
		return (1);
	this->_map[str.substr(0, str.find('='))] =
		str.substr(str.find('=') + 1);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x3d, %esi
xorl %edx, %edx
callq 0x4480
movl $0x1, %ebp
cmpq $-0x1, %rax
je 0x7626
movq %r14, %rdi
movl $0x3d, %esi
xorl %edx, %edx
callq 0x4480
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4370
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6fa0
movl %eax, %r15d
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7542
callq 0x4320
testb %r15b, %r15b
je 0x7626
movq %r14, %rdi
movl $0x3d, %esi
xorl %edx, %edx
callq 0x4480
leaq 0x1(%rax), %rdx
leaq 0x60(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x4370
movq %r12, %rsi
callq 0x7678
movl %eax, %r15d
movq (%r12), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x7593
callq 0x4320
testb %r15b, %r15b
je 0x7626
movq %r14, %rdi
movl $0x3d, %esi
xorl %edx, %edx
callq 0x4480
leaq 0x1(%rax), %rdx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x4370
movq %r14, %rdi
movl $0x3d, %esi
xorl %edx, %edx
callq 0x4480
movq %rsp, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4370
addq $0x8, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5eae
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x4430
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7611
callq 0x4320
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7624
callq 0x4320
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7653
callq 0x4320
jmp 0x7653
movq %rax, %rbx
leaq 0x30(%rsp), %rax
jmp 0x7662
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7670
callq 0x4320
movq %rbx, %rdi
callq 0x45c0
// File: /workspace/github_cpp_makefile_star2_O3/acherkaoui[P]HTOP/core/Parser.cpp
// Function: Parser::isBool(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
bool Parser::isBool(std::string boolean) const
{
	return (boolean == "1" ||
		boolean == "0" ||
		boolean == "true" ||
		boolean == "false");
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x5b6f(%rip), %rsi      # 0xd1f4
movq %rbx, %rdi
callq 0x4120
movb $0x1, %bpl
testl %eax, %eax
je 0x76cf
leaq 0x5b5b(%rip), %rsi      # 0xd1f6
movq %rbx, %rdi
callq 0x4120
testl %eax, %eax
je 0x76cf
leaq 0x59ff(%rip), %rsi      # 0xd0ad
movq %rbx, %rdi
callq 0x4120
testl %eax, %eax
je 0x76cf
leaq 0x5b37(%rip), %rsi      # 0xd1f8
movq %rbx, %rdi
callq 0x4120
testl %eax, %eax
sete %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/acherkaoui[P]HTOP/modules/CPU.cpp
// Function: Cpu::PrintStats()
void Cpu::PrintStats()
{
	std::vector<CPUData> cpu = this->getStats();
	const size_t NUM_STAT = cpu.size();

	for(size_t i = 0; i < NUM_STAT; ++i) {

		std::cout.width(3);
		std::cout << cpu[i].cpu << "] ";
		std::cout << "active: ";
		std::cout.setf(std::ios::fixed, std::ios::floatfield);
		std::cout.width(6);
		std::cout.precision(2);
		std::cout << cpu[i].active << "%";

		std::cout << " - idle: ";
		std::cout.setf(std::ios::fixed, std::ios::floatfield);
		std::cout.width(6);
		std::cout.precision(2);
		std::cout << cpu[i].active << "%" << std::endl;

		std::cout << std::endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x8064
movq 0x8(%rbx), %rax
subq (%rbx), %rax
je 0x8464
sarq $0x3, %rax
movabsq $-0x1111111111111111, %r14 # imm = 0xEEEEEEEEEEEEEEEF
imulq %rax, %r14
cmpq $0x1, %r14
adcq $0x0, %r14
xorl %r15d, %r15d
movq 0x9ce8(%rip), %rbx      # 0x11fd8
movl $0xfffffefb, %r13d      # imm = 0xFFFFFEFB
leaq 0x54c4(%rip), %r12      # 0xd7c1
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rbx,%rax)
movq (%rsp), %rax
movq (%rax,%r15), %rsi
movq 0x8(%rax,%r15), %rdx
movq %rbx, %rdi
callq 0x43d0
movl $0x2, %edx
movq %rax, %rdi
leaq 0x4f22(%rip), %rsi      # 0xd253
callq 0x43d0
movl $0x8, %edx
movq %rbx, %rdi
leaq 0x4f11(%rip), %rsi      # 0xd256
callq 0x43d0
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl %r13d, %edx
orl $0x4, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rcx
movq $0x6, 0x10(%rbx,%rcx)
movq -0x18(%rax), %rax
movq $0x2, 0x8(%rbx,%rax)
movq (%rsp), %rax
cvtss2sd 0x70(%rax,%r15), %xmm0
movq %rbx, %rdi
callq 0x4540
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x43d0
movl $0x9, %edx
movq %rbx, %rdi
leaq 0x4eb4(%rip), %rsi      # 0xd25f
callq 0x43d0
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl %r13d, %edx
orl $0x4, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rcx
movq $0x6, 0x10(%rbx,%rcx)
movq -0x18(%rax), %rax
movq $0x2, 0x8(%rbx,%rax)
movq (%rsp), %rax
xorps %xmm0, %xmm0
cvtss2sd 0x70(%rax,%r15), %xmm0
movq %rbx, %rdi
callq 0x4540
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x43d0
movq (%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x4330
movsbl %al, %esi
movq %rbp, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4260
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4330
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4260
addq $0x78, %r15
decq %r14
jne 0x82fd
movq %rsp, %rdi
callq 0x84fe
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x84fe
movq %rbx, %rdi
callq 0x45c0
// File: /workspace/github_cpp_makefile_star2_O3/acherkaoui[P]HTOP/modules/Clock.cpp
// Function: Clock::getTime[abi:cxx11]()
std::string Clock::getTime()
{
	time_t rawTime;
	struct tm *localTime;
	std::stringstream now;

	time(&rawTime);
	localTime = localtime(&rawTime);
	now << formatTime(localTime->tm_hour) << ":";
	now << formatTime(1 + localTime->tm_min) << ":";
	now << formatTime(1 + localTime->tm_sec);
	return now.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4280
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x4310
movq %r14, %rdi
callq 0x42b0
movq %rax, %r15
movl 0x8(%rax), %esi
leaq 0x8(%rsp), %rdi
callq 0x8ae0
leaq 0x40(%rsp), %r14
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x43d0
leaq 0x4983(%rip), %rsi      # 0xd299
movl $0x1, %edx
movq %rax, %rdi
callq 0x43d0
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x8937
callq 0x4320
movl 0x4(%r15), %esi
incl %esi
leaq 0x8(%rsp), %rdi
callq 0x8ae0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x43d0
leaq 0x4939(%rip), %rsi      # 0xd299
movl $0x1, %edx
movq %rax, %rdi
callq 0x43d0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x897c
callq 0x4320
movl (%r15), %esi
incl %esi
leaq 0x8(%rsp), %rdi
callq 0x8ae0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x43d0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x89ac
callq 0x4320
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x4520
movq 0x95e0(%rip), %rsi      # 0x11fa0
leaq 0x30(%rsp), %rdi
callq 0x42a0
leaq 0xb0(%rsp), %rdi
callq 0x4160
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x89f1
jmp 0x89f6
jmp 0x89f1
jmp 0x89f1
movq %rax, %rbx
jmp 0x8a08
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x8a08
callq 0x4320
movq 0x9591(%rip), %rsi      # 0x11fa0
leaq 0x30(%rsp), %rdi
callq 0x42a0
leaq 0xb0(%rsp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x45c0
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x8a03
jmp 0x8a08
nop
// File: /workspace/github_cpp_makefile_star2_O3/acherkaoui[P]HTOP/modules/Clock.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> formatTime<int>(int)
std::string formatTime(T time)
{
	std::stringstream str;
	if (time < 10) {
		str << 0;
	}

	str << time;
	return str.str();
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x4280
cmpl $0x9, %ebp
jg 0x8b07
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x45a0
leaq 0x10(%rsp), %rdi
movl %ebp, %esi
callq 0x45a0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x4520
movq 0x9479(%rip), %rsi      # 0x11fa0
movq %rsp, %rdi
callq 0x42a0
leaq 0x80(%rsp), %rdi
callq 0x4160
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq 0x944d(%rip), %rsi      # 0x11fa0
movq %rsp, %rdi
callq 0x42a0
leaq 0x80(%rsp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x45c0
// File: /workspace/github_cpp_makefile_star2_O3/acherkaoui[P]HTOP/terminal/terminal.cpp
// Function: Curses::clearTerminal()
void Curses::clearTerminal()
{
	int i = 4;
	wclear(stdscr);
	wclear(_ram);
	wclear(_cpu);
	wclear(_user);
	wclear(_time);
	wclear(_net);
	if(COLS > 200)
	{
		print(stdscr, i++, _xlogo, "  _____  _____  _____  _____  ", 5);
		print(stdscr, i++, _xlogo, " |  |  ||  _  ||     ||_   _| ", 4);
		print(stdscr, i++, _xlogo, " |     ||   __||  |  |  | |   ", 7);
		print(stdscr, i++, _xlogo, " |__|__||__|   |_____|  |_|   ", 5);
		print(stdscr, i++, _xlogo, " |__|__||__|   |_____|  |_|   ", 4);
		print(stdscr, i++, _xlogo, "       The Lion Monitor       ", 7);
		print(stdscr, i++, _xlogo, "                              ", 7);
		printLion();
	}
	if(_xlogo == COLS - 30 - 45)
		_side = false;
	else if(_xlogo == 69)
		_side = true;
	if(_side != 0)
		_xlogo++;
	else
		_xlogo--;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x5946(%rip), %r15      # 0x11fd0
movq (%r15), %rdi
callq 0x4360
movq 0x6b0(%rbx), %rdi
callq 0x4360
movq 0x6b8(%rbx), %rdi
callq 0x4360
movq 0x6c8(%rbx), %rdi
callq 0x4360
movq 0x6c0(%rbx), %rdi
callq 0x4360
movq 0x6d0(%rbx), %rdi
callq 0x4360
movq 0x58d3(%rip), %r12      # 0x11fa8
movl (%r12), %ecx
cmpl $0xc9, %ecx
jl 0xc7bb
movq (%r15), %rsi
movl 0xc(%rbx), %ecx
leaq 0x1023(%rip), %r8       # 0xd715
movl $0x4, %edx
movl $0x5, %r9d
callq 0xa156
movq (%r15), %rsi
movl 0xc(%rbx), %ecx
leaq 0x1029(%rip), %r8       # 0xd738
movl $0x5, %edx
movl $0x4, %r9d
callq 0xa156
movq (%r15), %rsi
movl 0xc(%rbx), %ecx
leaq 0x102f(%rip), %r8       # 0xd75b
movl $0x6, %edx
movl $0x7, %r9d
callq 0xa156
movq (%r15), %rsi
movl 0xc(%rbx), %ecx
leaq 0x1035(%rip), %r14      # 0xd77e
movl $0x7, %edx
movq %r14, %r8
movl $0x5, %r9d
callq 0xa156
movq (%r15), %rsi
movl 0xc(%rbx), %ecx
movl $0x8, %edx
movq %r14, %r8
movl $0x4, %r9d
callq 0xa156
movq (%r15), %rsi
movl 0xc(%rbx), %ecx
leaq 0x101f(%rip), %r8       # 0xd7a1
movl $0x9, %edx
movl $0x7, %r9d
callq 0xa156
movq (%r15), %rsi
movl 0xc(%rbx), %ecx
leaq 0x10c0(%rip), %r8       # 0xd85f
movl $0xa, %edx
movl $0x7, %r9d
callq 0xa156
movq %rbx, %rdi
callq 0xa1a6
movl (%r12), %ecx
movl 0xc(%rbx), %eax
addl $-0x4b, %ecx
cmpl %ecx, %eax
jne 0xc7d3
movl $0x0, 0x10(%rbx)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jmp 0xc7f1
cmpl $0x45, %eax
jne 0xc7e6
movl $0x1, 0x10(%rbx)
movl $0x1, %ecx
jmp 0xc7f1
xorl %ecx, %ecx
cmpl $0x1, 0x10(%rbx)
sbbl %ecx, %ecx
orl $0x1, %ecx
addl %eax, %ecx
movl %ecx, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/acherkaoui[P]HTOP/terminal/terminal.cpp
// Function: Curses::getchTerminal()
int Curses::getchTerminal()
{
	_ch = getch();
	if (_ch == KEY_ENTER)
	{
		printw("UP");
	}
	else if(_ch == KEY_DOWN)
	{
		wprintw(_ram, "DOWN");
		waddch(_ram, 'B');
	}
	wclear(stdscr);
	wclear(_ram);
	wclear(_cpu);
	wclear(_user);
	wclear(_time);
	return _ch;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x577e(%rip), %r14      # 0x11fd0
movq (%r14), %rdi
callq 0x4180
movl %eax, 0x8(%rbx)
cmpl $0x102, %eax            # imm = 0x102
je 0xc87b
cmpl $0x157, %eax            # imm = 0x157
jne 0xc8a1
leaq 0x1115(%rip), %rdi      # 0xd987
xorl %eax, %eax
callq 0x4350
jmp 0xc8a1
movq 0x6b0(%rbx), %rdi
leaq 0x1101(%rip), %rsi      # 0xd98a
xorl %eax, %eax
callq 0x4060
movq 0x6b0(%rbx), %rdi
movl $0x42, %esi
callq 0x4130
movq (%r14), %rdi
callq 0x4360
movq 0x6b0(%rbx), %rdi
callq 0x4360
movq 0x6b8(%rbx), %rdi
callq 0x4360
movq 0x6c8(%rbx), %rdi
callq 0x4360
movq 0x6c0(%rbx), %rdi
callq 0x4360
movl 0x8(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/metopa[P]HTTP_Server/src/config/CConfig.cpp
// Function: CConfig::load(int, char**)
void CConfig::load( int argc, char * argv[] ) {
	const char * iniFile;
	if ( argc > 1 )
		iniFile = argv[1];
	else
		iniFile = DEFAULT_INIFILE;

	ifstream ifile( iniFile );
	if ( !ifile.is_open() )
		throw FileNotFoundException( iniFile, MSG_CRIT_ERR );

	ini_struct_t defVals;
	loadDefVals( defVals );
	parse( CParserINI( ifile, defVals ) );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2c0, %rsp            # imm = 0x2C0
movq %rdi, %rbx
cmpl $0x2, %esi
jge 0x5b92
leaq 0x1c898(%rip), %rdx     # 0x22428
jmp 0x5b96
addq $0x8, %rdx
movq (%rdx), %r14
leaq 0xb8(%rsp), %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x5760
leaq 0x130(%rsp), %rdi
callq 0x50f0
testb %al, %al
je 0x5c78
leaq 0x10(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x8(%rsp), %rsi
callq 0x5d9a
leaq 0x38(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x9f00
leaq 0x88(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x85ba
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x6458
leaq 0x88(%rsp), %rdi
callq 0x8b4e
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5c4b
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x53f0
leaq 0x38(%rsp), %rdi
callq 0x8b4e
leaq 0x8(%rsp), %rdi
callq 0x8b4e
leaq 0xb8(%rsp), %rdi
callq 0x5110
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbx
popq %r14
popq %rbp
retq
movl $0x48, %edi
callq 0x5200
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x7ae4
leaq 0x1c782(%rip), %rax     # 0x22420
movq (%rax), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x7ae4
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x8492
leaq 0x1b77c(%rip), %rax     # 0x21448
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1b700(%rip), %rsi     # 0x213d8
leaq 0x1e43(%rip), %rdx      # 0x7b22
movq %rbx, %rdi
callq 0x56f0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5d05
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5d20
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x53f0
testb %bpl, %bpl
jne 0x5d4a
jmp 0x5d84
movq %rax, %r14
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5d4a
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x5d4a
movq %rax, %r14
movq %rbx, %rdi
callq 0x52e0
jmp 0x5d84
movq %rax, %r14
leaq 0x88(%rsp), %rdi
callq 0x8b4e
jmp 0x5d69
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x7b64
jmp 0x5d7a
jmp 0x5d77
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8b4e
leaq 0xb8(%rsp), %rdi
callq 0x5110
movq %r14, %rdi
callq 0x5720
nop
// File: /workspace/github_cpp_makefile_star2_O3/metopa[P]HTTP_Server/src/config/CConfig.cpp
// Function: operator<<(std::ostream&, CConfig&)
ostream& operator <<( ostream& out, CConfig& c ) {
	out << "Ports:";
	for ( auto it = c.getPorts().begin(); it != c.getPorts().end(); it++ ) {
		out << ' ' << *it;
	}
	out << endl;

	out << "Working directory: " << c.getWorkDir() << endl;

	out << "Logger flags:";
	for ( int i = 0; i < E_LOG_FLAGS_MAX; i++ )
		if ( c.logFlags_m[i] )
			out << ' ' << logflagsNS::logFlagsToString( (ELogFlags) i );

	out << endl;
	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x11814(%rip), %rsi     # 0x18061
movl $0x6, %edx
callq 0x5450
movq 0x18(%r14), %r12
cmpq 0x20(%r14), %r12
je 0x6896
leaq 0x6(%rsp), %r15
movb $0x20, 0x6(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5450
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rax, %rdi
callq 0x5450
addq $0x20, %r12
cmpq 0x20(%r14), %r12
jne 0x6866
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5290
leaq 0x117a4(%rip), %rsi     # 0x18068
movl $0x13, %edx
movq %rbx, %rdi
callq 0x5450
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %rbx, %rdi
callq 0x5450
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x53c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5290
leaq 0x1176a(%rip), %rsi     # 0x1807c
movl $0xd, %edx
movq %rbx, %rdi
callq 0x5450
xorl %r15d, %r15d
leaq 0x7(%rsp), %r12
cmpb $0x1, (%r14,%r15)
jne 0x6989
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5450
movq %rax, %r13
movl %r15d, %edi
callq 0x11014
testq %rax, %rax
je 0x696e
movq %rax, %rbp
movq %rax, %rdi
callq 0x51f0
movq %r13, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x5450
jmp 0x6989
movq (%r13), %rax
movq -0x18(%rax), %rax
movq %r13, %rdi
addq %rax, %rdi
movl 0x20(%r13,%rax), %esi
orl $0x1, %esi
callq 0x56e0
incq %r15
cmpq $0xc, %r15
jne 0x6927
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5290
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/metopa[P]HTTP_Server/src/config/CConfig.cpp
// Function: CConfig::parseMapper(std::_Rb_tree_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, 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>>>>>>>>>&)
void CConfig::parseMapper( map<string, map<string, vector<string>>>::iterator& data ) {
	for ( auto it = data->second.begin(); it != data->second.end(); it++ )
		fileMapping_m.push_back( make_pair( it->first, it->second.front() ) );

	auto comp = []( const pair<string, string>& a, const pair<string, string>& b ) -> bool {
		return a.first.length() > b.first.length();
	};

	sort( fileMapping_m.begin(), fileMapping_m.end(), comp );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, (%rsp)
movq (%rsi), %rax
movq 0x58(%rax), %r15
addq $0x48, %rax
cmpq %rax, %r15
je 0x70c6
movq %rsi, %r14
movq (%rsp), %rax
leaq 0x78(%rax), %r12
leaq 0x38(%rsp), %rbp
leaq 0x18(%rsp), %rbx
leaq 0x8(%rsp), %r13
leaq 0x20(%r15), %rsi
movq 0x40(%r15), %rdx
movq %r13, %rdi
callq 0x8d1e
movq %r12, %rdi
movq %r13, %rsi
callq 0x91fe
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7098
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53f0
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x70af
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %r15, %rdi
callq 0x52a0
movq %rax, %r15
movq (%r14), %rax
addq $0x48, %rax
cmpq %rax, %r15
jne 0x7066
movq (%rsp), %rax
movq 0x78(%rax), %r14
movq 0x80(%rax), %rbx
cmpq %rbx, %r14
je 0x7138
movq %rbx, %r15
subq %r14, %r15
movq %r15, %rax
sarq $0x6, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x72dc
cmpq $0x401, %r15            # imm = 0x401
jl 0x712d
leaq 0x400(%r14), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7903
cmpq %rbx, %r15
je 0x7138
movq %r15, %rdi
callq 0x79d0
addq $0x40, %r15
jmp 0x711a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7903
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8046
movq %rbx, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O3/metopa[P]HTTP_Server/src/config/CConfig.cpp
// Function: CConfig::parseExec(std::_Rb_tree_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, 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>>>>>>>>>&)
void CConfig::parseExec( map<string, map<string, vector<string>>>::iterator& data ) {
	auto it = data->second.find( "regular_exe_ext" );
	if ( it != data->second.end() ) {
		regExeExt_m.insert( it->second.begin(), it->second.end() );
	}
	it = data->second.find( "script_exe_ext" );
	if ( it != data->second.end() ) {
		scriptExeExt_m.insert( it->second.begin(), it->second.end() );
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x10fb0(%rip), %rsi     # 0x18134
leaq 0x10fb8(%rip), %rdx     # 0x18143
movq %rsp, %rdi
callq 0x8e2c
addq $0x40, %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x94d0
movq %rax, %r13
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x71bb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %r14, 0x20(%rsp)
movq (%r14), %r15
leaq 0x48(%r15), %rax
cmpq %rax, %r13
je 0x7215
leaq 0x90(%rbx), %r12
movq 0x40(%r13), %rbp
movq 0x48(%r13), %r14
movq %r12, (%rsp)
cmpq %r14, %rbp
je 0x7210
leaq 0x98(%rbx), %r15
movq %rsp, %r13
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x9516
addq $0x20, %rbp
cmpq %r14, %rbp
jne 0x71ee
movq 0x20(%rsp), %rax
movq (%rax), %r15
leaq 0x10(%rsp), %r12
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x10f22(%rip), %rsi     # 0x18144
leaq 0x10f29(%rip), %rdx     # 0x18152
callq 0x8e2c
addq $0x40, %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x94d0
movq 0x20(%rsp), %r14
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x725b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
movq (%r14), %rax
addq $0x48, %rax
cmpq %rax, %r15
je 0x72a3
leaq 0xc0(%rbx), %r14
movq 0x40(%r15), %r12
movq 0x48(%r15), %r13
movq %r14, (%rsp)
cmpq %r13, %r12
je 0x72a3
addq $0xc8, %rbx
movq %rsp, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x9516
addq $0x20, %r12
cmpq %r13, %r12
jne 0x7289
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x72b6
jmp 0x72d1
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x72d4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0x72d4
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O3/metopa[P]HTTP_Server/src/config/CParserINI.cpp
// Function: CParserINI::parseLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void CParserINI::parseLine( string& line ) {
	unsigned int pos = 0;
	skipWS( line, pos );
	if ( pos == line.size() )
		return;

	switch ( line[pos] ) {
		case ';':
		case '#':
			return;
		case '[':
			parseNewBlock( line, pos );
			return;
		default:
			string id = getID( line, pos );
			vector<string> args = getArgs( line, pos );
			addParam( id, args );
			return;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0xa09e
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdx
xorl %ecx, %ecx
movzbl (%rdx,%rcx), %esi
cmpl $0x20, %esi
je 0xa08c
cmpl $0x9, %esi
jne 0xa093
incl %ecx
cmpq %rcx, %rax
ja 0xa07e
movl %ecx, 0xc(%rsp)
movl %ecx, %ecx
cmpq %rcx, %rax
jne 0xa0ab
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rax
movzbl (%rax,%rcx), %eax
cmpl $0x23, %eax
je 0xa09e
cmpl $0x3b, %eax
je 0xa09e
cmpl $0x5b, %eax
jne 0xa0d3
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa296
jmp 0xa09e
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %r15
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0xa3f0
leaq 0x68(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0xa4e6
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x8d96
leaq 0x50(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x7f5e
leaq 0x10(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0xa1ee
leaq 0x50(%rsp), %rdi
callq 0x7fe8
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0xa160
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53f0
leaq 0x68(%rsp), %rdi
callq 0x7fe8
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa09e
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0xa09e
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x7fe8
jmp 0xa1a0
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0xa1bc
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53f0
jmp 0xa1bc
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x7fe8
jmp 0xa1cb
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa1e6
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53f0
movq %rbx, %rdi
callq 0x5720