LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x48, %rsp
movq %rdx, 0x18(%rsp)
movq 0x10(%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x38(%rsp)
subq %rcx, %rax
je 0x31e0b5
movq %rdi, 0x10(%rsp)
movq (%rdi), %rcx
sarq $0x4, %rax
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rdx
movq 0x3b0(%rcx), %rax
movq %rax, 0x30(%rsp)
movq (%rsi), %rax
movq %rax, 0x40(%rsp)
movq 0x8(%rsi), %rbx
cmpq $0x1, %rdx
movq %rdx, 0x28(%rsp)
adcq $0x0, %rdx
movq %rdx, 0x20(%rsp)
movb $0x1, %r13b
xorl %r12d, %r12d
imulq $0x70, %r12, %rax
movq 0x38(%rsp), %rcx
leaq (%rcx,%rax), %rdx
movq %rdx, 0x8(%rsp)
movq 0x30(%rsp), %rdx
cmpq %rdx, 0x30(%rcx,%rax)
ja 0x31e089
movq 0x8(%rsp), %rax
cmpq %rbx, 0x8(%rax)
jne 0x31e089
testq %rbx, %rbx
je 0x31e079
movq 0x8(%rsp), %rax
movq (%rax), %r15
xorl %r14d, %r14d
movsbl (%r15,%r14), %edi
callq 0x11e450
movl %eax, %ebp
movq 0x40(%rsp), %rax
movsbl (%rax,%r14), %edi
callq 0x11e450
cmpl %eax, %ebp
jne 0x31e089
incq %r14
cmpq %r14, %rbx
jne 0x31e052
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq %rax, 0x28(%rcx)
je 0x31e0a0
incq %r12
cmpq 0x28(%rsp), %r12
setb %r13b
cmpq 0x20(%rsp), %r12
jne 0x31e019
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
testb $0x1, %r13b
cmovneq 0x8(%rsp), %rdi
jmp 0x31e0b9
addq $0x20, %rdi
movq %rdi, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x31f477
jbe 0x31f46a
xorl %eax, %eax
retq
movq 0x30(%rdi), %rcx
movq 0x30(%rsi), %rdx
cmpq %rdx, %rcx
jae 0x31f478
retq
ja 0x31f467
movq 0x28(%rdi), %rcx
movq 0x28(%rsi), %rdx
cmpq %rdx, %rcx
jb 0x31f477
ja 0x31f467
jmp 0x1e76d0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x20(%rdi)
je 0x31fb30
cmpb $0x0, 0x28(%r14)
je 0x31fb30
leaq 0x20(%r14), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x1ead52
cmpq $0x0, 0x30(%r14)
je 0x31fb50
cmpb $0x0, 0x38(%r14)
je 0x31fb50
leaq 0x30(%r14), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x1ead52
cmpq $0x0, 0x40(%r14)
je 0x31fb70
cmpb $0x0, 0x48(%r14)
je 0x31fb70
leaq 0x40(%r14), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x1ead52
cmpq $0x0, 0x50(%r14)
je 0x31fb90
cmpb $0x0, 0x58(%r14)
je 0x31fb90
addq $0x50, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x1ead52
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x18, %rsp
movq %rdi, %rbx
movq $0x0, 0x60(%rdi)
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x31fbb9
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x40(%rbx), %r14
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
testq %r14, %r14
je 0x31fc60
ucomisd %xmm1, %xmm0
jne 0x31fbe0
jnp 0x31fcf4
movq 0x60(%rbx), %rax
movq 0x70(%rbx), %rcx
incq %rax
movq %rax, 0x60(%rbx)
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
cmpq (%rcx), %rax
ja 0x31fcd4
movsd %xmm0, (%rsp)
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
je 0x31fcd4
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movq 0x40(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x695ae(%rip), %xmm0    # 0x3891f0
jne 0x31fc4a
jnp 0x31fcef
movq 0x60(%rbx), %rax
movq 0x70(%rbx), %rcx
incq %rax
movq %rax, 0x60(%rbx)
cmpq (%rcx), %rax
jbe 0x31fc06
jmp 0x31fcd4
ucomisd %xmm1, %xmm0
jne 0x31fc6c
jnp 0x31fcf4
movq 0x60(%rbx), %rax
movq 0x70(%rbx), %rcx
incq %rax
movq %rax, 0x60(%rbx)
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
cmpq (%rcx), %rax
ja 0x31fcd4
movsd %xmm0, (%rsp)
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
je 0x31fcd4
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x69534(%rip), %xmm0    # 0x3891f0
jne 0x31fcc0
jnp 0x31fcef
movq 0x60(%rbx), %rax
movq 0x70(%rbx), %rcx
incq %rax
movq %rax, 0x60(%rbx)
cmpq (%rcx), %rax
jbe 0x31fc8e
movl 0x78(%rbx), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movl $0x1, 0x4(%rsi)
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movsd (%rsp), %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x31fd90
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x40(%rbx), %r14
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
testq %r14, %r14
je 0x31fde0
ucomisd %xmm1, %xmm0
jne 0x31fdaf
jnp 0x31fe12
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movq 0x40(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x69416(%rip), %xmm0    # 0x3891f0
jne 0x31fdaf
jp 0x31fdaf
jmp 0x31fe0d
ucomisd %xmm1, %xmm0
jne 0x31fde8
jnp 0x31fe12
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x693e7(%rip), %xmm0    # 0x3891f0
jne 0x31fde8
jp 0x31fde8
movsd (%rsp), %xmm1
movapd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r14
xorl %eax, %eax
movb %al, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
leaq 0x21198a(%rip), %rcx    # 0x531868
movq %rcx, (%rdi)
leaq 0x2119d0(%rip), %rcx    # 0x5318b8
movq %rcx, 0x8(%rdi)
movb %al, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movb %al, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movb %al, 0x58(%rdi)
testq %rsi, %rsi
je 0x31ff36
movq %rsi, %r13
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x31ff1e
xorl %eax, %eax
jmp 0x31ff2e
movq (%r13), %rax
movq %r13, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
setne %al
movq %r13, 0x20(%r14)
movb %al, 0x28(%r14)
testq %r12, %r12
je 0x31ff66
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x31ff4e
xorl %eax, %eax
jmp 0x31ff5e
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
setne %al
movq %r12, 0x30(%r14)
movb %al, 0x38(%r14)
testq %r15, %r15
je 0x31ff94
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x31ff7d
xorl %eax, %eax
jmp 0x31ff8c
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
setne %al
movq %r15, 0x40(%r14)
movb %al, 0x48(%r14)
testq %rbx, %rbx
je 0x31ffc2
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x31ffab
xorl %eax, %eax
jmp 0x31ffba
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
setne %al
movq %rbx, 0x50(%r14)
movb %al, 0x58(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x3201ba
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x40(%rbx), %r14
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm2, %xmm2
xorps %xmm1, %xmm1
testq %r14, %r14
je 0x32023f
movsd %xmm1, (%rsp)
ucomisd %xmm2, %xmm0
jne 0x3201e5
jnp 0x3202ab
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movq 0x40(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x68fd7(%rip), %xmm0    # 0x3891f0
jne 0x3201ee
jp 0x3201ee
jmp 0x3202ab
cmpl $0x2, %edx
je 0x320295
cmpl $0x1, %edx
jne 0x3202b8
movq %rax, %rdi
callq 0x11e070
callq 0x11e3d0
jmp 0x3201fd
movsd %xmm1, (%rsp)
ucomisd %xmm2, %xmm0
jne 0x32024c
jnp 0x3202ab
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x68f7a(%rip), %xmm0    # 0x3891f0
jne 0x320255
jp 0x320255
jmp 0x3202ab
cmpl $0x2, %edx
je 0x320295
cmpl $0x1, %edx
jne 0x3202b8
movq %rax, %rdi
callq 0x11e070
callq 0x11e3d0
jmp 0x320264
movq %rax, %rdi
callq 0x11e070
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
callq 0x11e3d0
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x11e330
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::switch_n_node<double, exprtk::parser<double>::expression_generator<double>::switch_nodes::switch_impl_1>::~switch_n_node()
class switch_n_node exprtk_final : public switch_node<T>
      {
      public:

         typedef expression_node<T>* expression_ptr;

         template <typename Allocator,
                   template <typename, typename> class Sequence>
         explicit switch_n_node(const Sequence<expression_ptr,Allocator>& arg_list)
         : switch_node<T>(arg_list)
         {}

         inline T value() const exprtk_override
         {
            return Switch_N::process(switch_node<T>::arg_list_);
         }
      }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x21103f(%rip), %rax    # 0x531ac8
movq %rax, (%rdi)
leaq 0x211085(%rip), %rax    # 0x531b18
movq %rax, 0x8(%rdi)
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x320aac
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x11e0c0
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x11e0c0
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::varnode_optimise_sf3(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [3])
inline expression_node_ptr varnode_optimise_sf3(const details::operator_type& operation, expression_node_ptr (&branch)[3])
         {
            typedef details::variable_node<Type>* variable_ptr;

            const Type& v0 = static_cast<variable_ptr>(branch[0])->ref();
            const Type& v1 = static_cast<variable_ptr>(branch[1])->ref();
            const Type& v2 = static_cast<variable_ptr>(branch[2])->ref();

            switch (operation)
            {
               #define case_stmt(op)                                                                \
               case details::e_sf##op : return node_allocator_->                                    \
                             allocate_rrr<details::sf3_var_node<Type,details::sf##op##_op<Type> > > \
                                (v0, v1, v2);                                                       \

               case_stmt(00) case_stmt(01) case_stmt(02) case_stmt(03)
               case_stmt(04) case_stmt(05) case_stmt(06) case_stmt(07)
               case_stmt(08) case_stmt(09) case_stmt(10) case_stmt(11)
               case_stmt(12) case_stmt(13) case_stmt(14) case_stmt(15)
               case_stmt(16) case_stmt(17) case_stmt(18) case_stmt(19)
               case_stmt(20) case_stmt(21) case_stmt(22) case_stmt(23)
               case_stmt(24) case_stmt(25) case_stmt(26) case_stmt(27)
               case_stmt(28) case_stmt(29) case_stmt(30) case_stmt(31)
               case_stmt(32) case_stmt(33) case_stmt(34) case_stmt(35)
               case_stmt(36) case_stmt(37) case_stmt(38) case_stmt(39)
               case_stmt(40) case_stmt(41) case_stmt(42) case_stmt(43)
               case_stmt(44) case_stmt(45) case_stmt(46) case_stmt(47)
               #undef case_stmt
               default : return error_node();
            }
         }

// Assembly:
movl $0xfffffc18, %eax       # imm = 0xFFFFFC18
addl (%rsi), %eax
cmpl $0x2f, %eax
ja 0x323ff5
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x10(%rdx), %rcx
movq 0x28(%rcx), %rbx
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
movq 0x28(%rdx), %r14
movq 0x28(%rcx), %r15
movl %eax, %eax
leaq 0x21b7b5(%rip), %rcx    # 0x53f768
movq (%rcx,%rax,8), %r12
leaq 0x21b92a(%rip), %rcx    # 0x53f8e8
movq (%rcx,%rax,8), %r13
movl $0x38, %edi
callq 0x11e0f0
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq %r12, (%rax)
movq %r13, 0x8(%rax)
movq %r15, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::sf3_node<double, exprtk::details::sf00_op<double>>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::sf3_node<double, exprtk::details::sf00_op<double>>, exprtk::details::operator_type const, exprtk::details::expression_node<double>*>(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [3])
inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[3])
         {
            expression_node<typename ResultNode::value_type>* result =
               allocate<ResultNode>(operation, branch[0], branch[1], branch[2]);
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movl $0x58, %edi
callq 0x11e0f0
movq %rax, %rbx
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq 0x10(%r14), %r8
movq %rax, %rdi
movq %r15, %rsi
callq 0x314f98
leaq 0x20f7f3(%rip), %rax    # 0x533820
movq %rax, (%rbx)
leaq 0x8(%rbx), %r14
leaq 0x20f835(%rip), %rax    # 0x533870
movq %rax, 0x8(%rbx)
movq %rbx, %rsi
addq $0x28, %rsi
movq %r14, %rdi
callq 0x315238
movq 0x8(%rbx), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x58, %esi
movq %rbx, %rdi
callq 0x11e0c0
movq %r14, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::varnode_optimise_sf4(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [4])
inline expression_node_ptr varnode_optimise_sf4(const details::operator_type& operation, expression_node_ptr (&branch)[4])
         {
            typedef details::variable_node<Type>* variable_ptr;

            const Type& v0 = static_cast<variable_ptr>(branch[0])->ref();
            const Type& v1 = static_cast<variable_ptr>(branch[1])->ref();
            const Type& v2 = static_cast<variable_ptr>(branch[2])->ref();
            const Type& v3 = static_cast<variable_ptr>(branch[3])->ref();

            switch (operation)
            {
               #define case_stmt(op)                                                                 \
               case details::e_sf##op : return node_allocator_->                                     \
                             allocate_rrrr<details::sf4_var_node<Type,details::sf##op##_op<Type> > > \
                                (v0, v1, v2, v3);                                                    \

               case_stmt(48) case_stmt(49) case_stmt(50) case_stmt(51)
               case_stmt(52) case_stmt(53) case_stmt(54) case_stmt(55)
               case_stmt(56) case_stmt(57) case_stmt(58) case_stmt(59)
               case_stmt(60) case_stmt(61) case_stmt(62) case_stmt(63)
               case_stmt(64) case_stmt(65) case_stmt(66) case_stmt(67)
               case_stmt(68) case_stmt(69) case_stmt(70) case_stmt(71)
               case_stmt(72) case_stmt(73) case_stmt(74) case_stmt(75)
               case_stmt(76) case_stmt(77) case_stmt(78) case_stmt(79)
               case_stmt(80) case_stmt(81) case_stmt(82) case_stmt(83)
               case_stmt(84) case_stmt(85) case_stmt(86) case_stmt(87)
               case_stmt(88) case_stmt(89) case_stmt(90) case_stmt(91)
               case_stmt(92) case_stmt(93) case_stmt(94) case_stmt(95)
               case_stmt(96) case_stmt(97) case_stmt(98) case_stmt(99)
               #undef case_stmt
               default : return error_node();
            }
         }

// Assembly:
movl $0xfffffbe8, %eax       # imm = 0xFFFFFBE8
addl (%rsi), %eax
cmpl $0x33, %eax
ja 0x3282ca
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rdx), %rcx
movq 0x28(%rcx), %rbx
movq 0x10(%rdx), %rcx
movq 0x28(%rcx), %r14
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
movq 0x28(%rdx), %r15
movq 0x28(%rcx), %r12
movl %eax, %eax
leaq 0x2177e9(%rip), %rcx    # 0x53fa68
movq (%rcx,%rax,8), %r13
leaq 0x21797e(%rip), %rcx    # 0x53fc08
movq (%rcx,%rax,8), %rbp
movl $0x40, %edi
callq 0x11e0f0
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq %r13, (%rax)
movq %rbp, 0x8(%rax)
movq %r12, 0x20(%rax)
movq %r15, 0x28(%rax)
movq %r14, 0x30(%rax)
movq %rbx, 0x38(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::sf4_node<double, exprtk::details::sf48_op<double>>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::sf4_node<double, exprtk::details::sf48_op<double>>, exprtk::details::operator_type const, exprtk::details::expression_node<double>*>(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [4])
inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[4])
         {
            expression_node<typename ResultNode::value_type>* result =
               allocate<ResultNode>(operation, branch[0], branch[1], branch[2], branch[3]);
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movl $0x68, %edi
callq 0x11e0f0
movq %rax, %rbx
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq 0x10(%r14), %r8
movq 0x18(%r14), %r9
movq %rax, %rdi
movq %r15, %rsi
callq 0x315896
leaq 0x20ebb9(%rip), %rax    # 0x536ec0
movq %rax, (%rbx)
leaq 0x8(%rbx), %r14
leaq 0x20ebfb(%rip), %rax    # 0x536f10
movq %rax, 0x8(%rbx)
movq %rbx, %rsi
addq $0x28, %rsi
movq %r14, %rdi
callq 0x315aac
movq 0x8(%rbx), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x11e0c0
movq %r14, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::sf4_node<double, exprtk::details::sf98_op<double>>::value() const
inline T value() const exprtk_override
         {
            const T x = quaternary_node<T>::branch_[0].first->value();
            const T y = quaternary_node<T>::branch_[1].first->value();
            const T z = quaternary_node<T>::branch_[2].first->value();
            const T w = quaternary_node<T>::branch_[3].first->value();

            return SpecialFunction::process(x, y, z, w);
         }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, 0x10(%rsp)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, (%rsp)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, 0x20(%rsp)
movq 0x58(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd 0x10(%rsp), %xmm4
movapd %xmm4, %xmm2
movapd (%rsp), %xmm5
subsd %xmm5, %xmm2
movapd 0x5cd10(%rip), %xmm3    # 0x389430
movapd %xmm2, %xmm1
xorpd %xmm3, %xmm1
unpcklpd %xmm5, %xmm4            # xmm4 = xmm4[0],xmm5[0]
xorpd %xmm4, %xmm3
maxpd %xmm4, %xmm3
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
maxsd %xmm3, %xmm4
maxsd 0x5c8d8(%rip), %xmm4    # 0x389020
maxsd %xmm2, %xmm1
mulsd 0x5c904(%rip), %xmm4    # 0x389058
cmplesd %xmm4, %xmm1
movapd 0x20(%rsp), %xmm2
andpd %xmm1, %xmm2
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
movapd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::break_node<double>::value() const
inline T value() const exprtk_override
         {
            const T result = return_.first ?
                             return_.first->value() :
                             std::numeric_limits<T>::quiet_NaN();

            throw break_exception<T>(result);

            #if !defined(_MSC_VER) && !defined(__NVCOMPILER)
            return std::numeric_limits<T>::quiet_NaN();
            #endif
         }

// Assembly:
pushq %rax
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
jne 0x32c8c6
movsd 0x5c944(%rip), %xmm0    # 0x389208
jmp 0x32c8cc
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movl $0x8, %edi
callq 0x11e1f0
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
leaq 0x204c05(%rip), %rsi    # 0x5314f0
movq %rax, %rdi
xorl %edx, %edx
callq 0x11e310
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::is_reserved_symbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool is_reserved_symbol(const std::string& symbol)
      {
         for (std::size_t i = 0; i < reserved_symbols_size; ++i)
         {
            if (imatch(symbol, reserved_symbols[i]))
            {
               return true;
            }
         }

         return false;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r14
movq 0x8(%rdi), %r15
movb $0x1, %al
xorl %r13d, %r13d
movb %al, 0x7(%rsp)
movq %r13, %rax
shlq $0x5, %rax
leaq 0x213d9f(%rip), %rcx    # 0x540780
cmpq 0x8(%rax,%rcx), %r15
jne 0x32ca20
testq %r15, %r15
je 0x32ca36
leaq 0x213d8c(%rip), %rcx    # 0x540780
addq %rcx, %rax
movq (%rax), %r12
xorl %ebx, %ebx
movsbl (%r14,%rbx), %edi
callq 0x11e450
movl %eax, %ebp
movsbl (%r12,%rbx), %edi
callq 0x11e450
cmpl %eax, %ebp
jne 0x32ca20
incq %rbx
cmpq %rbx, %r15
jne 0x32c9fc
jmp 0x32ca36
cmpq $0x58, %r13
leaq 0x1(%r13), %rcx
setb %al
movq %rcx, %r13
cmpq $0x59, %rcx
jne 0x32c9cf
jmp 0x32ca3a
movb 0x7(%rsp), %al
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_element_manager::get_active_element(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
inline scope_element& get_active_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)                &&
                         (se.active)
                       )
                  return se;
            }

            return null_element_;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x18(%rsp)
movq 0x10(%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x38(%rsp)
subq %rcx, %rax
je 0x332c9e
movq %rdi, 0x10(%rsp)
movq (%rdi), %rcx
sarq $0x4, %rax
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rdx
movq 0x3b0(%rcx), %rax
movq %rax, 0x30(%rsp)
movq (%rsi), %rax
movq %rax, 0x40(%rsp)
movq 0x8(%rsi), %rbx
cmpq $0x1, %rdx
movq %rdx, 0x28(%rsp)
adcq $0x0, %rdx
movq %rdx, 0x20(%rsp)
movb $0x1, %r13b
xorl %r12d, %r12d
imulq $0x70, %r12, %rax
movq 0x38(%rsp), %rcx
leaq (%rcx,%rax), %rdx
movq %rdx, 0x8(%rsp)
movq 0x30(%rsp), %rdx
cmpq %rdx, 0x30(%rcx,%rax)
ja 0x332c72
movq 0x8(%rsp), %rax
cmpq %rbx, 0x8(%rax)
jne 0x332c72
testq %rbx, %rbx
je 0x332c57
movq 0x8(%rsp), %rax
movq (%rax), %r15
xorl %r14d, %r14d
movsbl (%r15,%r14), %edi
callq 0x11e450
movl %eax, %ebp
movq 0x40(%rsp), %rax
movsbl (%rax,%r14), %edi
callq 0x11e450
cmpl %eax, %ebp
jne 0x332c72
incq %r14
cmpq %r14, %rbx
jne 0x332c30
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq %rax, 0x28(%rcx)
jne 0x332c72
movq 0x8(%rsp), %rax
cmpb $0x0, 0x4c(%rax)
jne 0x332c89
incq %r12
cmpq 0x28(%rsp), %r12
setb %r13b
cmpq 0x20(%rsp), %r12
jne 0x332bf7
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
testb $0x1, %r13b
cmovneq 0x8(%rsp), %rdi
jmp 0x332ca2
addq $0x20, %rdi
movq %rdi, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::parser_helper::token_is(exprtk::lexer::token::token_type const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::lexer::parser_helper::token_advance_mode)
inline bool token_is(const token_t::token_type& ttype,
                              const std::string& value,
                              const token_advance_mode mode = e_advance)
         {
            if (
                 (current_token().type != ttype) ||
                 !exprtk::details::imatch(value,current_token().value)
               )
            {
               return false;
            }

            advance_token(mode);

            return true;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x70(%rdi), %eax
cmpl (%rsi), %eax
jne 0x332dbb
movq %rdi, %rbx
movq 0x8(%rdx), %r12
cmpq 0x80(%rdi), %r12
jne 0x332dbb
movl %ecx, 0xc(%rsp)
leaq 0x78(%rbx), %rax
movq %rax, 0x10(%rsp)
testq %r12, %r12
je 0x332d9d
movq (%rdx), %r13
movq 0x10(%rsp), %rax
movq (%rax), %r14
xorl %ebp, %ebp
movsbl (%r13,%rbp), %edi
callq 0x11e450
movl %eax, %r15d
movsbl (%r14,%rbp), %edi
callq 0x11e450
cmpl %eax, %r15d
jne 0x332dbb
incq %rbp
cmpq %rbp, %r12
jne 0x332d78
movb $0x1, %r15b
cmpl $0x1, 0xc(%rsp)
jne 0x332dbe
movq 0x18(%rbx), %r14
cmpq %r14, 0x8(%rbx)
je 0x332dd0
leaq 0x30(%r14), %rax
movq %rax, 0x18(%rbx)
jmp 0x332dd4
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%rbx), %r14
movl (%r14), %eax
movl %eax, 0x70(%rbx)
leaq 0x8(%r14), %rsi
movq 0x10(%rsp), %rdi
callq 0x11e5a0
movq 0x28(%r14), %rax
movq %rax, 0x98(%rbx)
jmp 0x332dbe
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::vector_init_zero_value_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::vector_init_zero_value_node<double>, double*, unsigned long, std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>>>(double* const&, unsigned long const&, std::vector<exprtk::details::expression_node<double>*, std::allocator<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
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl $0x48, %edi
callq 0x11e0f0
movq %rax, %rbx
movq (%r12), %rax
movb $0x0, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
leaq 0x205eed(%rip), %rcx    # 0x538d18
movq %rcx, (%rbx)
leaq 0x205f33(%rip), %rcx    # 0x538d68
movq %rcx, 0x8(%rbx)
movq %rax, 0x20(%rbx)
movq (%r15), %rax
movq %rax, 0x28(%rbx)
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x333224
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x48, %esi
movq %rbx, %rdi
callq 0x11e0c0
movq %r14, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::vector_initialisation_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::vector_initialisation_node<double>, double*, unsigned long, std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>>, bool>(double* const&, unsigned long const&, std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&, bool 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
movl $0x58, %edi
callq 0x11e0f0
movq %rax, %rbx
movq (%r13), %rsi
movzbl (%r14), %r8d
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x3340ec
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
movl $0x58, %esi
movq %rbx, %rdi
callq 0x11e0c0
movq %r14, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::details::node_depth_base<exprtk::details::expression_node<double>>::compute_node_depth<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&) const
std::size_t compute_node_depth(const Sequence<node_ptr_t, Allocator>& branch_list) const
         {
            if (!depth_set)
            {
               for (std::size_t i = 0; i < branch_list.size(); ++i)
               {
                  if (branch_list[i])
                  {
                     depth = std::max(depth, compute_node_depth(branch_list[i]));
                  }
               }

               depth_set = true;
            }

            return depth;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb 0x8(%rdi), %cl
testb %cl, %cl
jne 0x333482
movq %rsi, %r14
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
cmpq %rdx, %rsi
je 0x33347e
xorl %r15d, %r15d
movq (%rdx,%r15,8), %rdi
testq %rdi, %rdi
je 0x33346c
testb $0x1, %cl
je 0x33344d
movq 0x10(%rbx), %rax
jmp 0x333468
movq 0x8(%rdi), %rax
addq $0x8, %rdi
callq *0x10(%rax)
incq %rax
movb $0x1, 0x8(%rbx)
movq (%r14), %rdx
movq 0x8(%r14), %rsi
movb $0x1, %cl
movq %rax, 0x10(%rbx)
incq %r15
movq %rsi, %rax
subq %rdx, %rax
sarq $0x3, %rax
cmpq %rax, %r15
jb 0x333439
movb $0x1, 0x8(%rbx)
movq 0x10(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_single_constvalue_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return vector_base_ &&
                   (initialiser_list_.size() == 1) &&
                   (details::is_constant_node(initialiser_list_[0])) &&
                   (single_initialiser_value_ != T(0));
         }

// Assembly:
cmpq $0x0, 0x20(%rdi)
je 0x333677
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0x33366d
movq (%rax), %r14
testq %r14, %r14
je 0x33366d
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x333659
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
jne 0x33366d
xorpd %xmm0, %xmm0
cmpneqsd 0x48(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x33366f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_single_value_node<double>::value() const
inline T value() const exprtk_override
         {
            expression_node<T>& node = *initialiser_list_[0];

            for (std::size_t i = 0; i < size_; ++i)
            {
               *(vector_base_ + i) = node.value();
            }

            return *(vector_base_);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x333767
movq 0x30(%rbx), %rax
movq (%rax), %r14
xorl %r15d, %r15d
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq 0x20(%rbx), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
cmpq 0x28(%rbx), %r15
jb 0x333749
jmp 0x33376b
movq 0x20(%rbx), %rax
movsd (%rax), %xmm0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_constconst_node<double>::value() const
inline T value() const exprtk_override
         {
            T value = base_value_;

            for (std::size_t i = 0; i < size_; ++i, value += increment_value_)
            {
               *(vector_base_ + i) = value;
            }

            return *(vector_base_);
         }

// Assembly:
movq 0x28(%rdi), %rcx
testq %rcx, %rcx
je 0x333934
movsd 0x48(%rdi), %xmm0
movq 0x20(%rdi), %rax
xorl %edx, %edx
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
addsd 0x50(%rdi), %xmm0
cmpq %rdx, %rcx
jne 0x333920
jmp 0x333938
movq 0x20(%rdi), %rax
movsd (%rax), %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_constconst_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return vector_base_ &&
                   (initialiser_list_.size() == 2) &&
                   (details::is_constant_node(initialiser_list_[0])) &&
                   (details::is_constant_node(initialiser_list_[1])) ;
         }

// Assembly:
cmpq $0x0, 0x20(%rdi)
je 0x3339c1
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rcx
subq %rax, %rcx
cmpq $0x10, %rcx
jne 0x3339b7
movq (%rax), %r14
testq %r14, %r14
je 0x3339b7
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x333987
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
jne 0x3339b7
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rbx
testq %rbx, %rbx
je 0x3339b7
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movl %eax, %ecx
movb $0x1, %al
cmpl $0x2, %ecx
je 0x3339b9
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
sete %al
jmp 0x3339b9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_constnconst_node<double>::value() const
inline T value() const exprtk_override
         {
            T value = base_value_;
            expression_node<T>& increment = *initialiser_list_[1];

            for (std::size_t i = 0; i < size_; ++i, value += increment.value())
            {
               *(vector_base_ + i) = value;
            }

            return *(vector_base_);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x333b4f
movq 0x30(%rbx), %rax
movq 0x8(%rax), %r14
movsd 0x48(%rbx), %xmm0
xorl %r15d, %r15d
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rbx), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
cmpq 0x28(%rbx), %r15
jb 0x333b17
movq 0x20(%rbx), %rax
movsd (%rax), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_nconstconst_node<double>::value() const
inline T value() const exprtk_override
         {
            T value = initialiser_list_[0]->value();
            const T increment = initialiser_list_[1]->value();

            for (std::size_t i = 0; i < size_; ++i, value += increment)
            {
               *(vector_base_ + i) = value;
            }

            return *(vector_base_);
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd 0x8(%rsp), %xmm1
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
testq %rcx, %rcx
je 0x333ced
xorl %edx, %edx
movsd %xmm1, (%rax,%rdx,8)
incq %rdx
addsd %xmm0, %xmm1
cmpq %rdx, %rcx
jne 0x333cdc
movsd (%rax), %xmm0
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_nconstnconst_node<double>::value() const
inline T value() const exprtk_override
         {
            T value = initialiser_list_[0]->value();
            expression_node<T>& increment = *initialiser_list_[1];

            for (std::size_t i = 0; i < size_; ++i, value += increment.value())
            {
               *(vector_base_ + i) = value;
            }

            return *(vector_base_);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpq $0x0, 0x28(%rbx)
je 0x333e97
movq 0x30(%rbx), %rax
movq 0x8(%rax), %r14
xorl %r15d, %r15d
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rbx), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
cmpq 0x28(%rbx), %r15
jb 0x333e5f
movq 0x20(%rbx), %rax
movsd (%rax), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::interval_container_t<void const*, exprtk::parser<double>::halfopen_range_policy<void const*>>::add_interval(void const*, void const*)
bool add_interval(const interval_point_t begin, const interval_point_t end)
         {
            if ((end <= begin) || in_interval(begin) || in_interval(end))
            {
               return false;
            }

            interval_map_[end] = std::make_pair(begin, end);

            return true;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, 0x8(%rsp)
cmpq %rsi, %rdx
jbe 0x3362e2
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
callq 0x2a3428
testb %al, %al
jne 0x3362e2
leaq 0x10(%rsp), %rdx
xorps %xmm0, %xmm0
movaps %xmm0, (%rdx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2a3428
testb %al, %al
je 0x3362ee
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x336306
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movb $0x1, %al
jmp 0x3362e4
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::rebasevector_celem_rtc_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               vector_holder_     &&
               vector_node_.first &&
               vector_node_.first->valid();
         }

// Assembly:
cmpq $0x0, 0x30(%rdi)
je 0x338cc6
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x338cc6
movq (%rdi), %rax
jmpq *0x30(%rax)
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::rebasevector_elem_rtc_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               vector_holder_        &&
               index_.first          &&
               vector_node_.first    &&
               index_.first->valid() &&
               vector_node_.first->valid();
         }

// Assembly:
pushq %rbx
cmpq $0x0, 0x28(%rdi)
je 0x339784
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x339784
cmpq $0x0, 0x30(%rbx)
je 0x339784
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x339784
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x30(%rax)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::generic_function_node<double, exprtk::details::null_igenfunc<double>>::~generic_function_node()
virtual ~generic_function_node()
         {
            for (std::size_t i = 0; i < vv_list_.size(); ++i)
            {
               vecview_t& vv = vv_list_[i];
               if (vv && typestore_list_[i].vec_data)
               {
                  vv->remove_ref(&typestore_list_[i].vec_data);
                  typestore_list_[i].vec_data = 0;
               }
            }
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1feb81(%rip), %rax    # 0x539ba0
movq %rax, (%rdi)
leaq 0x1febd7(%rip), %rax    # 0x539c00
movq %rax, 0x8(%rdi)
movq 0x70(%rdi), %rax
movq 0x78(%rdi), %rcx
cmpq %rax, %rcx
je 0x33b086
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x33b070
movq 0x28(%rbx), %rsi
cmpq $0x0, (%rsi,%r14)
je 0x33b070
addq %r14, %rsi
callq 0x33b3d0
movq 0x28(%rbx), %rax
movq $0x0, (%rax,%r14)
movq 0x70(%rbx), %rax
movq 0x78(%rbx), %rcx
incq %r15
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
addq $0x18, %r14
cmpq %rdx, %r15
jb 0x33b040
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x33b0a1
movq 0xc8(%rbx), %rsi
subq %rdi, %rsi
callq 0x11e0c0
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x33b0bc
movq 0xb0(%rbx), %rsi
subq %rdi, %rsi
callq 0x11e0c0
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x33b0d7
movq 0x98(%rbx), %rsi
subq %rdi, %rsi
callq 0x11e0c0
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x33b0ef
movq 0x80(%rbx), %rsi
subq %rdi, %rsi
callq 0x11e0c0
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x33b104
movq 0x68(%rbx), %rsi
subq %rdi, %rsi
callq 0x11e0c0
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x33b119
movq 0x50(%rbx), %rsi
subq %rdi, %rsi
callq 0x11e0c0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x33b133
movq 0x38(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x11e0c0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x1e4735
nop