LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Kingsford-Group[P]ghost2/include/Eigen/src/Core/TriangularMatrix.h
// Function: void Eigen::TriangularView<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1u>::lazyAssign<Eigen::CwiseUnaryOp<Eigen::internal::scalar_quotient1_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1> const>>(Eigen::MatrixBase<Eigen::CwiseUnaryOp<Eigen::internal::scalar_quotient1_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1> const>> const&)
void TriangularView<MatrixType, Mode>::lazyAssign(const MatrixBase<OtherDerived>& other)
{
  enum {
    unroll = MatrixType::SizeAtCompileTime != Dynamic
          && internal::traits<OtherDerived>::CoeffReadCost != Dynamic
          && MatrixType::SizeAtCompileTime*internal::traits<OtherDerived>::CoeffReadCost/2 <= EIGEN_UNROLLING_LIMIT
  };
  eigen_assert(m_matrix.rows() == other.rows() && m_matrix.cols() == other.cols());

  internal::triangular_assignment_selector
    <MatrixType, OtherDerived, int(Mode),
    unroll ? int(MatrixType::SizeAtCompileTime) : Dynamic,
    false // do not change the opposite triangular part
    >::run(m_matrix.const_cast_derived(), other.derived());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rdi
movq 0x8(%rdi), %rax
movq (%rsi), %rcx
movq 0x8(%rcx), %r9
cmpq %r9, %rax
jne 0x3039e
movq 0x10(%rdi), %rdx
cmpq 0x10(%rcx), %rdx
jne 0x3039e
testq %rdx, %rdx
jle 0x30398
movq (%rdi), %rdi
leaq 0x8(,%rax,8), %r8
leaq 0x8(,%r9,8), %r9
xorl %r10d, %r10d
xorl %r11d, %r11d
cmpq %rax, %r11
jge 0x3038a
movq (%rcx), %rbx
addq %r10, %rbx
xorl %r14d, %r14d
movsd (%rbx,%r14,8), %xmm0
divsd 0x8(%rsi), %xmm0
movsd %xmm0, (%rdi,%r14,8)
leaq (%r11,%r14), %r15
incq %r15
incq %r14
cmpq %rax, %r15
jl 0x3036a
incq %r11
addq %r8, %rdi
addq %r9, %r10
cmpq %rdx, %r11
jne 0x3035c
popq %rbx
popq %r14
popq %r15
retq
leaq 0x23253(%rip), %rdi     # 0x535f8
leaq 0x2328f(%rip), %rsi     # 0x5363b
leaq 0x232b2(%rip), %rcx     # 0x53665
movl $0x269, %edx            # imm = 0x269
callq 0xd340
nop
// File: /workspace/github_cpp_makefile_star2_O1/Kingsford-Group[P]ghost2/include/Eigen/src/Core/Dot.h
// Function: Eigen::internal::scalar_product_traits<double, Eigen::internal::traits<Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, true>, -1, 1, false>>::Scalar>::ReturnType Eigen::MatrixBase<Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false>>::dot<Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, true>, -1, 1, false>>(Eigen::MatrixBase<Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, true>, -1, 1, false>> const&) const
typename internal::scalar_product_traits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType
MatrixBase<Derived>::dot(const MatrixBase<OtherDerived>& other) const
{
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
  EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived)
  typedef internal::scalar_conj_product_op<Scalar,typename OtherDerived::Scalar> func;
  EIGEN_CHECK_BINARY_COMPATIBILIY(func,Scalar,typename OtherDerived::Scalar);

  eigen_assert(size() == other.size());

  return internal::dot_nocheck<Derived,OtherDerived>::run(*this, other);
}

// Assembly:
subq $0x88, %rsp
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0x30dd1
movups (%rdi), %xmm0
movaps %xmm0, 0x10(%rsp)
movups 0x18(%rdi), %xmm0
movups %xmm0, 0x28(%rsp)
movups (%rsi), %xmm0
movups %xmm0, 0x38(%rsp)
movups 0x18(%rsi), %xmm0
movaps %xmm0, 0x50(%rsp)
movups 0x30(%rsi), %xmm0
movups %xmm0, 0x68(%rsp)
movq 0x40(%rsi), %rax
movq %rax, 0x78(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x30dc6
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rsi
callq 0x31a10
jmp 0x30dc9
xorps %xmm0, %xmm0
addq $0x88, %rsp
retq
leaq 0x23a04(%rip), %rdi     # 0x547dc
leaq 0x23a14(%rip), %rsi     # 0x547f3
leaq 0x23a2a(%rip), %rcx     # 0x54810
movl $0x47, %edx
callq 0xd340
// File: /workspace/github_cpp_makefile_star2_O1/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>::wait(unsigned long) const volatile
void wait(size_t const task_threshold = 0) const volatile
    {
      const pool_type* self = const_cast<const pool_type*>(this);
      recursive_mutex::scoped_lock lock(self->m_monitor);

      if(0 == task_threshold)
      {
        while(0 != self->m_active_worker_count || !self->m_scheduler.empty())
        { 
          self->m_worker_idle_or_terminated_event.wait(lock);
        }
      }
      else
      {
        while(task_threshold < self->m_active_worker_count + self->m_scheduler.size())
        { 
          self->m_worker_idle_or_terminated_event.wait(lock);
        }
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa0(%rdi), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
callq 0x35a54
testq %r14, %r14
je 0x3580d
leaq 0xc8(%rbx), %r15
leaq 0x8(%rsp), %r12
movq 0x70(%rbx), %rax
movq %rax, %rcx
subq 0x50(%rbx), %rcx
shrq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
shlq $0x4, %rcx
movq 0x48(%rbx), %rax
movq 0x58(%rbx), %rdx
subq 0x60(%rbx), %rdx
sarq $0x5, %rdx
subq 0x38(%rbx), %rax
sarq $0x5, %rax
addq %rcx, %rax
addq 0x20(%rbx), %rdx
addq %rax, %rdx
cmpq %r14, %rdx
jbe 0x35837
movq %r15, %rdi
movq %r12, %rsi
callq 0x3597e
jmp 0x357be
leaq 0xc8(%rbx), %r14
leaq 0x8(%rsp), %r15
cmpq $0x0, 0x20(%rbx)
jne 0x3582a
movq 0x58(%rbx), %rax
cmpq 0x38(%rbx), %rax
je 0x35837
movq %r14, %rdi
movq %r15, %rsi
callq 0x3597e
jmp 0x35819
cmpb $0x1, 0x10(%rsp)
jne 0x35848
movq 0x8(%rsp), %rdi
callq 0x363de
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x35856
movq %rax, %rbx
cmpb $0x1, 0x10(%rsp)
jne 0x3586a
movq 0x8(%rsp), %rdi
callq 0x363de
movq %rbx, %rdi
callq 0xd9c0
// File: /workspace/github_cpp_makefile_star2_O1/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>::terminate_all_workers(bool) volatile
void terminate_all_workers(bool const wait) volatile
    {
      pool_type* self = const_cast<pool_type*>(this);
      recursive_mutex::scoped_lock lock(self->m_monitor);

      self->m_terminate_all_workers = true;

      m_target_worker_count = 0;
      self->m_task_or_terminate_workers_event.notify_all();

      if(wait)
      {
        while(m_active_worker_count > 0)
        {
          self->m_worker_idle_or_terminated_event.wait(lock);
        }

        for(typename std::vector<shared_ptr<worker_type> >::iterator it = self->m_terminated_workers.begin();
          it != self->m_terminated_workers.end();
          ++it)
        {
          (*it)->join();
        }
        self->m_terminated_workers.clear();
      }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xa0(%rdi), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
callq 0x35a54
movb $0x1, 0x80(%rbx)
movq $0x0, 0x18(%rbx)
leaq 0x120(%rbx), %rdi
callq 0x3680e
testl %ebp, %ebp
je 0x35925
leaq 0xc8(%rbx), %r14
movq %rsp, %r15
cmpq $0x0, 0x20(%rbx)
je 0x358d6
movq %r14, %rdi
movq %r15, %rsi
callq 0x3597e
jmp 0x358c2
movq 0x88(%rbx), %r14
movq 0x90(%rbx), %r15
cmpq %r15, %r14
je 0x358fc
movq (%r14), %rdi
testq %rdi, %rdi
je 0x35942
callq 0x36866
addq $0x10, %r14
jmp 0x358dd
movq 0x88(%rbx), %r14
cmpq %r14, %r15
je 0x35925
movq %r14, %r12
leaq 0x8(%r12), %rdi
callq 0x2307a
addq $0x10, %r12
cmpq %r15, %r12
jne 0x3590b
movq %r14, 0x90(%rbx)
cmpb $0x1, 0x8(%rsp)
jne 0x35935
movq (%rsp), %rdi
callq 0x363de
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15bde(%rip), %rdi     # 0x4b527
leaq 0x15bdf(%rip), %rsi     # 0x4b52f
leaq 0x23e92(%rip), %rcx     # 0x597e9
movl $0x2d8, %edx            # imm = 0x2D8
callq 0xd340
jmp 0x35963
movq %rax, %rbx
cmpb $0x1, 0x8(%rsp)
jne 0x35976
movq (%rsp), %rdi
callq 0x363de
movq %rbx, %rdi
callq 0xd9c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35bd4
cmpb $0x0, 0x80(%r14)
je 0x36b2d
xorl %ebp, %ebp
jmp 0x36b91
movq %r15, 0x18(%r14)
movq 0x10(%r14), %rax
cmpq 0x18(%r14), %rax
jbe 0x36b4f
addq $0x120, %r14            # imm = 0x120
movq %r14, %rdi
callq 0x3680e
movb $0x1, %bpl
jmp 0x36b91
movq 0x10(%r14), %rax
movb $0x1, %bpl
cmpq 0x18(%r14), %rax
jae 0x36b91
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x36d1c
movq %r12, %rdi
callq 0x36c0e
movq %r15, %rdi
callq 0x2307a
incq 0x10(%r14)
incq 0x20(%r14)
movq 0x10(%r14), %rax
cmpq 0x18(%r14), %rax
jb 0x36b64
movq %rbx, %rdi
callq 0x363de
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, %r14
jmp 0x36bc0
movq %rdx, %r15
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2307a
cmpl $0x1, %r15d
jne 0x36bf6
movq %r14, %rdi
callq 0xd6e0
movq %rsp, %rdi
movq %rax, %rsi
callq 0x36d5a
movq %r14, %rdi
callq 0xd240
movq %rsp, %rdi
callq 0x36252
callq 0xd960
jmp 0x36b29
movq %rax, %r14
movq %rbx, %rdi
callq 0x363de
movq %r14, %rdi
callq 0xd9c0
movq %rax, %rdi
callq 0x1d63c
// File: /workspace/github_cpp_makefile_star2_O1/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 0x42f(%rip), %rax       # 0x373d4
leaq 0x38(%rsp), %rdi
movq %rax, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq %rbx, 0x18(%rdi)
leaq 0x40e48(%rip), %rax     # 0x77e09
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 0x1e464
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x3703c
callq 0x37446
testb %al, %al
jne 0x36fea
movb $0x0, 0x30(%rsp)
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x3703c
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x375c4
movq %rsp, %rsi
movq %r14, %rdi
callq 0x37558
leaq 0x8(%rsp), %rdi
callq 0x2307a
leaq 0x10(%rsp), %rdi
callq 0x37602
addq $0x58, %rsp
popq %rbx
popq %r14
retq
leaq 0x144e4(%rip), %rdi     # 0x4b527
leaq 0x144e5(%rip), %rsi     # 0x4b52f
leaq 0x22f17(%rip), %rcx     # 0x59f68
movl $0x2d8, %edx            # imm = 0x2D8
callq 0xd340
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2307a
jmp 0x3706f
jmp 0x3706c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x37602
movq %rbx, %rdi
callq 0xd9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35a54
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
jbe 0x37483
xorl %ebx, %ebx
jmp 0x374e7
movq 0x38(%rbx), %rsi
cmpq %rsi, 0x58(%rbx)
jne 0x374cf
leaq 0xc8(%rbx), %r14
leaq 0x120(%rbx), %r15
leaq 0x8(%rsp), %r12
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
ja 0x3747f
decq 0x20(%rbx)
movq %r14, %rdi
callq 0x3680e
movq %r15, %rdi
movq %r12, %rsi
callq 0x3597e
incq 0x20(%rbx)
movq 0x38(%rbx), %rsi
cmpq %rsi, 0x58(%rbx)
je 0x374a0
leaq 0x18(%rsp), %rdi
callq 0x3794c
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x37a40
movb $0x1, %bl
cmpb $0x1, 0x10(%rsp)
jne 0x374f8
movq 0x8(%rsp), %rdi
callq 0x363de
cmpq $0x0, 0x18(%rsp)
setne %al
andb %bl, %al
cmpb $0x1, %al
jne 0x37511
leaq 0x18(%rsp), %rdi
callq 0x379ec
leaq 0x18(%rsp), %rdi
callq 0x1e464
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x37532
jmp 0x3752d
movq %rax, %rbx
jmp 0x37546
movq %rax, %rbx
cmpb $0x1, 0x10(%rsp)
jne 0x37546
movq 0x8(%rsp), %rdi
callq 0x363de
leaq 0x18(%rsp), %rdi
callq 0x1e464
movq %rbx, %rdi
callq 0xd9c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35bd4
decq 0x10(%r15)
decq 0x20(%r15)
leaq 0xc8(%r15), %rdi
callq 0x3680e
movb 0x80(%r15), %al
cmpb $0x1, %al
jne 0x375a3
addq $0x88, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x376d0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x363de
movq %rax, %r14
movq %rbx, %rdi
callq 0x363de
movq %r14, %rdi
callq 0xd9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35bd4
decq 0x10(%r14)
decq 0x20(%r14)
leaq 0xc8(%r14), %rdi
callq 0x3680e
movb 0x80(%r14), %al
cmpb $0x1, %al
jne 0x37679
addq $0x88, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x376d0
jmp 0x37691
movq 0x78(%r14), %rax
testq %rax, %rax
je 0x3769e
movq 0x10(%r14), %rsi
movq (%rax), %rdi
incq %rsi
callq 0x36afe
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x363de
leaq 0x13e82(%rip), %rdi     # 0x4b527
leaq 0x21b07(%rip), %rsi     # 0x591b3
leaq 0x226ab(%rip), %rcx     # 0x59d5e
movl $0x69, %edx
callq 0xd340
movq %rax, %r14
movq %rbx, %rdi
callq 0x363de
movq %r14, %rdi
callq 0xd9c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35bd4
leaq 0x28(%r14), %rdi
movq %r15, %rsi
callq 0x38c18
addq $0x120, %r14            # imm = 0x120
movq %r14, %rdi
callq 0x38bc0
movq %rbx, %rdi
callq 0x363de
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x363de
movq %r14, %rdi
callq 0xd9c0
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, 0x37d59(%rip)     # 0x79600
jne 0x41924
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 0x4197a
movl (%r15), %eax
testl %eax, %eax
movl $0x2000, %ecx           # imm = 0x2000
cmovgl %eax, %ecx
movslq %ecx, %rax
movq %rax, 0x37d13(%rip)     # 0x795f8
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 0x4197a
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, 0x37cdc(%rip)     # 0x79600
movq 0x37ccd(%rip), %rax     # 0x795f8
leaq 0x7f(%rax), %rcx
testq %rax, %rax
cmovnsq %rax, %rcx
movq 0x37cc3(%rip), %rax     # 0x79600
sarq $0x7, %rcx
movq (%r14), %rdx
cmpq %rdx, %rcx
cmovgeq %rdx, %rcx
movq %rcx, (%r14)
testq %rcx, %rcx
jle 0x4195e
shlq $0x5, %rcx
xorl %edx, %edx
divq %rcx
jmp 0x41960
xorl %eax, %eax
cmpq (%rbx), %rax
jge 0x4196b
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_O1/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 0x3478(%rip), %rdx      # 0x6104
movq %rdx, %rsi
callq 0x403c
leaq 0x20(%rsp), %rdi
movl $0x22, %esi
movq %r15, %rdx
callq 0x3b00
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), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2ce7
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x2cef
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x2280
movq %rax, %r12
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2d33
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d4e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
cmpq $-0x1, %r12
je 0x2de8
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
cmpq %r13, %rdi
je 0x2d99
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x3316(%rip), %rsi      # 0x60b6
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2200
cmpq $-0x1, %rax
je 0x2de8
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 %r13, %rdi
je 0x2de8
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 0x3af5
// File: /workspace/github_cpp_makefile_star2_O1/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 0x680c
leaq 0x68(%r15), %r14
movq %r14, %rdi
callq 0x5cd2
movq %rbx, %rdi
callq 0x7770
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x606c
movq %rbx, %rdi
callq 0x7770
movq %r15, %rdi
movq %rax, %rsi
callq 0x496e
movq %rbx, %rdi
callq 0x7886
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 0x9e64
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_O1/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 0x7770
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 0xc798
movq %r14, %rdi
callq 0x7d24
testb %al, %al
je 0x555d
movq 0x700(%rbx), %rdi
callq 0xc408
movq %r15, %rdi
callq 0x7d24
testb %al, %al
je 0x5575
movq 0x700(%rbx), %rdi
callq 0xbc90
movq %r12, %rdi
callq 0x7d24
testb %al, %al
je 0x558d
movq 0x700(%rbx), %rdi
callq 0xa63a
movq %r13, %rdi
callq 0x7d24
testb %al, %al
je 0x55a5
movq 0x700(%rbx), %rdi
callq 0xb3f6
movq %rbp, %rdi
callq 0x7d24
testb %al, %al
je 0x55bd
movq 0x700(%rbx), %rdi
callq 0xb7a0
movq 0x700(%rbx), %rdi
callq 0xa210
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_O1/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, %r14
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, %ebx
testb %al, %al
je 0x6caf
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x80(%rsp,%rax)
jne 0x6ca6
leaq (%rsp,%rax), %rdi
addq $0x60, %rdi
addq $0x8, %r14
leaq 0x50(%rsp), %rbx
leaq 0x60(%rsp), %r15
movq %rsp, %r12
leaq 0x20(%rsp), %r13
leaq 0x40(%rsp), %rbp
movl $0xa, %esi
callq 0x4330
movsbl %al, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x45f0
movq %r12, %rdi
movl $0x3d, %esi
xorl %edx, %edx
callq 0x4480
cmpq $-0x1, %rax
je 0x6caa
movq %r12, %rdi
movl $0x3d, %esi
xorl %edx, %edx
callq 0x4480
leaq 0x1(%rax), %rdx
movq %r13, %rdi
movq %r12, %rsi
movq $-0x1, %rcx
callq 0x4370
movq %r12, %rdi
movl $0x3d, %esi
xorl %edx, %edx
callq 0x4480
movq %rbp, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4370
movq %r14, %rdi
movq %rbp, %rsi
callq 0x5eae
movq %rax, %rdi
movq %r13, %rsi
callq 0x4430
movq 0x40(%rsp), %rdi
cmpq %rbx, %rdi
je 0x6c77
callq 0x4320
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x6c8b
callq 0x4320
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x60, %rdi
testb $0x2, 0x20(%rdi)
je 0x6bdd
xorl %ebx, %ebx
jmp 0x6caf
movl $0x1, %ebx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x6cc2
callq 0x4320
leaq 0x60(%rsp), %rdi
callq 0x4100
movl %ebx, %eax
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %rbx, %rdi
je 0x6cf7
callq 0x4320
jmp 0x6cf7
movq %rax, %r14
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x6d12
callq 0x4320
jmp 0x6d12
jmp 0x6d0f
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x6d25
callq 0x4320
leaq 0x60(%rsp), %rdi
callq 0x4100
movq %r14, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rax, %r15
cmpq $-0x1, %rax
je 0x75b9
movq %r14, %rdi
movl $0x3d, %esi
xorl %edx, %edx
callq 0x4480
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4370
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6fb8
movl %eax, %r12d
xorb $0x1, %r12b
jmp 0x75bc
movb $0x1, %r12b
cmpq $-0x1, %r15
je 0x75d5
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x75d5
callq 0x4320
movl $0x1, %ebp
testb %r12b, %r12b
jne 0x76be
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 0x7710
movl %eax, %r15d
movq (%r12), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x762b
callq 0x4320
testb %r15b, %r15b
je 0x76be
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 0x76a9
callq 0x4320
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x76bc
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 0x76eb
callq 0x4320
jmp 0x76eb
movq %rax, %rbx
leaq 0x30(%rsp), %rax
jmp 0x76fa
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7708
callq 0x4320
movq %rbx, %rdi
callq 0x45c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5ad7(%rip), %rsi      # 0xd1f4
movq %rbx, %rdi
callq 0x4120
movb $0x1, %bpl
testl %eax, %eax
je 0x7767
leaq 0x5ac3(%rip), %rsi      # 0xd1f6
movq %rbx, %rdi
callq 0x4120
testl %eax, %eax
je 0x7767
leaq 0x5967(%rip), %rsi      # 0xd0ad
movq %rbx, %rdi
callq 0x4120
testl %eax, %eax
je 0x7767
leaq 0x5a9f(%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_O1/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 0x811e
movq 0x8(%rbx), %rax
subq (%rbx), %rax
je 0x853a
sarq $0x3, %rax
movabsq $-0x1111111111111111, %r14 # imm = 0xEEEEEEEEEEEEEEEF
imulq %rax, %r14
cmpq $0x1, %r14
adcq $0x0, %r14
xorl %r15d, %r15d
movq 0x9c12(%rip), %rbx      # 0x11fd8
movl $0xfffffefb, %r13d      # imm = 0xFFFFFEFB
leaq 0x53de(%rip), %r12      # 0xd7b1
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 0x4e4c(%rip), %rsi      # 0xd253
callq 0x43d0
movl $0x8, %edx
movq %rbx, %rdi
leaq 0x4e3b(%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 0x4dde(%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 0x83d3
movq %rsp, %rdi
callq 0x85d4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x85d4
movq %rbx, %rdi
callq 0x45c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8bb0
leaq 0x40(%rsp), %r14
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x43d0
leaq 0x48b3(%rip), %rsi      # 0xd299
movl $0x1, %edx
movq %rax, %rdi
callq 0x43d0
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x8a07
callq 0x4320
movl 0x4(%r15), %esi
incl %esi
leaq 0x8(%rsp), %rdi
callq 0x8bb0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x43d0
leaq 0x4869(%rip), %rsi      # 0xd299
movl $0x1, %edx
movq %rax, %rdi
callq 0x43d0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x8a4c
callq 0x4320
movl (%r15), %esi
incl %esi
leaq 0x8(%rsp), %rdi
callq 0x8bb0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x43d0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x8a7c
callq 0x4320
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x4520
movq 0x9510(%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 0x8ac1
jmp 0x8ac6
jmp 0x8ac1
jmp 0x8ac1
movq %rax, %rbx
jmp 0x8ad8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x8ad8
callq 0x4320
movq 0x94c1(%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 0x8ad3
jmp 0x8ad8
nop
// File: /workspace/github_cpp_makefile_star2_O1/acherkaoui[P]HTOP/modules/Clock.cpp
// Function: Clock::getUtc[abi:cxx11]()
std::string Clock::getUtc()
{
	time_t now;
	struct tm *localTime;
	std::string utc;
	char buff[128];

	time(&now);
	localTime = localtime(&now);
	strftime(buff, 128, "%a %d %b %Y", localTime);
	utc = buff;
	return utc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4310
movq %r14, %rdi
callq 0x42b0
leaq 0x4722(%rip), %rdx      # 0xd274
leaq 0x10(%rsp), %r14
movl $0x80, %esi
movq %r14, %rdi
movq %rax, %rcx
callq 0x42e0
movq 0x8(%rbx), %r15
movq %r14, %rdi
callq 0x41e0
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x4500
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x8ba8
callq 0x4320
movq %r14, %rdi
callq 0x45c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8bd7
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 0x93a9(%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 0x937d(%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_O1/acherkaoui[P]HTOP/terminal/terminal.cpp
// Function: Curses::Curses(Data&)
Curses::Curses(Data &newData)
{
	_status = true;
	_xlogo = 70;
	_side = false;
	data = newData;
	initscr();
	noecho();
	curs_set(FALSE);
	keypad(stdscr,TRUE);

	_time = newwin(10, 26, LINES - 10, COLS - 27);
	_ram = newwin(20, 36, 1, COLS - 38);
	_user = newwin(15, 65, LINES - 15, 1);
	_cpu = newwin(20, 58, 1, 1);
	_net = newwin(15, 65, LINES - 15 - 18,1);

	assume_default_colors(COLOR_RED, COLOR_BLACK);
	start_color();
	init_pair(0, COLOR_GREEN, COLOR_GREEN);
	init_pair(1, COLOR_YELLOW, COLOR_YELLOW);
	init_pair(2, COLOR_RED, COLOR_RED);
	init_pair(4, COLOR_GREEN, COLOR_BLACK);
	init_pair(5, COLOR_RED, COLOR_BLACK);
	init_pair(6, COLOR_WHITE, COLOR_WHITE);
	init_pair(7, COLOR_YELLOW, COLOR_BLACK);
	init_pair(8, COLOR_WHITE, COLOR_BLACK);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x5cd2
movb $0x1, 0x14(%r14)
movq $0x46, 0xc(%r14)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xca0a
callq 0x44d0
callq 0x43e0
xorl %edi, %edi
callq 0x42d0
movq 0x8122(%rip), %rax      # 0x11fd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x41a0
movq 0x80ce(%rip), %r15      # 0x11f90
movl (%r15), %edx
addl $-0xa, %edx
movq 0x80d9(%rip), %r12      # 0x11fa8
movl (%r12), %ecx
addl $-0x1b, %ecx
movl $0xa, %edi
movl $0x1a, %esi
callq 0x4380
movq %rax, 0x6c0(%r14)
movl (%r12), %ecx
addl $-0x26, %ecx
movl $0x14, %edi
movl $0x24, %esi
movl $0x1, %edx
callq 0x4380
movq %rax, 0x6b0(%r14)
movl (%r15), %edx
addl $-0xf, %edx
movl $0xf, %edi
movl $0x41, %esi
movl $0x1, %ecx
callq 0x4380
movq %rax, 0x6c8(%r14)
movl $0x14, %edi
movl $0x3a, %esi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x4380
movq %rax, 0x6b8(%r14)
movl (%r15), %edx
addl $-0x21, %edx
movl $0xf, %edi
movl $0x41, %esi
movl $0x1, %ecx
callq 0x4380
movq %rax, 0x6d0(%r14)
movl $0x1, %edi
xorl %esi, %esi
callq 0x41f0
callq 0x40c0
xorl %edi, %edi
movl $0x2, %esi
movl $0x2, %edx
callq 0x40a0
movl $0x1, %edi
movl $0x3, %esi
movl $0x3, %edx
callq 0x40a0
movl $0x2, %edi
movl $0x1, %esi
movl $0x1, %edx
callq 0x40a0
movl $0x4, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x40a0
movl $0x5, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x40a0
movl $0x6, %edi
movl $0x7, %esi
movl $0x7, %edx
callq 0x40a0
movl $0x7, %edi
movl $0x3, %esi
xorl %edx, %edx
callq 0x40a0
movl $0x8, %edi
movl $0x7, %esi
xorl %edx, %edx
callq 0x40a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5de8
movq %r14, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/acherkaoui[P]HTOP/terminal/terminal.cpp
// Function: Curses::refreshTerminal()
void Curses::refreshTerminal()
{

	refresh();
	refreshTerminal(_ram);
	refreshTerminal(_user);
	refreshTerminal(_cpu);
	refreshTerminal(_time);
	refreshTerminal(_net);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x4590
movq 0x6b0(%rbx), %rdi
callq 0x43c0
movq 0x6c8(%rbx), %rdi
callq 0x43c0
movq 0x6b8(%rbx), %rdi
callq 0x43c0
movq 0x6c0(%rbx), %rdi
callq 0x43c0
movq 0x6d0(%rbx), %rdi
popq %rbx
jmp 0x43c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5826(%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 0x57b3(%rip), %r12      # 0x11fa8
cmpl $0xc9, (%r12)
jl 0xc8d5
movq (%r15), %rsi
movl 0xc(%rbx), %ecx
leaq 0xef5(%rip), %r8        # 0xd705
movl $0x4, %edx
movl $0x5, %r9d
callq 0xa25e
movq (%r15), %rsi
movl 0xc(%rbx), %ecx
leaq 0xefb(%rip), %r8        # 0xd728
movl $0x5, %edx
movl $0x4, %r9d
callq 0xa25e
movq (%r15), %rsi
movl 0xc(%rbx), %ecx
leaq 0xf01(%rip), %r8        # 0xd74b
movl $0x6, %edx
movl $0x7, %r9d
callq 0xa25e
movq (%r15), %rsi
movl 0xc(%rbx), %ecx
leaq 0xf07(%rip), %r14       # 0xd76e
movl $0x7, %edx
movq %r14, %r8
movl $0x5, %r9d
callq 0xa25e
movq (%r15), %rsi
movl 0xc(%rbx), %ecx
movl $0x8, %edx
movq %r14, %r8
movl $0x4, %r9d
callq 0xa25e
movq (%r15), %rsi
movl 0xc(%rbx), %ecx
leaq 0xef1(%rip), %r8        # 0xd791
movl $0x9, %edx
movl $0x7, %r9d
callq 0xa25e
movq (%r15), %rsi
movl 0xc(%rbx), %ecx
leaq 0xf92(%rip), %r8        # 0xd84f
movl $0xa, %edx
movl $0x7, %r9d
callq 0xa25e
movq %rbx, %rdi
callq 0xa2ae
movl 0xc(%rbx), %eax
movl (%r12), %edx
addl $-0x4b, %edx
xorl %ecx, %ecx
cmpl %edx, %eax
je 0xc8ef
movl $0x1, %ecx
cmpl $0x45, %eax
jne 0xc8f2
movl %ecx, 0x10(%rbx)
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_O1/acherkaoui[P]HTOP/terminal/terminal.cpp
// Function: Curses::closeTerminal()
void Curses::closeTerminal()
{
	closeTerminal(_ram);
	closeTerminal(_user);
	closeTerminal(_cpu);
	closeTerminal(_time);
//	clearTerminal(_net);
	endwin();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x6b0(%rdi), %rdi
callq 0x4090
movq 0x6c8(%rbx), %rdi
callq 0x4090
movq 0x6b8(%rbx), %rdi
callq 0x4090
movq 0x6c0(%rbx), %rdi
callq 0x4090
popq %rbx
jmp 0x4400
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5672(%rip), %r14      # 0x11fd0
movq (%r14), %rdi
callq 0x4180
movl %eax, 0x8(%rbx)
cmpl $0x102, %eax            # imm = 0x102
je 0xc987
cmpl $0x157, %eax            # imm = 0x157
jne 0xc9ad
leaq 0xff9(%rip), %rdi       # 0xd977
xorl %eax, %eax
callq 0x4350
jmp 0xc9ad
movq 0x6b0(%rbx), %rdi
leaq 0xfe5(%rip), %rsi       # 0xd97a
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