diff --git a/exprtk.hpp b/exprtk.hpp
index dd3c8ca..8773dc1 100644
--- a/exprtk.hpp
+++ b/exprtk.hpp
@@ -601,8 +601,10 @@
                                  std::size_t&       diff_index,
                                  char&              diff_value)
       {
-         if (str.empty() || pattern.empty())
-            return false;
+         if (str.empty())
+         {
+            return ("Z" == pattern);
+         }
          else if ('*' == pattern[0])
             return false;
 
@@ -1875,6 +1877,7 @@
          //typedef T Type;
          //typedef const T Type;
          typedef const T& Type;
+         typedef       T& RefType;
          typedef T (*qfunc_t)(Type t0, Type t1, Type t2, Type t3);
          typedef T (*tfunc_t)(Type t0, Type t1, Type t2);
          typedef T (*bfunc_t)(Type t0, Type t1);
@@ -2186,6 +2189,7 @@
          {
             const char* begin_itr = ((base_itr_ + begin) < s_end_) ? (base_itr_ + begin) : s_end_;
             const char* end_itr   = ((base_itr_ +   end) < s_end_) ? (base_itr_ +   end) : s_end_;
+
             return std::string(begin_itr,end_itr);
          }
 
@@ -2244,7 +2248,7 @@
                }
             };
 
-            int mode = 0;
+            int mode      = 0;
             int increment = 0;
 
             if (is_end(s_itr_) || is_end((s_itr_ + 1)))
@@ -5226,6 +5230,7 @@
          {
             const T arg0 = branch_[0].first->value();
             const T arg1 = branch_[1].first->value();
+
             return Operation::process(arg0,arg1);
          }
 
@@ -6795,7 +6800,7 @@
 
          static std::string null_value;
 
-         explicit string_range_node(std::string& v, range_t rp)
+         explicit string_range_node(std::string& v, const range_t& rp)
          : value_(&v),
            rp_(rp)
          {}
@@ -6878,7 +6883,7 @@
 
          typedef range_pack<T> range_t;
 
-         explicit const_string_range_node(const std::string& v, range_t rp)
+         explicit const_string_range_node(const std::string& v, const range_t& rp)
          : value_(v),
            rp_(rp)
          {}
@@ -6951,7 +6956,7 @@
          typedef range_interface<T>          irange_t;
          typedef irange_t*                 irange_ptr;
 
-         generic_string_range_node(expression_ptr str_branch, range_t brange)
+         generic_string_range_node(expression_ptr str_branch, const range_t& brange)
          : initialised_(false),
            branch_(str_branch),
            branch_deletable_(branch_deletable(branch_)),
@@ -7847,15 +7852,15 @@
          {
             if (initialised_)
             {
-               std::size_t r0 = 0;
-               std::size_t r1 = 0;
-
                if (is_true(test_))
                {
                   consequent_->value();
 
                   range_t& range = str0_range_ptr_->range_ref();
 
+                  std::size_t r0 = 0;
+                  std::size_t r1 = 0;
+
                   if (range(r0,r1,str0_base_ptr_->size()))
                   {
                      const std::size_t size = (r1 - r0) + 1;
@@ -8486,6 +8491,28 @@
          vector_elem_node<T>* vec_node_ptr_;
       };
 
+      namespace loop_unroll
+      {
+         #ifndef exprtk_disable_superscalar_unroll
+         const std::size_t loop_batch_size = 8;
+         #else
+         const std::size_t loop_batch_size = 4;
+         #endif
+
+         struct details
+         {
+            details(const std::size_t& vsize)
+            : batch_size(loop_batch_size),
+              remainder (vsize % batch_size),
+              upper_bound(static_cast<int>(vsize - (remainder ? loop_batch_size : 0)))
+            {}
+
+            int  batch_size;
+            int   remainder;
+            int upper_bound;
+         };
+      }
+
       template <typename T>
       class assignment_vec_node : public binary_node     <T>,
                                   public vector_interface<T>
@@ -8516,9 +8543,34 @@
                vector_holder<T>& vec_hldr = vec_node_ptr_->ref();
                const T v = binary_node<T>::branch_[1].first->value();
 
-               for (std::size_t i = 0; i < vec_size_; ++i)
+               loop_unroll::details lud(vec_size_);
+               int i = 0;
+
+               for (; i < lud.upper_bound; i += lud.batch_size)
                {
-                  (*vec_hldr[i]) = v;
+                  (*vec_hldr[i    ]) = v;
+                  (*vec_hldr[i + 1]) = v;
+                  (*vec_hldr[i + 2]) = v;
+                  (*vec_hldr[i + 3]) = v;
+                  #ifndef exprtk_disable_superscalar_unroll
+                  (*vec_hldr[i + 4]) = v;
+                  (*vec_hldr[i + 5]) = v;
+                  (*vec_hldr[i + 6]) = v;
+                  (*vec_hldr[i + 7]) = v;
+                  #endif
+               }
+
+               switch (lud.remainder)
+               {
+                  #ifndef exprtk_disable_superscalar_unroll
+                  case 7 : (*vec_hldr[i++]) = v;
+                  case 6 : (*vec_hldr[i++]) = v;
+                  case 5 : (*vec_hldr[i++]) = v;
+                  case 4 : (*vec_hldr[i++]) = v;
+                  #endif
+                  case 3 : (*vec_hldr[i++]) = v;
+                  case 2 : (*vec_hldr[i++]) = v;
+                  case 1 : (*vec_hldr[i++]) = v;
                }
 
                return vec_node_ptr_->value();
@@ -8608,9 +8660,34 @@
                vector_holder<T>& vec0 = vec0_node_ptr_->ref();
                vector_holder<T>& vec1 = vec1_node_ptr_->ref();
 
-               for (std::size_t i = 0; i < vec_size_; ++i)
+               loop_unroll::details lud(vec_size_);
+               int i = 0;
+
+               for (; i < lud.upper_bound; i += lud.batch_size)
                {
-                  (*vec0[i]) = (*vec1[i]);
+                  (*vec0[i    ]) = (*vec1[i    ]);
+                  (*vec0[i + 1]) = (*vec1[i + 1]);
+                  (*vec0[i + 2]) = (*vec1[i + 2]);
+                  (*vec0[i + 3]) = (*vec1[i + 3]);
+                  #ifndef exprtk_disable_superscalar_unroll
+                  (*vec0[i + 4]) = (*vec1[i + 4]);
+                  (*vec0[i + 5]) = (*vec1[i + 5]);
+                  (*vec0[i + 6]) = (*vec1[i + 6]);
+                  (*vec0[i + 7]) = (*vec1[i + 7]);
+                  #endif
+               }
+
+               switch (lud.remainder)
+               {
+                  #ifndef exprtk_disable_superscalar_unroll
+                  case 7 : { (*vec0[i]) = (*vec1[i]); ++i; }
+                  case 6 : { (*vec0[i]) = (*vec1[i]); ++i; }
+                  case 5 : { (*vec0[i]) = (*vec1[i]); ++i; }
+                  case 4 : { (*vec0[i]) = (*vec1[i]); ++i; }
+                  #endif
+                  case 3 : { (*vec0[i]) = (*vec1[i]); ++i; }
+                  case 2 : { (*vec0[i]) = (*vec1[i]); ++i; }
+                  case 1 : { (*vec0[i]) = (*vec1[i]); ++i; }
                }
 
                return vec0_node_ptr_->value();
@@ -8751,10 +8828,34 @@
                vector_holder<T>& vec_hldr = vec_node_ptr_->ref();
                const T v = binary_node<T>::branch_[1].first->value();
 
-               for (std::size_t i = 0; i < vec_size_; ++i)
+               loop_unroll::details lud(vec_size_);
+               int i = 0;
+
+               for (; i < lud.upper_bound; i += lud.batch_size)
                {
-                  T& vec_i = *vec_hldr[i];
-                     vec_i = Operation::process(vec_i,v);
+                  Operation::assign(*vec_hldr[i    ],v);
+                  Operation::assign(*vec_hldr[i + 1],v);
+                  Operation::assign(*vec_hldr[i + 2],v);
+                  Operation::assign(*vec_hldr[i + 3],v);
+                  #ifndef exprtk_disable_superscalar_unroll
+                  Operation::assign(*vec_hldr[i + 4],v);
+                  Operation::assign(*vec_hldr[i + 5],v);
+                  Operation::assign(*vec_hldr[i + 6],v);
+                  Operation::assign(*vec_hldr[i + 7],v);
+                  #endif
+               }
+
+               switch (lud.remainder)
+               {
+                  #ifndef exprtk_disable_superscalar_unroll
+                  case 7 : Operation::assign((*vec_hldr[i++]),v);
+                  case 6 : Operation::assign((*vec_hldr[i++]),v);
+                  case 5 : Operation::assign((*vec_hldr[i++]),v);
+                  case 4 : Operation::assign((*vec_hldr[i++]),v);
+                  #endif
+                  case 3 : Operation::assign((*vec_hldr[i++]),v);
+                  case 2 : Operation::assign((*vec_hldr[i++]),v);
+                  case 1 : Operation::assign((*vec_hldr[i++]),v);
                }
 
                return vec_node_ptr_->value();
@@ -8845,13 +8946,37 @@
                vector_holder<T>& vec0 = vec0_node_ptr_->ref();
                vector_holder<T>& vec1 = vec1_node_ptr_->ref();
 
-               for (std::size_t i = 0; i < vec_size_; ++i)
+               loop_unroll::details lud(vec_size_);
+               int i = 0;
+
+               #define exprtk_loop(N)                                            \
+               (*vec0[i + N]) = Operation::process((*vec0[i + N]),*vec1[i + N]); \
+
+               for (; i < lud.upper_bound; i += lud.batch_size)
                {
-                  T& vec0_i = *vec0[i];
-                  T& vec1_i = *vec1[i];
-                  vec0_i = Operation::process(vec0_i,vec1_i);
+                  exprtk_loop(0) exprtk_loop(1)
+                  exprtk_loop(2) exprtk_loop(3)
+                  #ifndef exprtk_disable_superscalar_unroll
+                  exprtk_loop(4) exprtk_loop(5)
+                  exprtk_loop(6) exprtk_loop(7)
+                  #endif
                }
 
+               switch (lud.remainder)
+               {
+                  #ifndef exprtk_disable_superscalar_unroll
+                  case 7 : { exprtk_loop(0) ++i; }
+                  case 6 : { exprtk_loop(0) ++i; }
+                  case 5 : { exprtk_loop(0) ++i; }
+                  case 4 : { exprtk_loop(0) ++i; }
+                  #endif
+                  case 3 : { exprtk_loop(0) ++i; }
+                  case 2 : { exprtk_loop(0) ++i; }
+                  case 1 : { exprtk_loop(0) ++i; }
+               }
+
+               #undef exprtk_loop
+
                return vec0_node_ptr_->value();
             }
             else
@@ -9246,16 +9371,37 @@
                vector_holder<T>& vec1 = vec1_node_ptr_->ref();
                vector_holder<T>& vec2 = *temp_;
 
-               for (std::size_t i = 0; i < vec_size_; ++i)
+               loop_unroll::details lud(vec_size_);
+               int i = 0;
+
+               #define exprtk_loop(N)                                              \
+               (*vec2[i + N]) = Operation::process((*vec0[i + N]),(*vec1[i + N])); \
+
+               for (; i < lud.upper_bound; i += lud.batch_size)
                {
-
-                  T& vec0_i = *vec0[i];
-                  T& vec1_i = *vec1[i];
-                  T& vec2_i = *vec2[i];
-
-                  vec2_i = Operation::process(vec0_i,vec1_i);
+                  exprtk_loop(0) exprtk_loop(1)
+                  exprtk_loop(2) exprtk_loop(3)
+                  #ifndef exprtk_disable_superscalar_unroll
+                  exprtk_loop(4) exprtk_loop(5)
+                  exprtk_loop(6) exprtk_loop(7)
+                  #endif
                }
 
+               switch (lud.remainder)
+               {
+                  #ifndef exprtk_disable_superscalar_unroll
+                  case 7 : { exprtk_loop(0); ++i; }
+                  case 6 : { exprtk_loop(0); ++i; }
+                  case 5 : { exprtk_loop(0); ++i; }
+                  case 4 : { exprtk_loop(0); ++i; }
+                  #endif
+                  case 3 : { exprtk_loop(0); ++i; }
+                  case 2 : { exprtk_loop(0); ++i; }
+                  case 1 : { exprtk_loop(0); ++i; }
+               }
+
+               #undef exprtk_loop
+
                return *vec2[0];
             }
             else
@@ -9355,14 +9501,37 @@
                vector_holder<T>& vec0 = vec0_node_ptr_->ref();
                vector_holder<T>& vec1 = *temp_;
 
-               for (std::size_t i = 0; i < vec_size_; ++i)
-               {
-                  T& vec0_i = *vec0[i];
-                  T& vec1_i = *vec1[i];
+               loop_unroll::details lud(vec_size_);
+               int i = 0;
 
-                  vec1_i = Operation::process(vec0_i,v);
+               #define exprtk_loop(N)                                 \
+               (*vec1[i + N]) = Operation::process((*vec0[i + N]),v); \
+
+               for (; i < lud.upper_bound; i += lud.batch_size)
+               {
+                  exprtk_loop(0) exprtk_loop(1)
+                  exprtk_loop(2) exprtk_loop(3)
+                  #ifndef exprtk_disable_superscalar_unroll
+                  exprtk_loop(4) exprtk_loop(5)
+                  exprtk_loop(6) exprtk_loop(7)
+                  #endif
                }
 
+               switch (lud.remainder)
+               {
+                  #ifndef exprtk_disable_superscalar_unroll
+                  case 7 : { exprtk_loop(0); ++i; }
+                  case 6 : { exprtk_loop(0); ++i; }
+                  case 5 : { exprtk_loop(0); ++i; }
+                  case 4 : { exprtk_loop(0); ++i; }
+                  #endif
+                  case 3 : { exprtk_loop(0); ++i; }
+                  case 2 : { exprtk_loop(0); ++i; }
+                  case 1 : { exprtk_loop(0); ++i; }
+               }
+
+               #undef exprtk_loop
+
                return *vec1[0];
             }
             else
@@ -9460,14 +9629,37 @@
                vector_holder<T>& vec1 = vec1_node_ptr_->ref();
                vector_holder<T>& vec2 = *temp_;
 
-               for (std::size_t i = 0; i < vec_size_; ++i)
-               {
-                  T& vec1_i = *vec1[i];
-                  T& vec2_i = *vec2[i];
+               loop_unroll::details lud(vec_size_);
+               int i = 0;
 
-                  vec2_i = Operation::process(v,vec1_i);
+               #define exprtk_loop(N)                                 \
+               (*vec2[i + N]) = Operation::process(v,(*vec1[i + N])); \
+
+               for (; i < lud.upper_bound; i += lud.batch_size)
+               {
+                  exprtk_loop(0) exprtk_loop(1)
+                  exprtk_loop(2) exprtk_loop(3)
+                  #ifndef exprtk_disable_superscalar_unroll
+                  exprtk_loop(4) exprtk_loop(5)
+                  exprtk_loop(6) exprtk_loop(7)
+                  #endif
                }
 
+               switch (lud.remainder)
+               {
+                  #ifndef exprtk_disable_superscalar_unroll
+                  case 7 : { exprtk_loop(0); ++i; }
+                  case 6 : { exprtk_loop(0); ++i; }
+                  case 5 : { exprtk_loop(0); ++i; }
+                  case 4 : { exprtk_loop(0); ++i; }
+                  #endif
+                  case 3 : { exprtk_loop(0); ++i; }
+                  case 2 : { exprtk_loop(0); ++i; }
+                  case 1 : { exprtk_loop(0); ++i; }
+               }
+
+               #undef exprtk_loop
+
                return *vec2[0];
             }
             else
@@ -9562,12 +9754,34 @@
                vector_holder<T>& vec0 = vec0_node_ptr_->ref();
                vector_holder<T>& vec1 = *temp_;
 
-               for (std::size_t i = 0; i < vec_size_; ++i)
-               {
-                  T& vec0_i = *vec0[i];
-                  T& vec1_i = *vec1[i];
+               loop_unroll::details lud(vec_size_);
+               int i = 0;
 
-                  vec1_i = Operation::process(vec0_i);
+               for (; i < lud.upper_bound; i += lud.batch_size)
+               {
+                  (*vec1[i    ]) = Operation::process((*vec0[i    ]));
+                  (*vec1[i + 1]) = Operation::process((*vec0[i + 1]));
+                  (*vec1[i + 2]) = Operation::process((*vec0[i + 2]));
+                  (*vec1[i + 3]) = Operation::process((*vec0[i + 3]));
+                  #ifndef exprtk_disable_superscalar_unroll
+                  (*vec1[i + 4]) = Operation::process((*vec0[i + 4]));
+                  (*vec1[i + 5]) = Operation::process((*vec0[i + 5]));
+                  (*vec1[i + 6]) = Operation::process((*vec0[i + 6]));
+                  (*vec1[i + 7]) = Operation::process((*vec0[i + 7]));
+                  #endif
+               }
+
+               switch (lud.remainder)
+               {
+                  #ifndef exprtk_disable_superscalar_unroll
+                  case 7 : { (*vec1[i]) = Operation::process((*vec0[i])); ++i; }
+                  case 6 : { (*vec1[i]) = Operation::process((*vec0[i])); ++i; }
+                  case 5 : { (*vec1[i]) = Operation::process((*vec0[i])); ++i; }
+                  case 4 : { (*vec1[i]) = Operation::process((*vec0[i])); ++i; }
+                  #endif
+                  case 3 : { (*vec1[i]) = Operation::process((*vec0[i])); ++i; }
+                  case 2 : { (*vec1[i]) = Operation::process((*vec0[i])); ++i; }
+                  case 1 : { (*vec1[i]) = Operation::process((*vec0[i])); ++i; }
                }
 
                return *vec1[0];
@@ -10610,6 +10824,7 @@
       struct opr_base
       {
          typedef typename details::functor_t<T>::Type Type;
+         typedef typename details::functor_t<T>::RefType RefType;
          typedef typename details::functor_t<T> functor_t;
          typedef typename functor_t::qfunc_t quaternary_functor_t;
          typedef typename functor_t::tfunc_t    trinary_functor_t;
@@ -10621,8 +10836,10 @@
       struct add_op : public opr_base<T>
       {
          typedef typename opr_base<T>::Type Type;
+         typedef typename opr_base<T>::RefType RefType;
          static inline T process(Type t1, Type t2) { return t1 + t2; }
          static inline T process(Type t1, Type t2, Type t3) { return t1 + t2 + t3; }
+         static inline void assign(RefType& t1, Type t2) { t1 += t2; }
          static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_add; }
          static inline details::operator_type operation() { return details::e_add; }
       };
@@ -10631,8 +10848,10 @@
       struct mul_op : public opr_base<T>
       {
          typedef typename opr_base<T>::Type Type;
+         typedef typename opr_base<T>::RefType RefType;
          static inline T process(Type t1, Type t2) { return t1 * t2; }
          static inline T process(Type t1, Type t2, Type t3) { return t1 * t2 * t3; }
+         static inline void assign(RefType& t1, Type t2) { t1 *= t2; }
          static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_mul; }
          static inline details::operator_type operation() { return details::e_mul; }
       };
@@ -10641,8 +10860,10 @@
       struct sub_op : public opr_base<T>
       {
          typedef typename opr_base<T>::Type Type;
+         typedef typename opr_base<T>::RefType RefType;
          static inline T process(Type t1, Type t2) { return t1 - t2; }
          static inline T process(Type t1, Type t2, Type t3) { return t1 - t2 - t3; }
+         static inline void assign(RefType& t1, Type t2) { t1 -= t2; }
          static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_sub; }
          static inline details::operator_type operation() { return details::e_sub; }
       };
@@ -10651,8 +10872,10 @@
       struct div_op : public opr_base<T>
       {
          typedef typename opr_base<T>::Type Type;
+         typedef typename opr_base<T>::RefType RefType;
          static inline T process(Type t1, Type t2) { return t1 / t2; }
          static inline T process(Type t1, Type t2, Type t3) { return t1 / t2 / t3; }
+         static inline void assign(RefType& t1, Type t2) { t1 /= t2; }
          static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_div; }
          static inline details::operator_type operation() { return details::e_div; }
       };
@@ -10661,7 +10884,9 @@
       struct mod_op : public opr_base<T>
       {
          typedef typename opr_base<T>::Type Type;
+         typedef typename opr_base<T>::RefType RefType;
          static inline T process(Type t1, Type t2) { return numeric::modulus<T>(t1,t2); }
+         static inline void assign(RefType& t1, Type t2) { t1 = numeric::modulus<T>(t1,t2); }
          static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_mod; }
          static inline details::operator_type operation() { return details::e_mod; }
       };
@@ -10670,7 +10895,9 @@
       struct pow_op : public opr_base<T>
       {
          typedef typename opr_base<T>::Type Type;
+         typedef typename opr_base<T>::RefType RefType;
          static inline T process(Type t1, Type t2) { return numeric::pow<T>(t1,t2); }
+         static inline void assign(RefType& t1, Type t2) { t1 = numeric::pow<T>(t1,t2); }
          static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_pow; }
          static inline details::operator_type operation() { return details::e_pow; }
       };
@@ -11454,14 +11681,64 @@
          {
             vector_holder<T>& vec = v->vec()->ref();
 
-            T result = T(0);
+            loop_unroll::details lud(vec.size());
+            int i = 0;
 
-            for (std::size_t i = 0; i < vec.size(); ++i)
+            if (vec.size() <= static_cast<std::size_t>(lud.batch_size))
             {
-              result += (*vec[i]);
+               T result = T(0);
+
+               switch (vec.size())
+               {
+                  #ifndef exprtk_disable_superscalar_unroll
+                  case 8 : result += (*vec[i++]);
+                  case 7 : result += (*vec[i++]);
+                  case 6 : result += (*vec[i++]);
+                  case 5 : result += (*vec[i++]);
+                  #endif
+                  case 4 : result += (*vec[i++]);
+                  case 3 : result += (*vec[i++]);
+                  case 2 : result += (*vec[i++]);
+                  case 1 : result += (*vec[i++]);
+               }
+
+               return result;
             }
 
-            return result;
+            T r[8] = { T(0), T(0), T(0), T(0), T(0), T(0), T(0), T(0) };
+
+            for (; i < lud.upper_bound; i += lud.batch_size)
+            {
+               r[0] += (*vec[i    ]);
+               r[1] += (*vec[i + 1]);
+               r[2] += (*vec[i + 2]);
+               r[3] += (*vec[i + 3]);
+               #ifndef exprtk_disable_superscalar_unroll
+               r[4] += (*vec[i + 4]);
+               r[5] += (*vec[i + 5]);
+               r[6] += (*vec[i + 6]);
+               r[7] += (*vec[i + 7]);
+               #endif
+            }
+
+            switch (lud.remainder)
+            {
+               #ifndef exprtk_disable_superscalar_unroll
+               case 7 : r[0] += (*vec[i++]);
+               case 6 : r[0] += (*vec[i++]);
+               case 5 : r[0] += (*vec[i++]);
+               case 4 : r[0] += (*vec[i++]);
+               #endif
+               case 3 : r[0] += (*vec[i++]);
+               case 2 : r[0] += (*vec[i++]);
+               case 1 : r[0] += (*vec[i++]);
+            }
+
+            return (r[0] + r[1] + r[2] + r[3])
+                   #ifndef exprtk_disable_superscalar_unroll
+                 + (r[4] + r[5] + r[6] + r[7])
+                   #endif
+                   ;
          }
       };
 
@@ -11474,14 +11751,64 @@
          {
             vector_holder<T>& vec = v->vec()->ref();
 
-            T result = (*vec[0]);
+            loop_unroll::details lud(vec.size());
+            int i = 0;
 
-            for (std::size_t i = 1; i < vec.size(); ++i)
+            if (vec.size() <= static_cast<std::size_t>(lud.batch_size))
             {
-              result *= (*vec[i]);
+               T result = T(1);
+
+               switch (vec.size())
+               {
+                  #ifndef exprtk_disable_superscalar_unroll
+                  case 8 : result *= (*vec[i++]);
+                  case 7 : result *= (*vec[i++]);
+                  case 6 : result *= (*vec[i++]);
+                  case 5 : result *= (*vec[i++]);
+                  #endif
+                  case 4 : result *= (*vec[i++]);
+                  case 3 : result *= (*vec[i++]);
+                  case 2 : result *= (*vec[i++]);
+                  case 1 : result *= (*vec[i++]);
+               }
+
+               return result;
             }
 
-            return result;
+            T r[8] = { T(1), T(1), T(1), T(1), T(1), T(1), T(1), T(1) };
+
+            for (; i < lud.upper_bound; i += lud.batch_size)
+            {
+               r[0] *= (*vec[i    ]);
+               r[1] *= (*vec[i + 1]);
+               r[2] *= (*vec[i + 2]);
+               r[3] *= (*vec[i + 3]);
+               #ifndef exprtk_disable_superscalar_unroll
+               r[4] *= (*vec[i + 4]);
+               r[5] *= (*vec[i + 5]);
+               r[6] *= (*vec[i + 6]);
+               r[7] *= (*vec[i + 7]);
+               #endif
+            }
+
+            switch (lud.remainder)
+            {
+               #ifndef exprtk_disable_superscalar_unroll
+               case 7 : r[0] *= (*vec[i++]);
+               case 6 : r[0] *= (*vec[i++]);
+               case 5 : r[0] *= (*vec[i++]);
+               case 4 : r[0] *= (*vec[i++]);
+               #endif
+               case 3 : r[0] *= (*vec[i++]);
+               case 2 : r[0] *= (*vec[i++]);
+               case 1 : r[0] *= (*vec[i++]);
+            }
+
+            return (r[0] * r[1] * r[2] * r[3])
+                   #ifndef exprtk_disable_superscalar_unroll
+                 * (r[4] * r[5] * r[6] * r[7])
+                   #endif
+                   ;
          }
       };
 
@@ -11496,9 +11823,34 @@
 
             T result = T(0);
 
-            for (std::size_t i = 0; i < vec.size(); ++i)
+            loop_unroll::details lud(vec.size());
+            int i = 0;
+
+            for (; i < lud.upper_bound; i += lud.batch_size)
             {
-              result += (*vec[i]);
+               result += (*vec[i]);
+               result += (*vec[i + 1]);
+               result += (*vec[i + 2]);
+               result += (*vec[i + 3]);
+               #ifndef exprtk_disable_superscalar_unroll
+               result += (*vec[i + 4]);
+               result += (*vec[i + 5]);
+               result += (*vec[i + 6]);
+               result += (*vec[i + 7]);
+               #endif
+            }
+
+            switch (lud.remainder)
+            {
+               #ifndef exprtk_disable_superscalar_unroll
+               case 7 : result += (*vec[i++]);
+               case 6 : result += (*vec[i++]);
+               case 5 : result += (*vec[i++]);
+               case 4 : result += (*vec[i++]);
+               #endif
+               case 3 : result += (*vec[i++]);
+               case 2 : result += (*vec[i++]);
+               case 1 : result += (*vec[i++]);
             }
 
             return result / vec.size();
@@ -15293,7 +15645,7 @@
             return false;
          else if (symbol_exists(function_name))
             return false;
-         else if (std::string::npos != function.parameter_sequence.find_first_not_of("STV*?|"))
+         else if (std::string::npos != function.parameter_sequence.find_first_not_of("STVZ*?|"))
             return false;
          else if (generic_function_t::e_rtrn_scalar == function.rtrn_type)
             return local_data().generic_function_store.add(function_name,function);
@@ -15614,8 +15966,9 @@
       inline bool symbol_exists(const std::string& symbol_name, const bool check_reserved_symb = true) const
       {
          /*
-            Will return true if symbol_name exists as either a reserved symbol,
-            variable, stringvar or function name in any of the type stores.
+            Function will return true if symbol_name exists as either a
+            reserved symbol, variable, stringvar or function name in any
+            of the type stores.
          */
          if (!valid())
             return false;
@@ -15787,7 +16140,7 @@
       {
          if (symbol.empty())
             return false;
-         if (!details::is_letter(symbol[0]))
+         else if (!details::is_letter(symbol[0]))
             return false;
          else if (symbol.size() > 1)
          {
@@ -15811,7 +16164,7 @@
       {
          if (symbol.empty())
             return false;
-         if (!details::is_letter(symbol[0]))
+         else if (!details::is_letter(symbol[0]))
             return false;
          else if (symbol.size() > 1)
          {
@@ -16149,7 +16502,7 @@
             {
                typename expression_holder::data_type dt = expression_holder::e_data;
 
-               switch(data_mode)
+               switch (data_mode)
                {
                   case 0 : dt = expression_holder::e_data;    break;
                   case 1 : dt = expression_holder::e_vecdata; break;
@@ -17314,6 +17667,7 @@
             }
 
             std::sort(symbol_name_list_.begin(),symbol_name_list_.end());
+
             std::unique_copy(symbol_name_list_.begin(),
                              symbol_name_list_.end(),
                              std::back_inserter(symbols_list));
@@ -17337,6 +17691,7 @@
             }
 
             std::sort(assignment_name_list_.begin(),assignment_name_list_.end());
+
             std::unique_copy(assignment_name_list_.begin(),
                              assignment_name_list_.end(),
                              std::back_inserter(assignment_list));
@@ -21219,6 +21574,14 @@
             return !invalid_state_;
          }
 
+         bool allow_zero_parameters() const
+         {
+            return
+               param_seq_list_.end() != std::find(param_seq_list_.begin(),
+                                                  param_seq_list_.end(),
+                                                  "Z");
+         }
+
       private:
 
          void split(const std::string& s)
@@ -21245,7 +21608,12 @@
                   {
                      const std::string curr_str = str.substr(s,e - s);
 
-                     if (std::string::npos == curr_str.find_first_not_of("STV*?|"))
+                     if ("Z" == curr_str)
+                     {
+                        psl.push_back(curr_str);
+                        return true;
+                     }
+                     else if (std::string::npos == curr_str.find_first_not_of("STV*?|"))
                      {
                         psl.push_back(curr_str);
                         return true;
@@ -21327,16 +21695,34 @@
             return error_node();
          }
 
+         if (
+              !function->parameter_sequence.empty() &&
+              function->allow_zero_parameters    () &&
+              !tc      .allow_zero_parameters    ()
+            )
+         {
+            set_error(
+               make_error(parser_error::e_syntax,
+                          current_token(),
+                          "ERR116 - Mismatch in zero parameter condition for generic function: "
+                          + function_name));
+
+            return error_node();
+         }
+
          if (token_is(token_t::e_lbracket))
          {
             if (token_is(token_t::e_rbracket))
             {
-               if (!function->allow_zero_parameters())
+               if (
+                    !function->allow_zero_parameters() &&
+                    !tc       .allow_zero_parameters()
+                  )
                {
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR116 - Zero parameter call to generic function: "
+                                "ERR117 - Zero parameter call to generic function: "
                                 + function_name + " not allowed"));
 
                   return error_node();
@@ -21367,19 +21753,23 @@
                      set_error(
                         make_error(parser_error::e_syntax,
                                    current_token(),
-                                   "ERR117 - Expected ',' for call to generic function: " + function_name));
+                                   "ERR118 - Expected ',' for call to generic function: " + function_name));
 
                      return error_node();
                   }
                }
             }
          }
-         else if (!function->allow_zero_parameters())
+         else if (
+                   !function->parameter_sequence.empty() &&
+                   function->allow_zero_parameters    () &&
+                   !tc      .allow_zero_parameters    ()
+                 )
          {
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR118 - Zero parameter call to generic function: "
+                          "ERR119 - Zero parameter call to generic function: "
                           + function_name + " not allowed"));
 
             return error_node();
@@ -21392,7 +21782,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR119 - Expected ',' for call to generic function: " + function_name));
+                          "ERR120 - Expected ',' for call to generic function: " + function_name));
 
             return error_node();
          }
@@ -21458,7 +21848,7 @@
                      set_error(
                         make_error(parser_error::e_syntax,
                                    current_token(),
-                                   "ERR120 - Expected ',' for call to string function: " + function_name));
+                                   "ERR121 - Expected ',' for call to string function: " + function_name));
 
                      return error_node();
                   }
@@ -21473,7 +21863,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR121 - Expected ',' for call to string function: " + function_name));
+                          "ERR122 - Expected ',' for call to string function: " + function_name));
 
             return error_node();
          }
@@ -21509,7 +21899,7 @@
                p.set_error(
                     make_error(parser_error::e_syntax,
                                p.current_token(),
-                               "ERR122 - Expected '(' for special function"));
+                               "ERR123 - Expected '(' for special function"));
 
                return error_node();
             }
@@ -21529,7 +21919,7 @@
                      p.set_error(
                           make_error(parser_error::e_syntax,
                                      p.current_token(),
-                                     "ERR123 - Expected ',' before next parameter of special function"));
+                                     "ERR124 - Expected ',' before next parameter of special function"));
 
                      return p.error_node();
                   }
@@ -21558,7 +21948,7 @@
             set_error(
                make_error(parser_error::e_token,
                           current_token(),
-                          "ERR124 - Invalid special function[1]: " + current_token().value));
+                          "ERR125 - Invalid special function[1]: " + current_token().value));
 
             return error_node();
          }
@@ -21570,7 +21960,7 @@
             set_error(
                make_error(parser_error::e_token,
                           current_token(),
-                          "ERR125 - Invalid special function[2]: " + current_token().value));
+                          "ERR126 - Invalid special function[2]: " + current_token().value));
 
             return error_node();
          }
@@ -21601,7 +21991,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR126 - Break call within a break call is not allowed"));
+                          "ERR127 - Break call within a break call is not allowed"));
 
             return error_node();
          }
@@ -21623,7 +22013,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR127 - Failed to parse return expression for 'break' statement"));
+                                "ERR128 - Failed to parse return expression for 'break' statement"));
 
                   return error_node();
                }
@@ -21632,7 +22022,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR128 - Expected ']' at the completion of break's return expression"));
+                                "ERR129 - Expected ']' at the completion of break's return expression"));
 
                   free_node(node_allocator_,return_expr);
 
@@ -21649,7 +22039,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR129 - Invalid use of 'break', allowed only in the scope of a loop"));
+                          "ERR130 - Invalid use of 'break', allowed only in the scope of a loop"));
          }
 
          return error_node();
@@ -21671,7 +22061,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR130 - Invalid use of 'continue', allowed only in the scope of a loop"));
+                          "ERR131 - Invalid use of 'continue', allowed only in the scope of a loop"));
 
             return error_node();
          }
@@ -21687,7 +22077,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR131 - Expected '[' as part of vector size definition"));
+                          "ERR132 - Expected '[' as part of vector size definition"));
 
             return error_node();
          }
@@ -21696,7 +22086,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR132 - Failed to determine size of vector '" + vec_name + "'"));
+                          "ERR133 - Failed to determine size of vector '" + vec_name + "'"));
 
             return error_node();
          }
@@ -21707,7 +22097,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR133 - Expected a literal number as size of vector '" + vec_name + "'"));
+                          "ERR134 - Expected a literal number as size of vector '" + vec_name + "'"));
 
             return error_node();
          }
@@ -21725,7 +22115,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR134 - Invalid vector size. Must be an integer greater than zero, size: " +
+                          "ERR135 - Invalid vector size. Must be an integer greater than zero, size: " +
                           details::to_str(details::numeric::to_int32(vector_size))));
 
             return error_node();
@@ -21742,7 +22132,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR135 - Expected ']' as part of vector size definition"));
+                          "ERR136 - Expected ']' as part of vector size definition"));
 
             return error_node();
          }
@@ -21753,7 +22143,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR136 - Expected ':=' as part of vector definition"));
+                             "ERR137 - Expected ':=' as part of vector definition"));
 
                return error_node();
             }
@@ -21766,7 +22156,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR137 - Failed to parse single vector initialiser"));
+                                "ERR138 - Failed to parse single vector initialiser"));
 
                   return error_node();
                }
@@ -21778,7 +22168,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR138 - Expected ']' to close single value vector initialiser"));
+                                "ERR139 - Expected ']' to close single value vector initialiser"));
 
                   return error_node();
                }
@@ -21790,7 +22180,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR139 - Expected '{' as part of vector initialiser list"));
+                             "ERR140 - Expected '{' as part of vector initialiser list"));
 
                return error_node();
             }
@@ -21805,7 +22195,7 @@
                      set_error(
                         make_error(parser_error::e_syntax,
                                    current_token(),
-                                   "ERR140 - Expected '{' as part of vector initialiser list"));
+                                   "ERR141 - Expected '{' as part of vector initialiser list"));
 
                      return error_node();
                   }
@@ -21822,7 +22212,7 @@
                      set_error(
                         make_error(parser_error::e_syntax,
                                    current_token(),
-                                   "ERR141 - Expected ',' between vector initialisers"));
+                                   "ERR142 - Expected ',' between vector initialisers"));
 
                      return error_node();
                   }
@@ -21843,7 +22233,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR142 - Expected ';' at end of vector definition"));
+                                "ERR143 - Expected ';' at end of vector definition"));
 
                   return error_node();
                }
@@ -21854,7 +22244,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR143 - Initialiser list larger than the number of elements in the vector: '" + vec_name + "'"));
+                             "ERR144 - Initialiser list larger than the number of elements in the vector: '" + vec_name + "'"));
 
                return error_node();
             }
@@ -21873,7 +22263,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR144 - Illegal redefinition of local vector: '" + vec_name + "'"));
+                             "ERR145 - Illegal redefinition of local vector: '" + vec_name + "'"));
 
                return error_node();
             }
@@ -21906,7 +22296,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR145 - Failed to add new local vector '" + vec_name + "' to SEM"));
+                             "ERR146 - Failed to add new local vector '" + vec_name + "' to SEM"));
 
                sem_.free_element(nse);
 
@@ -21951,7 +22341,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR146 - Illegal redefinition of local variable: '" + str_name + "'"));
+                             "ERR147 - Illegal redefinition of local variable: '" + str_name + "'"));
 
                free_node(node_allocator_,initialisation_expression);
 
@@ -21982,7 +22372,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR147 - Failed to add new local string variable '" + str_name + "' to SEM"));
+                             "ERR148 - Failed to add new local string variable '" + str_name + "' to SEM"));
 
                free_node(node_allocator_,initialisation_expression);
 
@@ -22027,7 +22417,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR148 - Illegal variable definition"));
+                          "ERR149 - Illegal variable definition"));
 
             return error_node();
          }
@@ -22047,7 +22437,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR149 - Expected a symbol for variable definition"));
+                          "ERR150 - Expected a symbol for variable definition"));
 
             return error_node();
          }
@@ -22056,7 +22446,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR150 - Illegal redefinition of reserved keyword: '" + var_name + "'"));
+                          "ERR151 - Illegal redefinition of reserved keyword: '" + var_name + "'"));
 
             return error_node();
          }
@@ -22065,7 +22455,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR151 - Illegal redefinition of variable '" + var_name + "'"));
+                          "ERR152 - Illegal redefinition of variable '" + var_name + "'"));
 
             return error_node();
          }
@@ -22074,7 +22464,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR152 - Illegal redefinition of local variable: '" + var_name + "'"));
+                          "ERR153 - Illegal redefinition of local variable: '" + var_name + "'"));
 
             return error_node();
          }
@@ -22093,7 +22483,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR153 - Failed to parse initialisation expression"));
+                             "ERR154 - Failed to parse initialisation expression"));
 
                return error_node();
             }
@@ -22110,7 +22500,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR154 - Expected ';' after variable definition"));
+                             "ERR155 - Expected ';' after variable definition"));
 
                free_node(node_allocator_,initialisation_expression);
 
@@ -22137,7 +22527,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR155 - Illegal redefinition of local variable: '" + var_name + "'"));
+                             "ERR156 - Illegal redefinition of local variable: '" + var_name + "'"));
 
                free_node(node_allocator_,initialisation_expression);
 
@@ -22168,7 +22558,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR156 - Failed to add new local variable '" + var_name + "' to SEM"));
+                             "ERR157 - Failed to add new local variable '" + var_name + "' to SEM"));
 
                free_node(node_allocator_,initialisation_expression);
 
@@ -22204,7 +22594,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR157 - Expected a '{}' for uninitialised var definition"));
+                          "ERR158 - Expected a '{}' for uninitialised var definition"));
 
             return error_node();
          }
@@ -22213,7 +22603,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR158 - Expected ';' after uninitialised variable definition"));
+                          "ERR159 - Expected ';' after uninitialised variable definition"));
 
             return error_node();
          }
@@ -22229,7 +22619,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR159 - Illegal redefinition of local variable: '" + var_name + "'"));
+                             "ERR160 - Illegal redefinition of local variable: '" + var_name + "'"));
 
                return error_node();
             }
@@ -22258,7 +22648,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR160 - Failed to add new local variable '" + var_name + "' to SEM"));
+                             "ERR161 - Failed to add new local variable '" + var_name + "' to SEM"));
 
                sem_.free_element(nse);
 
@@ -22290,7 +22680,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR161 - Expected '(' at start of swap statement"));
+                          "ERR162 - Expected '(' at start of swap statement"));
 
             return error_node();
          }
@@ -22308,7 +22698,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR162 - Expected a symbol for variable or vector element definition"));
+                          "ERR163 - Expected a symbol for variable or vector element definition"));
 
             return error_node();
          }
@@ -22319,7 +22709,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR163 - First parameter to swap is an invalid vector element: '" + var0_name + "'"));
+                             "ERR164 - First parameter to swap is an invalid vector element: '" + var0_name + "'"));
 
                return error_node();
             }
@@ -22351,7 +22741,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR164 - First parameter to swap is an invalid variable: '" + var0_name + "'"));
+                             "ERR165 - First parameter to swap is an invalid variable: '" + var0_name + "'"));
 
                return error_node();
             }
@@ -22364,7 +22754,7 @@
             set_error(
                 make_error(parser_error::e_syntax,
                            current_token(),
-                           "ERR165 - Expected ',' between parameters to swap"));
+                           "ERR166 - Expected ',' between parameters to swap"));
 
             if (variable0_generated)
             {
@@ -22381,7 +22771,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR166 - Expected a symbol for variable or vector element definition"));
+                          "ERR167 - Expected a symbol for variable or vector element definition"));
 
             if (variable0_generated)
             {
@@ -22397,7 +22787,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR167 - Second parameter to swap is an invalid vector element: '" + var1_name + "'"));
+                             "ERR168 - Second parameter to swap is an invalid vector element: '" + var1_name + "'"));
 
                if (variable0_generated)
                {
@@ -22434,7 +22824,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR168 - Second parameter to swap is an invalid variable: '" + var1_name + "'"));
+                             "ERR169 - Second parameter to swap is an invalid variable: '" + var1_name + "'"));
 
                if (variable0_generated)
                {
@@ -22452,7 +22842,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR169 - Expected ')' at end of swap statement"));
+                          "ERR170 - Expected ')' at end of swap statement"));
 
             if (variable0_generated)
             {
@@ -22505,7 +22895,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR170 - Return call within a return call is not allowed"));
+                          "ERR171 - Return call within a return call is not allowed"));
 
             return error_node();
          }
@@ -22528,7 +22918,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR171 - Expected '[' at start of return statement"));
+                          "ERR172 - Expected '[' at start of return statement"));
 
             return error_node();
          }
@@ -22550,7 +22940,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR172 - Expected ',' between values during call to return"));
+                                "ERR173 - Expected ',' between values during call to return"));
 
                   return error_node();
                }
@@ -22561,7 +22951,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR173 - Zero parameter return statement not allowed"));
+                          "ERR174 - Zero parameter return statement not allowed"));
 
             return error_node();
          }
@@ -22575,7 +22965,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              prev_token,
-                             "ERR174 - Invalid ']' found during return call"));
+                             "ERR175 - Invalid ']' found during return call"));
 
                return error_node();
             }
@@ -22621,7 +23011,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR175 - Invalid sequence of variable '"+ symbol + "' and bracket"));
+                             "ERR176 - Invalid sequence of variable '"+ symbol + "' and bracket"));
 
                return false;
             }
@@ -22668,7 +23058,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR176 - Invalid sequence of brackets"));
+                             "ERR177 - Invalid sequence of brackets"));
 
                return false;
             }
@@ -22769,7 +23159,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR177 - Failed to generate node for function: '" + symbol + "'"));
+                                "ERR178 - Failed to generate node for function: '" + symbol + "'"));
 
                   return error_node();
                }
@@ -22794,7 +23184,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR178 - Failed to generate node for vararg function: '" + symbol + "'"));
+                                "ERR179 - Failed to generate node for vararg function: '" + symbol + "'"));
 
                   return error_node();
                }
@@ -22819,7 +23209,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR179 - Failed to generate node for generic function: '" + symbol + "'"));
+                                "ERR180 - Failed to generate node for generic function: '" + symbol + "'"));
 
                   return error_node();
                }
@@ -22844,7 +23234,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR180 - Failed to generate node for string function: '" + symbol + "'"));
+                                "ERR181 - Failed to generate node for string function: '" + symbol + "'"));
 
                   return error_node();
                }
@@ -22865,7 +23255,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR181 - Invalid use of reserved symbol '" + symbol + "'"));
+                                "ERR182 - Invalid use of reserved symbol '" + symbol + "'"));
 
                   return error_node();
                }
@@ -22922,7 +23312,7 @@
                   set_error(
                      make_error(parser_error::e_symtab,
                                 current_token(),
-                                "ERR182 - Failed to create variable: '" + symbol + "'"));
+                                "ERR183 - Failed to create variable: '" + symbol + "'"));
 
                   return error_node();
                }
@@ -22932,7 +23322,7 @@
          set_error(
             make_error(parser_error::e_syntax,
                        current_token(),
-                       "ERR183 - Undefined symbol: '" + symbol + "'"));
+                       "ERR184 - Undefined symbol: '" + symbol + "'"));
 
          return error_node();
       }
@@ -23033,7 +23423,7 @@
             set_error(
                make_error(parser_error::e_symtab,
                           current_token(),
-                          "ERR184 - Variable or function detected, yet symbol-table is invalid, Symbol: " + current_token().value));
+                          "ERR185 - Variable or function detected, yet symbol-table is invalid, Symbol: " + current_token().value));
 
             return error_node();
          }
@@ -23058,7 +23448,7 @@
                set_error(
                   make_error(parser_error::e_numeric,
                              current_token(),
-                             "ERR185 - Failed to convert '" + current_token().value + "' to a number"));
+                             "ERR186 - Failed to convert '" + current_token().value + "' to a number"));
 
                return error_node();
             }
@@ -23084,7 +23474,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR186 - Expected ')' instead of: '" + current_token().value + "'"));
+                             "ERR187 - Expected ')' instead of: '" + current_token().value + "'"));
 
                free_node(node_allocator_,branch);
 
@@ -23108,7 +23498,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR187 - Expected ']' instead of: '" + current_token().value + "'"));
+                             "ERR188 - Expected ']' instead of: '" + current_token().value + "'"));
 
                free_node(node_allocator_,branch);
 
@@ -23132,7 +23522,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR188 - Expected '}' instead of: '" + current_token().value + "'"));
+                             "ERR189 - Expected '}' instead of: '" + current_token().value + "'"));
 
                free_node(node_allocator_,branch);
 
@@ -23171,7 +23561,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR189 - Premature end of expression[1]"));
+                          "ERR190 - Premature end of expression[1]"));
 
             return error_node();
          }
@@ -23180,7 +23570,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR190 - Premature end of expression[2]"));
+                          "ERR191 - Premature end of expression[2]"));
 
             return error_node();
          }
@@ -23767,7 +24157,7 @@
 
             bool result = false;
 
-            if (b0_string ^ b1_string)
+            if (b0_string != b1_string)
                result = true;
             else if (!valid_string_operation(operation) && b0_string && b1_string)
                result = true;
@@ -23788,7 +24178,7 @@
 
             bool result = false;
 
-            if ((b0_string ^ b1_string) || (b1_string ^ b2_string))
+            if ((b0_string != b1_string) || (b1_string != b2_string))
                result = true;
             else if ((details::e_inrange != operation) && b0_string && b1_string && b2_string)
                result = true;
diff --git a/exprtk_simple_example_07.cpp b/exprtk_simple_example_07.cpp
index 52b7a85..07eebc9 100644
--- a/exprtk_simple_example_07.cpp
+++ b/exprtk_simple_example_07.cpp
@@ -48,9 +48,9 @@
 
    for (int i = 0; i < 8; ++i)
    {
-      symbol_table.get_variable("A")->ref() = T(i & 0x01 ? 1 : 0);
-      symbol_table.get_variable("B")->ref() = T(i & 0x02 ? 1 : 0);
-      symbol_table.get_variable("C")->ref() = T(i & 0x04 ? 1 : 0);
+      symbol_table.get_variable("A")->ref() = T((i & 0x01) ? 1 : 0);
+      symbol_table.get_variable("B")->ref() = T((i & 0x02) ? 1 : 0);
+      symbol_table.get_variable("C")->ref() = T((i & 0x04) ? 1 : 0);
 
       int result = static_cast<int>(expression.value());
 
diff --git a/exprtk_simple_example_15.cpp b/exprtk_simple_example_15.cpp
index f8cf1ed..4808d17 100644
--- a/exprtk_simple_example_15.cpp
+++ b/exprtk_simple_example_15.cpp
@@ -32,9 +32,9 @@
                   " var d1 := (log(s / x) + (r + v^2 / 2) * t) / (v * sqrt(t)); "
                   " var d2 := d1 - v * sqrt(t);                                 "
                   "                                                             "
-                  " if(callput_flag == 'call')                                  "
+                  " if (callput_flag == 'call')                                 "
                   "   s * ncdf(d1) - x * e^(-r * t) * ncdf(d2);                 "
-                  " else if(callput_flag == 'put')                              "
+                  " else if (callput_flag == 'put')                             "
                   "   x * e^(-r * t) * ncdf(-d2) - s * ncdf(-d1);               "
                   "                                                             ";
 
@@ -66,6 +66,7 @@
 
    {
       callput_flag = "call";
+
       T bsm = expression.value();
 
       printf("BSM(%s,%5.3f,%5.3f,%5.3f,%5.3f,%5.3f) = %10.6f\n",
@@ -76,6 +77,7 @@
 
    {
       callput_flag = "put";
+
       T bsm = expression.value();
 
       printf("BSM(%s,%5.3f,%5.3f,%5.3f,%5.3f,%5.3f) = %10.6f\n",
diff --git a/exprtk_test.cpp b/exprtk_test.cpp
index 4743bcd..d7125ac 100644
--- a/exprtk_test.cpp
+++ b/exprtk_test.cpp
@@ -1193,7 +1193,7 @@
 template <typename T>
 struct test_xy
 {
-   test_xy(std::string e, const T& v0, const T& v1, const T& r)
+   test_xy(const std::string& e, const T& v0, const T& v1, const T& r)
    : expr(e),
      x(v0),
      y(v1),
@@ -1209,7 +1209,7 @@
 template <typename T>
 struct test_xyzw
 {
-   test_xyzw(std::string e, const T& v0, const T& v1, const T& v2, const T& v3, const T& r)
+   test_xyzw(const std::string& e, const T& v0, const T& v1, const T& v2, const T& v3, const T& r)
    : expr(e),
      x(v0),
      y(v1),
@@ -1850,7 +1850,7 @@
 template <typename T>
 struct test_ab
 {
-   test_ab(std::string e, const std::string& v0, const std::string& v1, const T& r)
+   test_ab(const std::string& e, const std::string& v0, const std::string& v1, const T& r)
    : expr(e),
      a(v0),
      b(v1),
@@ -5342,6 +5342,35 @@
 };
 
 template <typename T>
+struct vararg_func : public exprtk::igeneric_function<T>
+{
+   typedef typename exprtk::igeneric_function<T>::parameter_list_t
+                                                  parameter_list_t;
+
+   typedef typename exprtk::igeneric_function<T>::generic_type
+                                                  generic_type;
+
+   typedef typename generic_type::scalar_view scalar_t;
+   typedef typename generic_type::vector_view vector_t;
+
+   vararg_func()
+   : exprtk::igeneric_function<T>("Z|T*|V")
+   {}
+
+   inline T operator()(const std::size_t& ps_index, parameter_list_t /*arglist*/)
+   {
+      switch (ps_index)
+      {                         // Overload resolution:
+         case 0  : return T(0); // Z  - Zero arguments
+         case 1  : return T(1); // T* - One or more scalars
+         case 2  : return T(2); // V  - One vector
+         default : return std::numeric_limits<T>::quiet_NaN();
+      }
+   }
+};
+
+
+template <typename T>
 inline bool run_test18()
 {
    {
@@ -5868,7 +5897,7 @@
 
          if (!parser.compile(program,expression))
          {
-            printf("Error: %s\tExpression: %s\n",
+            printf("run_test18() - Error: %s\tExpression: %s\n",
                    parser.error().c_str(),
                    program.c_str());
 
@@ -5931,6 +5960,77 @@
          return false;
    }
 
+   {
+      bool failure = false;
+
+      typedef exprtk::symbol_table<T> symbol_table_t;
+      typedef exprtk::expression<T>     expression_t;
+      typedef exprtk::parser<T>             parser_t;
+
+      symbol_table_t symbol_table;
+
+      T v[4] = {T(5), T(6), T(7), T(8)};
+
+      symbol_table.add_vector("v",v);
+
+      vararg_func<T> vaf;
+      symbol_table.add_function("vararg_func",vaf);
+
+      expression_t expression;
+      expression.register_symbol_table(symbol_table);
+
+      parser_t parser;
+
+      std::string programs[] =
+                     {
+                        "equal(0,vararg_func())",
+                        "equal(1,vararg_func() + 1)",
+                        "equal(1,1 + vararg_func())",
+                        "equal(1,vararg_func + 1)",
+                        "equal(1,1 + vararg_func)",
+                        "equal(0,vararg_func() + vararg_func)",
+                        "equal(0,vararg_func + vararg_func())",
+                        "equal(1,vararg_func + vararg_func(1))",
+                        "equal(1,vararg_func + vararg_func(1,2))",
+                        "equal(2,vararg_func + vararg_func(v))",
+                        "equal(1,vararg_func() + vararg_func(1))",
+                        "equal(1,vararg_func() + vararg_func(1,2))",
+                        "equal(2,vararg_func() + vararg_func(v))",
+                        "equal(2,vararg_func(v))",
+                        "equal(1,vararg_func(1))",
+                        "equal(1,vararg_func(1,2,3))",
+                        "equal(1,vararg_func(5,6,7,8))",
+                        "equal(5,vararg_func(v) + 3)",
+                        "equal(5,vararg_func(1) + 4)",
+                        "equal(6,vararg_func(1,2,3) + 5)",
+                        "equal(7,vararg_func(5,6,7,8) + 6)"
+                     };
+
+      static const std::size_t programs_size = sizeof(programs) / sizeof(std::string);
+
+      for (std::size_t i = 0; i < programs_size; ++i)
+      {
+         if (!parser.compile(programs[i],expression))
+         {
+            printf("run_test18() - Error: %s\tExpression: %s\n",
+                   parser.error().c_str(),
+                   programs[i].c_str());
+
+            failure = true;
+         }
+         else if (T(1) != expression.value())
+         {
+            printf("run_test18() - Error in evaluation! (5) Expression: %s\n",
+                   programs[i].c_str());
+
+            failure = true;
+         }
+      }
+
+      if (failure)
+         return false;
+   }
+
    return true;
 }
 
diff --git a/readme.txt b/readme.txt
index 88e180a..8e6ebbc 100644
--- a/readme.txt
+++ b/readme.txt
@@ -1334,23 +1334,23 @@
 
 There are five types of function interface:
 
-   +---+----------------------+-------------+
-   | # |         Name         | Return Type |
-   +---+----------------------+-------------+
-   | 1 | ifunction            | Scalar      |
-   | 2 | ivararg_function     | Scalar      |
-   | 3 | igeneric_function    | Scalar      |
-   | 4 | igeneric_function II | String      |
-   | 5 | function_compositor  | Scalar      |
-   +---+----------------------+-------------+
-
+  +---+----------------------+-------------+----------------------+
+  | # |         Name         | Return Type | Input Types          |
+  +---+----------------------+-------------+----------------------+
+  | 1 | ifunction            | Scalar      | Scalar               |
+  | 2 | ivararg_function     | Scalar      | Scalar               |
+  | 3 | igeneric_function    | Scalar      | Scalar,Vector,String |
+  | 4 | igeneric_function II | String      | Scalar,Vector,String |
+  | 5 | function_compositor  | Scalar      | Scalar               |
+  +---+----------------------+-------------+----------------------+
 
 (1) ifunction
-This  interface  supports  zero  to  20  input  parameters.  The usage
-requires a custom function be  derived from ifunction and to  override
-one  of the  21 function  operators. As  part of  the constructor  the
-custom function will define how many parameters it expects to  handle.
-The following example defines a 3 parameter function called 'foo':
+This interface supports zero to 20 input parameters of only the scalar
+type (numbers). The  usage requires a custom function be  derived from
+ifunction and to override one of the 21 function operators. As part of
+the constructor the custom function will define how many parameters it
+expects  to  handle.  The  following  example  defines  a  3 parameter
+function called 'foo':
 
    template <typename T>
    struct foo : public exprtk::ifunction<T>
@@ -1366,8 +1366,8 @@
 
 
 (2) ivararg_function
-This interface supports a variable  number of arguments as input  into
-the  function.  The  function operator  interface  uses  a std::vector
+This interface supports a variable number of scalar arguments as input
+into the function. The function operator interface uses a  std::vector
 specialized upon type T to facilitate parameter passing. The following
 example defines a vararg function called 'boo':
 
@@ -1504,12 +1504,13 @@
    (1) T - Scalar
    (2) V - Vector
    (3) S - String
-   (4) ? - Any type (Scalar, Vector or String)
-   (5) * - Wildcard operator
-   (6) | - Parameter sequence delimiter
+   (4) Z - Zero or no parameters
+   (5) ? - Any type (Scalar, Vector or String)
+   (6) * - Wildcard operator
+   (7) | - Parameter sequence delimiter
 
 
-No other characters other than  the six denoted above may  be included
+No other characters other than the seven denoted above may be included
 in the parameter sequence  definition. If any such  invalid characters
 do exist, registration of the associated generic function to a  symbol
 table ('add_function' method) will fail. If the parameter sequence  is
@@ -1545,6 +1546,12 @@
    (3) Scalar
    (4) Scalar
 
+Note: The  'Z' or  no parameter option may not be  used in conjunction
+with any other type option in a parameter sequence. When  incorporated
+in the parameter sequence list, the no parameter option indicates that
+the function may be invoked  without any parameters being passed.  For
+more information refer to the section: 'Zero Parameter Functions'
+
 
 (4) igeneric_function II
 This interface is identical to  the igeneric_function, in that in  can
@@ -1851,6 +1858,11 @@
       { ... }
    };
 
+
+Note: For  the igeneric_function  type, there  also needs  to be a 'Z'
+parameter sequence  defined inorder  for the  zero parameter  trait to
+properly take effect otherwise a compilation error will occur.
+
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [16 - EXPRESSION DEPENDENTS]
@@ -2822,6 +2834,7 @@
    (4) exprtk_disable_sc_andor
    (5) exprtk_disable_enhanced_features
    (6) exprtk_disable_string_capabilities
+   (7) exprtk_disable_superscalar_unroll
 
 
 (1) exprtk_enable_debugging
@@ -2854,6 +2867,14 @@
 expression that contains a string or string related syntax will result
 in a compilation failure.
 
+(7) exprtk_disable_superscalar_unroll
+This define will set  the loop unroll batch  size to 4 operations  per
+loop  instead of  the default  8 operations.  This define  is used  in
+operations that  involve vectors  and aggregations  over vectors. When
+targeting  non-superscalar  architectures, it  may  be recommended  to
+build using this particular option if efficiency of evaluations is  of
+concern.
+
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [23 - FILES]