LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::trinary_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::trinary_node<double>, exprtk::details::operator_type, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*>(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* const&, exprtk::details::expression_node<double>* const&, exprtk::details::expression_node<double>* const&) const
inline expression_node<typename node_type::value_type>* allocate(const T1& t1, const T2& t2,
                                                                          const T3& t3, const T4& t4) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3, t4));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
pushq $0x58
popq %rdi
callq 0x118100
movq %rax, %rbx
movq (%r12), %rdx
movq (%r15), %rcx
movq (%r14), %r8
movq %rax, %rdi
movq %r13, %rsi
callq 0x288268
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
pushq $0x58
popq %rsi
movq %rbx, %rdi
callq 0x1180d0
movq %r14, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::trinary_node<double>::value() const
inline T value() const exprtk_override
         {
            const T arg0 = branch_[0].first->value();
            const T arg1 = branch_[1].first->value();
            const T arg2 = branch_[2].first->value();

            switch (operation_)
            {
               case e_inrange : return (arg1 < arg0) ? T(0) : ((arg1 > arg2) ? T(0) : T(1));

               case e_clamp   : return (arg1 < arg0) ? arg0 : (arg1 > arg2 ? arg2 : arg1);

               case e_iclamp  : if ((arg1 <= arg0) || (arg1 >= arg2))
                                   return arg1;
                                else
                                   return ((T(2) * arg1  <= (arg2 + arg0)) ? arg0 : arg2);

               default        : exprtk_debug(("trinary_node::value() - Error: Invalid operation\n"));
                                return std::numeric_limits<T>::quiet_NaN();
            }
         }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, (%rsp)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, 0x10(%rsp)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl 0x20(%rbx), %eax
cmpl $0x42, %eax
je 0x2884a9
cmpl $0x43, %eax
je 0x28846e
cmpl $0x44, %eax
movapd 0x10(%rsp), %xmm2
jne 0x2884cf
cmpltsd %xmm2, %xmm0
cmpltsd (%rsp), %xmm2
movsd 0x45d5c(%rip), %xmm1    # 0x2ce1c0
andnpd %xmm1, %xmm0
andnpd %xmm0, %xmm2
jmp 0x2884d7
movapd 0x10(%rsp), %xmm2
movapd (%rsp), %xmm1
ucomisd %xmm2, %xmm1
jae 0x2884d7
ucomisd %xmm0, %xmm2
jae 0x2884d7
addsd %xmm2, %xmm2
movapd (%rsp), %xmm3
movapd %xmm3, %xmm1
addsd %xmm0, %xmm1
cmplesd %xmm1, %xmm2
movapd %xmm2, %xmm1
andpd %xmm3, %xmm1
andnpd %xmm0, %xmm2
jmp 0x2884c9
movapd 0x10(%rsp), %xmm2
minsd %xmm2, %xmm0
movapd (%rsp), %xmm3
cmpltsd %xmm3, %xmm2
movapd %xmm2, %xmm1
andnpd %xmm0, %xmm1
andpd %xmm3, %xmm2
orpd %xmm1, %xmm2
jmp 0x2884d7
movsd 0x45de9(%rip), %xmm2    # 0x2ce2c0
movapd %xmm2, %xmm0
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::trinary_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               branch_[0].first && branch_[0].first->valid() &&
               branch_[1].first && branch_[1].first->valid() &&
               branch_[2].first && branch_[2].first->valid() ;
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x288520
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x288520
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x288520
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x288520
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x288520
movq (%rdi), %rax
popq %rbx
jmpq *0x30(%rax)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::quaternary_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::quaternary_node<double>, exprtk::details::operator_type, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*>(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* const&, exprtk::details::expression_node<double>* const&, exprtk::details::expression_node<double>* const&, exprtk::details::expression_node<double>* const&) const
inline expression_node<typename node_type::value_type>* allocate(const T1& t1, const T2& t2,
                                                                          const T3& t3, const T4& t4,
                                                                          const T5& t5) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3, t4, t5));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
pushq $0x68
popq %rdi
callq 0x118100
movq %rax, %rbx
movq (%r13), %rdx
movq (%r12), %rcx
movq (%r15), %r8
movq (%r14), %r9
movq %rax, %rdi
movq %rbp, %rsi
callq 0x288922
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
pushq $0x68
popq %rsi
movq %rbx, %rdi
callq 0x1180d0
movq %r14, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::quaternary_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               branch_[0].first && branch_[0].first->valid() &&
               branch_[1].first && branch_[1].first->valid() &&
               branch_[2].first && branch_[2].first->valid() &&
               branch_[3].first && branch_[3].first->valid() ;
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x288b1d
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x288b1d
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x288b1d
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x288b1d
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x288b1d
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x288b1d
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x288b1d
movq (%rdi), %rax
popq %rbx
jmpq *0x30(%rax)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::conditional_string_node<double>::value() const
inline T value() const exprtk_override
         {
            std::size_t r0 = 0;
            std::size_t r1 = 0;

            if (is_true(condition_))
            {
               consequent_->value();

               const range_t& range = str0_range_ptr_->range_ref();

               if (range(r0, r1, str0_base_ptr_->size()))
               {
                  const std::size_t size = (r1 - r0);

                  value_.assign(str0_base_ptr_->base() + r0, size);

                  range_.n1_c.second  = value_.size();
                  range_.cache.second = range_.n1_c.second;

                  return T(1);
               }
            }
            else
            {
               alternative_->value();

               const range_t& range = str1_range_ptr_->range_ref();

               if (range(r0, r1, str1_base_ptr_->size()))
               {
                  const std::size_t size = (r1 - r0);

                  value_.assign(str1_base_ptr_->base() + r0, size);

                  range_.n1_c.second  = value_.size();
                  range_.cache.second = range_.n1_c.second;

                  return T(0);
               }
            }

            return std::numeric_limits<T>::quiet_NaN();
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
andq $0x0, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movq %rdi, %rbx
movq 0x100(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x28adaf
jnp 0x28ae30
movq 0x108(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x80(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r14
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x22cc40
testb %al, %al
je 0x28aebe
movq 0x10(%rsp), %r14
subq 0x8(%rsp), %r14
leaq 0xe0(%rbx), %r15
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq 0x8(%rsp), %rax
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x1182b0
movsd 0x43392(%rip), %xmm0    # 0x2ce1c0
jmp 0x28aea7
movq 0x110(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x88(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r14
movq 0x78(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x22cc40
testb %al, %al
je 0x28aebe
movq 0x10(%rsp), %r14
subq 0x8(%rsp), %r14
leaq 0xe0(%rbx), %r15
movq 0x78(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq 0x8(%rsp), %rax
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x1182b0
xorpd %xmm0, %xmm0
movq 0xe8(%rbx), %rax
movq %rax, 0xc8(%rbx)
movq %rax, 0xd8(%rbx)
jmp 0x28aec6
movsd 0x433fa(%rip), %xmm0    # 0x2ce2c0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::conditional_string_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               initialised_                         &&
               condition_  && condition_  ->valid() &&
               consequent_ && consequent_ ->valid() &&
               alternative_&& alternative_->valid() ;
         }

// Assembly:
pushq %rbx
cmpb $0x1, 0x68(%rdi)
jne 0x28af1d
movq %rdi, %rbx
movq 0x100(%rdi), %rdi
testq %rdi, %rdi
je 0x28af1d
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x28af1d
movq 0x108(%rbx), %rdi
testq %rdi, %rdi
je 0x28af1d
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x28af1d
movq 0x110(%rbx), %rdi
testq %rdi, %rdi
je 0x28af1d
movq (%rdi), %rax
popq %rbx
jmpq *0x30(%rax)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::conditional_vector_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);
            T* source_vector = 0;
            T* result_vector = vds().data();

            if (is_true(condition_))
            {
               result           = consequent_.first->value();
               source_vector    = consequent_node_ptr_->vds().data();
               result_vec_size_ = consequent_node_ptr_->size();
            }
            else
            {
               result           = alternative_.first->value();
               source_vector    = alternative_node_ptr_->vds().data();
               result_vec_size_ = alternative_node_ptr_->size();
            }

            for (std::size_t i = 0; i < result_vec_size_; ++i)
            {
               result_vector[i] = source_vector[i];
            }

            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq 0x78(%rbx), %rax
movq 0x10(%rax), %r14
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
cmpeqsd %xmm0, %xmm1
movq %xmm1, %r15
andl $0x1, %r15d
movl %r15d, %eax
shll $0x4, %eax
movq 0x38(%rax,%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x58(%rbx,%r15,8), %rax
movq 0x28(%rax), %rcx
movq 0x30(%rax), %rax
movq 0x10(%rax), %r15
movq (%rcx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, 0x80(%rbx)
xorl %ecx, %ecx
cmpq %rax, %rcx
jae 0x28b344
movsd (%r15,%rcx,8), %xmm0
movsd %xmm0, (%r14,%rcx,8)
incq %rcx
jmp 0x28b32e
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::conditional_vector_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               initialised_                                      &&
               condition_  .first && condition_  .first->valid() &&
               consequent_ .first && consequent_ .first->valid() &&
               alternative_.first && alternative_.first->valid() &&
               size() <= base_size();
         }

// Assembly:
cmpb $0x1, 0x88(%rdi)
jne 0x28b3ba
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x28b3bd
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x28b3bd
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x28b3bd
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x28b3bd
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x28b3bd
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x28b3bd
movq 0x80(%rbx), %r14
movq %rbx, %rdi
callq 0x28b3e0
cmpq %rax, %r14
setbe %al
jmp 0x28b3bf
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::details::node_depth_base<exprtk::details::expression_node<double>>::compute_node_depth<std::pair<exprtk::details::expression_node<double>*, bool>>(std::pair<exprtk::details::expression_node<double>*, bool> const&, std::pair<exprtk::details::expression_node<double>*, bool> const&, std::pair<exprtk::details::expression_node<double>*, bool> const&) const
std::size_t compute_node_depth(const BranchType& n0, const BranchType& n1,
                                        const BranchType& n2) const
         {
            if (!depth_set)
            {
               depth = 1 + max_node_depth(n0, n1, n2);
               depth_set = true;
            }

            return depth;
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x28b4a4
movq 0x10(%rbx), %rax
jmp 0x28b4b7
movq %rbx, %rdi
callq 0x28b4ba
incq %rax
movq %rax, 0x10(%rbx)
movb $0x1, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::conditional_node<double>::conditional_node(exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*)
conditional_node(expression_ptr condition,
                          expression_ptr consequent,
                          expression_ptr alternative)
         {
            construct_branch_pair(condition_  , condition  );
            construct_branch_pair(consequent_ , consequent );
            construct_branch_pair(alternative_, alternative);
            assert(valid());
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
xorl %ecx, %ecx
movb %cl, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
leaq 0x21eb55(%rip), %rax    # 0x4aa130
movq %rax, (%rdi)
leaq 0x21eb9b(%rip), %rax    # 0x4aa180
movq %rax, 0x8(%rdi)
movb %cl, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
leaq 0x20(%rdi), %rax
leaq 0x30(%rdi), %r15
movb %cl, 0x38(%rdi)
leaq 0x40(%rdi), %r12
andq $0x0, 0x40(%rdi)
movb %cl, 0x48(%rdi)
movq %rax, %rdi
callq 0x2085be
movq %r15, %rdi
movq %r14, %rsi
callq 0x2085be
movq %r12, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2085be
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::conditional_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               condition_  .first && condition_  .first->valid() &&
               consequent_ .first && consequent_ .first->valid() &&
               alternative_.first && alternative_.first->valid() ;
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x28b6ea
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x28b6ea
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x28b6ea
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x28b6ea
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x28b6ea
movq (%rdi), %rax
popq %rbx
jmpq *0x30(%rax)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::cons_conditional_node<double>::value() const
inline T value() const exprtk_override
         {
            if (is_true(condition_))
               return consequent_.first->value();
            else
               return std::numeric_limits<T>::quiet_NaN();
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x28b7ca
jnp 0x28b7d5
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)
movsd 0x42ae3(%rip), %xmm0    # 0x2ce2c0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::details::node_depth_base<exprtk::details::expression_node<double>>::compute_node_depth<std::pair<exprtk::details::expression_node<double>*, bool>>(std::pair<exprtk::details::expression_node<double>*, bool> const&, std::pair<exprtk::details::expression_node<double>*, bool> const&) const
std::size_t compute_node_depth(const BranchType& n0, const BranchType& n1) const
         {
            if (!depth_set)
            {
               depth = 1 + max_node_depth(n0, n1);
               depth_set = true;
            }

            return depth;
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x28b84a
movq 0x10(%rbx), %rax
jmp 0x28b85d
movq %rbx, %rdi
callq 0x28b860
incq %rax
movq %rax, 0x10(%rbx)
movb $0x1, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::while_loop_rtc_node<double>::value() const
inline T value() const exprtk_override
         {

            T result = T(0);

            loop_runtime_checker::reset();

            while (is_true(parent_t::condition_) && loop_runtime_checker::check())
            {
               result = parent_t::loop_body_.first->value();
            }

            return result;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x40(%rdi)
leaq 0x40(%rdi), %r14
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x421e9(%rip), %xmm0    # 0x2ce2a8
jne 0x28c0c3
jnp 0x28c0db
movq %r14, %rdi
callq 0x28c1ac
testb %al, %al
je 0x28c0db
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x28c0a8
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::while_loop_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            while (is_true(condition_))
            {
               result = loop_body_.first->value();
            }

            return result;
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x42150(%rip), %xmm0    # 0x2ce2a8
jne 0x28c15c
jnp 0x28c168
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x28c140
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::loop_runtime_checker::check() const
inline bool check() const
         {
            assert(loop_runtime_check_);

            if (
                 (++iteration_count_ <= max_loop_iterations_) &&
                 loop_runtime_check_->check()
               )
            {
               return true;
            }

            loop_runtime_check::violation_context ctxt;
            ctxt.loop      = loop_type_;
            ctxt.violation = loop_runtime_check::e_iteration_count;

            loop_runtime_check_->handle_runtime_violation(ctxt);

            return false;
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x10(%rdi), %rcx
incq %rax
movq %rax, (%rdi)
cmpq (%rcx), %rax
ja 0x28c1d7
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x28c1f2
movl 0x18(%rbx), %eax
movq %rsp, %rsi
movl %eax, (%rsi)
movl $0x1, 0x4(%rsi)
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::while_loop_bc_rtc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            loop_runtime_checker::reset();

            while (is_true(parent_t::condition_) && loop_runtime_checker::check())
            {
               try
               {
                  result = parent_t::loop_body_.first->value();
               }
               catch(const break_exception<T>& e)
               {
                  return e.value;
               }
               catch(const continue_exception&)
               {}
            }

            return result;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x40(%rdi)
leaq 0x40(%rdi), %r14
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x41fe1(%rip), %xmm0    # 0x2ce2a8
jne 0x28c2cb
jnp 0x28c30f
movq %r14, %rdi
callq 0x28c1ac
testb %al, %al
je 0x28c30f
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x28c2b0
movq %rax, %rdi
cmpl $0x2, %edx
je 0x28c2fc
cmpl $0x1, %edx
jne 0x28c31c
callq 0x118070
callq 0x1183d0
jmp 0x28c2b5
callq 0x118070
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
callq 0x1183d0
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::while_loop_bc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            while (is_true(parent_t::condition_))
            {
               try
               {
                  result = parent_t::loop_body_.first->value();
               }
               catch(const break_exception<T>& e)
               {
                  return e.value;
               }
               catch(const continue_exception&)
               {}
            }

            return result;
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x41f38(%rip), %xmm0    # 0x2ce2a8
jne 0x28c374
jnp 0x28c3ad
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x28c358
movq %rax, %rdi
cmpl $0x2, %edx
je 0x28c399
cmpl $0x1, %edx
jne 0x28c3b9
callq 0x118070
callq 0x1183d0
jmp 0x28c35e
callq 0x118070
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x1183d0
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::repeat_until_loop_rtc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            loop_runtime_checker::reset(1);

            do
            {
               result = parent_t::loop_body_.first->value();
            }
            while (is_false(parent_t::condition_.first) && loop_runtime_checker::check());

            return result;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x40(%rdi), %r14
movq $0x1, 0x40(%rdi)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x41b66(%rip), %xmm0    # 0x2ce2a8
jne 0x28c752
jp 0x28c752
movq %r14, %rdi
callq 0x28c1ac
testb %al, %al
jne 0x28c721
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::repeat_until_loop_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            do
            {
               result = loop_body_.first->value();
            }
            while (is_false(condition_.first));

            return result;
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x41ad2(%rip), %xmm0    # 0x2ce2a8
jne 0x28c7da
jnp 0x28c7b4
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::repeat_until_loop_bc_rtc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            loop_runtime_checker::reset();

            do
            {
               try
               {
                  result = parent_t::loop_body_.first->value();
               }
               catch(const break_exception<T>& e)
               {
                  return e.value;
               }
               catch(const continue_exception&)
               {}
            }
            while (is_false(parent_t::condition_.first) && loop_runtime_checker::check());

            return result;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x40(%rdi)
leaq 0x40(%rdi), %r14
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x419ac(%rip), %xmm0    # 0x2ce2a8
jne 0x28c93a
jp 0x28c93a
movq %r14, %rdi
callq 0x28c1ac
testb %al, %al
jne 0x28c8db
jmp 0x28c93a
movq %rax, %rdi
cmpl $0x2, %edx
je 0x28c927
cmpl $0x1, %edx
jne 0x28c947
callq 0x118070
callq 0x1183d0
jmp 0x28c8ea
callq 0x118070
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
callq 0x1183d0
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::repeat_until_loop_bc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            do
            {
               try
               {
                  result = parent_t::loop_body_.first->value();
               }
               catch(const break_exception<T>& e)
               {
                  return e.value;
               }
               catch(const continue_exception&)
               {}
            }
            while (is_false(parent_t::condition_.first));

            return result;
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x418fe(%rip), %xmm0    # 0x2ce2a8
jne 0x28c9dd
jnp 0x28c988
jmp 0x28c9dd
movq %rax, %rdi
cmpl $0x2, %edx
je 0x28c9c9
cmpl $0x1, %edx
jne 0x28c9e9
callq 0x118070
callq 0x1183d0
jmp 0x28c998
callq 0x118070
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x1183d0
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_element_manager::get_element(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
inline scope_element& get_element(const std::string& var_name,
                                           const std::size_t index = std::numeric_limits<std::size_t>::max())
         {
            const std::size_t current_depth = parser_.state_.scope_depth;

            for (std::size_t i = 0; i < element_.size(); ++i)
            {
               scope_element& se = element_[i];

               if (se.depth > current_depth)
                  continue;
               else if (
                         details::imatch(se.name, var_name) &&
                         (se.index == index)
                       )
                  return se;
            }

            return null_element_;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, %r8
movq (%rdi), %rax
movq 0x3b0(%rax), %r13
xorl %r15d, %r15d
pushq $0x70
popq %rbx
xorl %ebp, %ebp
movq %rdi, 0x18(%rsp)
movq 0x8(%r8), %r14
movq 0x10(%r8), %rax
subq %r14, %rax
cqto
idivq %rbx
movq %rax, %r12
cmpq %r12, %rbp
jae 0x28caa1
cmpq %r13, 0x30(%r14,%r15)
ja 0x28ca93
leaq (%r14,%r15), %rdi
movq %rdi, 0x10(%rsp)
movq 0x20(%rsp), %rsi
callq 0x1fbcc5
movq 0x18(%rsp), %r8
testb %al, %al
je 0x28ca93
movq 0x8(%rsp), %rax
cmpq %rax, 0x28(%r14,%r15)
je 0x28ca9c
incq %rbp
addq $0x70, %r15
jmp 0x28ca4c
movq 0x10(%rsp), %rax
addq $0x20, %r8
cmpq %r12, %rbp
cmovbq %rax, %r8
movq %r8, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::is_variable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool is_variable(const std::string& variable_name) const
         {
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else if (
                         symtab_list_[i].local_data().variable_store
                           .symbol_exists(variable_name)
                       )
                  return true;
            }

            return false;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq (%r14), %rax
movq 0x8(%r14), %r12
subq %rax, %r12
sarq $0x3, %r12
cmpq %r12, %r15
jae 0x28cb05
movq (%rax,%r15,8), %rax
testq %rax, %rax
je 0x28cb00
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x28cb00
movq %rbx, %rsi
callq 0x196770
testb %al, %al
jne 0x28cb05
incq %r15
jmp 0x28cacf
cmpq %r12, %r15
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_element_manager::add_element(exprtk::parser<double>::scope_element const&)
inline bool add_element(const scope_element& se)
         {
            for (std::size_t i = 0; i < element_.size(); ++i)
            {
               scope_element& cse = element_[i];

               if (
                    details::imatch(cse.name, se.name) &&
                    (cse.depth <= se.depth)            &&
                    (cse.index == se.index)            &&
                    (cse.size  == se.size )            &&
                    (cse.type  == se.type )            &&
                    (cse.active)
                  )
                  return false;
            }

            switch (se.type)
            {
               case scope_element::e_variable : total_local_symb_size_bytes_ += sizeof(T);
                                                break;

               case scope_element::e_literal  : total_local_symb_size_bytes_ += sizeof(T);
                                                break;

               case scope_element::e_vector   : total_local_symb_size_bytes_ += sizeof(T) * se.size;
                                                break;

               default                        : break;
            }

            element_.push_back(se);
            std::sort(element_.begin(),element_.end());

            return true;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movq %rax, (%rsp)
xorl %ebp, %ebp
xorl %r13d, %r13d
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %rax
subq %r15, %rax
cqto
pushq $0x70
popq %rcx
idivq %rcx
movq %rax, %r12
cmpq %rax, %r13
jae 0x28cbda
leaq (%r15,%rbp), %rdi
movq %r14, %rsi
callq 0x1fbcc5
testb %al, %al
je 0x28cbd1
movq 0x30(%r15,%rbp), %rax
cmpq 0x30(%r14), %rax
ja 0x28cbd1
movq 0x28(%r15,%rbp), %rax
cmpq 0x28(%r14), %rax
jne 0x28cbd1
movq 0x20(%r15,%rbp), %rax
cmpq 0x20(%r14), %rax
jne 0x28cbd1
movl 0x48(%r15,%rbp), %eax
cmpl 0x48(%r14), %eax
jne 0x28cbd1
cmpb $0x0, 0x4c(%r15,%rbp)
jne 0x28cc18
incq %r13
addq $0x70, %rbp
jmp 0x28cb72
movl 0x48(%r14), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x28cbeb
pushq $0x8
popq %rax
jmp 0x28cbf8
cmpl $0x3, %eax
jne 0x28cbff
movq 0x20(%r14), %rax
shlq $0x3, %rax
addq %rax, 0x98(%rbx)
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x28cec2
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x28d141
cmpq %r12, %r13
setae %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_element::operator<(exprtk::parser<double>::scope_element const&) const
bool operator < (const scope_element& se) const
         {
            if (ip_index < se.ip_index)
               return true;
            else if (ip_index > se.ip_index)
               return false;
            else if (depth < se.depth)
               return true;
            else if (depth > se.depth)
               return false;
            else if (index < se.index)
               return true;
            else if (index > se.index)
               return false;
            else
               return (name < se.name);
         }

// Assembly:
movq 0x40(%rdi), %rcx
movq 0x40(%rsi), %rdx
movb $0x1, %al
cmpq %rdx, %rcx
jb 0x28d671
jbe 0x28d664
xorl %eax, %eax
retq
movq 0x30(%rdi), %rcx
movq 0x30(%rsi), %rdx
cmpq %rdx, %rcx
jae 0x28d672
retq
ja 0x28d661
movq 0x28(%rdi), %rcx
movq 0x28(%rsi), %rdx
cmpq %rdx, %rcx
jb 0x28d671
ja 0x28d661
jmp 0x195caa
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::for_loop_node<double>::collect_nodes(std::vector<exprtk::details::expression_node<double>**, std::allocator<exprtk::details::expression_node<double>**>>&)
void collect_nodes(typename expression_node<T>::noderef_list_t& node_delete_list) exprtk_override
         {
            expression_node<T>::ndb_t::collect(initialiser_ , node_delete_list);
            expression_node<T>::ndb_t::collect(condition_   , node_delete_list);
            expression_node<T>::ndb_t::collect(incrementor_ , node_delete_list);
            expression_node<T>::ndb_t::collect(loop_body_   , node_delete_list);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %r15
leaq 0x20(%rdi), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x2093c4
leaq 0x30(%r14), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x2093c4
leaq 0x40(%r14), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x2093c4
addq $0x50, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2093c4
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::for_loop_rtc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            loop_runtime_checker::reset();

            if (parent_t::initialiser_.first)
               parent_t::initialiser_.first->value();

            if (parent_t::incrementor_.first)
            {
               while (is_true(parent_t::condition_) && loop_runtime_checker::check())
               {
                  result = parent_t::loop_body_.first->value();
                  parent_t::incrementor_.first->value();
               }
            }
            else
            {
               while (is_true(parent_t::condition_) && loop_runtime_checker::check())
               {
                  result = parent_t::loop_body_.first->value();
               }
            }

            return result;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x60(%rdi)
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x28db81
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x60(%rbx), %r14
cmpq $0x0, 0x40(%rbx)
je 0x28dbd2
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x40701(%rip), %xmm0    # 0x2ce2a8
jne 0x28dbab
jnp 0x28dc09
movq %r14, %rdi
callq 0x28c1ac
testb %al, %al
je 0x28dc09
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movq 0x40(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x28db95
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x406bb(%rip), %xmm0    # 0x2ce2a8
jne 0x28dbf1
jnp 0x28dc09
movq %r14, %rdi
callq 0x28c1ac
testb %al, %al
je 0x28dc09
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x28dbd6
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::for_loop_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            if (initialiser_.first)
               initialiser_.first->value();

            if (incrementor_.first)
            {
               while (is_true(condition_))
               {
                  result = loop_body_.first->value();
                  incrementor_.first->value();
               }
            }
            else
            {
               while (is_true(condition_))
               {
                  result = loop_body_.first->value();
               }
            }

            return result;
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x28dc85
movq (%rdi), %rax
callq *0x18(%rax)
cmpq $0x0, 0x40(%rbx)
je 0x28dcc8
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x40600(%rip), %xmm0    # 0x2ce2a8
jne 0x28dcac
jnp 0x28dcf4
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x40(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x28dc96
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x405c4(%rip), %xmm0    # 0x2ce2a8
jne 0x28dce8
jnp 0x28dcf4
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x28dccc
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::details::node_depth_base<exprtk::details::expression_node<double>>::compute_node_depth<std::pair<exprtk::details::expression_node<double>*, bool>>(std::pair<exprtk::details::expression_node<double>*, bool> const&, std::pair<exprtk::details::expression_node<double>*, bool> const&, std::pair<exprtk::details::expression_node<double>*, bool> const&, std::pair<exprtk::details::expression_node<double>*, bool> const&) const
std::size_t compute_node_depth(const BranchType& n0, const BranchType& n1,
                                        const BranchType& n2, const BranchType& n3) const
         {
            if (!depth_set)
            {
               depth = 1 + max_node_depth(n0, n1, n2, n3);
               depth_set = true;
            }

            return depth;
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x28dd30
movq 0x10(%rbx), %rax
jmp 0x28dd43
movq %rbx, %rdi
callq 0x28dd46
incq %rax
movq %rax, 0x10(%rbx)
movb $0x1, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::for_loop_node<double>::for_loop_node(exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*)
for_loop_node(expression_ptr initialiser,
                       expression_ptr condition,
                       expression_ptr incrementor,
                       expression_ptr loop_body)
         {
            construct_branch_pair(initialiser_, initialiser);
            construct_branch_pair(condition_  , condition  );
            construct_branch_pair(incrementor_, incrementor);
            construct_branch_pair(loop_body_  , loop_body  );
            assert(valid());
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
xorl %ecx, %ecx
movb %cl, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
leaq 0x21ca77(%rip), %rax    # 0x4aa848
movq %rax, (%rdi)
leaq 0x21cabd(%rip), %rax    # 0x4aa898
movq %rax, 0x8(%rdi)
leaq 0x20(%rdi), %rax
movb %cl, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %cl, 0x38(%rdi)
andq $0x0, 0x40(%rdi)
leaq 0x30(%rdi), %r12
leaq 0x40(%rdi), %r13
movb %cl, 0x48(%rdi)
leaq 0x50(%rdi), %rbp
andq $0x0, 0x50(%rdi)
movb %cl, 0x58(%rdi)
movq %rax, %rdi
callq 0x2085be
movq %r12, %rdi
movq %r15, %rsi
callq 0x2085be
movq %r13, %rdi
movq %r14, %rsi
callq 0x2085be
movq %rbp, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2085be
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::for_loop_bc_rtc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            loop_runtime_checker::reset();

            if (parent_t::initialiser_.first)
               parent_t::initialiser_.first->value();

            if (parent_t::incrementor_.first)
            {
               while (is_true(parent_t::condition_) && loop_runtime_checker::check())
               {
                  try
                  {
                     result = parent_t::loop_body_.first->value();
                  }
                  catch(const break_exception<T>& e)
                  {
                     return e.value;
                  }
                  catch(const continue_exception&)
                  {}

                  parent_t::incrementor_.first->value();
               }
            }
            else
            {
               while (is_true(parent_t::condition_) && loop_runtime_checker::check())
               {
                  try
                  {
                     result = parent_t::loop_body_.first->value();
                  }
                  catch(const break_exception<T>& e)
                  {
                     return e.value;
                  }
                  catch(const continue_exception&)
                  {}
               }
            }

            return result;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x60(%rdi)
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x28dead
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x60(%rbx), %r14
cmpq $0x0, 0x40(%rbx)
je 0x28df23
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x403d5(%rip), %xmm0    # 0x2ce2a8
jne 0x28dedb
jnp 0x28df89
movq %r14, %rdi
callq 0x28c1ac
testb %al, %al
je 0x28df89
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movq 0x40(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x28dec1
cmpl $0x2, %edx
je 0x28df73
cmpl $0x1, %edx
jne 0x28df96
movq %rax, %rdi
callq 0x118070
callq 0x1183d0
jmp 0x28defa
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x4036a(%rip), %xmm0    # 0x2ce2a8
jne 0x28df42
jnp 0x28df89
movq %r14, %rdi
callq 0x28c1ac
testb %al, %al
je 0x28df89
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x28df27
cmpl $0x2, %edx
je 0x28df73
cmpl $0x1, %edx
jne 0x28df96
movq %rax, %rdi
callq 0x118070
callq 0x1183d0
jmp 0x28df2c
movq %rax, %rdi
callq 0x118070
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
callq 0x1183d0
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::for_loop_bc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            if (parent_t::initialiser_.first)
               parent_t::initialiser_.first->value();

            if (parent_t::incrementor_.first)
            {
               while (is_true(parent_t::condition_))
               {
                  try
                  {
                     result = parent_t::loop_body_.first->value();
                  }
                  catch(const break_exception<T>& e)
                  {
                     return e.value;
                  }
                  catch(const continue_exception&)
                  {}

                  parent_t::incrementor_.first->value();
               }
            }
            else
            {
               while (is_true(parent_t::condition_))
               {
                  try
                  {
                     result = parent_t::loop_body_.first->value();
                  }
                  catch(const break_exception<T>& e)
                  {
                     return e.value;
                  }
                  catch(const continue_exception&)
                  {}
               }
            }

            return result;
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x28dfe3
movq (%rdi), %rax
callq *0x18(%rax)
cmpq $0x0, 0x40(%rbx)
je 0x28e043
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x402a2(%rip), %xmm0    # 0x2ce2a8
jne 0x28e00e
jnp 0x28e09f
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x40(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x28dff4
cmpl $0x2, %edx
je 0x28e088
cmpl $0x1, %edx
jne 0x28e0ab
movq %rax, %rdi
callq 0x118070
callq 0x1183d0
jmp 0x28e01e
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x40249(%rip), %xmm0    # 0x2ce2a8
jne 0x28e063
jnp 0x28e09f
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x28e047
cmpl $0x2, %edx
je 0x28e088
cmpl $0x1, %edx
jne 0x28e0ab
movq %rax, %rdi
callq 0x118070
callq 0x1183d0
jmp 0x28e04d
movq %rax, %rdi
callq 0x118070
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x1183d0
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x118360
nop