diff --git a/Makefile b/Makefile
index a8d7d28..ebc72fd 100644
--- a/Makefile
+++ b/Makefile
@@ -2,7 +2,7 @@
 # **************************************************************
 # *         C++ Mathematical Expression Toolkit Library        *
 # *                                                            *
-# * Author: Arash Partow (1999-2024)                           *
+# * Author: Arash Partow (1999-2025)                           *
 # * URL: https://www.partow.net/programming/exprtk/index.html  *
 # *                                                            *
 # * Copyright notice:                                          *
diff --git a/exprtk.hpp b/exprtk.hpp
index d53048a..e28a96d 100644
--- a/exprtk.hpp
+++ b/exprtk.hpp
@@ -2,7 +2,7 @@
  ******************************************************************
  *           C++ Mathematical Expression Toolkit Library          *
  *                                                                *
- * Author: Arash Partow (1999-2024)                               *
+ * Author: Arash Partow (1999-2025)                               *
  * URL: https://www.partow.net/programming/exprtk/index.html      *
  *                                                                *
  * Copyright notice:                                              *
@@ -1020,7 +1020,7 @@
                   return (v1 == trunc_impl(v1, real_type_tag())) &&
                          (modulus_impl(v1, T(2), real_type_tag()) != T(0)) ?
                          -std::pow(abs_impl(v0, real_type_tag()), T(1) / v1) :
-                          std::numeric_limits<double>::quiet_NaN();
+                          std::numeric_limits<T>::quiet_NaN();
                }
 
                return std::pow(v0, T(1) / v1);
@@ -1873,7 +1873,7 @@
                case 4 : exprtk_process_digit
                case 3 : exprtk_process_digit
                case 2 : exprtk_process_digit
-               case 1 : if ((digit = (*itr - zero))>= 10)
+               case 1 : if ((digit = (*itr - zero)) >= 10)
                         {
                            digit = 0;
                            return_result = false;
@@ -2081,7 +2081,8 @@
                   {
                      if (end == ++itr)
                         return false;
-                     else if (('I' <= (*itr)) && ((*itr) <= 'n'))
+
+                     if (('I' <= (*itr)) && ((*itr) <= 'n'))
                      {
                         if (('i' == (*itr)) || ('I' == (*itr)))
                         {
@@ -2690,6 +2691,14 @@
 
             while (!is_end(s_itr_))
             {
+               if (details::is_invalid(*s_itr_))
+               {
+                  token_t t;
+                  t.set_error(token::e_error, s_itr_, s_itr_ + 1, base_itr_);
+                  token_list_.push_back(t);
+                  return;
+               }
+
                if ((1 == mode) && test::comment_end(*s_itr_, 0, mode))
                {
                   ++s_itr_;
@@ -3237,6 +3246,8 @@
                                  }
                               }
                               break;
+
+                     default: continue;
                   }
                }
             }
@@ -4646,6 +4657,8 @@
 
       inline void rebase(data_ptr_t data)
       {
+         assert(data);
+
          data_ = data;
 
          if (!data_ref_.empty())
@@ -4657,6 +4670,17 @@
          }
       }
 
+      inline bool rebase(data_ptr_t data, const std::size_t new_size)
+      {
+         if (set_size(new_size))
+         {
+            rebase(data);
+            return true;
+         }
+
+         return false;
+      }
+
       inline data_ptr_t data() const
       {
          return data_;
@@ -4692,6 +4716,14 @@
                        static_cast<int>(data_ref_.size())));
       }
 
+      void set_size_ref(std::size_t* size_ref)
+      {
+         size_ref_.push_back(size_ref);
+         exprtk_debug(("vector_view::set_size_ref() - size_ref: %p size_ref_.size(): %d\n",
+                       reinterpret_cast<void*>(size_ref),
+                       static_cast<int>(size_ref_.size())));
+      }
+
       void remove_ref(data_ptr_t* data_ref)
       {
          data_ref_.erase(
@@ -4702,6 +4734,16 @@
                        static_cast<int>(data_ref_.size())));
       }
 
+      void remove_size_ref(std::size_t* size_ref)
+      {
+         size_ref_.erase(
+            std::remove(size_ref_.begin(), size_ref_.end(), size_ref),
+            size_ref_.end());
+         exprtk_debug(("vector_view::remove_size_ref() - size_ref: %p size_ref_.size(): %d\n",
+                       reinterpret_cast<void*>(size_ref),
+                       static_cast<int>(size_ref_.size())));
+      }
+
       bool set_size(const std::size_t new_size)
       {
          if ((new_size > 0) && (new_size <= base_size_))
@@ -4710,6 +4752,15 @@
             exprtk_debug(("vector_view::set_size() - data_: %p size: %lu\n",
                           reinterpret_cast<void*>(data_),
                           size_));
+
+            if (!size_ref_.empty())
+            {
+               for (std::size_t i = 0; i < size_ref_.size(); ++i)
+               {
+                  (*size_ref_[i]) = new_size;
+               }
+            }
+
             return true;
          }
 
@@ -4725,6 +4776,7 @@
       std::size_t size_;
       data_ptr_t  data_;
       std::vector<data_ptr_t*> data_ref_;
+      std::vector<std::size_t*> size_ref_;
    };
 
    template <typename T>
@@ -4742,6 +4794,7 @@
    }
 
    template <typename T> class results_context;
+   namespace  details { template <typename T> class vector_interface; }
 
    template <typename T>
    struct type_store
@@ -4758,6 +4811,7 @@
       : data(0)
       , size(0)
       , type(e_unknown)
+      , ivec(0)
       {}
 
       union
@@ -4766,8 +4820,11 @@
          T*    vec_data;
       };
 
+      typedef details::vector_interface<T>* ivec_t;
+
       std::size_t size;
       store_type  type;
+      ivec_t      ivec;
 
       class parameter_list
       {
@@ -4817,6 +4874,26 @@
             return parameter_list_.back();
          }
 
+         inline typename std::vector<type_store>::const_iterator begin() const
+         {
+            return parameter_list_.begin();
+         }
+
+         inline typename std::vector<type_store>::const_iterator end() const
+         {
+            return parameter_list_.end();
+         }
+
+         inline typename std::vector<type_store>::iterator begin()
+         {
+            return parameter_list_.begin();
+         }
+
+         inline typename std::vector<type_store>::iterator end()
+         {
+            return parameter_list_.end();
+         }
+
       private:
 
          std::vector<type_store>& parameter_list_;
@@ -5849,6 +5926,24 @@
       }
 
       template <typename T>
+      inline bool amalgamated_vecop(const expression_node<T>* node)
+      {
+         if (node)
+         {
+            switch (node->type())
+            {
+               case details::expression_node<T>::e_vecvecarith :
+               case details::expression_node<T>::e_vecvalarith :
+               case details::expression_node<T>::e_valvecarith :
+               case details::expression_node<T>::e_vecunaryop  : return true;
+               default                                         : return false;
+            }
+         }
+         else
+            return false;
+      }
+
+      template <typename T>
       inline bool is_constant_node(const expression_node<T>* node)
       {
          return node &&
@@ -6382,6 +6477,12 @@
             virtual void remove_ref(value_ptr*)
             {}
 
+            virtual void set_size_ref(std::size_t*)
+            {}
+
+            virtual void remove_size_ref(std::size_t*)
+            {}
+
             virtual vector_view<Type>* rebaseable_instance()
             {
                return reinterpret_cast<vector_view<Type>*>(0);
@@ -6635,6 +6736,14 @@
             }
          }
 
+         void set_size_ref(std::size_t* ref)
+         {
+            if (rebaseable())
+            {
+               vector_holder_base_->set_size_ref(ref);
+            }
+         }
+
          void remove_ref(value_ptr* ref)
          {
             if (rebaseable())
@@ -6643,6 +6752,14 @@
             }
          }
 
+         void remove_size_ref(std::size_t* ref)
+         {
+            if (rebaseable())
+            {
+               vector_holder_base_->remove_size_ref(ref);
+            }
+         }
+
          bool rebaseable() const
          {
             return vector_holder_base_->rebaseable();
@@ -7454,8 +7571,9 @@
             }
 
             loop_runtime_check::violation_context ctxt;
-            ctxt.loop      = loop_type_;
-            ctxt.violation = loop_runtime_check::e_iteration_count;
+            ctxt.loop            = loop_type_;
+            ctxt.violation       = loop_runtime_check::e_iteration_count;
+            ctxt.iteration_count = iteration_count_;
 
             loop_runtime_check_->handle_runtime_violation(ctxt);
 
@@ -8368,9 +8486,23 @@
       template <typename T>
       struct range_pack
       {
-         typedef expression_node<T>*           expression_node_ptr;
+         typedef expression_node<T>*                expression_node_ptr;
          typedef std::pair<std::size_t,std::size_t> cached_range_t;
 
+         struct size_holder_t
+         {
+            std::size_t size_;
+
+            size_holder_t(const std::size_t sz = std::numeric_limits<std::size_t>::max())
+            : size_(sz)
+            {}
+
+            std::size_t size() const
+            {
+               return size_;
+            }
+         };
+
          range_pack()
          : n0_e (std::make_pair(false,expression_node_ptr(0)))
          , n1_e (std::make_pair(false,expression_node_ptr(0)))
@@ -8429,8 +8561,8 @@
                   (!n0_c.first && !n1_c.first);
          }
 
-         bool operator() (std::size_t& r0, std::size_t& r1,
-                          const std::size_t& size = std::numeric_limits<std::size_t>::max()) const
+         template <typename StrBaseType>
+         bool operator() (std::size_t& r0, std::size_t& r1, const StrBaseType& str_base) const
          {
             if (n0_c.first)
                r0 = n0_c.second;
@@ -8450,6 +8582,8 @@
             else
                return false;
 
+            const std::size_t size = str_base.size();
+
             if (
                  (std::numeric_limits<std::size_t>::max() != size) &&
                  (std::numeric_limits<std::size_t>::max() == r1  )
@@ -8461,10 +8595,10 @@
             cache.first  = r0;
             cache.second = r1;
 
-            #ifndef exprtk_enable_range_runtime_checks
-            return (r0 <= r1);
-            #else
+            #ifdef exprtk_enable_range_runtime_checks
             return range_runtime_check(r0, r1, size);
+            #else
+            return (r0 <= r1) && (r1 <= size);
             #endif
          }
 
@@ -8948,10 +9082,12 @@
 
             assert(vec_rt_chk_);
 
+            const _uint64_t base_address = reinterpret_cast<_uint64_t>(vector_base_);
+
             vector_access_runtime_check::violation_context context;
-            context.base_ptr   = reinterpret_cast<void*>(vector_base_);
-            context.end_ptr    = reinterpret_cast<void*>(vector_base_ + vector_holder_->size());
-            context.access_ptr = reinterpret_cast<void*>(vector_base_ + index);
+            context.base_ptr   = reinterpret_cast<void*>(base_address);
+            context.end_ptr    = reinterpret_cast<void*>(base_address + vector_holder_->size() * sizeof(T));
+            context.access_ptr = reinterpret_cast<void*>(base_address + index * sizeof(T));
             context.type_size  = sizeof(T);
 
             return vec_rt_chk_->handle_runtime_violation(context) ?
@@ -9049,10 +9185,12 @@
 
             assert(vec_rt_chk_);
 
+            const _uint64_t base_address = reinterpret_cast<_uint64_t>(vector_base_);
+
             vector_access_runtime_check::violation_context context;
-            context.base_ptr   = reinterpret_cast<void*>(vector_base_);
-            context.end_ptr    = reinterpret_cast<void*>(vector_base_ + vector_holder_->size());
-            context.access_ptr = reinterpret_cast<void*>(vector_base_ + index_);
+            context.base_ptr   = reinterpret_cast<void*>(base_address);
+            context.end_ptr    = reinterpret_cast<void*>(base_address + vector_holder_->size() * sizeof(T));
+            context.access_ptr = reinterpret_cast<void*>(base_address + index_ * sizeof(T));
             context.type_size  = sizeof(T);
 
             return vec_rt_chk_->handle_runtime_violation(context) ?
@@ -9309,10 +9447,12 @@
 
             assert(vec_rt_chk_);
 
+            const _uint64_t base_address = reinterpret_cast<_uint64_t>(vector_holder_->data());
+
             vector_access_runtime_check::violation_context context;
-            context.base_ptr   = reinterpret_cast<void*>(vector_holder_->data());
-            context.end_ptr    = reinterpret_cast<void*>(vector_holder_->data() + vector_holder_->size());
-            context.access_ptr = reinterpret_cast<void*>(vector_holder_->data() + index);
+            context.base_ptr   = reinterpret_cast<void*>(base_address);
+            context.end_ptr    = reinterpret_cast<void*>(base_address + vector_holder_->size() * sizeof(T));
+            context.access_ptr = reinterpret_cast<void*>(base_address + index * sizeof(T));
             context.type_size  = sizeof(T);
 
             return vec_rt_chk_->handle_runtime_violation(context) ?
@@ -9407,10 +9547,12 @@
 
             assert(vec_rt_chk_);
 
+            const _uint64_t base_address = reinterpret_cast<_uint64_t>(vector_base_);
+
             vector_access_runtime_check::violation_context context;
-            context.base_ptr   = reinterpret_cast<void*>(vector_base_);
-            context.end_ptr    = reinterpret_cast<void*>(vector_base_ + vector_holder_->size());
-            context.access_ptr = reinterpret_cast<void*>(vector_base_ + index_);
+            context.base_ptr   = reinterpret_cast<void*>(base_address);
+            context.end_ptr    = reinterpret_cast<void*>(base_address + vector_holder_->size() * sizeof(T));
+            context.access_ptr = reinterpret_cast<void*>(base_address + index_ * sizeof(T));
             context.type_size  = sizeof(T);
 
             return vec_rt_chk_->handle_runtime_violation(context) ?
@@ -10019,9 +10161,17 @@
 
          swap_generic_node(expression_ptr var0, expression_ptr var1)
          : binary_node<T>(details::e_swap, var0, var1)
-         , var0_(dynamic_cast<ivariable_ptr>(var0))
-         , var1_(dynamic_cast<ivariable_ptr>(var1))
-         {}
+         , var0_(0)
+         , var1_(0)
+         , initialised_(false)
+         {
+            var0_ = dynamic_cast<ivariable_ptr>(var0);
+            var1_ = dynamic_cast<ivariable_ptr>(var1);
+
+            initialised_ = (var0_ && var1_);
+
+            assert(valid());
+         }
 
          inline T value() const exprtk_override
          {
@@ -10034,10 +10184,16 @@
             return expression_node<T>::e_swap;
          }
 
+         inline bool valid() const exprtk_override
+         {
+            return initialised_ && binary_node<T>::valid();
+         }
+
       private:
 
          ivariable_ptr var0_;
          ivariable_ptr var1_;
+         bool          initialised_;
       };
 
       template <typename T>
@@ -10289,7 +10445,7 @@
             return std::numeric_limits<T>::quiet_NaN();
          }
 
-         inline std::string str() const exprtk_override
+         std::string str() const exprtk_override
          {
             return (*value_);
          }
@@ -10428,6 +10584,7 @@
          typedef range_interface<T>   irange_t;
          typedef irange_t*            irange_ptr;
          typedef std::pair<expression_ptr,bool>  branch_t;
+         typedef typename range_t::size_holder_t size_holder_t;
 
          generic_string_range_node(expression_ptr str_branch, const range_t& brange)
          : initialised_(false)
@@ -10479,8 +10636,8 @@
             const std::size_t base_str_size = str_base_ptr_->size();
 
             if (
-                  range      (str_r0, str_r1, base_str_size         ) &&
-                  base_range_(r0    , r1    , base_str_size - str_r0)
+                  range      (str_r0, str_r1, size_holder_t(base_str_size         )) &&
+                  base_range_(r0    , r1    , size_holder_t(base_str_size - str_r0))
                )
             {
                const std::size_t size = r1 - r0;
@@ -10632,8 +10789,8 @@
             const range_t& range1 = str1_range_ptr_->range_ref();
 
             if (
-                  range0(str0_r0, str0_r1, str0_base_ptr_->size()) &&
-                  range1(str1_r0, str1_r1, str1_base_ptr_->size())
+                  range0(str0_r0, str0_r1, *str0_base_ptr_) &&
+                  range1(str1_r0, str1_r1, *str1_base_ptr_)
                )
             {
                const std::size_t size0 = (str0_r1 - str0_r0);
@@ -10861,8 +11018,8 @@
             const range_t& range1 = (*str1_range_ptr_);
 
             if (
-                  range0(str0_r0, str0_r1, str0_base_ptr_->size()) &&
-                  range1(str1_r0, str1_r1, str1_base_ptr_->size())
+                  range0(str0_r0, str0_r1, *str0_base_ptr_) &&
+                  range1(str1_r0, str1_r1, *str1_base_ptr_)
                )
             {
                const std::size_t size0    = range0.cache_size();
@@ -11110,7 +11267,7 @@
 
             const range_t& range = (*str1_range_ptr_);
 
-            if (range(r0, r1, str1_base_ptr_->size()))
+            if (range(r0, r1, *str1_base_ptr_))
             {
                AssignmentProcess::execute(
                   str0_node_ptr_->ref(),
@@ -11247,8 +11404,8 @@
             const range_t& range1 = (*str1_range_ptr_);
 
             if (
-                  range0(s0_r0, s0_r1, str0_base_ptr_->size()) &&
-                  range1(s1_r0, s1_r1, str1_base_ptr_->size())
+                  range0(s0_r0, s0_r1, *str0_base_ptr_) &&
+                  range1(s1_r0, s1_r1, *str1_base_ptr_)
                )
             {
                const std::size_t size = std::min((s0_r1 - s0_r0), (s1_r1 - s1_r0));
@@ -11386,7 +11543,7 @@
 
                const range_t& range = str0_range_ptr_->range_ref();
 
-               if (range(r0, r1, str0_base_ptr_->size()))
+               if (range(r0, r1, *str0_base_ptr_))
                {
                   const std::size_t size = (r1 - r0);
 
@@ -11404,7 +11561,7 @@
 
                const range_t& range = str1_range_ptr_->range_ref();
 
-               if (range(r0, r1, str1_base_ptr_->size()))
+               if (range(r0, r1, *str1_base_ptr_))
                {
                   const std::size_t size = (r1 - r0);
 
@@ -11550,27 +11707,27 @@
             return std::numeric_limits<T>::quiet_NaN();
          }
 
-         std::string str() const
+         std::string str() const exprtk_override
          {
             return value_;
          }
 
-         char_cptr base() const
+         char_cptr base() const exprtk_override
          {
             return &value_[0];
          }
 
-         std::size_t size() const
+         std::size_t size() const exprtk_override
          {
             return value_.size();
          }
 
-         range_t& range_ref()
+         range_t& range_ref() exprtk_override
          {
             return range_;
          }
 
-         const range_t& range_ref() const
+         const range_t& range_ref() const exprtk_override
          {
             return range_;
          }
@@ -11751,7 +11908,7 @@
          assert_node(expression_ptr   assert_condition_node,
                      expression_ptr   assert_message_node,
                      assert_check_ptr assert_check,
-                     assert_context_t context)
+                     const assert_context_t& context)
          : assert_message_str_base_(0)
          , assert_check_(assert_check)
          , context_(context)
@@ -13749,9 +13906,10 @@
 
          std::size_t size() const exprtk_override
          {
-            return std::min(
+            return std::min(vds().size(),
+               std::min(
                vec0_node_ptr_->vec_holder().size(),
-               vec1_node_ptr_->vec_holder().size());
+               vec1_node_ptr_->vec_holder().size()));
          }
 
          std::size_t base_size() const exprtk_override
@@ -13919,7 +14077,7 @@
 
          std::size_t size() const exprtk_override
          {
-            return vec0_node_ptr_->size();
+            return std::min(vec0_node_ptr_->size(), vds().size());
          }
 
          std::size_t base_size() const exprtk_override
@@ -14084,7 +14242,7 @@
 
          std::size_t size() const exprtk_override
          {
-            return vec1_node_ptr_->vec_holder().size();
+            return std::min(vec1_node_ptr_->size(), vds().size());
          }
 
          std::size_t base_size() const exprtk_override
@@ -14243,7 +14401,7 @@
 
          std::size_t size() const exprtk_override
          {
-            return vec0_node_ptr_->vec_holder().size();
+            return std::min(vds().size(),vec0_node_ptr_->vec_holder().size());
          }
 
          std::size_t base_size() const exprtk_override
@@ -14281,7 +14439,7 @@
          typedef vector_holder   <T>  vector_holder_t;
          typedef vector_holder_t*     vector_holder_ptr;
          typedef vec_data_store  <T>  vds_t;
-         typedef memory_context_t<T> memory_context;
+         typedef memory_context_t<T>  memory_context;
          typedef std::pair<expression_ptr,bool> branch_t;
 
          conditional_vector_node(expression_ptr condition,
@@ -14360,7 +14518,9 @@
                result_vec_size_ = alternative_node_ptr_->size();
             }
 
-            for (std::size_t i = 0; i < result_vec_size_; ++i)
+            const std::size_t copy_size = std::min(result_vec_size_, vds().size());
+
+            for (std::size_t i = 0; i < copy_size; ++i)
             {
                result_vector[i] = source_vector[i];
             }
@@ -14959,9 +15119,14 @@
             for (std::size_t i = 0; i < vv_list_.size(); ++i)
             {
                vecview_t& vv = vv_list_[i];
-               if (vv && typestore_list_[i].vec_data)
+               if (vv)
                {
-                  vv->remove_ref(&typestore_list_[i].vec_data);
+                  if (typestore_list_[i].vec_data)
+                  {
+                     vv->remove_ref(&typestore_list_[i].vec_data);
+                  }
+
+                  vv->remove_size_ref(&typestore_list_[i].size);
                   typestore_list_[i].vec_data = 0;
                }
             }
@@ -15001,6 +15166,12 @@
                   ts.size = vi->size();
                   ts.data = vi->vds().data();
                   ts.type = type_store_t::e_vector;
+                  ts.ivec = vi;
+
+                  if (expression_node<T>::e_vecondition == arg_list_[i]->type())
+                  {
+                     vec_size_refresh_list_.push_back(i);
+                  }
 
                   if (
                        vi->vec()->vec_holder().rebaseable() &&
@@ -15008,7 +15179,12 @@
                      )
                   {
                      vv_list_[i] = vi->vec()->vec_holder().rebaseable_instance();
-                     vv_list_[i]->set_ref(&ts.vec_data);
+                     vv_list_[i]->set_size_ref(&ts.size);
+
+                     if (!amalgamated_vecop(arg_list_[i]))
+                     {
+                        vv_list_[i]->set_ref(&ts.vec_data);
+                     }
                   }
                }
                #ifndef exprtk_disable_string_capabilities
@@ -15106,11 +15282,23 @@
 
          inline virtual bool populate_value_list() const
          {
+            assert(branch_.size() == typestore_list_.size());
+
             for (std::size_t i = 0; i < branch_.size(); ++i)
             {
                expr_as_vec1_store_[i] = branch_[i].first->value();
             }
 
+            if (!vec_size_refresh_list_.empty())
+            {
+               for (std::size_t i = 0; i < vec_size_refresh_list_.size(); ++i)
+               {
+                  const std::size_t index = vec_size_refresh_list_[i];
+                  type_store_t&     ts    = typestore_list_[index];
+                  ts.size = ts.ivec->size();
+               }
+            }
+
             if (!range_param_list_.empty())
             {
                assert(range_param_list_.size() <= branch_.size());
@@ -15131,7 +15319,7 @@
                      rdt.size;
                   #endif
 
-                  if (!rp(r0, r1, data_size))
+                  if (!rp(r0, r1, typename range_t::size_holder_t(data_size)))
                   {
                      return false;
                   }
@@ -15162,6 +15350,7 @@
          mutable tmp_vs_t            expr_as_vec1_store_;
          mutable range_list_t        range_list_;
          std::vector<std::size_t>    range_param_list_;
+         std::vector<std::size_t>    vec_size_refresh_list_;
       };
 
       #ifndef exprtk_disable_string_capabilities
@@ -15391,6 +15580,8 @@
          {
             if (gen_function_t::populate_value_list())
             {
+               prepare_typestore_list();
+
                typedef typename type_store<T>::parameter_list parameter_list_t;
 
                results_context_->
@@ -15414,6 +15605,19 @@
 
       private:
 
+         void prepare_typestore_list() const
+         {
+            for (std::size_t i = 0; i < gen_function_t::typestore_list_.size(); ++i)
+            {
+               typename gen_function_t::type_store_t& ts = gen_function_t::typestore_list_[i];
+
+               if (ts.ivec)
+               {
+                  ts.size = ts.ivec->size();
+               }
+            }
+         }
+
          results_context_t* results_context_;
       };
 
@@ -18427,8 +18631,8 @@
             std::size_t r0 = 0;
             std::size_t r1 = 0;
 
-            if (rp0_(r0, r1, s0_.size()))
-               return Operation::process(s0_.substr(r0, (r1 - r0) + 1), s1_);
+            if (rp0_(r0, r1, s0_))
+               return Operation::process(s0_.substr(r0, (r1 - r0)), s1_);
             else
                return T(0);
          }
@@ -18491,12 +18695,12 @@
             std::size_t r0 = 0;
             std::size_t r1 = 0;
 
-            if (rp1_(r0, r1, s1_.size()))
+            if (rp1_(r0, r1, s1_))
             {
                return Operation::process
                       (
                          s0_,
-                         s1_.substr(r0, (r1 - r0) + 1)
+                         s1_.substr(r0, (r1 - r0))
                       );
             }
             else
@@ -18566,14 +18770,14 @@
             std::size_t r1_1 = 0;
 
             if (
-                 rp0_(r0_0, r1_0, s0_.size()) &&
-                 rp1_(r0_1, r1_1, s1_.size())
+                 rp0_(r0_0, r1_0, s0_) &&
+                 rp1_(r0_1, r1_1, s1_)
                )
             {
                return Operation::process
                       (
-                         s0_.substr(r0_0, (r1_0 - r0_0) + 1),
-                         s1_.substr(r0_1, (r1_1 - r0_1) + 1)
+                         s0_.substr(r0_0, (r1_0 - r0_0)),
+                         s1_.substr(r0_1, (r1_1 - r0_1))
                       );
             }
             else
@@ -18691,8 +18895,8 @@
             const range_t& range1 = (*str1_range_ptr_);
 
             if (
-                 range0(str0_r0, str0_r1, str0_base_ptr_->size()) &&
-                 range1(str1_r0, str1_r1, str1_base_ptr_->size())
+                 range0(str0_r0, str0_r1, *str0_base_ptr_) &&
+                 range1(str1_r0, str1_r1, *str1_base_ptr_)
                )
             {
                return Operation::process
@@ -19813,6 +20017,32 @@
 
       std::string parameter_sequence;
       return_type rtrn_type;
+
+      static inline std::string generate_prefix_args(const std::string& prefix_args, std::size_t start = 0, std::size_t end = 10)
+      {
+         std::string result;
+
+         for (std::size_t i = start; i <= end; ++i)
+         {
+            result += prefix_args + std::string(i,'?');
+            result += (i != end) ? "|" : "";
+         }
+
+         return result;
+      }
+
+      static inline std::string generate_suffix_args(const std::string& suffix_args, std::size_t start = 0, std::size_t end = 10)
+      {
+         std::string result;
+
+         for (std::size_t i = start; i <= end; ++i)
+         {
+            result += std::string(i,'?') + suffix_args;
+            result += (i != end) ? "|" : "";
+         }
+
+         return result;
+      }
    };
 
    #ifndef exprtk_disable_string_capabilities
@@ -19936,7 +20166,7 @@
          ff04_functor f;
       };
 
-      struct freefunc05 : public exprtk::ifunction<T>
+      struct freefunc05 exprtk_final : public exprtk::ifunction<T>
       {
          using exprtk::ifunction<T>::operator();
 
@@ -20362,10 +20592,10 @@
          {
             struct init_type
             {
-               static inline double set(double)           { return (0.0);           }
-               static inline double set(long double)      { return (0.0);           }
-               static inline float  set(float)            { return (0.0f);          }
-               static inline std::string set(std::string) { return std::string(""); }
+               static inline double set(double)            { return (0.0);           }
+               static inline double set(long double)       { return (0.0);           }
+               static inline float  set(float)             { return (0.0f);          }
+               static inline std::string set(std::string&) { return std::string(""); }
             };
 
             static RawType null_type = init_type::set(RawType());
@@ -21882,7 +22112,11 @@
 
       inline bool return_invoked() const
       {
-         return (*control_block_->return_invoked);
+         assert(control_block_);
+
+         return control_block_                 &&
+                control_block_->return_invoked &&
+                (*control_block_->return_invoked);
       }
 
    private:
@@ -24063,7 +24297,7 @@
 
          bool arithmetic_enabled(const details::operator_type& arithmetic_operation) const
          {
-            if (disabled_logic_set_.empty())
+            if (disabled_arithmetic_set_.empty())
                return true;
             else
                return disabled_arithmetic_set_.end() == disabled_arithmetic_set_
@@ -24704,6 +24938,7 @@
             dec_.clear    ();
             sem_.cleanup  ();
             return_cleanup();
+            expr = expression_t();
 
             return false;
          }
@@ -25180,7 +25415,7 @@
          inline void set(const precedence_level& l,
                          const precedence_level& r,
                          const details::operator_type& o,
-                         const token_t tkn = token_t())
+                         const token_t& tkn = token_t())
          {
             left      = l;
             right     = r;
@@ -27375,6 +27610,8 @@
                   "ERR101 - Expected ':' for case of [*] statement",
                   exprtk_error_location));
 
+               free_node(node_allocator_, condition);
+
                return error_node();
             }
 
@@ -27384,7 +27621,10 @@
                parse_expression();
 
             if (0 == consequent)
+            {
+               free_node(node_allocator_, condition);
                return error_node();
+            }
 
             if (!token_is(token_t::e_eof))
             {
@@ -27394,6 +27634,9 @@
                   "ERR102 - Expected ';' at end of case for [*] statement",
                   exprtk_error_location));
 
+               free_node(node_allocator_, condition );
+               free_node(node_allocator_, consequent);
+
                return error_node();
             }
 
@@ -27998,7 +28241,7 @@
 
             try
             {
-               rp_result = rp(r0, r1);
+               rp_result = rp(r0, r1, typename range_t::size_holder_t());
             }
             catch (std::runtime_error&)
             {}
@@ -28164,13 +28407,13 @@
 
             if (rp.n1_c.first && (rp.n1_c.second == std::numeric_limits<std::size_t>::max()))
             {
-               rp.n1_c.second  = const_str.size() - 1;
+               rp.n1_c.second  = const_str.size();
                rp.cache.second = rp.n1_c.second;
             }
 
             if (
                  (rp.n0_c.first && (rp.n0_c.second >= const_str.size())) ||
-                 (rp.n1_c.first && (rp.n1_c.second >= const_str.size()))
+                 (rp.n1_c.first && (rp.n1_c.second >  const_str.size()))
                )
             {
                set_error(make_error(
@@ -28305,8 +28548,8 @@
          return error_node();
       }
 
-      inline expression_node_ptr synthesize_vector_element(const std::string& vector_name,
-                                                           vector_holder_ptr vec,
+      inline expression_node_ptr synthesize_vector_element(const std::string&  vector_name,
+                                                           vector_holder_ptr   vec,
                                                            expression_node_ptr vec_node,
                                                            expression_node_ptr index_expr)
       {
@@ -30960,7 +31203,11 @@
             }
 
             if (!post_variable_process(symbol))
+            {
+               free_node(node_allocator_, result_variable);
+
                return error_node();
+            }
 
             lodge_symbol(symbol, e_st_variable);
 
@@ -31216,7 +31463,10 @@
                            lodge_symbol(symbol, e_st_variable);
 
                            if (!post_variable_process(symbol))
+                           {
+                              free_node(node_allocator_, var);
                               return error_node();
+                           }
 
                            next_token();
 
@@ -31892,10 +32142,26 @@
             }
             else if (details::is_break_node(branch[0]))
             {
+               parser_->set_error(parser_error::make_error(
+                  parser_error::e_syntax,
+                  parser_->current_state().token,
+                  "ERR249 - Invalid use of break statement",
+                  exprtk_error_location));
+
+               parser_->node_allocator_.free(branch[0]);
+
                return error_node();
             }
             else if (details::is_continue_node(branch[0]))
             {
+               parser_->set_error(parser_error::make_error(
+                  parser_error::e_syntax,
+                  parser_->current_state().token,
+                  "ERR250 - Invalid use of continue statement",
+                  exprtk_error_location));
+
+               parser_->node_allocator_.free(branch[0]);
+
                return error_node();
             }
             else if (details::is_constant_node(branch[0]))
@@ -32333,40 +32599,48 @@
          {
             if ((0 == branch[0]) || (0 == branch[1]))
             {
+               details::free_all_nodes(*node_allocator_, branch);
+
                parser_->set_error(parser_error::make_error(
                   parser_error::e_syntax,
                   parser_->current_state().token,
-                  "ERR249 - Invalid branches received for operator '" + details::to_str(operation) + "'",
+                  "ERR251 - Invalid branches received for operator '" + details::to_str(operation) + "'",
                   exprtk_error_location));
 
                return error_node();
             }
             else if (is_invalid_string_op(operation,branch))
             {
+               details::free_all_nodes(*node_allocator_, branch);
+
                parser_->set_error(parser_error::make_error(
                   parser_error::e_syntax,
                   parser_->current_state().token,
-                  "ERR250 - Invalid branch pair for string operator '" + details::to_str(operation) + "'",
+                  "ERR252 - Invalid branch pair for string operator '" + details::to_str(operation) + "'",
                   exprtk_error_location));
 
                return error_node();
             }
             else if (is_invalid_assignment_op(operation,branch))
             {
+               details::free_all_nodes(*node_allocator_, branch);
+
                parser_->set_error(parser_error::make_error(
                   parser_error::e_syntax,
                   parser_->current_state().token,
-                  "ERR251 - Invalid branch pair for assignment operator '" + details::to_str(operation) + "'",
+                  "ERR253 - Invalid branch pair for assignment operator '" + details::to_str(operation) + "'",
                   exprtk_error_location));
 
                return error_node();
             }
             else if (is_invalid_break_continue_op(branch))
             {
+               details::free_all_nodes(*node_allocator_, branch);
+
                parser_->set_error(parser_error::make_error(
                   parser_error::e_syntax,
                   parser_->current_state().token,
-                  "ERR252 - Invalid branch pair for break/continue operator '" + details::to_str(operation) + "'",
+                  "ERR254 - Invalid branch pair for break/continue operator '" + details::to_str(operation) + "'",
                   exprtk_error_location));
 
                return error_node();
@@ -32490,17 +32764,19 @@
                parser_->set_error(parser_error::make_error(
                   parser_error::e_syntax,
                   parser_->current_state().token,
-                  "ERR253 - Invalid branches operator '" + details::to_str(operation) + "'",
+                  "ERR255 - Invalid branches operator '" + details::to_str(operation) + "'",
                   exprtk_error_location));
 
                return error_node();
             }
             else if (is_invalid_string_op(operation, branch))
             {
+               details::free_all_nodes(*node_allocator_,branch);
+
                parser_->set_error(parser_error::make_error(
                   parser_error::e_syntax,
                   parser_->current_state().token,
-                  "ERR254 - Invalid branches for string operator '" + details::to_str(operation) + "'",
+                  "ERR256 - Invalid branches for string operator '" + details::to_str(operation) + "'",
                   exprtk_error_location));
 
                return error_node();
@@ -32556,7 +32832,7 @@
                parser_->set_error(parser_error::make_error(
                   parser_error::e_parser,
                   parser_->current_state().token,
-                  "ERR255 - Invalid " + invalid_branches + " for conditional statement",
+                  "ERR257 - Invalid " + invalid_branches + " for conditional statement",
                   exprtk_error_location));
 
                return error_node();
@@ -32607,7 +32883,7 @@
             parser_->set_error(parser_error::make_error(
                parser_error::e_parser,
                token_t(),
-               "ERR256 - Failed to synthesize node: " + node_name,
+               "ERR258 - Failed to synthesize node: " + node_name,
                exprtk_error_location));
 
             details::free_node(*node_allocator_, result);
@@ -32632,7 +32908,7 @@
                parser_->set_error(parser_error::make_error(
                   parser_error::e_parser,
                   parser_->current_state().token,
-                  "ERR257 - Invalid " + invalid_branches + " for string conditional statement",
+                  "ERR259 - Invalid " + invalid_branches + " for string conditional statement",
                   exprtk_error_location));
 
                return error_node();
@@ -32674,7 +32950,7 @@
                parser_->set_error(parser_error::make_error(
                   parser_error::e_parser,
                   token_t(),
-                  "ERR258 - Failed to synthesize node: conditional_string_node_t",
+                  "ERR260 - Failed to synthesize node: conditional_string_node_t",
                   exprtk_error_location));
 
                details::free_node(*node_allocator_, result);
@@ -32708,7 +32984,7 @@
                parser_->set_error(parser_error::make_error(
                   parser_error::e_parser,
                   parser_->current_state().token,
-                  "ERR259 - Invalid " + invalid_branches + " for vector conditional statement",
+                  "ERR261 - Invalid " + invalid_branches + " for vector conditional statement",
                   exprtk_error_location));
 
                return error_node();
@@ -32782,7 +33058,7 @@
                   parser_->set_error(parser_error::make_error(
                      parser_error::e_parser,
                      parser_->current_state().token,
-                     "ERR260 - Infinite loop condition without 'break' or 'return' not allowed in while-loops",
+                     "ERR262 - Infinite loop condition without 'break' or 'return' not allowed in while-loops",
                      exprtk_error_location));
 
                   result = error_node();
@@ -32903,7 +33179,7 @@
                   parser_->set_error(parser_error::make_error(
                      parser_error::e_parser,
                      parser_->current_state().token,
-                     "ERR261 - Infinite loop condition without 'break' or 'return' not allowed in for-loop",
+                     "ERR263 - Infinite loop condition without 'break' or 'return' not allowed in for-loop",
                      exprtk_error_location));
 
                   result = error_node();
@@ -33654,7 +33930,7 @@
                parser_->set_error(parser_error::make_error(
                   parser_error::e_synthesis,
                   token_t(),
-                  "ERR262 - Failed to synthesize node: str_vararg_node<vararg_multi_op>",
+                  "ERR264 - Failed to synthesize node: str_vararg_node<vararg_multi_op>",
                   exprtk_error_location));
 
                details::free_node(*node_allocator_, result);
@@ -33691,7 +33967,7 @@
                parser_->set_error(parser_error::make_error(
                   parser_error::e_synthesis,
                   token_t(),
-                  "ERR263 - Failed to synthesize node: vararg_node",
+                  "ERR265 - Failed to synthesize node: vararg_node",
                   exprtk_error_location));
 
                details::free_node(*node_allocator_, result);
@@ -33746,7 +34022,7 @@
                parser_->set_error(parser_error::make_error(
                   parser_error::e_synthesis,
                   token_t(),
-                  "ERR264 - Failed to synthesize node: function_N_node_t",
+                  "ERR266 - Failed to synthesize node: function_N_node_t",
                   exprtk_error_location));
 
                details::free_node(*node_allocator_, result);
@@ -33795,7 +34071,7 @@
             parser_->set_error(parser_error::make_error(
                parser_error::e_synthesis,
                token_t(),
-               "ERR265 - Failed to synthesize node: vararg_function_node<ivararg_function_t>",
+               "ERR267 - Failed to synthesize node: vararg_function_node<ivararg_function_t>",
                exprtk_error_location));
 
             details::free_node(*node_allocator_, result);
@@ -33861,7 +34137,7 @@
                parser_->set_error(parser_error::make_error(
                   parser_error::e_synthesis,
                   token_t(),
-                  "ERR266 - Failed to synthesize node: " + node_name,
+                  "ERR268 - Failed to synthesize node: " + node_name,
                   exprtk_error_location));
 
                details::free_node(*node_allocator_, result);
@@ -33935,7 +34211,7 @@
                parser_->set_error(parser_error::make_error(
                   parser_error::e_synthesis,
                   token_t(),
-                  "ERR267 - Failed to synthesize node: " + node_name,
+                  "ERR269 - Failed to synthesize node: " + node_name,
                   exprtk_error_location));
 
                details::free_node(*node_allocator_, result);
@@ -33980,7 +34256,7 @@
                parser_->set_error(parser_error::make_error(
                   parser_error::e_synthesis,
                   token_t(),
-                  "ERR268 - Failed to synthesize node: return_node",
+                  "ERR270 - Failed to synthesize node: return_node",
                   exprtk_error_location));
 
                details::free_node(*node_allocator_, result);
@@ -34041,7 +34317,7 @@
                   parser_->set_error(parser_error::make_error(
                      parser_error::e_parser,
                      token_t(),
-                     "ERR269 - Index of " + details::to_str(vec_index) + " out of range for "
+                     "ERR271 - Index of " + details::to_str(vec_index) + " out of range for "
                      "vector '" + symbol + "' of size " + details::to_str(vector_base->size()),
                      exprtk_error_location));
 
@@ -34070,7 +34346,7 @@
                   parser_->set_error(parser_error::make_error(
                      parser_error::e_synthesis,
                      token_t(),
-                     "ERR270 - Failed to synthesize node: " + node_name + " for vector: " + symbol,
+                     "ERR272 - Failed to synthesize node: " + node_name + " for vector: " + symbol,
                      exprtk_error_location));
 
                   details::free_node(*node_allocator_, result);
@@ -34096,7 +34372,7 @@
                   parser_->set_error(parser_error::make_error(
                      parser_error::e_synthesis,
                      token_t(),
-                     "ERR271 - Failed to synthesize node: " + node_name + " for vector: " + symbol,
+                     "ERR273 - Failed to synthesize node: " + node_name + " for vector: " + symbol,
                      exprtk_error_location));
 
                   details::free_node(*node_allocator_, result);
@@ -34177,7 +34453,7 @@
             parser_->set_error(parser_error::make_error(
                parser_error::e_synthesis,
                token_t(),
-               "ERR272 - Failed to synthesize node: " + node_name,
+               "ERR274 - Failed to synthesize node: " + node_name,
                exprtk_error_location));
 
             details::free_node(*node_allocator_, result);
@@ -34276,28 +34552,28 @@
                      return reinterpret_cast<const void*>(&static_cast<variable_node_t*>(node)->ref());
 
                   case details::expression_node<T>::e_vecelem:
-                     return reinterpret_cast<const void*>(&static_cast<vector_elem_node_t*>(node)->ref());
+                     return reinterpret_cast<const void*>(static_cast<vector_elem_node_t*>(node)->vec_holder().data());
 
                   case details::expression_node<T>::e_veccelem:
-                     return reinterpret_cast<const void*>(&static_cast<vector_celem_node_t*>(node)->ref());
+                     return reinterpret_cast<const void*>(static_cast<vector_celem_node_t*>(node)->vec_holder().data());
 
                   case details::expression_node<T>::e_vecelemrtc:
-                     return reinterpret_cast<const void*>(&static_cast<vector_elem_rtc_node_t*>(node)->ref());
+                     return reinterpret_cast<const void*>(static_cast<vector_elem_rtc_node_t*>(node)->vec_holder().data());
 
                   case details::expression_node<T>::e_veccelemrtc:
-                     return reinterpret_cast<const void*>(&static_cast<vector_celem_rtc_node_t*>(node)->ref());
+                     return reinterpret_cast<const void*>(static_cast<vector_celem_rtc_node_t*>(node)->vec_holder().data());
 
                   case details::expression_node<T>::e_rbvecelem:
-                     return reinterpret_cast<const void*>(&static_cast<rebasevector_elem_node_t*>(node)->ref());
+                     return reinterpret_cast<const void*>(static_cast<rebasevector_elem_node_t*>(node)->vec_holder().data());
 
                   case details::expression_node<T>::e_rbvecelemrtc:
-                     return reinterpret_cast<const void*>(&static_cast<rebasevector_elem_rtc_node_t*>(node)->ref());
+                     return reinterpret_cast<const void*>(static_cast<rebasevector_elem_rtc_node_t*>(node)->vec_holder().data());
 
                   case details::expression_node<T>::e_rbveccelem:
-                     return reinterpret_cast<const void*>(&static_cast<rebasevector_celem_node_t*>(node)->ref());
+                     return reinterpret_cast<const void*>(static_cast<rebasevector_celem_node_t*>(node)->vec_holder().data());
 
                   case details::expression_node<T>::e_rbveccelemrtc:
-                     return reinterpret_cast<const void*>(&static_cast<rebasevector_celem_rtc_node_t*>(node)->ref());
+                     return reinterpret_cast<const void*>(static_cast<rebasevector_celem_rtc_node_t*>(node)->vec_holder().data());
 
                   case details::expression_node<T>::e_vector:
                      return reinterpret_cast<const void*>(static_cast<vector_node_t*>(node)->vec_holder().data());
@@ -34333,7 +34609,7 @@
                   parser_->set_error(parser_error::make_error(
                      parser_error::e_parser,
                      token,
-                     "ERR273 - Symbol '" + token.value + "' cannot be assigned-to as it is immutable.",
+                     "ERR275 - Symbol '" + token.value + "' cannot be assigned-to as it is immutable.",
                      exprtk_error_location));
                }
                else
@@ -34407,7 +34683,7 @@
                parser_->set_error(parser_error::make_error(
                   parser_error::e_syntax,
                   parser_->current_state().token,
-                  "ERR274 - Cannot assign value to const variable",
+                  "ERR276 - Cannot assign value to const variable",
                   exprtk_error_location));
 
                return error_node();
@@ -34417,7 +34693,7 @@
                parser_->set_error(parser_error::make_error(
                   parser_error::e_syntax,
                   parser_->current_state().token,
-                  "ERR275 - Invalid branches for assignment operator '" + details::to_str(operation) + "'",
+                  "ERR277 - Invalid branches for assignment operator '" + details::to_str(operation) + "'",
                   exprtk_error_location));
 
                return error_node();
@@ -34675,7 +34951,7 @@
                parser_->set_error(parser_error::make_error(
                   parser_error::e_syntax,
                   parser_->current_state().token,
-                  "ERR276 - Invalid branches for assignment operator '" + details::to_str(operation) + "'",
+                  "ERR278 - Invalid branches for assignment operator '" + details::to_str(operation) + "'",
                   exprtk_error_location));
 
                return error_node();
@@ -34689,7 +34965,7 @@
             parser_->set_error(parser_error::make_error(
                parser_error::e_synthesis,
                token_t(),
-               "ERR277 - Failed to synthesize node: " + node_name,
+               "ERR279 - Failed to synthesize node: " + node_name,
                exprtk_error_location));
 
             details::free_node(*node_allocator_, result);
@@ -34779,7 +35055,7 @@
             parser_->set_error(parser_error::make_error(
                parser_error::e_synthesis,
                token_t(),
-               "ERR278 - Failed to synthesize node: " + node_name,
+               "ERR280 - Failed to synthesize node: " + node_name,
                exprtk_error_location));
 
             details::free_node(*node_allocator_, result);
@@ -34865,7 +35141,7 @@
             parser_->set_error(parser_error::make_error(
                parser_error::e_synthesis,
                token_t(),
-               "ERR279 - Failed to synthesize node: " + node_name,
+               "ERR281 - Failed to synthesize node: " + node_name,
                exprtk_error_location));
 
             details::free_node(*node_allocator_, result);
@@ -34948,7 +35224,7 @@
             parser_->set_error(parser_error::make_error(
                parser_error::e_synthesis,
                token_t(),
-               "ERR280 - Failed to synthesize node: " + node_name,
+               "ERR282 - Failed to synthesize node: " + node_name,
                exprtk_error_location));
 
             details::free_node(*node_allocator_, result);
@@ -41447,7 +41723,10 @@
                return node_allocator_->allocate_type<inrange_t, std::string, std::string&, std::string&>(s0, s1, s2);
             }
             else
+            {
+               details::free_all_nodes(*node_allocator_,branch);
                return error_node();
+            }
          }
          #else
          inline expression_node_ptr synthesize_string_expression(const details::operator_type&, expression_node_ptr (&branch)[3])
@@ -41593,7 +41872,7 @@
                parser_->set_error(parser_error::make_error(
                   parser_error::e_parser,
                   token_t(),
-                  "ERR281 - Failed to synthesize node: NodeType",
+                  "ERR283 - Failed to synthesize node: NodeType",
                   exprtk_error_location));
 
                details::free_node(*node_allocator_, expression_point);
@@ -41751,6 +42030,7 @@
          register_unary_op(details::e_acosh , details::acosh_op)
          register_unary_op(details::e_asin  , details::asin_op )
          register_unary_op(details::e_asinh , details::asinh_op)
+         register_unary_op(details::e_atan  , details::atan_op )
          register_unary_op(details::e_atanh , details::atanh_op)
          register_unary_op(details::e_ceil  , details::ceil_op )
          register_unary_op(details::e_cos   , details::cos_op  )
@@ -41898,7 +42178,7 @@
          register_sf4ext(24) register_sf4ext(25) register_sf4ext(26) register_sf4ext(27)
          register_sf4ext(28) register_sf4ext(29) register_sf4ext(30) register_sf4ext(31)
          register_sf4ext(32) register_sf4ext(33) register_sf4ext(34) register_sf4ext(35)
-         register_sf4ext(36) register_sf4ext(36) register_sf4ext(38) register_sf4ext(39)
+         register_sf4ext(36) register_sf4ext(37) register_sf4ext(38) register_sf4ext(39)
          register_sf4ext(40) register_sf4ext(41) register_sf4ext(42) register_sf4ext(43)
          register_sf4ext(44) register_sf4ext(45) register_sf4ext(46) register_sf4ext(47)
          register_sf4ext(48) register_sf4ext(49) register_sf4ext(50) register_sf4ext(51)
@@ -41939,7 +42219,7 @@
          {
             set_error(make_error(
                parser_error::e_parser,
-               "ERR282 - Max local vector size of " + details::to_str(max_local_vector_size_bytes) + " bytes "
+               "ERR284 - Max local vector size of " + details::to_str(max_local_vector_size_bytes) + " bytes "
                "is larger than max total local symbol size of " + details::to_str(settings_.max_total_local_symbol_size_bytes()) + " bytes",
                exprtk_error_location));
 
@@ -43575,7 +43855,7 @@
                parser_error::make_error(
                   parser_error::e_parser,
                   lexer::token(),
-                  "ERR283 - Function '" + name + "' is an invalid overload",
+                  "ERR285 - Function '" + name + "' is an invalid overload",
                   exprtk_error_location);
 
             error_list_.push_back(error);
@@ -44268,7 +44548,7 @@
          #ifdef _MSC_VER
          #pragma warning(pop)
          #endif
-         assert(sizeof(T) <= sizeof(void*));
+         assert(sizeof(T) >= sizeof(void*));
       }
 
    } // namespace exprtk::rtl::io::file::details
@@ -44562,6 +44842,17 @@
             return false;
       }
 
+      template <typename Vector>
+      inline bool invalid_shift(const Vector& v, const std::size_t& r1, const std::size_t& s)
+      {
+         return s >= (v.size() - r1);
+      }
+
+      inline bool invalid_stride(const std::size_t& stride)
+      {
+         return 0 == stride;
+      }
+
       template <typename T>
       struct load_vector_range
       {
@@ -45333,6 +45624,13 @@
             return std::numeric_limits<T>::quiet_NaN();
          }
 
+         const std::size_t dist = r1 - r0 + 1;
+
+         if (n > dist)
+         {
+            return T(0);
+         }
+
          std::nth_element(
             vec.begin() + r0,
             vec.begin() + r0 + n ,
@@ -45374,6 +45672,11 @@
          const std::size_t step_size = (2 != ps_index) ? 1 :
                                        static_cast<std::size_t>(scalar_t(parameters.back())());
 
+         if (helper::invalid_stride(step_size))
+         {
+            return T(0);
+         }
+
          std::size_t r0 = 0;
          std::size_t r1 = vec.size() - 1;
 
@@ -45484,6 +45787,11 @@
          const std::size_t stride = (2 != ps_index) ? 1 :
                                     static_cast<std::size_t>(scalar_t(parameters[3])());
 
+         if (helper::invalid_stride(stride))
+         {
+            return std::numeric_limits<T>::quiet_NaN();
+         }
+
          std::size_t r0 = 0;
          std::size_t r1 = vec.size() - 1;
 
@@ -45744,6 +46052,11 @@
 
          const std::size_t s = static_cast<std::size_t>(scalar_t(parameters[3])());
 
+         if (helper::invalid_shift(y, r1, s))
+         {
+            return std::numeric_limits<T>::quiet_NaN();
+         }
+
          for (std::size_t i = r0; i <= r1; ++i)
          {
             y[i] = (a * x[i]) + (b * y[i + s]);
@@ -45797,6 +46110,11 @@
 
          const std::size_t s = static_cast<std::size_t>(scalar_t(parameters[3])());
 
+         if (helper::invalid_shift(y, r1, s))
+         {
+            return std::numeric_limits<T>::quiet_NaN();
+         }
+
          for (std::size_t i = r0; i <= r1; ++i)
          {
             z[i] = (a * x[i]) + (b * y[i + s]);
@@ -46114,6 +46432,196 @@
    };
 
    template <typename T>
+   class min_elemwise exprtk_final : public exprtk::igeneric_function<T>
+   {
+   public:
+
+      typedef typename exprtk::igeneric_function<T> igfun_t;
+      typedef typename igfun_t::parameter_list_t    parameter_list_t;
+      typedef typename igfun_t::generic_type        generic_type;
+      typedef typename generic_type::scalar_view    scalar_t;
+      typedef typename generic_type::vector_view    vector_t;
+
+      using igfun_t::operator();
+
+      min_elemwise()
+      : exprtk::igeneric_function<T>("VT|VVT|VTTT|VVTTT")
+      /*
+         Overloads:
+         0. VT    - vector, T
+         0. VVT   - vector, vector, T
+         0. VTTT  - vector, r0, r1, T
+         0. VVTTT - vector, vector, r0, r1, T
+      */
+      {}
+
+      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
+      {
+         std::size_t out_vec_index = 0;
+         std::size_t in_vec_index  = (ps_index & 1) ? 1 : 0;
+         std::size_t scalar_index  = parameters.size() - 1;
+
+         vector_t out_vec(parameters[out_vec_index]);
+         vector_t in_vec (parameters[in_vec_index ]);
+
+         const T s = scalar_t(parameters[scalar_index ])();
+
+         std::size_t r0 = 0;
+         std::size_t r1 = in_vec.size() - 1;
+
+         if ((2 == ps_index) || (3 == ps_index))
+         {
+            std::size_t rng_idx0 = 0;
+            std::size_t rng_idx1 = 0;
+
+            switch (ps_index)
+            {
+               case 2 : { rng_idx0 = 1; rng_idx1 = 2; }; break;
+               case 3 : { rng_idx0 = 2; rng_idx1 = 3; }; break;
+            }
+
+            if (!helper::load_vector_range<T>::process(parameters, r0, r1, rng_idx0, rng_idx1, 0))
+            {
+               return T(0);
+            }
+         }
+
+         r1 = std::min(r1, std::min(out_vec.size(), in_vec.size()) - 1);
+
+         for (std::size_t i = r0; i <= r1; ++i)
+         {
+            out_vec[i] = exprtk::details::numeric::min(in_vec[i], s);
+         }
+
+         return T(1);
+      }
+   };
+
+   template <typename T>
+   class max_elemwise exprtk_final : public exprtk::igeneric_function<T>
+   {
+   public:
+
+      typedef typename exprtk::igeneric_function<T> igfun_t;
+      typedef typename igfun_t::parameter_list_t    parameter_list_t;
+      typedef typename igfun_t::generic_type        generic_type;
+      typedef typename generic_type::scalar_view    scalar_t;
+      typedef typename generic_type::vector_view    vector_t;
+
+      using igfun_t::operator();
+
+      max_elemwise()
+      : exprtk::igeneric_function<T>("VT|VVT|VTTT|VVTTT")
+      /*
+         Overloads:
+         0. VT    - vector, T
+         1. VVT   - vector, vector, T
+         2. VTTT  - vector, r0, r1, T
+         3. VVTTT - vector, vector, r0, r1, T
+      */
+      {}
+
+      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
+      {
+         std::size_t out_vec_index = 0;
+         std::size_t in_vec_index  = (ps_index & 1) ? 1 : 0;
+         std::size_t scalar_index  = parameters.size() - 1;
+
+         vector_t out_vec(parameters[out_vec_index]);
+         vector_t in_vec (parameters[in_vec_index ]);
+
+         const T s = scalar_t(parameters[scalar_index ])();
+
+         std::size_t r0 = 0;
+         std::size_t r1 = in_vec.size() - 1;
+
+         if ((2 == ps_index) || (3 == ps_index))
+         {
+            std::size_t rng_idx0 = 0;
+            std::size_t rng_idx1 = 0;
+
+            switch (ps_index)
+            {
+               case 2 : { rng_idx0 = 1; rng_idx1 = 2; }; break;
+               case 3 : { rng_idx0 = 2; rng_idx1 = 3; }; break;
+            }
+
+            if (!helper::load_vector_range<T>::process(parameters, r0, r1, rng_idx0, rng_idx1, 0))
+            {
+               return T(0);
+            }
+         }
+
+         r1 = std::min(r1, std::min(out_vec.size(), in_vec.size()) - 1);
+
+         for (std::size_t i = r0; i <= r1; ++i)
+         {
+            out_vec[i] = exprtk::details::numeric::max(in_vec[i], s);
+         }
+
+         return T(1);
+      }
+   };
+
+   template <typename T>
+   class select exprtk_final : public exprtk::igeneric_function<T>
+   {
+   public:
+
+      typedef typename exprtk::igeneric_function<T> igfun_t;
+      typedef typename igfun_t::parameter_list_t    parameter_list_t;
+      typedef typename igfun_t::generic_type        generic_type;
+      typedef typename generic_type::vector_view    vector_t;
+
+      using igfun_t::operator();
+
+      select()
+      : exprtk::igeneric_function<T>("VVVV|VVVVTT")
+      /*
+         Overloads:
+         0. VVVV  - out vector, mask, vector 0, vector 1
+         1. VVVV  - out vector, mask, vector 0, vector 1, r0, r1
+      */
+      {}
+
+      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
+      {
+               vector_t out (parameters[0]);
+         const vector_t mask(parameters[1]);
+         const vector_t vec0(parameters[2]);
+         const vector_t vec1(parameters[3]);
+
+         std::size_t r0 = 0;
+         std::size_t r1 = std::min(out.size(),
+                          std::min(mask.size(),
+                          std::min(vec0.size(), vec1.size()))) - 1;
+
+         if (1 == ps_index)
+         {
+            std::size_t rng_idx0 = 4;
+            std::size_t rng_idx1 = 5;
+
+            if (!helper::load_vector_range<T>::process(parameters, r0, r1, rng_idx0, rng_idx1, 0))
+            {
+               return T(0);
+            }
+
+            if (helper::invalid_range(out , r0, r1)) return T(0);
+            if (helper::invalid_range(mask, r0, r1)) return T(0);
+            if (helper::invalid_range(vec0, r0, r1)) return T(0);
+            if (helper::invalid_range(vec1, r0, r1)) return T(0);
+         }
+
+         for (std::size_t i = r0; i <= r1; ++i)
+         {
+            out[i] = (mask[i] != T(0)) ? vec0[i] : vec1[i];
+         }
+
+         return T(1);
+      }
+   };
+
+   template <typename T>
    struct package
    {
       all_true       <T> at;
@@ -46144,6 +46652,9 @@
       dotk           <T> dtk;
       threshold_above<T> ta;
       threshold_below<T> tb;
+      min_elemwise<T>    miew;
+      max_elemwise<T>    maew;
+      select<T>          slct;
 
       bool register_package(exprtk::symbol_table<T>& symtab)
       {
@@ -46186,6 +46697,10 @@
          exprtk_register_function("dotk"            , dtk       )
          exprtk_register_function("threshold_above" , ta        )
          exprtk_register_function("threshold_below" , tb        )
+         exprtk_register_function("min_elemwise"    , miew      )
+         exprtk_register_function("max_elemwise"    , maew      )
+         exprtk_register_function("select"          , slct      )
+
          #undef exprtk_register_function
 
          return true;
@@ -46204,11 +46719,11 @@
       using ::exprtk::details::char_cptr;
 
       static char_cptr library = "Mathematical Expression Toolkit";
-      static char_cptr version = "2.718281828459045235360287471352662497757"
-                                 "24709369995957496696762772407663035354759"
-                                 "45713821785251664274274663919320030599218"
-                                 "17413596629043572900334295260595630738132";
-      static char_cptr date    = "20240101";
+      static char_cptr version = "2.71828182845904523536028747135266249775724"
+                                 "7093699959574966967627724076630353547594571"
+                                 "3821785251664274274663919320030599218174135"
+                                 "9662904357290033429526059563073813232862794";
+      static char_cptr date    = "20250101";
       static char_cptr min_cpp = "199711L";
 
       static inline std::string data()
diff --git a/exprtk_benchmark.cpp b/exprtk_benchmark.cpp
index c989954..31ee6db 100644
--- a/exprtk_benchmark.cpp
+++ b/exprtk_benchmark.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * ExprTk vs Native Benchmarks                                *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
@@ -404,7 +404,6 @@
 
    std::string buffer;
    buffer.reserve(1024);
-   std::size_t line_count = 0;
 
    while (std::getline(stream,buffer))
    {
@@ -413,11 +412,10 @@
       else if ('#' == buffer[0])
          continue;
 
-      ++line_count;
       expression_list.push_back(buffer);
    }
 
-   return line_count;
+   return expression_list.size();
 }
 
 void perform_file_based_benchmark(const std::string& file_name, const std::size_t& rounds)
diff --git a/exprtk_functional_test.txt b/exprtk_functional_test.txt
index 2bb2a91..fecc608 100644
--- a/exprtk_functional_test.txt
+++ b/exprtk_functional_test.txt
@@ -9267,57 +9267,86 @@
 equal('abc'       ilike 'xyzw'  ,false)
 equal('abcd'      ilike 'ab?'   ,false)
 equal('abcd'      ilike 'a?'    ,false)
-equal(true, ~{var xx := 'abcdefgh'; xx[1:4]     == 'bcde'     })
-equal(true, ~{var xx := 'abcdefgh'; xx[ :8 / 2] == 'abcde'    })
-equal(true, ~{var xx := 'abcdefgh'; xx[ :4]     == 'abcde'    })
-equal(true, ~{var xx := 'abcdefgh'; xx[ :4]     == xx[:8 / 2] })
-equal(true, ~{var xx := 'abcdefgh'; xx[2 + 1: ] =='defgh'     })
-equal(true, ~{var xx := 'abcdefgh'; xx[ : ]     == 'abcdefgh' })
-equal(true, ~{var xx := 'abcdefgh'; xx[:]       == 'abcdefgh' })
-equal(true, ~{var xx := 'abcdefgh'; xx[4/2:3+1] == 'cde'      })
-equal(true, ~{var xx := 'abcdefgh'; xx[2:4]     == 'cde'      })
-equal(true, ~{var xx := 'abcdefgh'; xx[0:xx[]-1] == 'abcdefgh'})
-equal(true, ~{var xx := 'abcdefgh'; xx[0:xx[]-2] == 'abcdefg' })
-equal(true, ~{var xx := 'abcdefgh'; xx[0:xx[]-3] == 'abcdef'  })
-equal(true, ~{var xx := 'abcdefgh'; xx[0:xx[]-4] == 'abcde'   })
-equal(true, ~{var xx := 'abcdefgh'; xx[0:xx[]-5] == 'abcd'    })
-equal(true, ~{var xx := 'abcdefgh'; xx[0:xx[]-6] == 'abc'     })
-equal(true, ~{var xx := 'abcdefgh'; xx[0:xx[]-7] == 'ab'      })
-equal(true, ~{var xx := 'abcdefgh'; xx[0:xx[]-8] == 'a'       })
-equal(true, ~{var xx := 'abcdefgh'; xx[0:xx[]  ] == 'abcdefgh'})
-equal(true, ~{var xx := 'abcdefgh'; xx[1:xx[]  ] == 'bcdefgh' })
-equal(true, ~{var xx := 'abcdefgh'; xx[2:xx[]  ] == 'cdefgh'  })
-equal(true, ~{var xx := 'abcdefgh'; xx[3:xx[]  ] == 'defgh'   })
-equal(true, ~{var xx := 'abcdefgh'; xx[4:xx[]  ] == 'efgh'    })
-equal(true, ~{var xx := 'abcdefgh'; xx[5:xx[]  ] == 'fgh'     })
-equal(true, ~{var xx := 'abcdefgh'; xx[6:xx[]  ] == 'gh'      })
-equal(true, ~{var xx := 'abcdefgh'; xx[7:xx[]  ] == 'h'       })
-equal(true, ~{var xx := 'abcdefgh'; xx[8:xx[]  ] == ''        })
-equal(true, ~{var xx := 'abcdefgh'; xx[1:xx[]-2] == 'bcdefg'  })
-equal(true, ~{var xx := 'abcdefgh'; xx[2:xx[]-3] == 'cdef'    })
-equal(true, ~{var xx := 'abcdefgh'; xx[3:xx[]-4] == 'de'      })
-equal(true, ~{var xx := 'abcdefgh'; 'cde'      == xx[4/2:3+1] })
-equal(true, ~{var xx := 'abcdefgh'; 'cde'      == xx[2:4]     })
-equal(true, ~{var xx := 'abcdefgh'; 'abcdefgh' == xx[0:xx[]-1]})
-equal(true, ~{var xx := 'abcdefgh'; 'abcdefg'  == xx[0:xx[]-2]})
-equal(true, ~{var xx := 'abcdefgh'; 'abcdef'   == xx[0:xx[]-3]})
-equal(true, ~{var xx := 'abcdefgh'; 'abcde'    == xx[0:xx[]-4]})
-equal(true, ~{var xx := 'abcdefgh'; 'abcd'     == xx[0:xx[]-5]})
-equal(true, ~{var xx := 'abcdefgh'; 'abc'      == xx[0:xx[]-6]})
-equal(true, ~{var xx := 'abcdefgh'; 'ab'       == xx[0:xx[]-7]})
-equal(true, ~{var xx := 'abcdefgh'; 'a'        == xx[0:xx[]-8]})
-equal(true, ~{var xx := 'abcdefgh'; 'abcdefgh' == xx[0:xx[]  ]})
-equal(true, ~{var xx := 'abcdefgh'; 'bcdefgh'  == xx[1:xx[]  ]})
-equal(true, ~{var xx := 'abcdefgh'; 'cdefgh'   == xx[2:xx[]  ]})
-equal(true, ~{var xx := 'abcdefgh'; 'defgh'    == xx[3:xx[]  ]})
-equal(true, ~{var xx := 'abcdefgh'; 'efgh'     == xx[4:xx[]  ]})
-equal(true, ~{var xx := 'abcdefgh'; 'fgh'      == xx[5:xx[]  ]})
-equal(true, ~{var xx := 'abcdefgh'; 'gh'       == xx[6:xx[]  ]})
-equal(true, ~{var xx := 'abcdefgh'; 'h'        == xx[7:xx[]  ]})
-equal(true, ~{var xx := 'abcdefgh'; ''         == xx[8:xx[]  ]})
-equal(true, ~{var xx := 'abcdefgh'; 'bcdefg'   == xx[1:xx[]-2]})
-equal(true, ~{var xx := 'abcdefgh'; 'cdef'     == xx[2:xx[]-3]})
-equal(true, ~{var xx := 'abcdefgh'; 'de'       == xx[3:xx[]-4]})
+equal(true, ~{var xx := 'abcdefgh'; xx[1:5]       == 'bcde'     })
+equal(true, ~{var xx := 'abcdefgh'; xx[ :8 / 2 + 1] == 'abcde'  })
+equal(true, ~{var xx := 'abcdefgh'; xx[ :5]       == 'abcde'    })
+equal(true, ~{var xx := 'abcdefgh'; xx[ :5]       == xx[:8 / 2 + 1]})
+equal(true, ~{var xx := 'abcdefgh'; xx[2 + 1: ]   =='defgh'     })
+equal(true, ~{var xx := 'abcdefgh'; xx[ : ]       == 'abcdefgh' })
+equal(true, ~{var xx := 'abcdefgh'; xx[:]         == 'abcdefgh' })
+equal(true, ~{var xx := 'abcdefgh'; xx[4/2:3+1+1] == 'cde'      })
+equal(true, ~{var xx := 'abcdefgh'; xx[2:5]       == 'cde'      })
+equal(true, ~{var xx := 'abcdefgh'; xx[0:xx[]-0] == 'abcdefgh'  })
+equal(true, ~{var xx := 'abcdefgh'; xx[0:xx[]-1] == 'abcdefg'   })
+equal(true, ~{var xx := 'abcdefgh'; xx[0:xx[]-2] == 'abcdef'    })
+equal(true, ~{var xx := 'abcdefgh'; xx[0:xx[]-3] == 'abcde'     })
+equal(true, ~{var xx := 'abcdefgh'; xx[0:xx[]-4] == 'abcd'      })
+equal(true, ~{var xx := 'abcdefgh'; xx[0:xx[]-5] == 'abc'       })
+equal(true, ~{var xx := 'abcdefgh'; xx[0:xx[]-6] == 'ab'        })
+equal(true, ~{var xx := 'abcdefgh'; xx[0:xx[]-7] == 'a'         })
+equal(true, ~{var xx := 'abcdefgh'; xx[0:xx[]  ] == 'abcdefgh'  })
+equal(true, ~{var xx := 'abcdefgh'; xx[1:xx[]  ] == 'bcdefgh'   })
+equal(true, ~{var xx := 'abcdefgh'; xx[2:xx[]  ] == 'cdefgh'    })
+equal(true, ~{var xx := 'abcdefgh'; xx[3:xx[]  ] == 'defgh'     })
+equal(true, ~{var xx := 'abcdefgh'; xx[4:xx[]  ] == 'efgh'      })
+equal(true, ~{var xx := 'abcdefgh'; xx[5:xx[]  ] == 'fgh'       })
+equal(true, ~{var xx := 'abcdefgh'; xx[6:xx[]  ] == 'gh'        })
+equal(true, ~{var xx := 'abcdefgh'; xx[7:xx[]  ] == 'h'         })
+equal(true, ~{var xx := 'abcdefgh'; xx[8:xx[]  ] == ''          })
+equal(true, ~{var xx := 'abcdefgh'; xx[1:xx[]-1] == 'bcdefg'    })
+equal(true, ~{var xx := 'abcdefgh'; xx[2:xx[]-2] == 'cdef'      })
+equal(true, ~{var xx := 'abcdefgh'; xx[3:xx[]-3] == 'de'        })
+equal(true, ~{var xx := 'abcdefgh'; 'cde'      == xx[4/2:3+1+1] })
+equal(true, ~{var xx := 'abcdefgh'; 'cde'      == xx[2:5]       })
+equal(true, ~{var xx := 'abcdefgh'; 'abcdefgh' == xx[0:xx[]-0]  })
+equal(true, ~{var xx := 'abcdefgh'; 'abcdefg'  == xx[0:xx[]-1]  })
+equal(true, ~{var xx := 'abcdefgh'; 'abcdef'   == xx[0:xx[]-2]  })
+equal(true, ~{var xx := 'abcdefgh'; 'abcde'    == xx[0:xx[]-3]  })
+equal(true, ~{var xx := 'abcdefgh'; 'abcd'     == xx[0:xx[]-4]  })
+equal(true, ~{var xx := 'abcdefgh'; 'abc'      == xx[0:xx[]-5]  })
+equal(true, ~{var xx := 'abcdefgh'; 'ab'       == xx[0:xx[]-6]  })
+equal(true, ~{var xx := 'abcdefgh'; 'a'        == xx[0:xx[]-7]  })
+equal(true, ~{var xx := 'abcdefgh'; 'abcdefgh' == xx[0:xx[]  ]  })
+equal(true, ~{var xx := 'abcdefgh'; 'bcdefgh'  == xx[1:xx[]  ]  })
+equal(true, ~{var xx := 'abcdefgh'; 'cdefgh'   == xx[2:xx[]  ]  })
+equal(true, ~{var xx := 'abcdefgh'; 'defgh'    == xx[3:xx[]  ]  })
+equal(true, ~{var xx := 'abcdefgh'; 'efgh'     == xx[4:xx[]  ]  })
+equal(true, ~{var xx := 'abcdefgh'; 'fgh'      == xx[5:xx[]  ]  })
+equal(true, ~{var xx := 'abcdefgh'; 'gh'       == xx[6:xx[]  ]  })
+equal(true, ~{var xx := 'abcdefgh'; 'h'        == xx[7:xx[]  ]  })
+equal(true, ~{var xx := 'abcdefgh'; ''         == xx[8:xx[]  ]  })
+equal(true, ~{var xx := 'abcdefgh'; 'bcdefg'   == xx[1:xx[]-1]  })
+equal(true, ~{var xx := 'abcdefgh'; 'cdef'     == xx[2:xx[]-2]  })
+equal(true, ~{var xx := 'abcdefgh'; 'de'       == xx[3:xx[]-3]  })
+equal(true, ~{ var ss := '0123456789'; var tt := 'XXXXXXXXXXXXXXXXXXXX'; ss[0 : ~{ss<=>tt; ss[] - 1}] := 'AAAA'; ss == 'AAAAXXXXXXXXXXXXXXXX'})
+equal(true, ~{ var ss := '0123456789'; var tt := 'XXXXXXXXXXXXXXXXXXXX'; ss[1 : ~{ss<=>tt; ss[] - 1}] := 'AAAA'; ss == 'XAAAAXXXXXXXXXXXXXXX'})
+equal(true, ~{ var ss := '0123456789'; var tt := 'XXXXXXXXXXXXXXXXXXXX'; ss[2 : ~{ss<=>tt; ss[] - 1}] := 'AAAA'; ss == 'XXAAAAXXXXXXXXXXXXXX'})
+equal(true, ~{ var ss := '0123456789'; var tt := 'XXXXXXXXXXXXXXXXXXXX'; ss[3 : ~{ss<=>tt; ss[] - 1}] := 'AAAA'; ss == 'XXXAAAAXXXXXXXXXXXXX'})
+equal(true, ~{ var ss := '0123456789'; var tt := 'XXXXXXXXXXXXXXXXXXXX'; ss[4 : ~{ss<=>tt; ss[] - 1}] := 'AAAA'; ss == 'XXXXAAAAXXXXXXXXXXXX'})
+equal(true, ~{ var ss := '012345'; ss[0:0+1] == '0'})
+equal(true, ~{ var ss := '012345'; ss[1:1+1] == '1'})
+equal(true, ~{ var ss := '012345'; ss[2:2+1] == '2'})
+equal(true, ~{ var ss := '012345'; ss[3:3+1] == '3'})
+equal(true, ~{ var ss := '012345'; ss[4:4+1] == '4'})
+equal(true, ~{ var ss := '012345'; ss[5:5+1] == '5'})
+equal(true, ~{ var ss := '012345'; var r0 := 0; ss[r0:r0+1] == '0'})
+equal(true, ~{ var ss := '012345'; var r0 := 1; ss[r0:r0+1] == '1'})
+equal(true, ~{ var ss := '012345'; var r0 := 2; ss[r0:r0+1] == '2'})
+equal(true, ~{ var ss := '012345'; var r0 := 3; ss[r0:r0+1] == '3'})
+equal(true, ~{ var ss := '012345'; var r0 := 4; ss[r0:r0+1] == '4'})
+equal(true, ~{ var ss := '012345'; var r0 := 5; ss[r0:r0+1] == '5'})
+equal(true, ~{ var ss := '012345'; var r0 := 0; var r1 := 0; ss[r0:r1+1] == '0'})
+equal(true, ~{ var ss := '012345'; var r0 := 1; var r1 := 1; ss[r0:r1+1] == '1'})
+equal(true, ~{ var ss := '012345'; var r0 := 2; var r1 := 2; ss[r0:r1+1] == '2'})
+equal(true, ~{ var ss := '012345'; var r0 := 3; var r1 := 3; ss[r0:r1+1] == '3'})
+equal(true, ~{ var ss := '012345'; var r0 := 4; var r1 := 4; ss[r0:r1+1] == '4'})
+equal(true, ~{ var ss := '012345'; var r0 := 5; var r1 := 5; ss[r0:r1+1] == '5'})
+equal(true, ~{ var ss := '012345'; var r0 := 0; var r1 := 1; ss[r0:r1]   == '0'})
+equal(true, ~{ var ss := '012345'; var r0 := 1; var r1 := 2; ss[r0:r1]   == '1'})
+equal(true, ~{ var ss := '012345'; var r0 := 2; var r1 := 3; ss[r0:r1]   == '2'})
+equal(true, ~{ var ss := '012345'; var r0 := 3; var r1 := 4; ss[r0:r1]   == '3'})
+equal(true, ~{ var ss := '012345'; var r0 := 4; var r1 := 5; ss[r0:r1]   == '4'})
+equal(true, ~{ var ss := '012345'; var r0 := 5; var r1 := 6; ss[r0:r1]   == '5'})
 equal(true, ~{var s := ~{var n := 1; var m := 2; if (n < m) 'n < m';  else 'n >= m'; }; (s == 'n < m')})
 equal(true, ~{var s := ~{var n := 1; var m := 2; if (n > m) 'n <= m'; else 'n > m'; }; (s == 'n > m')})
 equal(true, ~{var s := ~{var n := 1; var m := 2; if (n < m) 'n < m';  else 'n >' + '= m'; }; (s == 'n < m')})
@@ -10266,6 +10295,22 @@
 equal(true,~{const var xx := 2; const var n := 111; var v[n] := [xx - 1 : 4 / xx]; equal(sum(v),v[]^2)})
 equal(true,~{const var xx := 2; const var n := 1101; var v[n] := [xx - 1 : 4 / xx]; equal(sum(v),v[]^2)})
 equal(true,~{const var xx := 2; const var n := 11001; var v[n] := [xx - 1 : 4 / xx]; equal(sum(v),v[]^2)})
+equal(true, ~{ var aa[3] := { 1, 2, 3 }; var bb[2] := { 0 , 0 }; var cc[2] := { 2 , 3 }; bb := aa + 1; (bb == cc) });
+equal(true, ~{ var aa[3] := { 1, 2, 3 }; var bb[2] := { 0 , 0 }; var cc[2] := { 2 , 3 }; bb := 1 + aa; (bb == cc) });
+equal(true, ~{ var aa[3] := { 1, 2, 3 }; var bb[2] := { 0 , 0 }; var cc[2] := { 2 , 3 }; var n := 1; bb := aa + n; (bb == cc) });
+equal(true, ~{ var aa[3] := { 1, 2, 3 }; var bb[2] := { 0 , 0 }; var cc[2] := { 2 , 3 }; var n := 1; bb := n + aa; (bb == cc) });
+equal(true, ~{ var aa[3] := { 1, 2, 3 }; var bb[2] := { 0 , 0 }; var cc[2] := { 2 , 3 }; const var n := 1; bb := aa + n; (bb == cc) });
+equal(true, ~{ var aa[3] := { 1, 2, 3 }; var bb[2] := { 0 , 0 }; var cc[2] := { 2 , 3 }; const var n := 1; bb := n + aa; (bb == cc) });
+equal(true, ~{ var aa[3] := { 1, 2, 3 }; var bb[2] := { 0 , 0 }; var cc[2] := { 2 , 3 }; var n[2] := { 1 , 1 }; bb := aa + n[1]; (bb == cc) });
+equal(true, ~{ var aa[3] := { 1, 2, 3 }; var bb[2] := { 0 , 0 }; var cc[2] := { 2 , 3 }; var n[2] := { 1 , 1 }; bb := n[1] + aa; (bb == cc) });
+equal(true, ~{ var aa[3] := { 1, 2, 3 }; var bb[2] := { 0 , 0 }; var cc[2] := { 1 , 0 }; bb := aa == 1; (bb == cc) });
+equal(true, ~{ var aa[3] := { 1, 2, 3 }; var bb[2] := { 0 , 0 }; var cc[2] := { 1 , 0 }; bb := 1 == aa; (bb == cc) });
+equal(true, ~{ var aa[3] := { 1, 2, 3 }; var bb[2] := { 0 , 0 }; var cc[2] := { 1 , 0 }; var n := 1; bb := aa == n; (bb == cc) });
+equal(true, ~{ var aa[3] := { 1, 2, 3 }; var bb[2] := { 0 , 0 }; var cc[2] := { 1 , 0 }; var n := 1; bb := n == aa; (bb == cc) });
+equal(true, ~{ var aa[3] := { 1, 2, 3 }; var bb[2] := { 0 , 0 }; var cc[2] := { 1 , 0 }; const var n := 1; bb := aa == n; (bb == cc) });
+equal(true, ~{ var aa[3] := { 1, 2, 3 }; var bb[2] := { 0 , 0 }; var cc[2] := { 1 , 0 }; const var n := 1; bb := n == aa; (bb == cc) });
+equal(true, ~{ var aa[3] := { 1, 2, 3 }; var bb[2] := { 0 , 0 }; var cc[2] := { 1 , 0 }; var n[2] := { 1 , 1 }; bb := aa == n[1]; (bb == cc) });
+equal(true, ~{ var aa[3] := { 1, 2, 3 }; var bb[2] := { 0 , 0 }; var cc[2] := { 1 , 0 }; var n[2] := { 1 , 1 }; bb := n[1] == aa; (bb == cc) });
 equal(true,~{var zz := for (var i := 0; i < 10; i+=1) { var yy := if (i % 2) { const var xx := 3; i + xx; } else if (i % 2 == 0) { const var xx := 2; i + xx; } }; zz == 12})
 equal(true,~{var zz := for (var i := 0; i < 10; i+=1) { var yy := if (i % 2 == true) { const var xx := 3; i + xx; } else if (i % 2 == false) { const var xx := 2; i + xx; } }; zz == 12})
 equal(true,~{var result := 0; if (true) { result := 2 }; if (true) { result := 3 }; result == 3})
@@ -10511,4 +10556,20 @@
 equal(~{ var xx[1000   ] := [1:1]; sqrt(sum([xx - avg(xx)]^2) / xx[]) } , 000288.67499025720950043826670416494563681823480183371010816)
 equal(~{ var xx[10000  ] := [1:1]; sqrt(sum([xx - avg(xx)]^2) / xx[]) } , 002886.75133151437205672070778500749723447196977023066362870)
 equal(~{ var xx[100000 ] := [1:1]; sqrt(sum([xx - avg(xx)]^2) / xx[]) } , 028867.51345803791255244729022199884500125204178136741699959)
-equal(~{ var xx[1000000] := [1:1]; sqrt(sum([xx - avg(xx)]^2) / xx[]) } , 288675.13459466854468727694772545961625902290853716567468578)
\ No newline at end of file
+equal(~{ var xx[1000000] := [1:1]; sqrt(sum([xx - avg(xx)]^2) / xx[]) } , 288675.13459466854468727694772545961625902290853716567468578)
+equal(true, ~{ const var n := 1; var v[n] := [1:1]; var o[n] := [0]; max_elemwise(o, v, 0); v == o});
+equal(true, ~{ const var n := 2; var v[n] := [1:1]; var o[n] := [0]; max_elemwise(o, v, 0); v == o});
+equal(true, ~{ const var n := 3; var v[n] := [1:1]; var o[n] := [0]; max_elemwise(o, v, 0); v == o});
+equal(true, ~{ const var n := 4; var v[n] := [1:1]; var o[n] := [0]; max_elemwise(o, v, 0); v == o});
+equal(true, ~{ const var n := 5; var v[n] := [1:1]; var o[n] := [0]; max_elemwise(o, v, 0); v == o});
+equal(true, ~{ const var n := 1; var v[n] := [1:1]; var o[n] := [n + 1]; min_elemwise(o, v, n + 1); v == o});
+equal(true, ~{ const var n := 2; var v[n] := [1:1]; var o[n] := [n + 1]; min_elemwise(o, v, n + 1); v == o});
+equal(true, ~{ const var n := 3; var v[n] := [1:1]; var o[n] := [n + 1]; min_elemwise(o, v, n + 1); v == o});
+equal(true, ~{ const var n := 4; var v[n] := [1:1]; var o[n] := [n + 1]; min_elemwise(o, v, n + 1); v == o});
+equal(true, ~{ const var n := 5; var v[n] := [1:1]; var o[n] := [n + 1]; min_elemwise(o, v, n + 1); v == o});
+equal(true, ~{ const var n := 10; var v[n] := [1:1]; var o[n] := [0]; var p[n] := { 0, 0, 0, 4, 5, 6, 7, 8, 0,  0}; max_elemwise(o, v, 3, 7, 0) == 1 and all_true((o == p)) })
+equal(true, ~{ const var n := 10; var v[n] := [1:1]; var o[n] := [0]; var p[n] := { 1, 2, 3, 4, 5, 0, 0, 0, 0,  0}; max_elemwise(o, v, 0, 4, 0) == 1 and all_true((o == p)) })
+equal(true, ~{ const var n := 10; var v[n] := [1:1]; var o[n] := [0]; var p[n] := { 0, 0, 0, 0, 5, 6, 7, 8, 9, 10}; max_elemwise(o, v, 4, 9, 0) == 1 and all_true((o == p)) })
+equal(true, ~{ const var n := 10; var q := n + 10; var v[n] := [1:1]; var o[n] := [n + 10]; var p[n] := { q, q, q, 4, 5, 6, 7, 8, q,  q }; min_elemwise(o, v, 3, 7, q) == 1 and all_true((o == p)) })
+equal(true, ~{ const var n := 10; var q := n + 10; var v[n] := [1:1]; var o[n] := [n + 10]; var p[n] := { 1, 2, 3, 4, 5, q, q, q, q,  q }; min_elemwise(o, v, 0, 4, q) == 1 and all_true((o == p)) })
+equal(true, ~{ const var n := 10; var q := n + 10; var v[n] := [1:1]; var o[n] := [n + 10]; var p[n] := { q, q, q, q, 5, 6, 7, 8, 9, 10 }; min_elemwise(o, v, 4, 9, q) == 1 and all_true((o == p)) })
diff --git a/exprtk_simple_example_01.cpp b/exprtk_simple_example_01.cpp
index 52c5565..a4c7839 100644
--- a/exprtk_simple_example_01.cpp
+++ b/exprtk_simple_example_01.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 01                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_02.cpp b/exprtk_simple_example_02.cpp
index 279046a..5dc9f64 100644
--- a/exprtk_simple_example_02.cpp
+++ b/exprtk_simple_example_02.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 02                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_03.cpp b/exprtk_simple_example_03.cpp
index 3b8ad07..35c4d6b 100644
--- a/exprtk_simple_example_03.cpp
+++ b/exprtk_simple_example_03.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 03                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_04.cpp b/exprtk_simple_example_04.cpp
index 04a4b3f..532c8f9 100644
--- a/exprtk_simple_example_04.cpp
+++ b/exprtk_simple_example_04.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 04                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_05.cpp b/exprtk_simple_example_05.cpp
index 3eb4a4f..99fb156 100644
--- a/exprtk_simple_example_05.cpp
+++ b/exprtk_simple_example_05.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 05                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_06.cpp b/exprtk_simple_example_06.cpp
index dbb805d..62b0905 100644
--- a/exprtk_simple_example_06.cpp
+++ b/exprtk_simple_example_06.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 06                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_07.cpp b/exprtk_simple_example_07.cpp
index 85e94f1..872188a 100644
--- a/exprtk_simple_example_07.cpp
+++ b/exprtk_simple_example_07.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 07                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_08.cpp b/exprtk_simple_example_08.cpp
index f82b992..b39cda8 100644
--- a/exprtk_simple_example_08.cpp
+++ b/exprtk_simple_example_08.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 08                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_09.cpp b/exprtk_simple_example_09.cpp
index f7cd0f2..327f174 100644
--- a/exprtk_simple_example_09.cpp
+++ b/exprtk_simple_example_09.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 09                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_10.cpp b/exprtk_simple_example_10.cpp
index 67add61..eeab3d1 100644
--- a/exprtk_simple_example_10.cpp
+++ b/exprtk_simple_example_10.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 10                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_11.cpp b/exprtk_simple_example_11.cpp
index 8a26fb5..dc15ef7 100644
--- a/exprtk_simple_example_11.cpp
+++ b/exprtk_simple_example_11.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 11                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_12.cpp b/exprtk_simple_example_12.cpp
index 8045de4..07df710 100644
--- a/exprtk_simple_example_12.cpp
+++ b/exprtk_simple_example_12.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 12                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_13.cpp b/exprtk_simple_example_13.cpp
index cebdf73..46916d6 100644
--- a/exprtk_simple_example_13.cpp
+++ b/exprtk_simple_example_13.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 13                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_14.cpp b/exprtk_simple_example_14.cpp
index 56208e1..57d90ac 100644
--- a/exprtk_simple_example_14.cpp
+++ b/exprtk_simple_example_14.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 14                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_15.cpp b/exprtk_simple_example_15.cpp
index 3dc6d4d..74338aa 100644
--- a/exprtk_simple_example_15.cpp
+++ b/exprtk_simple_example_15.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 15                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_16.cpp b/exprtk_simple_example_16.cpp
index 8970072..9e816eb 100644
--- a/exprtk_simple_example_16.cpp
+++ b/exprtk_simple_example_16.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 16                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_17.cpp b/exprtk_simple_example_17.cpp
index 2c2221c..d6000ab 100644
--- a/exprtk_simple_example_17.cpp
+++ b/exprtk_simple_example_17.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 17                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_18.cpp b/exprtk_simple_example_18.cpp
index f4c714b..2233cf1 100644
--- a/exprtk_simple_example_18.cpp
+++ b/exprtk_simple_example_18.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 18                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_19.cpp b/exprtk_simple_example_19.cpp
index bcf4593..6544968 100644
--- a/exprtk_simple_example_19.cpp
+++ b/exprtk_simple_example_19.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 19                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_20.cpp b/exprtk_simple_example_20.cpp
index 8baa7f1..136a6ee 100644
--- a/exprtk_simple_example_20.cpp
+++ b/exprtk_simple_example_20.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 20                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_21.cpp b/exprtk_simple_example_21.cpp
index 8838ff4..633139b 100644
--- a/exprtk_simple_example_21.cpp
+++ b/exprtk_simple_example_21.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 21                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_22.cpp b/exprtk_simple_example_22.cpp
index c3a2f19..941b66e 100644
--- a/exprtk_simple_example_22.cpp
+++ b/exprtk_simple_example_22.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 22                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
@@ -33,40 +33,40 @@
    typedef typename compositor_t::function function_t;
 
    const std::string option_implied_volatility_program =
-      " const var epsilon   := 0.0000001;                               "
-      " const var max_iters := 1000;                                    "
-      "                                                                 "
-      " var v   := 0.5; /* Initial volatility guess */                  "
-      " var itr := 0;                                                   "
-      "                                                                 "
-      " while ((itr += 1) <= max_iters)                                 "
-      " {                                                               "
-      "    var price :=                                                 "
-      "       switch                                                    "
-      "       {                                                         "
-      "          case callput_flag == 'call' : bsm_call(s, k, r, t, v); "
-      "          case callput_flag == 'put'  : bsm_put (s, k, r, t, v); "
-      "       };                                                        "
-      "                                                                 "
-      "    var price_diff := price - target_price;                      "
-      "                                                                 "
-      "    if (abs(price_diff) <= epsilon)                              "
-      "    {                                                            "
-      "       break;                                                    "
-      "    };                                                           "
-      "                                                                 "
-      "    var vega := bsm_vega(s, k, r, t, v);                         "
-      "                                                                 "
-      "    if (vega < epsilon)                                          "
-      "    {                                                            "
-      "       itr := max_iters + 1;                                     "
-      "       break;                                                    "
-      "    };                                                           "
-      "                                                                 "
-      "    v -= price_diff / vega;                                      "
-      " };                                                              "
-      "                                                                 "
-      " itr <= max_iters ? v : null;                                    ";
+      " const var epsilon   := 0.0000001;                                  "
+      " const var max_iters := 1000;                                       "
+      "                                                                    "
+      " var vola := 0.5; /* Initial volatility guess */                    "
+      " var itr  := 0;                                                     "
+      "                                                                    "
+      " while ((itr += 1) <= max_iters)                                    "
+      " {                                                                  "
+      "    var price :=                                                    "
+      "       switch                                                       "
+      "       {                                                            "
+      "          case callput_flag == 'call' : bsm_call(s, k, r, t, vola); "
+      "          case callput_flag == 'put'  : bsm_put (s, k, r, t, vola); "
+      "       };                                                           "
+      "                                                                    "
+      "    var price_diff := price - target_price;                         "
+      "                                                                    "
+      "    if (abs(price_diff) <= epsilon)                                 "
+      "    {                                                               "
+      "       break;                                                       "
+      "    };                                                              "
+      "                                                                    "
+      "    var vega := bsm_vega(s, k, r, t, vola);                         "
+      "                                                                    "
+      "    if (vega < epsilon)                                             "
+      "    {                                                               "
+      "       itr := max_iters + 1;                                        "
+      "       break;                                                       "
+      "    };                                                              "
+      "                                                                    "
+      "    vola -= price_diff / vega;                                      "
+      " };                                                                 "
+      "                                                                    "
+      " itr <= max_iters ? vola : null;                                    ";
 
    T s            = T(100.00); // Spot / Stock / Underlying / Base price
    T k            = T(110.00); // Strike price
@@ -126,22 +126,22 @@
       callput_flag = "call";
       target_price = T(18.339502);
 
-      const T call_option_implied_vol = expression.value();
+      const T call_option_implied_vola = expression.value();
 
       printf("Call Option(s: %5.3f, k: %5.3f, t: %5.3f, r: %5.3f) "
              "@ $%8.6f Implied volatility = %10.8f\n",
-             s, k, t, r, target_price, call_option_implied_vol);
+             s, k, t, r, target_price, call_option_implied_vola);
    }
 
    {
       callput_flag = "put";
       target_price = T(16.782764);
 
-      const T put_option_implied_vol = expression.value();
+      const T put_option_implied_vola = expression.value();
 
       printf("Put  Option(s: %5.3f, k: %5.3f, t: %5.3f, r: %5.3f) "
              "@ $%8.6f Implied volatility = %10.8f\n",
-             s, k, t, r, target_price, put_option_implied_vol);
+             s, k, t, r, target_price, put_option_implied_vola);
    }
 }
 
diff --git a/exprtk_simple_example_23.cpp b/exprtk_simple_example_23.cpp
index f81a2fe..00cb835 100644
--- a/exprtk_simple_example_23.cpp
+++ b/exprtk_simple_example_23.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 23                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_simple_example_24.cpp b/exprtk_simple_example_24.cpp
index d9eba7d..32c8943 100644
--- a/exprtk_simple_example_24.cpp
+++ b/exprtk_simple_example_24.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Simple Example 24                                          *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
diff --git a/exprtk_test.cpp b/exprtk_test.cpp
index 8262a7f..4ff4f75 100644
--- a/exprtk_test.cpp
+++ b/exprtk_test.cpp
@@ -3,7 +3,7 @@
  *         C++ Mathematical Expression Toolkit Library        *
  *                                                            *
  * Examples and Unit-Tests                                    *
- * Author: Arash Partow (1999-2024)                           *
+ * Author: Arash Partow (1999-2025)                           *
  * URL: https://www.partow.net/programming/exprtk/index.html  *
  *                                                            *
  * Copyright notice:                                          *
@@ -2201,174 +2201,174 @@
       test_ab<T>("~{var x := 'xxx'; var y := 'yyy';~{x == (x != (x + '2') ? x : y)  }}","","",T(1.0)),
       test_ab<T>("~{var x := 'xxx'; var y := 'yyy';~{'xxx1' == (x < y ? x + '1' : y)}}","","",T(1.0)),
       test_ab<T>("~{var x := 'xxx'; var y := 'yyy';~{'yyy2' == (x > y ? x : y + '2')}}","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[0:9] == '0123456789'    ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[0:9] == '0123456789'[:] ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[0:9] == '0123456789'[0:]","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[0:9] == '0123456789'[:9]","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[:9]  == '0123456789'[:9]","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[10:] == '0123456789'[:] ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[0:9] != '123456789'     ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[0:9] != '123456789'[:]  ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[0:9] != '123456789'[0:] ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[0:9] != '123456789'[:8] ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[:9]  != '123456789'[:8] ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[10:] != '123456789'[:]  ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[2*6:10+6] == '23456'    ","","",T(1.0)),
-      test_ab<T>("'0123456789'     == '01234567890123456789'[0:9]","","",T(1.0)),
-      test_ab<T>("'0123456789'[:]  == '01234567890123456789'[0:9]","","",T(1.0)),
-      test_ab<T>("'0123456789'[0:] == '01234567890123456789'[0:9]","","",T(1.0)),
-      test_ab<T>("'0123456789'[:9] == '01234567890123456789'[0:9]","","",T(1.0)),
-      test_ab<T>("'0123456789'[:9] == '01234567890123456789'[:9] ","","",T(1.0)),
-      test_ab<T>("'0123456789'[:]  == '01234567890123456789'[10:]","","",T(1.0)),
-      test_ab<T>("'0123456789'[3:3] == '3'[:]                    ","","",T(1.0)),
-      test_ab<T>("'0123456789'[3:3] == '3'[0:0]                  ","","",T(1.0)),
-      test_ab<T>("'123456789'      != '01234567890123456789'[0:9]","","",T(1.0)),
-      test_ab<T>("'123456789'[:]   != '01234567890123456789'[0:9]","","",T(1.0)),
-      test_ab<T>("'123456789'[0:]  != '01234567890123456789'[0:9]","","",T(1.0)),
-      test_ab<T>("'123456789'[:8]  != '01234567890123456789'[0:9]","","",T(1.0)),
-      test_ab<T>("'123456789'[:8]  != '01234567890123456789'[:9] ","","",T(1.0)),
-      test_ab<T>("'123456789'[:]   != '01234567890123456789'[10:]","","",T(1.0)),
-      test_ab<T>("'23456' == '01234567890123456789'[2*6:10+6]    ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[r0: 6]   == '23456'              ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[2: r1]   == '23456'              ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[r0:3*2]  == '23456'              ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[1+1:r1]  == '23456'              ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[r0:  ]   == '234567890123456789' ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[:  r1]   == '0123456'            ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[r0:r1]   == '23456'              ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[r0:r1+2] == '2345678'            ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[r0+2:r1] == '456'                ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[r1-r0:]  == '4567890123456789'   ","","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[:r1-r0]  == '01234'              ","","",T(1.0)),
-      test_ab<T>("'23456'              == '01234567890123456789'[r0: 6]   ","","",T(1.0)),
-      test_ab<T>("'23456'              == '01234567890123456789'[2: r1]   ","","",T(1.0)),
-      test_ab<T>("'23456'              == '01234567890123456789'[r0:3*2]  ","","",T(1.0)),
-      test_ab<T>("'23456'              == '01234567890123456789'[1+1:r1]  ","","",T(1.0)),
-      test_ab<T>("'234567890123456789' == '01234567890123456789'[r0:  ]   ","","",T(1.0)),
-      test_ab<T>("'0123456'            == '01234567890123456789'[:  r1]   ","","",T(1.0)),
-      test_ab<T>("'23456'              == '01234567890123456789'[r0:r1]   ","","",T(1.0)),
-      test_ab<T>("'2345678'            == '01234567890123456789'[r0:r1+2] ","","",T(1.0)),
-      test_ab<T>("'456'                == '01234567890123456789'[r0+2:r1] ","","",T(1.0)),
-      test_ab<T>("'4567890123456789'   == '01234567890123456789'[r1-r0:]  ","","",T(1.0)),
-      test_ab<T>("'01234'              == '01234567890123456789'[:r1-r0]  ","","",T(1.0)),
-      test_ab<T>("a[r0: 6]   == '23456'              ","01234567890123456789","",T(1.0)),
-      test_ab<T>("a[2: r1]   == '23456'              ","01234567890123456789","",T(1.0)),
-      test_ab<T>("a[r0:3*2]  == '23456'              ","01234567890123456789","",T(1.0)),
-      test_ab<T>("a[1+1:r1]  == '23456'              ","01234567890123456789","",T(1.0)),
-      test_ab<T>("a[r0:  ]   == '234567890123456789' ","01234567890123456789","",T(1.0)),
-      test_ab<T>("a[:  r1]   == '0123456'            ","01234567890123456789","",T(1.0)),
-      test_ab<T>("a[r0:r1]   == '23456'              ","01234567890123456789","",T(1.0)),
-      test_ab<T>("a[r0:r1+2] == '2345678'            ","01234567890123456789","",T(1.0)),
-      test_ab<T>("a[r0+2:r1] == '456'                ","01234567890123456789","",T(1.0)),
-      test_ab<T>("a[r1-r0:]  == '4567890123456789'   ","01234567890123456789","",T(1.0)),
-      test_ab<T>("a[:r1-r0]  == '01234'              ","01234567890123456789","",T(1.0)),
-      test_ab<T>("'23456'              == a[r0: 6]   ","01234567890123456789","",T(1.0)),
-      test_ab<T>("'23456'              == a[2: r1]   ","01234567890123456789","",T(1.0)),
-      test_ab<T>("'23456'              == a[r0:3*2]  ","01234567890123456789","",T(1.0)),
-      test_ab<T>("'23456'              == a[1+1:r1]  ","01234567890123456789","",T(1.0)),
-      test_ab<T>("'234567890123456789' == a[r0:  ]   ","01234567890123456789","",T(1.0)),
-      test_ab<T>("'0123456'            == a[:  r1]   ","01234567890123456789","",T(1.0)),
-      test_ab<T>("'23456'              == a[r0:r1]   ","01234567890123456789","",T(1.0)),
-      test_ab<T>("'2345678'            == a[r0:r1+2] ","01234567890123456789","",T(1.0)),
-      test_ab<T>("'456'                == a[r0+2:r1] ","01234567890123456789","",T(1.0)),
-      test_ab<T>("'4567890123456789'   == a[r1-r0:]  ","01234567890123456789","",T(1.0)),
-      test_ab<T>("'01234'              == a[:r1-r0]  ","01234567890123456789","",T(1.0)),
-      test_ab<T>("a[r0: 6]   == b                    ","01234567890123456789","23456",T(1.0)),
-      test_ab<T>("a[2: r1]   == b                    ","01234567890123456789","23456",T(1.0)),
-      test_ab<T>("a[r0:3*2]  == b                    ","01234567890123456789","23456",T(1.0)),
-      test_ab<T>("a[1+1:r1]  == b                    ","01234567890123456789","23456",T(1.0)),
-      test_ab<T>("a[r0:  ]   == b                    ","01234567890123456789","234567890123456789",T(1.0)),
-      test_ab<T>("a[:  r1]   == b                    ","01234567890123456789","0123456",T(1.0)),
-      test_ab<T>("a[r0:r1]   == b                    ","01234567890123456789","23456",T(1.0)),
-      test_ab<T>("a[r0:r1+2] == b                    ","01234567890123456789","2345678",T(1.0)),
-      test_ab<T>("a[r0+2:r1] == b                    ","01234567890123456789","456",T(1.0)),
-      test_ab<T>("a[r1-r0:]  == b                    ","01234567890123456789","4567890123456789",T(1.0)),
-      test_ab<T>("a[:r1-r0]  == b                    ","01234567890123456789","01234",T(1.0)),
-      test_ab<T>("b == a[r0: 6]                      ","01234567890123456789","23456",T(1.0)),
-      test_ab<T>("b == a[2: r1]                      ","01234567890123456789","23456",T(1.0)),
-      test_ab<T>("b == a[r0:3*2]                     ","01234567890123456789","23456",T(1.0)),
-      test_ab<T>("b == a[1+1:r1]                     ","01234567890123456789","23456",T(1.0)),
-      test_ab<T>("b == a[r0:  ]                      ","01234567890123456789","234567890123456789",T(1.0)),
-      test_ab<T>("b == a[:  r1]                      ","01234567890123456789","0123456",T(1.0)),
-      test_ab<T>("b == a[r0:r1]                      ","01234567890123456789","23456",T(1.0)),
-      test_ab<T>("b == a[r0:r1+2]                    ","01234567890123456789","2345678",T(1.0)),
-      test_ab<T>("b == a[r0+2:r1]                    ","01234567890123456789","456",T(1.0)),
-      test_ab<T>("b == a[r1-r0:]                     ","01234567890123456789","4567890123456789",T(1.0)),
-      test_ab<T>("b == a[:r1-r0]                     ","01234567890123456789","01234",T(1.0)),
-      test_ab<T>("'01234567890123456789'[0:9] == a     ","0123456789","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[0:9] == a[:]  ","0123456789","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[0:9] == a[0:] ","0123456789","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[0:9] == a[:9] ","0123456789","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[:9]  == a[:9] ","0123456789","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[10:] == a[:]  ","0123456789","",T(1.0)),
-      test_ab<T>("'01234567890123456789'[0:9] != a     ","123456789" ,"",T(1.0)),
-      test_ab<T>("'01234567890123456789'[0:9] != a[:]  ","123456789" ,"",T(1.0)),
-      test_ab<T>("'01234567890123456789'[0:9] != a[0:] ","123456789" ,"",T(1.0)),
-      test_ab<T>("'01234567890123456789'[0:9] != a[:8] ","123456789" ,"",T(1.0)),
-      test_ab<T>("'01234567890123456789'[:9]  != a[:8] ","123456789" ,"",T(1.0)),
-      test_ab<T>("'01234567890123456789'[10:] != a[:]  ","123456789" ,"",T(1.0)),
-      test_ab<T>("'01234567890123456789'[2*6:10+6] == a","23456"     ,"",T(1.0)),
-      test_ab<T>("'23456' == a[:]                      ","23456"     ,"",T(1.0)),
-      test_ab<T>("a     == '01234567890123456789'[0:9] ","0123456789","",T(1.0)),
-      test_ab<T>("a[:]  == '01234567890123456789'[0:9] ","0123456789","",T(1.0)),
-      test_ab<T>("a[0:] == '01234567890123456789'[0:9] ","0123456789","",T(1.0)),
-      test_ab<T>("a[:9] == '01234567890123456789'[0:9] ","0123456789","",T(1.0)),
-      test_ab<T>("a[:9] == '01234567890123456789'[:9]  ","0123456789","",T(1.0)),
-      test_ab<T>("a[:]  == '01234567890123456789'[10:] ","0123456789","",T(1.0)),
-      test_ab<T>("a     != '01234567890123456789'[0:9] ","123456789" ,"",T(1.0)),
-      test_ab<T>("a[:]  != '01234567890123456789'[0:9] ","123456789" ,"",T(1.0)),
-      test_ab<T>("a[0:] != '01234567890123456789'[0:9] ","123456789" ,"",T(1.0)),
-      test_ab<T>("a[:8] != '01234567890123456789'[0:9] ","123456789" ,"",T(1.0)),
-      test_ab<T>("a[:8] != '01234567890123456789'[:9]  ","123456789" ,"",T(1.0)),
-      test_ab<T>("a[:]  != '01234567890123456789'[10:] ","123456789" ,"",T(1.0)),
-      test_ab<T>("a == '01234567890123456789'[2*6:10+6]","23456"     ,"",T(1.0)),
-      test_ab<T>("a[:] == '23456'                      ","23456"     ,"",T(1.0)),
-      test_ab<T>("a[0:9] == b      ","01234567890123456789","0123456789",T(1.0)),
-      test_ab<T>("a[0:9] == b[:]   ","01234567890123456789","0123456789",T(1.0)),
-      test_ab<T>("a[0:9] == b[0:]  ","01234567890123456789","0123456789",T(1.0)),
-      test_ab<T>("a[0:9] == b[:9]  ","01234567890123456789","0123456789",T(1.0)),
-      test_ab<T>("a[:9]  == b[:9]  ","01234567890123456789","0123456789",T(1.0)),
-      test_ab<T>("a[10:] == b[:]   ","01234567890123456789","0123456789",T(1.0)),
-      test_ab<T>("a[0:9] != b      ","01234567890123456789","123456789" ,T(1.0)),
-      test_ab<T>("a[0:9] != b[:]   ","01234567890123456789","123456789" ,T(1.0)),
-      test_ab<T>("a[0:9] != b[0:]  ","01234567890123456789","123456789" ,T(1.0)),
-      test_ab<T>("a[0:9] != b[:8]  ","01234567890123456789","123456789" ,T(1.0)),
-      test_ab<T>("a[:9]  != b[:8]  ","01234567890123456789","123456789" ,T(1.0)),
-      test_ab<T>("a[10:] != b[:]   ","01234567890123456789","123456789" ,T(1.0)),
-      test_ab<T>("a[2*6:10+6] == b ","01234567890123456789","23456"     ,T(1.0)),
-      test_ab<T>("b     == a[0:9]  ","01234567890123456789","0123456789",T(1.0)),
-      test_ab<T>("b[:]  == a[0:9]  ","01234567890123456789","0123456789",T(1.0)),
-      test_ab<T>("b[0:] == a[0:9]  ","01234567890123456789","0123456789",T(1.0)),
-      test_ab<T>("b[:9] == a[0:9]  ","01234567890123456789","0123456789",T(1.0)),
-      test_ab<T>("b[:9] == a[:9]   ","01234567890123456789","0123456789",T(1.0)),
-      test_ab<T>("b[:]  == a[10:]  ","01234567890123456789","0123456789",T(1.0)),
-      test_ab<T>("b     != a[0:9]  ","01234567890123456789","123456789" ,T(1.0)),
-      test_ab<T>("b[:]  != a[0:9]  ","01234567890123456789","123456789" ,T(1.0)),
-      test_ab<T>("b[0:] != a[0:9]  ","01234567890123456789","123456789" ,T(1.0)),
-      test_ab<T>("b[:8] != a[0:9]  ","01234567890123456789","123456789" ,T(1.0)),
-      test_ab<T>("b[:8] != a[:9]   ","01234567890123456789","123456789" ,T(1.0)),
-      test_ab<T>("b[:]  != a[10:]  ","01234567890123456789","123456789" ,T(1.0)),
-      test_ab<T>("b == a[2*6:10+6] ","01234567890123456789","23456"     ,T(1.0)),
-      test_ab<T>("a[2:6] == b"         ,"0123456789","23456"  ,T(1.0)),
-      test_ab<T>("a == b[2:6]"         ,"23456","0123456789"  ,T(1.0)),
-      test_ab<T>("a[1+1:2*3] == b"     ,"0123456789","23456"  ,T(1.0)),
-      test_ab<T>("a == b[4/2:sqrt(36)]","23456","0123456789"  ,T(1.0)),
-      test_ab<T>("a[0:6] == b"         ,"0123456789","0123456",T(1.0)),
-      test_ab<T>("a[:6] == b"          ,"0123456789","0123456",T(1.0)),
-      test_ab<T>("a[4/2-2:2+4] == b"   ,"0123456789","0123456",T(1.0)),
-      test_ab<T>("a[:12/2] == b"       ,"0123456789","0123456",T(1.0)),
-      test_ab<T>("a[0:] == b"          ,"0123456","0123456"   ,T(1.0)),
-      test_ab<T>("a[:] == b"           ,"0123456","0123456"   ,T(1.0)),
-      test_ab<T>("a == b[0:6]"         ,"0123456","0123456789",T(1.0)),
-      test_ab<T>("a == b[:6]"          ,"0123456","0123456789",T(1.0)),
-      test_ab<T>("a == b[4/2-2:2+4]"   ,"0123456","0123456789",T(1.0)),
-      test_ab<T>("a == b[:12/2]"       ,"0123456","0123456789",T(1.0)),
-      test_ab<T>("a == b[0:]"          ,"0123456","0123456"   ,T(1.0)),
-      test_ab<T>("a == b[:]"           ,"0123456","0123456"   ,T(1.0)),
-      test_ab<T>("a[:9] == b[0:9]"     ,"0123456789","01234567890123456789",T(1.0)),
-      test_ab<T>("a[0:9] == b[0:9]"    ,"0123456789","01234567890123456789",T(1.0)),
-      test_ab<T>("a[0:] == b[0:9]"     ,"0123456789","01234567890123456789",T(1.0)),
-      test_ab<T>("a[:] == b[0:9]"      ,"0123456789","01234567890123456789",T(1.0)),
+      test_ab<T>("'01234567890123456789'[0:9] == '012345678'      ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[0:9] == '012345678'[:]   ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[0:9] == '012345678'[0:]  ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[0:9] == '012345678'[:9]  ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[:9]  == '0123456789'[:9] ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[10:] == '0123456789'[:]  ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[0:9] != '123456789'      ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[0:9] != '123456789'[:]   ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[0:9] != '123456789'[0:]  ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[0:9] != '123456789'[:8]  ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[:9]  != '123456789'[:8]  ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[10:] != '123456789'[:]   ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[2*6:10+7] == '23456'     ","","",T(1.0)),
+      test_ab<T>("'0123456789'     == '01234567890123456789'[0:10]","","",T(1.0)),
+      test_ab<T>("'0123456789'[:]  == '01234567890123456789'[0:10]","","",T(1.0)),
+      test_ab<T>("'0123456789'[0:] == '01234567890123456789'[0:10]","","",T(1.0)),
+      test_ab<T>("'0123456789'[:9] == '01234567890123456789'[0:9] ","","",T(1.0)),
+      test_ab<T>("'0123456789'[:9] == '01234567890123456789'[:9]  ","","",T(1.0)),
+      test_ab<T>("'0123456789'[:]  == '01234567890123456789'[10:] ","","",T(1.0)),
+      test_ab<T>("'0123456789'[3:4] == '3'[:]                     ","","",T(1.0)),
+      test_ab<T>("'0123456789'[3:4] == '3'[0:1]                   ","","",T(1.0)),
+      test_ab<T>("'123456789'      != '01234567890123456789'[0:9] ","","",T(1.0)),
+      test_ab<T>("'123456789'[:]   != '01234567890123456789'[0:9] ","","",T(1.0)),
+      test_ab<T>("'123456789'[0:]  != '01234567890123456789'[0:9] ","","",T(1.0)),
+      test_ab<T>("'123456789'[:8]  != '01234567890123456789'[0:9] ","","",T(1.0)),
+      test_ab<T>("'123456789'[:8]  != '01234567890123456789'[:9]  ","","",T(1.0)),
+      test_ab<T>("'123456789'[:]   != '01234567890123456789'[10:] ","","",T(1.0)),
+      test_ab<T>("'23456' == '01234567890123456789'[2*6:10+7]     ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[r0: 7]   == '23456'                ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[2: r1 + 1] == '23456'              ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[r0:3*2 + 1]  == '23456'            ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[1+1:r1 + 1]  == '23456'            ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[r0:  ]   == '234567890123456789'   ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[:  r1 + 1]   == '0123456'          ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[r0:r1 + 1]   == '23456'            ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[r0:r1+2+1] == '2345678'            ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[r0+2:r1+1] == '456'                ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[r1-r0:]  == '4567890123456789'     ","","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[:r1-r0 + 1]  == '01234'            ","","",T(1.0)),
+      test_ab<T>("'23456'              == '01234567890123456789'[r0: 7]     ","","",T(1.0)),
+      test_ab<T>("'23456'              == '01234567890123456789'[2: r1+1]   ","","",T(1.0)),
+      test_ab<T>("'23456'              == '01234567890123456789'[r0:3*2+1]  ","","",T(1.0)),
+      test_ab<T>("'23456'              == '01234567890123456789'[1+1:r1+1]  ","","",T(1.0)),
+      test_ab<T>("'234567890123456789' == '01234567890123456789'[r0:  ]     ","","",T(1.0)),
+      test_ab<T>("'0123456'            == '01234567890123456789'[:  1+r1]   ","","",T(1.0)),
+      test_ab<T>("'23456'              == '01234567890123456789'[r0:r1+1]   ","","",T(1.0)),
+      test_ab<T>("'2345678'            == '01234567890123456789'[r0:r1+3]   ","","",T(1.0)),
+      test_ab<T>("'456'                == '01234567890123456789'[r0+2:r1+1] ","","",T(1.0)),
+      test_ab<T>("'4567890123456789'   == '01234567890123456789'[r1-r0:]    ","","",T(1.0)),
+      test_ab<T>("'01234'              == '01234567890123456789'[:r1-r0+1]  ","","",T(1.0)),
+      test_ab<T>("a[r0: 7]    == '23456'                 ","01234567890123456789","",T(1.0)),
+      test_ab<T>("a[2: r1+1]  == '23456'                 ","01234567890123456789","",T(1.0)),
+      test_ab<T>("a[r0:3*2+1] == '23456'                 ","01234567890123456789","",T(1.0)),
+      test_ab<T>("a[1+1:r1+1] == '23456'                 ","01234567890123456789","",T(1.0)),
+      test_ab<T>("a[r0:  ]    == '234567890123456789'    ","01234567890123456789","",T(1.0)),
+      test_ab<T>("a[:1+r1]    == '0123456'               ","01234567890123456789","",T(1.0)),
+      test_ab<T>("a[r0:1+r1]  == '23456'                 ","01234567890123456789","",T(1.0)),
+      test_ab<T>("a[r0:r1+3]  == '2345678'               ","01234567890123456789","",T(1.0)),
+      test_ab<T>("a[r0+2:r1+1]== '456'                   ","01234567890123456789","",T(1.0)),
+      test_ab<T>("a[r1-r0:]   == '4567890123456789'      ","01234567890123456789","",T(1.0)),
+      test_ab<T>("a[:r1-r0+1] == '01234'                 ","01234567890123456789","",T(1.0)),
+      test_ab<T>("'23456'              == a[r0: 7]       ","01234567890123456789","",T(1.0)),
+      test_ab<T>("'23456'              == a[2: r1+1]     ","01234567890123456789","",T(1.0)),
+      test_ab<T>("'23456'              == a[r0:3*2+1]    ","01234567890123456789","",T(1.0)),
+      test_ab<T>("'23456'              == a[1+1:r1+1]    ","01234567890123456789","",T(1.0)),
+      test_ab<T>("'234567890123456789' == a[r0:  ]       ","01234567890123456789","",T(1.0)),
+      test_ab<T>("'0123456'            == a[:1+r1]       ","01234567890123456789","",T(1.0)),
+      test_ab<T>("'23456'              == a[r0:r1+1]     ","01234567890123456789","",T(1.0)),
+      test_ab<T>("'2345678'            == a[r0:r1+3]     ","01234567890123456789","",T(1.0)),
+      test_ab<T>("'456'                == a[r0+2:r1+1]   ","01234567890123456789","",T(1.0)),
+      test_ab<T>("'4567890123456789'   == a[r1-r0:]      ","01234567890123456789","",T(1.0)),
+      test_ab<T>("'01234'              == a[:r1-r0+1]    ","01234567890123456789","",T(1.0)),
+      test_ab<T>("a[r0: 7]     == b                      ","01234567890123456789","23456",T(1.0)),
+      test_ab<T>("a[2: r1+1]   == b                      ","01234567890123456789","23456",T(1.0)),
+      test_ab<T>("a[r0:3*2+1]  == b                      ","01234567890123456789","23456",T(1.0)),
+      test_ab<T>("a[1+1:r1+1]  == b                      ","01234567890123456789","23456",T(1.0)),
+      test_ab<T>("a[r0:  ]     == b                      ","01234567890123456789","234567890123456789",T(1.0)),
+      test_ab<T>("a[:  r1+1]   == b                      ","01234567890123456789","0123456",T(1.0)),
+      test_ab<T>("a[r0:r1+1]   == b                      ","01234567890123456789","23456",T(1.0)),
+      test_ab<T>("a[r0:r1+3]   == b                      ","01234567890123456789","2345678",T(1.0)),
+      test_ab<T>("a[r0+2:r1+1] == b                      ","01234567890123456789","456",T(1.0)),
+      test_ab<T>("a[r1-r0:]    == b                      ","01234567890123456789","4567890123456789",T(1.0)),
+      test_ab<T>("a[:r1-r0+1]  == b                      ","01234567890123456789","01234",T(1.0)),
+      test_ab<T>("b == a[r0: 7]                          ","01234567890123456789","23456",T(1.0)),
+      test_ab<T>("b == a[2: r1+1]                        ","01234567890123456789","23456",T(1.0)),
+      test_ab<T>("b == a[r0:3*2+1]                       ","01234567890123456789","23456",T(1.0)),
+      test_ab<T>("b == a[1+1:r1+1]                       ","01234567890123456789","23456",T(1.0)),
+      test_ab<T>("b == a[r0:  ]                          ","01234567890123456789","234567890123456789",T(1.0)),
+      test_ab<T>("b == a[:  r1+1]                        ","01234567890123456789","0123456",T(1.0)),
+      test_ab<T>("b == a[r0:r1+1]                        ","01234567890123456789","23456",T(1.0)),
+      test_ab<T>("b == a[r0:r1+3]                        ","01234567890123456789","2345678",T(1.0)),
+      test_ab<T>("b == a[r0+2:r1+1]                      ","01234567890123456789","456",T(1.0)),
+      test_ab<T>("b == a[r1-r0:]                         ","01234567890123456789","4567890123456789",T(1.0)),
+      test_ab<T>("b == a[:r1-r0+1]                       ","01234567890123456789","01234",T(1.0)),
+      test_ab<T>("'01234567890123456789'[0:10] == a      ","0123456789","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[0:10] == a[:]   ","0123456789","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[0:10] == a[0:]  ","0123456789","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[0:10] == a[:10] ","0123456789","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[:10]  == a[:10] ","0123456789","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[10:] == a[:]    ","0123456789","",T(1.0)),
+      test_ab<T>("'01234567890123456789'[0:10] != a      ","123456789" ,"",T(1.0)),
+      test_ab<T>("'01234567890123456789'[0:10] != a[:]   ","123456789" ,"",T(1.0)),
+      test_ab<T>("'01234567890123456789'[0:10] != a[0:]  ","123456789" ,"",T(1.0)),
+      test_ab<T>("'01234567890123456789'[0:10] != a[:8]  ","123456789" ,"",T(1.0)),
+      test_ab<T>("'01234567890123456789'[:10]  != a[:8]  ","123456789" ,"",T(1.0)),
+      test_ab<T>("'01234567890123456789'[10:] != a[:]    ","123456789" ,"",T(1.0)),
+      test_ab<T>("'01234567890123456789'[2*6:10+7] == a  ","23456"     ,"",T(1.0)),
+      test_ab<T>("'23456' == a[:]                        ","23456"     ,"",T(1.0)),
+      test_ab<T>("a     == '01234567890123456789'[0:10]  ","0123456789","",T(1.0)),
+      test_ab<T>("a[:]  == '01234567890123456789'[0:10]  ","0123456789","",T(1.0)),
+      test_ab<T>("a[0:] == '01234567890123456789'[0:10]  ","0123456789","",T(1.0)),
+      test_ab<T>("a[:9] == '01234567890123456789'[0:9]   ","0123456789","",T(1.0)),
+      test_ab<T>("a[:9] == '01234567890123456789'[:9]    ","0123456789","",T(1.0)),
+      test_ab<T>("a[:]  == '01234567890123456789'[10:]   ","0123456789","",T(1.0)),
+      test_ab<T>("a     != '01234567890123456789'[0:9]   ","123456789" ,"",T(1.0)),
+      test_ab<T>("a[:]  != '01234567890123456789'[0:9]   ","123456789" ,"",T(1.0)),
+      test_ab<T>("a[0:] != '01234567890123456789'[0:9]   ","123456789" ,"",T(1.0)),
+      test_ab<T>("a[:8] != '01234567890123456789'[0:9]   ","123456789" ,"",T(1.0)),
+      test_ab<T>("a[:8] != '01234567890123456789'[:9]    ","123456789" ,"",T(1.0)),
+      test_ab<T>("a[:]  != '01234567890123456789'[10:]   ","123456789" ,"",T(1.0)),
+      test_ab<T>("a == '01234567890123456789'[2*6:10+7]  ","23456"     ,"",T(1.0)),
+      test_ab<T>("a[:] == '23456'                        ","23456"     ,"",T(1.0)),
+      test_ab<T>("a[0:10] == b        ","01234567890123456789","0123456789",T(1.0)),
+      test_ab<T>("a[0:10] == b[:]     ","01234567890123456789","0123456789",T(1.0)),
+      test_ab<T>("a[0:10] == b[0:]    ","01234567890123456789","0123456789",T(1.0)),
+      test_ab<T>("a[0:10] == b[:10]   ","01234567890123456789","0123456789",T(1.0)),
+      test_ab<T>("a[:9]  == b[:9]     ","01234567890123456789","0123456789",T(1.0)),
+      test_ab<T>("a[10:] == b[:]      ","01234567890123456789","0123456789",T(1.0)),
+      test_ab<T>("a[0:9] != b         ","01234567890123456789","123456789" ,T(1.0)),
+      test_ab<T>("a[0:9] != b[:]      ","01234567890123456789","123456789" ,T(1.0)),
+      test_ab<T>("a[0:9] != b[0:]     ","01234567890123456789","123456789" ,T(1.0)),
+      test_ab<T>("a[0:9] != b[:8]     ","01234567890123456789","123456789" ,T(1.0)),
+      test_ab<T>("a[:9]  != b[:8]     ","01234567890123456789","123456789" ,T(1.0)),
+      test_ab<T>("a[10:] != b[:]      ","01234567890123456789","123456789" ,T(1.0)),
+      test_ab<T>("a[2*6:10+7] == b    ","01234567890123456789","23456"     ,T(1.0)),
+      test_ab<T>("b     == a[0:10]    ","01234567890123456789","0123456789",T(1.0)),
+      test_ab<T>("b[:]  == a[0:10]    ","01234567890123456789","0123456789",T(1.0)),
+      test_ab<T>("b[0:] == a[0:10]    ","01234567890123456789","0123456789",T(1.0)),
+      test_ab<T>("b[:9] == a[0:9]     ","01234567890123456789","0123456789",T(1.0)),
+      test_ab<T>("b[:9] == a[:9]      ","01234567890123456789","0123456789",T(1.0)),
+      test_ab<T>("b[:]  == a[10:]     ","01234567890123456789","0123456789",T(1.0)),
+      test_ab<T>("b     != a[0:9]     ","01234567890123456789","123456789" ,T(1.0)),
+      test_ab<T>("b[:]  != a[0:9]     ","01234567890123456789","123456789" ,T(1.0)),
+      test_ab<T>("b[0:] != a[0:9]     ","01234567890123456789","123456789" ,T(1.0)),
+      test_ab<T>("b[:8] != a[0:9]     ","01234567890123456789","123456789" ,T(1.0)),
+      test_ab<T>("b[:8] != a[:9]      ","01234567890123456789","123456789" ,T(1.0)),
+      test_ab<T>("b[:]  != a[10:]     ","01234567890123456789","123456789" ,T(1.0)),
+      test_ab<T>("b == a[2*6:10+7]    ","01234567890123456789","23456"     ,T(1.0)),
+      test_ab<T>("a[2:7] == b"         ,"0123456789","23456"               ,T(1.0)),
+      test_ab<T>("a == b[2:7]"         ,"23456","0123456789"               ,T(1.0)),
+      test_ab<T>("a[1+1:2*3+1] == b"   ,"0123456789","23456"               ,T(1.0)),
+      test_ab<T>("a == b[4/2:sqrt(49)]","23456","0123456789"               ,T(1.0)),
+      test_ab<T>("a[0:7] == b"         ,"0123456789","0123456"             ,T(1.0)),
+      test_ab<T>("a[:7] == b"          ,"0123456789","0123456"             ,T(1.0)),
+      test_ab<T>("a[4/2-2:2+5] == b"   ,"0123456789","0123456"             ,T(1.0)),
+      test_ab<T>("a[:12/2+1] == b"     ,"0123456789","0123456"             ,T(1.0)),
+      test_ab<T>("a[0:] == b"          ,"0123456","0123456"                ,T(1.0)),
+      test_ab<T>("a[:] == b"           ,"0123456","0123456"                ,T(1.0)),
+      test_ab<T>("a == b[0:7]"         ,"0123456","0123456789"             ,T(1.0)),
+      test_ab<T>("a == b[:7]"          ,"0123456","0123456789"             ,T(1.0)),
+      test_ab<T>("a == b[4/2-2:2+5]"   ,"0123456","0123456789"             ,T(1.0)),
+      test_ab<T>("a == b[:12/2+1]"     ,"0123456","0123456789"             ,T(1.0)),
+      test_ab<T>("a == b[0:]"          ,"0123456","0123456"                ,T(1.0)),
+      test_ab<T>("a == b[:]"           ,"0123456","0123456"                ,T(1.0)),
+      test_ab<T>("a[:10] == b[0:10]"   ,"0123456789","01234567890123456789",T(1.0)),
+      test_ab<T>("a[0:10] == b[0:10]"  ,"0123456789","01234567890123456789",T(1.0)),
+      test_ab<T>("a[0:] == b[0:10]"    ,"0123456789","01234567890123456789",T(1.0)),
+      test_ab<T>("a[:] == b[0:10]"     ,"0123456789","01234567890123456789",T(1.0)),
       test_ab<T>("a[:] == b[10:]"      ,"0123456789","01234567890123456789",T(1.0)),
       test_ab<T>("'!@#$%^&*([{}])-=' != ')]}{[(*&^%$#@!'","","",T(1.0)),
       test_ab<T>("('!@#$%^&*([{}])-=') != (')]}{[(*&^%$#@!')","","",T(1.0)),
@@ -10395,6 +10395,8 @@
    typedef exprtk::parser<T>       parser_t;
    typedef exprtk::parser_error::type error_type;
 
+   bool error_found = false;
+
    {
       T x = T(1.1);
       T y = T(2.2);
@@ -10448,8 +10450,6 @@
 
       static const std::size_t expression_list_size = sizeof(expression_list) / sizeof(std::string);
 
-      bool error_found = false;
-
       for (std::size_t i = 0; i < expression_list_size; ++i)
       {
          expression_t expression;
@@ -10542,8 +10542,6 @@
 
       static const std::size_t expression_list_size = sizeof(expression_list) / sizeof(std::string);
 
-      bool error_found = false;
-
       for (std::size_t i = 0; i < expression_list_size; ++i)
       {
          expression_t expression;
@@ -10823,8 +10821,6 @@
 
       const std::size_t expressions_size = sizeof(expressions) / sizeof(local_test_t);
 
-      bool error_found = false;
-
       for (std::size_t i = 0; i < expressions_size; ++i)
       {
          const std::string expression_str   = expressions[i].first;
@@ -11014,8 +11010,6 @@
       symbol_table.add_variable("b", b);
       symbol_table.add_variable("c", c);
 
-      bool error_found = false;
-
       for (std::size_t e = 0; e < expressions_size; ++e)
       {
          const std::string& expression_string = invalid_expressions[e];
@@ -11323,8 +11317,6 @@
          "var successes := 0; var x := 1 ; for(var i:=0; i < vv8[]; i += 1) { successes += (abs(x + vv8))[i / x] == i + x; }; successes == vv8[]",
       };
 
-      bool error_found = false;
-
       for (std::size_t e = 0; e < sizeof(expressions)/sizeof(std::string); ++e)
       {
          T vs8[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
@@ -11424,21 +11416,30 @@
          "sum(vv0 * 2) == (vv0[] * (vv0[] + 1)) and (vv0[] == vv0_size)",
          "sum(2vv0 + 1) == (vv0[] * (vv0[] + 1) + vv0[]) and (vv0[] == vv0_size)",
          "sum(1 + 2vv0) == (vv0[] * (vv0[] + 1) + vv0[]) and (vv0[] == vv0_size)",
+         "sum((2 * vv0) + 1) == (vv0[] * (vv0[] + 1) + vv0[]) and (vv0[] == vv0_size)",
+         "sum(1 + (2 * vv0)) == (vv0[] * (vv0[] + 1) + vv0[]) and (vv0[] == vv0_size)",
+         "sum((vv0 * 2) + 1) == (vv0[] * (vv0[] + 1) + vv0[]) and (vv0[] == vv0_size)",
+         "sum(1 + (vv0 * 2)) == (vv0[] * (vv0[] + 1) + vv0[]) and (vv0[] == vv0_size)",
          "var x := 1; sum(2vv0 + x) == (vv0[] * (vv0[] + 1) + x * vv0[]) and (vv0[] == vv0_size)",
          "var x := 1; sum(x + 2vv0) == (vv0[] * (vv0[] + 1) + x * vv0[]) and (vv0[] == vv0_size)",
+         "var x := 1; sum((2 * vv0) + x) == (vv0[] * (vv0[] + 1) + x * vv0[]) and (vv0[] == vv0_size)",
+         "var x := 1; sum(x + (2 * vv0)) == (vv0[] * (vv0[] + 1) + x * vv0[]) and (vv0[] == vv0_size)",
+         "var x := 1; sum((vv0 * 2) + x) == (vv0[] * (vv0[] + 1) + x * vv0[]) and (vv0[] == vv0_size)",
+         "var x := 1; sum(x + (vv0 * 2)) == (vv0[] * (vv0[] + 1) + x * vv0[]) and (vv0[] == vv0_size)",
          "sum(vv0 += 1) == (vv0[] * (vv0[] + 1) / 2 + vv0[]) and (vv0[] == vv0_size)",
          "var x:= 1; sum(vv0 += x) == (vv0[] * (vv0[] + 1) / 2 + x * vv0[]) and (vv0[] == vv0_size)",
          "var x:= 1; sum(vv0 -= x) == (vv0[] * (vv0[] + 1 - 2x) / 2) and (vv0[] == vv0_size)",
          "(sum(2vv0) == 2 * sum(vv0)) and (vv0[] == vv0_size)",
+         "(sum(2 * vv0) == 2 * sum(vv0)) and (vv0[] == vv0_size)",
          "(sum(vv0 * 2) == 2 * sum(vv0)) and (vv0[] == vv0_size)",
          "var x:= 1; sum(2vv0) == (vv0[] * (vv0[] + 1)) and (vv0[] == vv0_size)",
+         "var x:= 1; sum(2 * vv0) == (vv0[] * (vv0[] + 1)) and (vv0[] == vv0_size)",
+         "var x:= 1; sum(vv0 * 2) == (vv0[] * (vv0[] + 1)) and (vv0[] == vv0_size)",
          "var x := 2; sum(if (x > 1) { vv0 } else { vv1 }) == sum(vv0)",
          "dot(2 * vv0,vv1 - 1) + dot(2 * vv0,vv1 - 1) == 2sum(2vv0 * (vv1 - 1))",
          "(0 * dot(2 * vv0,vv1 - 1)) == 0"
       };
 
-      bool error_found = false;
-
       for (std::size_t e = 0; e < sizeof(expressions) / sizeof(std::string); ++e)
       {
          const T vanilla[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
@@ -11490,6 +11491,8 @@
                       error.diagnostic.c_str());
             }
 
+            error_found = true;
+
             continue;
          }
 
@@ -11510,6 +11513,8 @@
                       static_cast<unsigned int>(i),
                       result,
                       expression_string.c_str());
+
+               error_found = true;
             }
          }
 
@@ -11599,6 +11604,7 @@
       if (expression.value() != T(1))
       {
          printf("run_test21() - Error: Failed evaluation Expected 1 got: %f (1)\n", value0);
+         error_found = true;
       }
 
       vv.rebase(v1.data());
@@ -11609,6 +11615,7 @@
       if (expression.value() != T(1))
       {
          printf("run_test21() - Error: Failed evaluation Expected 1 got: %f (1)\n", value1);
+         error_found = true;
       }
 
       vv.rebase(v0.data());
@@ -11686,6 +11693,7 @@
       if (expression.value() != T(1))
       {
          printf("run_test21() - Error: Failed evaluation Expected 1 got: %f (2)\n", value0);
+         error_found = true;
       }
 
       vv.rebase(v1.data());
@@ -11696,6 +11704,7 @@
       if (expression.value() != T(1))
       {
          printf("run_test21() - Error: Failed evaluation Expected 1 got: %f (2)\n", value1);
+         error_found = true;
       }
 
       vv.rebase(v0.data());
@@ -11704,6 +11713,390 @@
       expression.release();
    }
 
+   {
+      const std::size_t max_vector_size = 10;
+
+      std::vector<T> vec1(max_vector_size, 1);
+      std::vector<T> vec2(max_vector_size, 2);
+      std::vector<T> vec3(max_vector_size, 3);
+
+      const std::string expressions[] =
+      {
+         "return [x + 10]",
+         "return [10 + x]",
+         "return [2x + 10]",
+         "return [10 + 2x]",
+         "return [(x * 2) + 10]",
+         "return [10 + (x * 2)]",
+         "return [(2 * x) + 10]",
+         "return [10 + (2 * x)]",
+         "return [x + k]",
+         "return [k + x]",
+         "return [2x + k]",
+         "return [k + 2x]",
+         "return [(x * 2) + k]",
+         "return [k + (x * 2)]",
+         "return [(2 * x) + k]",
+         "return [k + (2 * x)]",
+         "return [x + y]" ,
+         "return [y + x]" ,
+         "return [2x + y]",
+         "return [y + 2x]",
+         "return [2x + 2y]",
+         "return [2y + 2x]",
+         "return [(2 * x) + y]",
+         "return [y + (2 * x)]",
+         "return [(x * 2) + y]",
+         "return [y + (x * 2)]",
+         "return [(2 * x) + (2 * y)]",
+         "return [(2 * y) + (2 * x)]",
+         "return [(x * 2) + (y * 2)]",
+         "return [(y * 2) + (x * 2)]",
+      };
+
+      const T expected_values[] =
+      {
+         T(2 + 10),
+         T(2 + 10),
+         T(2 * 2 + 10),
+         T(2 * 2 + 10),
+         T(2 * 2 + 10),
+         T(2 * 2 + 10),
+         T(2 * 2 + 10),
+         T(2 * 2 + 10),
+         T(2 + 10),
+         T(2 + 10),
+         T(2 * 2 + 10),
+         T(2 * 2 + 10),
+         T(2 * 2 + 10),
+         T(2 * 2 + 10),
+         T(2 * 2 + 10),
+         T(2 * 2 + 10),
+         T(2 + 3),
+         T(3 + 2),
+         T(2 * 2 + 3),
+         T(3 + 2 * 2),
+         T(2 * 2 + 2 * 3),
+         T(2 * 3 + 2 * 2),
+         T(2 * 2 + 3),
+         T(3 + (2 * 2)),
+         T(2 * 2 + 3),
+         T(3 + 2 * 2),
+         T(2 * 2 + 2 * 3),
+         T(2 * 3 + 2 * 2),
+         T(2 * 2 + 3 * 2),
+         T(3 * 2 + 2 * 2),
+      };
+
+      const std::size_t expressions_size = sizeof(expressions) / sizeof(std::string);
+
+      for (std::size_t i = 0; i < expressions_size; ++i)
+      {
+         const std::string& expression_string = expressions[i];
+
+         exprtk::vector_view<T> x_view = exprtk::make_vector_view(vec1, vec1.size());
+
+         for (std::size_t vector_size = 1; vector_size <= 10; ++vector_size)
+         {
+            symbol_table_t symbol_table;
+            expression_t   expression;
+            parser_t       parser;
+
+            T k = T(10);
+
+            symbol_table.add_variable("k", k     );
+            symbol_table.add_vector  ("x", x_view);
+            symbol_table.add_vector  ("y", vec3  );
+
+            expression.register_symbol_table(symbol_table);
+
+            if (!parser.compile(expression_string, expression))
+            {
+               printf("run_test21() - Error: %s\tExpression: %s\n",
+                     parser.error().c_str(),
+                     expression_string.c_str());
+
+               error_found = true;
+
+               continue;
+            }
+
+            x_view.rebase(vec2.data());
+
+            x_view.set_size(vector_size);
+
+            expression.value();
+
+            if (!expression.return_invoked())
+            {
+               printf("run_test21() - Error: expected return_invoked for expression: %s\n",
+                      expression_string.c_str());
+
+               error_found = true;
+
+               continue;
+            }
+
+            const exprtk::results_context<T>& results = expression.results();
+
+            if (results.count() != 1)
+            {
+               printf("run_test21() - Error: expected 1 return value, instead got: %d for expression: %s\n",
+                      static_cast<int>(results.count()),
+                      expression_string.c_str());
+
+               error_found = true;
+
+               continue;
+            }
+
+            if (results[0].type != exprtk::results_context<T>::type_store_t::e_vector)
+            {
+               printf("run_test21() - Error: expected vector type for return value for expression: %s\n",
+                      expression_string.c_str());
+
+               error_found = true;
+
+               continue;
+            }
+
+            typename exprtk::type_store<T>::vector_view vector(results[0]);
+
+            if (vector.size() != vector_size)
+            {
+               printf("run_test21() - Error: expected vector size %d instead got: %d for expression: %s\n",
+                      static_cast<int>(vector_size),
+                      static_cast<int>(vector.size()),
+                      expression_string.c_str());
+
+               error_found = true;
+
+               continue;
+            }
+
+            for (std::size_t j = 0; j < vector.size(); ++j)
+            {
+               if (vector[j] != expected_values[i])
+               {
+                  printf("run_test21() - Error: expected vector[%d] expected %f instead got: %f for expression: %s\n",
+                         static_cast<int>(j),
+                         expected_values[i],
+                         vector[j],
+                         expression_string.c_str());
+
+                  error_found = true;
+               }
+            }
+         }
+      }
+   }
+
+   {
+      expression_t expression;
+      parser_t     parser;
+
+      std::string expressions[] =
+      {
+         "1 + 2"         ,
+         "return [1 + 2]",
+         "z + 2"         ,
+         "1 + 2"         ,
+         "z + 2"
+      };
+
+      typedef std::pair<T,bool> return_test_t;
+
+      return_test_t expected_results[] =
+      {
+         return_test_t(3                                   , false ),
+         return_test_t(std::numeric_limits<T>::quiet_NaN() , true  ),
+         return_test_t(std::numeric_limits<T>::quiet_NaN() , false ),
+         return_test_t(3                                   , false ),
+         return_test_t(std::numeric_limits<T>::quiet_NaN() , false )
+      };
+
+      const std::size_t expressions_size = sizeof(expressions) / sizeof(std::string);
+
+      for (std::size_t i = 0; i < expressions_size; ++i)
+      {
+         const std::string& expression_string = expressions[i];
+
+         parser.compile(expression_string, expression);
+
+         return_test_t& expected_result = expected_results[i];
+
+         const T    result      = expression.value();
+         const bool ret_invoked = expression.return_invoked();
+
+         const bool result_check = std::isnan(result) ? std::isnan(expected_result.first) : result == expected_result.first;
+
+         if (!result_check || (ret_invoked != expected_result.second))
+         {
+            printf("run_test21() - Error: Expression: %s result: %f ret_invoked: %c  "
+                   "expected result: %f ret_invoked: %c \n",
+                   expression_string.c_str(),
+                   result,
+                   ret_invoked ? 'T' : 'F',
+                   expected_result.first,
+                   expected_result.second ? 'T' : 'F');
+
+            error_found = true;
+
+            continue;
+         }
+      }
+
+   }
+
+   {
+      const std::size_t max_vector_size = 10;
+
+      std::vector<T> vec1(max_vector_size, 1);
+      std::vector<T> vec2(max_vector_size, 2);
+
+      std::vector<T> vec3(max_vector_size / 2, 3);
+
+      const std::string expressions[] =
+      {
+         "return [x + y]" ,
+         "return [y + x]" ,
+         "return [2x + y]",
+         "return [y + 2x]",
+         "return [2x + 2y]",
+         "return [2y + 2x]",
+         "return [(2 * x) + y]",
+         "return [y + (2 * x)]",
+         "return [(x * 2) + y]",
+         "return [y + (x * 2)]",
+         "return [(2 * x) + (2 * y)]",
+         "return [(2 * y) + (2 * x)]",
+         "return [(x * 2) + (y * 2)]",
+         "return [(y * 2) + (x * 2)]",
+      };
+
+      const T expected_values[] =
+      {
+         T(2 + 3),
+         T(3 + 2),
+         T(2 * 2 + 3),
+         T(3 + 2 * 2),
+         T(2 * 2 + 2 * 3),
+         T(2 * 3 + 2 * 2),
+         T(2 * 2 + 3),
+         T(3 + (2 * 2)),
+         T(2 * 2 + 3),
+         T(3 + 2 * 2),
+         T(2 * 2 + 2 * 3),
+         T(2 * 3 + 2 * 2),
+         T(2 * 2 + 3 * 2),
+         T(3 * 2 + 2 * 2),
+      };
+
+      const std::size_t expressions_size = sizeof(expressions) / sizeof(std::string);
+
+      for (std::size_t i = 0; i < expressions_size; ++i)
+      {
+         const std::string& expression_string = expressions[i];
+
+         exprtk::vector_view<T> x_view = exprtk::make_vector_view(vec1, vec1.size());
+
+         for (std::size_t vector_size = vec3.size() + 1; vector_size <= 10; ++vector_size)
+         {
+            symbol_table_t symbol_table;
+            expression_t   expression;
+            parser_t       parser;
+
+            symbol_table.add_vector  ("x", x_view);
+            symbol_table.add_vector  ("y", vec3  );
+
+            expression.register_symbol_table(symbol_table);
+
+            if (!parser.compile(expression_string, expression))
+            {
+               printf("run_test21() - Error: %s\tExpression: %s\n",
+                      parser.error().c_str(),
+                      expression_string.c_str());
+
+               error_found = true;
+
+               continue;
+            }
+
+            x_view.rebase(vec2.data());
+
+            x_view.set_size(vector_size);
+
+            expression.value();
+
+            if (!expression.return_invoked())
+            {
+               printf("run_test21() - Error: expected return_invoked for expression: %s\n",
+                      expression_string.c_str());
+
+               error_found = true;
+
+               continue;
+            }
+
+            const exprtk::results_context<T>& results = expression.results();
+
+            if (results.count() != 1)
+            {
+               printf("run_test21() - Error: expected 1 return value, instead got: %d for expression: %s\n",
+                      static_cast<int>(results.count()),
+                      expression_string.c_str());
+
+               error_found = true;
+
+               continue;
+            }
+
+            if (results[0].type != exprtk::results_context<T>::type_store_t::e_vector)
+            {
+               printf("run_test21() - Error: expected vector type for return value for expression: %s\n",
+                      expression_string.c_str());
+
+               error_found = true;
+
+               continue;
+            }
+
+            typename exprtk::type_store<T>::vector_view vector(results[0]);
+
+            if (vector.size() != vec3.size())
+            {
+               printf("run_test21() - Error: expected vector size %d instead got: %d for expression: %s\n",
+                      static_cast<int>(vec3.size()),
+                      static_cast<int>(vector.size()),
+                      expression_string.c_str());
+
+               error_found = true;
+
+               continue;
+            }
+
+            for (std::size_t j = 0; j < vector.size(); ++j)
+            {
+               if (vector[j] != expected_values[i])
+               {
+                  printf("run_test21() - Error: expected vector[%d] expected %f instead got: %f for expression: %s\n",
+                         static_cast<int>(j),
+                         expected_values[i],
+                         vector[j],
+                         expression_string.c_str());
+
+                  error_found = true;
+               }
+            }
+         }
+      }
+   }
+
+   if (error_found)
+   {
+      return false;
+   }
+
    return true;
 }
 
diff --git a/license.txt b/license.txt
index 1135827..7fd57f6 100644
--- a/license.txt
+++ b/license.txt
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 1999-2024 Arash Partow
+Copyright (c) 1999-2025 Arash Partow
 
 https://www.partow.net/programming/exprtk/index.html
 
diff --git a/readme.txt b/readme.txt
index 6400116..bfc3e39 100644
--- a/readme.txt
+++ b/readme.txt
@@ -122,7 +122,7 @@
 
    (1) https://www.opensource.org/licenses/MIT
    (2) SPDX-License-Identifier: MIT
-   (3) SPDX-FileCopyrightText : Copyright (C) 1999-2024 Arash Partow
+   (3) SPDX-FileCopyrightText : Copyright (C) 1999-2025 Arash Partow
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -439,13 +439,13 @@
 |          | matches respectively.                                   |
 |          | (eg: x ilike y or 'a1B2c3D4e5F6g7H' ilike 'a?d*h')      |
 +----------+---------------------------------------------------------+
-| [r0:r1]  | The closed interval[r0,r1] of the specified string.     |
+| [r0:r1]  | The half-open interval [r0,r1) of the specified string. |
 |          | eg: Given a string x with a value of 'abcdefgh' then:   |
-|          | 1. x[1:4] == 'bcde'                                     |
-|          | 2. x[ :4] == x[:8 / 2] == 'abcde'                       |
+|          | 1. x[1:5] == 'bcde'                                     |
+|          | 2. x[ :5] == x[:8 / 2 + 1] == 'abcde'                   |
 |          | 3. x[2 + 1: ] == x[3:] =='defgh'                        |
 |          | 4. x[ : ] == x[:] == 'abcdefgh'                         |
-|          | 5. x[4/2:3+1] == x[2:4] == 'cde'                        |
+|          | 5. x[4/2:3+2] == x[2:5] == 'cde'                        |
 |          |                                                         |
 |          | Note: Both r0 and r1 are assumed to be integers, where  |
 |          | r0 <= r1. They may also be the result of an expression, |
@@ -821,8 +821,8 @@
 
 
 A compiled expression that references variables from a symbol_table is
-dependent on  that symbol_table  instance and  the variables  it holds
-being valid.
+said to be dependent on  that symbol_table instance and the  variables
+it holds being valid.
 
    typedef exprtk::symbol_table<double> symbol_table_t;
    typedef exprtk::expression<double>   expression_t;
@@ -2612,7 +2612,7 @@
       typedef typename exprtk::igeneric_function<T>::parameter_list_t
                                                      parameter_list_t;
 
-      moo()
+      roo()
       : exprtk::igeneric_function<T>("SVTT|SS|TTV|S?V*S")
       {}
 
@@ -3055,12 +3055,12 @@
    (5) None          x + y + z
 
 
-Note23: In  expression 4,  both variables  'w' and  'z' are denoted as
+Note23: In  Expression 4,  both variables  'w' and  'z' are denoted as
 being assignments even though only one of them can ever be modified at
-the time of evaluation. Furthermore the determination of which of  the
-two variables the modification will occur upon can only be known  with
-certainty at evaluation time and not beforehand, hence both are listed
-as being candidates for assignment.
+the time of  evaluation. Furthermore determining  of which of  the two
+variables the  modification will  occur upon  can only  be known  with
+certainty at evaluation time  (aka runtime) and not  beforehand, hence
+both are listed as being candidates for assignment.
 
 The following builds upon the previous example demonstrating the usage
 of the DEC in determining the 'assignments' of the given expression:
@@ -4408,18 +4408,19 @@
 
 (3) Vector Operations functions:
 
-   (a) all_true     (b) all_false
-   (c) any_true     (d) any_false
-   (e) assign       (f) count
-   (g) copy         (h) reverse
-   (i) rotate-left  (j) rotate-right
-   (k) shift-left   (l) shift-right
-   (m) sort         (n) nth_element
-   (o) iota         (p) sumk
-   (q) axpy         (r) axpby
-   (s) axpyz        (t) axpbyz
-   (u) axpbz        (v) dot
-   (w) dotk         (x) diff
+   (00) all_true     (01) all_false
+   (02) any_true     (03) any_false
+   (04) assign       (05) count
+   (06) copy         (07) reverse
+   (08) rotate-left  (09) rotate-right
+   (10) shift-left   (11) shift-right
+   (12) sort         (13) nth_element
+   (14) iota         (15) sumk
+   (16) axpy         (17) axpby
+   (18) axpyz        (19) axpbyz
+   (20) axpbz        (21) dot
+   (22) dotk         (23) diff
+   (24) select       (25) min/max_elementwise
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -4742,9 +4743,10 @@
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [SECTION 24 - RUNTIME CHECKS]
-The  ExprTk library   provides the ability  to perform runtime  checks
-during expression evaluation so as  to ensure memory access  violation
-errors  are  caught and  handled  without causing further  issues. The
+The  ExprTk library  provides the  ability to  perform runtime  checks
+during expression evaluation so as to ensure situations such as memory
+access violation, compilation stack-overflow and evaluation time limit
+errors  are caught  and handled  without causing  further issues.  The
 checks typically cover:
 
    1. Vector access and handling
@@ -4965,13 +4967,13 @@
    typedef exprtk::parser<T> parser_t;
    typedef exprtk::loop_runtime_check loop_runtime_check_t;
 
-   my_loop_rtc loop_rtc;
+   my_loop_rtc loop_runtime_check;
    loop_runtime_check.loop_set = loop_runtime_check_t::e_all_loops;
    loop_runtime_check.max_loop_iterations = 100000;
 
    parser_t parser;
 
-   parser.register_loop_runtime_check(loop_rtc);
+   parser.register_loop_runtime_check(loop_runtime_check);
 
 
 The following is an example of how one could derive from and implement
@@ -4987,7 +4989,7 @@
       }
 
       void handle_runtime_violation
-         (const exprtk::violation_context&) override
+         (const violation_context&) override
       {
          throw std::runtime_error("Loop runtime violation.");
       }
@@ -5074,7 +5076,7 @@
    .
    .
    .
-   using std::chrono;
+   using namespace std::chrono;
    const auto max_duration = seconds(25);
 
    try
@@ -5155,7 +5157,8 @@
          return true;
       }
 
-      using time_point_t = std::chrono::time_point<std::chrono::steady_clock>;
+      using namespace std::chrono;
+      using time_point_t = time_point<steady_clock>;
 
       void set_timeout_time(const time_point_t& timeout_tp)
       {
@@ -5183,9 +5186,10 @@
    parser.
       register_compilation_timeout_check(compilation_timeout_check);
 
-   const auto max_duration = std::chrono::seconds(5);
-   const auto timeout_tp   =
-      std::chrono::steady_clock::now() + max_duration;
+   using namespace std::chrono;
+
+   const auto max_duration = seconds(5);
+   const auto timeout_tp   = steady_clock::now() + max_duration;
 
    compilation_timeout_check.set_timeout_time(timeout_tp);
 
@@ -5316,16 +5320,18 @@
    parser.
       register_compilation_timeout_check(compilation_timeout_check);
 
+   using namespace std::chrono;
+
    const auto compile_timeout_tp = []()
    {
-      const auto max_duration = std::chrono::seconds(5);
-      return std::chrono::steady_clock::now() + max_duration;
+      const auto max_duration = seconds(5);
+      return steady_clock::now() + max_duration;
    };
 
    const auto loop_timeout_tp = []()
    {
-      const auto max_duration = std::chrono::seconds(10);
-      return std::chrono::steady_clock::now() + max_duration;
+      const auto max_duration = seconds(10);
+      return steady_clock::now() + max_duration;
    };
 
    const std::vector<std::string> expressions =
@@ -5525,7 +5531,7 @@
 
  (02) Supported types  are float,  double, long  double and MPFR/GMP.
       Generally any user defined numerical type that supports all the
-      basic floating  point arithmetic  operations: -,+,*,/,^,%  etc;
+      basic floating point arithmetic operations: -, +, *,/,^, % etc;
       unary and binary operations: sin,cos,min,max,equal etc and  any
       other ExprTk dependent operations can be used to specialise the
       various components: expression, parser and symbol_table.
@@ -5561,7 +5567,7 @@
       storage capacity.
 
  (09) The  life-time of  objects registered  with or  created from  a
-      specific symbol-table must  span at least  the lifetime of  the
+      specific symbol-table must, at least, span the lifetime of  the
       symbol  table  instance  and  all  compiled  expressions  which
       utilise objects, such as variables, strings, vectors,  function
       compositor  functions  and  functions  of  that   symbol-table,
@@ -5999,63 +6005,65 @@
    (03) exprtk_binomial_coefficient.cpp
    (04) exprtk_bsm_benchmark.cpp
    (05) exprtk_calc.cpp
-   (06) exprtk_collatz.cpp
-   (07) exprtk_compilation_timeout.cpp
-   (08) exprtk_degree_trigonometry_example.cpp
-   (09) exprtk_exprgen.cpp
-   (00) exprtk_extract_dependents.cpp
-   (11) exprtk_e_10kdigits.cpp
-   (12) exprtk_factorize_fermat.cpp
-   (13) exprtk_factorize_pollard.cpp
-   (14) exprtk_fizzbuzz.cpp
-   (15) exprtk_funcall_benchmark.cpp
-   (16) exprtk_game_of_life.cpp
-   (17) exprtk_gcd.cpp
-   (18) exprtk_gnuplot.cpp
-   (19) exprtk_gnuplot_multi.cpp
-   (10) exprtk_groups_examples.cpp
-   (21) exprtk_immutable_symbol_table_example.cpp
-   (22) exprtk_import_packages.cpp
-   (23) exprtk_instruction_primer.cpp
-   (24) exprtk_jump_diffusion_process.cpp
-   (25) exprtk_loop_timeout_rtc.cpp
-   (26) exprtk_magic_square.cpp
-   (27) exprtk_mandelbrot.cpp
-   (28) exprtk_max_subarray_sum.cpp
-   (29) exprtk_maze_generator.cpp
-   (20) exprtk_miller_rabin_primality_test.cpp
-   (31) exprtk_montecarlo_e.cpp
-   (32) exprtk_montecarlo_option_pricing_model.cpp
-   (33) exprtk_montecarlo_pi.cpp
-   (34) exprtk_naive_primes.cpp
-   (35) exprtk_normal_random_marsaglia_method.cpp
-   (36) exprtk_nqueens_problem.cpp
-   (37) exprtk_nthroot_bisection.cpp
-   (38) exprtk_ornstein_uhlenbeck_process.cpp
-   (39) exprtk_pascals_triangle.cpp
-   (30) exprtk_pi_10kdigits.cpp
-   (41) exprtk_prime_sieve.cpp
-   (42) exprtk_prime_sieve_vectorized.cpp
-   (43) exprtk_pyramid.cpp
-   (44) exprtk_pythagorean_triples.cpp
-   (45) exprtk_recursive_fibonacci.cpp
-   (46) exprtk_repl.cpp
-   (47) exprtk_riddle.cpp
-   (48) exprtk_rtc_overhead.cpp
-   (49) exprtk_sudoku_solver.cpp
-   (50) exprtk_sumofprimes.cpp
-   (51) exprtk_symtab_functions.cpp
-   (52) exprtk_testgen.cpp
-   (53) exprtk_tower_of_hanoi.cpp
-   (54) exprtk_truthtable_gen.cpp
-   (55) exprtk_vectorized_binomial_model.cpp
-   (56) exprtk_vectornorm.cpp
-   (57) exprtk_vector_benchmark.cpp
-   (58) exprtk_vector_benchmark_multithreaded.cpp
-   (59) exprtk_vector_resize_example.cpp
-   (60) exprtk_vector_resize_inline_example.cpp
-   (61) exprtk_wiener_process_pi.cpp
-
+   (06) exprtk_chladni_contour.cpp
+   (07) exprtk_collatz.cpp
+   (08) exprtk_compilation_timeout.cpp
+   (09) exprtk_degree_trigonometry_example.cpp
+   (00) exprtk_exprgen.cpp
+   (11) exprtk_extract_dependents.cpp
+   (12) exprtk_e_10kdigits.cpp
+   (13) exprtk_factorize_fermat.cpp
+   (14) exprtk_factorize_pollard.cpp
+   (15) exprtk_fizzbuzz.cpp
+   (16) exprtk_funcall_benchmark.cpp
+   (17) exprtk_game_of_life.cpp
+   (18) exprtk_gcd.cpp
+   (19) exprtk_gnuplot.cpp
+   (10) exprtk_gnuplot_multi.cpp
+   (21) exprtk_groups_examples.cpp
+   (22) exprtk_immutable_symbol_table_example.cpp
+   (23) exprtk_import_packages.cpp
+   (24) exprtk_instruction_primer.cpp
+   (25) exprtk_julia_set_fractal.cpp
+   (26) exprtk_jump_diffusion_process.cpp
+   (27) exprtk_loop_timeout_rtc.cpp
+   (28) exprtk_magic_square.cpp
+   (29) exprtk_mandelbrot.cpp
+   (20) exprtk_max_subarray_sum.cpp
+   (31) exprtk_maze_generator.cpp
+   (32) exprtk_miller_rabin_primality_test.cpp
+   (33) exprtk_montecarlo_e.cpp
+   (34) exprtk_montecarlo_option_pricing_model.cpp
+   (35) exprtk_montecarlo_pi.cpp
+   (36) exprtk_naive_primes.cpp
+   (37) exprtk_normal_random_marsaglia_method.cpp
+   (38) exprtk_nqueens_problem.cpp
+   (39) exprtk_nthroot_bisection.cpp
+   (30) exprtk_ornstein_uhlenbeck_process.cpp
+   (41) exprtk_pascals_triangle.cpp
+   (42) exprtk_pi_10kdigits.cpp
+   (43) exprtk_prime_sieve.cpp
+   (44) exprtk_prime_sieve_vectorized.cpp
+   (45) exprtk_pyramid.cpp
+   (46) exprtk_pythagorean_triples.cpp
+   (47) exprtk_radial_contour.cpp
+   (48) exprtk_recursive_fibonacci.cpp
+   (49) exprtk_repl.cpp
+   (50) exprtk_riddle.cpp
+   (51) exprtk_rtc_overhead.cpp
+   (52) exprtk_sudoku_solver.cpp
+   (53) exprtk_sumofprimes.cpp
+   (54) exprtk_symtab_functions.cpp
+   (55) exprtk_testgen.cpp
+   (56) exprtk_tower_of_hanoi.cpp
+   (57) exprtk_truthtable_gen.cpp
+   (58) exprtk_vectorized_binomial_model.cpp
+   (59) exprtk_vectornorm.cpp
+   (60) exprtk_vector_benchmark.cpp
+   (61) exprtk_vector_benchmark_multithreaded.cpp
+   (62) exprtk_vector_resize_example.cpp
+   (63) exprtk_vector_resize_inline_example.cpp
+   (64) exprtk_wiener_process_pi.cpp
 
 Details for each of the above examples can be found here: