[Boost-commit] svn:boost r82122 - in branches/release: boost/multiprecision boost/multiprecision/cpp_int boost/multiprecision/detail boost/multiprecision/detail/functions doc/pdf libs/multiprecision libs/multiprecision/config libs/multiprecision/doc libs/multiprecision/doc/html libs/multiprecision/doc/html/boost_multiprecision/indexes libs/multiprecision/doc/html/boost_multiprecision/map libs/multiprecision/doc/html/boost_multiprecision/perf libs/multiprecision/doc/html/boost_multiprecision/ref libs/multiprecision/doc/html/boost_multiprecision/tut libs/multiprecision/doc/html/boost_multiprecision/tut/floats libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg libs/multiprecision/doc/html/boost_multiprecision/tut/ints libs/multiprecision/example libs/multiprecision/test

Subject: [Boost-commit] svn:boost r82122 - in branches/release: boost/multiprecision boost/multiprecision/cpp_int boost/multiprecision/detail boost/multiprecision/detail/functions doc/pdf libs/multiprecision libs/multiprecision/config libs/multiprecision/doc libs/multiprecision/doc/html libs/multiprecision/doc/html/boost_multiprecision/indexes libs/multiprecision/doc/html/boost_multiprecision/map libs/multiprecision/doc/html/boost_multiprecision/perf libs/multiprecision/doc/html/boost_multiprecision/ref libs/multiprecision/doc/html/boost_multiprecision/tut libs/multiprecision/doc/html/boost_multiprecision/tut/floats libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg libs/multiprecision/doc/html/boost_multiprecision/tut/ints libs/multiprecision/example libs/multiprecision/test
From: john_at_[hidden]
Date: 2012-12-20 12:42:20

Author: johnmaddock
Date: 2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
New Revision: 82122
URL: http://svn.boost.org/trac/boost/changeset/82122

Log:
Merge bug fixes from Trunk:
Mostly correct typos as per https://svn.boost.org/trac/boost/ticket/7806
Also fix cpp_dec_float docs and add some static asserts to catch misuse.
Fix performance bottleneck in cpp_int's gcd implementation.
Properties modified: 
   branches/release/boost/multiprecision/   (props changed)
   branches/release/libs/multiprecision/   (props changed)
Text files modified: 
   branches/release/boost/multiprecision/cpp_dec_float.hpp                                           |     6                                         
   branches/release/boost/multiprecision/cpp_int/add.hpp                                             |     2                                         
   branches/release/boost/multiprecision/cpp_int/bitwise.hpp                                         |     2                                         
   branches/release/boost/multiprecision/cpp_int/checked.hpp                                         |     2                                         
   branches/release/boost/multiprecision/cpp_int/cpp_int_config.hpp                                  |     4                                         
   branches/release/boost/multiprecision/cpp_int/misc.hpp                                            |   287 +++++++++                               
   branches/release/boost/multiprecision/detail/default_ops.hpp                                      |     2                                         
   branches/release/boost/multiprecision/detail/functions/pow.hpp                                    |    16                                         
   branches/release/boost/multiprecision/detail/functions/trig.hpp                                   |    14                                         
   branches/release/boost/multiprecision/detail/generic_interconvert.hpp                             |     2                                         
   branches/release/boost/multiprecision/number.hpp                                                  |     4                                         
   branches/release/boost/multiprecision/random.hpp                                                  |     2                                         
   branches/release/doc/pdf/build                                                                    |     3                                         
   branches/release/libs/multiprecision/config/Jamfile.v2                                            |     2                                         
   branches/release/libs/multiprecision/doc/html/boost_multiprecision/indexes/s01.html               |     4                                         
   branches/release/libs/multiprecision/doc/html/boost_multiprecision/indexes/s02.html               |     4                                         
   branches/release/libs/multiprecision/doc/html/boost_multiprecision/indexes/s03.html               |     4                                         
   branches/release/libs/multiprecision/doc/html/boost_multiprecision/indexes/s04.html               |     4                                         
   branches/release/libs/multiprecision/doc/html/boost_multiprecision/map/faq.html                   |     2                                         
   branches/release/libs/multiprecision/doc/html/boost_multiprecision/map/todo.html                  |    12                                         
   branches/release/libs/multiprecision/doc/html/boost_multiprecision/perf/integer_performance.html  |  1177 ++++++++++++++++++++++----------------- 
   branches/release/libs/multiprecision/doc/html/boost_multiprecision/perf/rational_performance.html |    40                                         
   branches/release/libs/multiprecision/doc/html/boost_multiprecision/ref/backendconc.html           |     6                                         
   branches/release/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_dec_ref.html           |    33                                         
   branches/release/libs/multiprecision/doc/html/boost_multiprecision/ref/headers.html               |     2                                         
   branches/release/libs/multiprecision/doc/html/boost_multiprecision/ref/number.html                |     7                                         
   branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/conversions.html           |     4                                         
   branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_dec_float.html  |     3                                         
   branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/jel.html      |     2                                         
   branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/nd.html       |     2                                         
   branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/mpfr_float.html     |     2                                         
   branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/cpp_int.html          |     2                                         
   branches/release/libs/multiprecision/doc/html/index.html                                          |     2                                         
   branches/release/libs/multiprecision/doc/html4_symbols.qbk                                        |     2                                         
   branches/release/libs/multiprecision/doc/multiprecision.qbk                                       |   319 +++++-----                              
   branches/release/libs/multiprecision/example/floating_point_examples.cpp                          |     4                                         
   branches/release/libs/multiprecision/test/Jamfile.v2                                              |     2                                         
   branches/release/libs/multiprecision/test/test_cpp_int.cpp                                        |     3                                         
   38 files changed, 1234 insertions(+), 756 deletions(-)

Modified: branches/release/boost/multiprecision/cpp_dec_float.hpp
==============================================================================
--- branches/release/boost/multiprecision/cpp_dec_float.hpp	(original)
+++ branches/release/boost/multiprecision/cpp_dec_float.hpp	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -73,6 +73,10 @@
 private:
    static const boost::int32_t cpp_dec_float_digits10_setting = Digits10;
 
+   // We need at least 16-bits in the exponent type to do anything sensible:
+   BOOST_STATIC_ASSERT_MSG(sizeof(ExponentType) > 1, "ExponentType is too small.");
+   BOOST_STATIC_ASSERT_MSG(boost::is_signed<ExponentType>::value, "ExponentType must be a signed built in integer type.");
+
 public:
    typedef mpl::list<long long>           signed_types;
    typedef mpl::list<unsigned long long>  unsigned_types;
@@ -808,7 +812,7 @@
    bool overflow = exp >= cpp_dec_float_max_exp10;
    if(exp == cpp_dec_float_max_exp10)
    {
-      // Check to see if we really truely have an overflow or not...
+      // Check to see if we really truly have an overflow or not...
       if(isneg())
       {
          cpp_dec_float t(*this);

Modified: branches/release/boost/multiprecision/cpp_int/add.hpp
==============================================================================
--- branches/release/boost/multiprecision/cpp_int/add.hpp	(original)
+++ branches/release/boost/multiprecision/cpp_int/add.hpp	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -79,7 +79,7 @@
 template <class CppInt1, class CppInt2>
 inline void add_unsigned(CppInt1& result, const CppInt2& a, const limb_type& o) BOOST_NOEXCEPT_IF(is_non_throwing_cpp_int<CppInt1>::value)
 {
-   // Addition using modular arithmatic.
+   // Addition using modular arithmetic.
    // Nothing fancy, just let uintmax_t take the strain:
    if(&result != &a)
       result.resize(a.size(), a.size());

Modified: branches/release/boost/multiprecision/cpp_int/bitwise.hpp
==============================================================================
--- branches/release/boost/multiprecision/cpp_int/bitwise.hpp	(original)
+++ branches/release/boost/multiprecision/cpp_int/bitwise.hpp	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -351,7 +351,7 @@
 }
 
 //
-// Over agin for trivial cpp_int's:
+// Over again for trivial cpp_int's:
 //
 template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, class T>
 BOOST_MP_FORCEINLINE typename enable_if<is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> > >::type

Modified: branches/release/boost/multiprecision/cpp_int/checked.hpp
==============================================================================
--- branches/release/boost/multiprecision/cpp_int/checked.hpp	(original)
+++ branches/release/boost/multiprecision/cpp_int/checked.hpp	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -10,7 +10,7 @@
 
 //
 // Simple routines for performing checked arithmetic with a builtin arithmetic type.
-// Note that is is not a complete header, it must be included as part of boost/multiprecision/cpp_int.hpp.
+// Note that this is not a complete header, it must be included as part of boost/multiprecision/cpp_int.hpp.
 //
 
 inline void raise_overflow(std::string op)

Modified: branches/release/boost/multiprecision/cpp_int/cpp_int_config.hpp
==============================================================================
--- branches/release/boost/multiprecision/cpp_int/cpp_int_config.hpp	(original)
+++ branches/release/boost/multiprecision/cpp_int/cpp_int_config.hpp	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -19,7 +19,7 @@
 
 //
 // These traits calculate the largest type in the list
-// [unsigned] ong long, long, int, which has the specified number
+// [unsigned] long long, long, int, which has the specified number
 // of bits.  Note that intN_t and boost::int_t<N> find the first
 // member of the above list, not the last.  We want the last in the 
 // list to ensure that mixed arithmetic operations are as efficient 
@@ -61,7 +61,7 @@
    >::type type;
 };
 
-} // namepsace detail
+} // namespace detail
 
 #if defined(BOOST_HAS_INT128)
 

Modified: branches/release/boost/multiprecision/cpp_int/misc.hpp
==============================================================================
--- branches/release/boost/multiprecision/cpp_int/misc.hpp	(original)
+++ branches/release/boost/multiprecision/cpp_int/misc.hpp	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -107,6 +107,64 @@
    result.sign(false);
 }
 
+template <class Unsigned, class Tag>
+inline unsigned find_lsb(Unsigned mask, const Tag&)
+{
+   unsigned result = 0;
+   while(!(mask & 1u))
+   {
+      mask >>= 1;
+      ++result;
+   }
+   return result;
+}
+
+#if defined(BOOST_MSVC) && (defined(_M_IX86) || defined(_M_X64))
+BOOST_FORCEINLINE unsigned find_lsb(limb_type mask, const mpl::int_<32>&)
+{
+   unsigned long result;
+   _BitScanForward(&result, mask);
+   return result;
+}
+#ifdef _M_X64
+BOOST_FORCEINLINE unsigned find_lsb(limb_type mask, const mpl::int_<64>&)
+{
+   unsigned long result;
+   _BitScanForward64(&result, mask);
+   return result;
+}
+#endif
+#endif
+
+#if defined(__GNUC__)
+BOOST_FORCEINLINE unsigned find_lsb_imp(limb_type mask, mpl::true_ const&)
+{
+   return __builtin_ctz(mask);
+}
+BOOST_FORCEINLINE unsigned find_lsb_imp(limb_type mask, mpl::false_ const&)
+{
+   return __builtin_ctzll(mask);
+}
+template <class Tag>
+BOOST_FORCEINLINE unsigned find_lsb(limb_type mask, const Tag&)
+{
+   return find_lsb_imp(mask, mpl::bool_<Tag::value <= static_cast<int>(sizeof(unsigned int) * CHAR_BIT)>());
+}
+#elif defined(BOOST_INTEL)
+BOOST_FORCEINLINE unsigned find_lsb_imp(limb_type mask, mpl::true_ const&)
+{
+   return _bit_scan_forward(mask);
+}
+BOOST_FORCEINLINE unsigned find_lsb_imp(limb_type mask, mpl::false_ const&)
+{
+   return find_lsb<limb_type, mpl::int_<0> >(mask, mpl::int_<0>());
+}
+template <class Tag>
+BOOST_FORCEINLINE unsigned find_lsb(limb_type mask, const Tag&)
+{
+   return find_lsb_imp(mask, mpl::bool_<Tag::value <= sizeof(int) * CHAR_BIT>());
+}
+#endif
 //
 // Get the location of the least-significant-bit:
 //
@@ -124,7 +182,6 @@
       BOOST_THROW_EXCEPTION(std::range_error("Testing individual bits in negative values is not supported - results are undefined."));
    }
 
-   unsigned result = 0;
    //
    // Find the index of the least significant limb that is non-zero:
    //
@@ -134,12 +191,7 @@
    //
    // Find the index of the least significant bit within that limb:
    //
-   limb_type l = a.limbs()[index];
-   while(!(l & 1u))
-   {
-      l >>= 1;
-      ++result;
-   }
+   unsigned result = find_lsb(a.limbs()[index], mpl::int_<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits>());
 
    return result + index * cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits;
 }
@@ -246,6 +298,208 @@
    return eval_integer_modulus(x, static_cast<unsigned_type>(abs(val)));
 }
 
+inline limb_type integer_gcd_reduce(limb_type u, limb_type v)
+{
+   do
+   {
+      if(u > v)
+         std::swap(u, v);
+      if(u == v)
+         break;
+      v -= u;
+      v >>= find_lsb(v, mpl::int_<CHAR_BIT * sizeof(limb_type)>());
+   } while(true);
+   return u;
+}
+
+inline double_limb_type integer_gcd_reduce(double_limb_type u, double_limb_type v)
+{
+   do
+   {
+      if(u > v)
+         std::swap(u, v);
+      if(u == v)
+         break;
+      if(v <= ~static_cast<limb_type>(0))
+      {
+         u = integer_gcd_reduce(static_cast<limb_type>(v), static_cast<limb_type>(u));
+         break;
+      }
+      v -= u;
+      while((static_cast<unsigned>(v) & 1u) == 0)
+         v >>= 1;
+   } while(true);
+   return u;
+}
+
+template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
+inline typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
+   eval_gcd(
+      cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result, 
+      const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a, 
+      limb_type v)
+{
+   using default_ops::eval_lsb;
+   using default_ops::eval_is_zero;
+   using default_ops::eval_get_sign;
+
+   int shift;
+
+   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> u(a);
+
+   int s = eval_get_sign(u);
+
+   /* GCD(0,x) := x */
+   if(s < 0)
+   {
+      u.negate();
+   }
+   else if(s == 0)
+   {
+      result = v;
+      return;
+   }
+   if(v == 0)
+   {
+      result = u;
+      return;
+   }
+
+   /* Let shift := lg K, where K is the greatest power of 2
+   dividing both u and v. */
+
+   unsigned us = eval_lsb(u);
+   unsigned vs = find_lsb(v, mpl::int_<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits>());
+   shift = (std::min)(us, vs);
+   eval_right_shift(u, us);
+   if(vs)
+      v >>= vs;
+
+   do 
+   {
+      /* Now u and v are both odd, so diff(u, v) is even.
+      Let u = min(u, v), v = diff(u, v)/2. */
+      if(u.size() == 1)
+      {
+         v = integer_gcd_reduce(*u.limbs(), v);
+         break;
+      }
+      eval_subtract(u, v);
+      us = eval_lsb(u);
+      eval_right_shift(u, us);
+   } 
+   while(true);
+
+   result = v;
+   eval_left_shift(result, shift);
+}
+template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, class Integer>
+inline typename enable_if_c<is_unsigned<Integer>::value && (sizeof(Integer) <= sizeof(limb_type)) && !is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
+   eval_gcd(
+      cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result, 
+      const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a, 
+      const Integer& v)
+{
+   eval_gcd(result, a, static_cast<limb_type>(v));
+}
+template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, class Integer>
+inline typename enable_if_c<is_signed<Integer>::value && (sizeof(Integer) <= sizeof(limb_type)) && !is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
+   eval_gcd(
+      cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result, 
+      const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a, 
+      const Integer& v)
+{
+   eval_gcd(result, a, static_cast<limb_type>(v < 0 ? -v : v));
+}
+
+template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
+inline typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type
+   eval_gcd(
+      cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result, 
+      const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a, 
+      const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& b)
+{
+   using default_ops::eval_lsb;
+   using default_ops::eval_is_zero;
+   using default_ops::eval_get_sign;
+
+   if(a.size() == 1)
+   {
+      eval_gcd(result, b, *a.limbs());
+      return;
+   }
+   if(b.size() == 1)
+   {
+      eval_gcd(result, a, *b.limbs());
+   }
+
+   int shift;
+
+   cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> u(a), v(b);
+
+   int s = eval_get_sign(u);
+
+   /* GCD(0,x) := x */
+   if(s < 0)
+   {
+      u.negate();
+   }
+   else if(s == 0)
+   {
+      result = v;
+      return;
+   }
+   s = eval_get_sign(v);
+   if(s < 0)
+   {
+      v.negate();
+   }
+   else if(s == 0)
+   {
+      result = u;
+      return;
+   }
+
+   /* Let shift := lg K, where K is the greatest power of 2
+   dividing both u and v. */
+
+   unsigned us = eval_lsb(u);
+   unsigned vs = eval_lsb(v);
+   shift = (std::min)(us, vs);
+   eval_right_shift(u, us);
+   eval_right_shift(v, vs);
+
+   do 
+   {
+      /* Now u and v are both odd, so diff(u, v) is even.
+      Let u = min(u, v), v = diff(u, v)/2. */
+      s = u.compare(v);
+      if(s > 0)
+         u.swap(v);
+      if(s == 0)
+         break;
+      if(v.size() <= 2)
+      {
+         if(v.size() == 1)
+            u = integer_gcd_reduce(*v.limbs(), *u.limbs());
+         else
+         {
+            double_limb_type i, j;
+            i = v.limbs()[0] | (static_cast<double_limb_type>(v.limbs()[1]) << sizeof(limb_type) * CHAR_BIT);
+            j = (u.size() == 1) ? *u.limbs() : u.limbs()[0] | (static_cast<double_limb_type>(u.limbs()[1]) << sizeof(limb_type) * CHAR_BIT);
+            u = integer_gcd_reduce(i, j);
+         }
+         break;
+      }
+      eval_subtract(v, u);
+      vs = eval_lsb(v);
+      eval_right_shift(v, vs);
+   } 
+   while(true);
+
+   result = u;
+   eval_left_shift(result, shift);
+}
 //
 // Now again for trivial backends:
 //
@@ -309,6 +563,25 @@
       *result = static_cast<R>(*val.limbs());
 }
 
+template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>
+inline typename enable_if_c<is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value, unsigned>::type
+   eval_lsb(const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a)
+{
+   using default_ops::eval_get_sign;
+   if(eval_get_sign(a) == 0)
+   {
+      BOOST_THROW_EXCEPTION(std::range_error("No bits were set in the operand."));
+   }
+   if(a.sign())
+   {
+      BOOST_THROW_EXCEPTION(std::range_error("Testing individual bits in negative values is not supported - results are undefined."));
+   }
+   //
+   // Find the index of the least significant bit within that limb:
+   //
+   return find_lsb(*a.limbs(), mpl::int_<CHAR_BIT * sizeof(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::local_limb_type)>());
+}
+
 #ifdef BOOST_MSVC
 #pragma warning(pop)
 #endif

Modified: branches/release/boost/multiprecision/detail/default_ops.hpp
==============================================================================
--- branches/release/boost/multiprecision/detail/default_ops.hpp	(original)
+++ branches/release/boost/multiprecision/detail/default_ops.hpp	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -862,7 +862,7 @@
 inline void eval_convert_to(terminal<R>* result, const B& backend)
 {
    //
-   // We ran out of types to try for the convertion, try
+   // We ran out of types to try for the conversion, try
    // a lexical_cast and hope for the best:
    //
    result->value = boost::lexical_cast<R>(backend.str(0, std::ios_base::fmtflags(0)));

Modified: branches/release/boost/multiprecision/detail/functions/pow.hpp
==============================================================================
--- branches/release/boost/multiprecision/detail/functions/pow.hpp	(original)
+++ branches/release/boost/multiprecision/detail/functions/pow.hpp	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -104,8 +104,11 @@
 
    ui_type n;
 
+   static const unsigned series_limit = 
+      boost::multiprecision::detail::digits2<number<T, et_on> >::value < 100
+      ? 100 : boost::multiprecision::detail::digits2<number<T, et_on> >::value;
    // Series expansion of hyperg_0f0(; ; x).
-   for(n = 2; n < 300; ++n)
+   for(n = 2; n < series_limit; ++n)
    {
       eval_multiply(x_pow_n_div_n_fact, x);
       eval_divide(x_pow_n_div_n_fact, n);
@@ -118,7 +121,7 @@
       if(neg)
          x_pow_n_div_n_fact.negate();
    }
-   if(n >= 300)
+   if(n >= series_limit)
       BOOST_THROW_EXCEPTION(std::runtime_error("H0F0 failed to converge"));
 }
 
@@ -153,8 +156,11 @@
    si_type n;
    T term, part;
 
+   static const unsigned series_limit = 
+      boost::multiprecision::detail::digits2<number<T, et_on> >::value < 100
+      ? 100 : boost::multiprecision::detail::digits2<number<T, et_on> >::value;
    // Series expansion of hyperg_1f0(a; ; x).
-   for(n = 2; n < boost::multiprecision::detail::digits2<number<T, et_on> >::value + 10; n++)
+   for(n = 2; n < series_limit; n++)
    {
       eval_multiply(x_pow_n_div_n_fact, x);
       eval_divide(x_pow_n_div_n_fact, n);
@@ -167,7 +173,7 @@
       if(lim.compare(term) >= 0)
          break;
    }
-   if(n >= boost::multiprecision::detail::digits2<number<T, et_on> >::value + 10)
+   if(n >= series_limit)
       BOOST_THROW_EXCEPTION(std::runtime_error("H1F0 failed to converge"));
 }
 
@@ -529,7 +535,7 @@
 template<class T, class A> 
 inline typename enable_if<is_floating_point<A>, void>::type eval_pow(T& result, const T& x, const A& a)
 {
-   // Note this one is resticted to float arguments since pow.hpp already has a version for
+   // Note this one is restricted to float arguments since pow.hpp already has a version for
    // integer powers....
    typedef typename boost::multiprecision::detail::canonical<A, T>::type canonical_type;
    typedef typename mpl::if_<is_same<A, canonical_type>, T, canonical_type>::type cast_type;

Modified: branches/release/boost/multiprecision/detail/functions/trig.hpp
==============================================================================
--- branches/release/boost/multiprecision/detail/functions/trig.hpp	(original)
+++ branches/release/boost/multiprecision/detail/functions/trig.hpp	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -42,8 +42,11 @@
       tol.negate();
    T term;
 
+   static const unsigned series_limit = 
+      boost::multiprecision::detail::digits2<number<T, et_on> >::value < 100
+      ? 100 : boost::multiprecision::detail::digits2<number<T, et_on> >::value;
    // Series expansion of hyperg_0f1(; b; x).
-   for(n = 2; n < 300; ++n)
+   for(n = 2; n < series_limit; ++n)
    {
       eval_multiply(x_pow_n_div_n_fact, x);
       eval_divide(x_pow_n_div_n_fact, n);
@@ -60,7 +63,7 @@
          break;
    }
 
-   if(n >= 300)
+   if(n >= series_limit)
       BOOST_THROW_EXCEPTION(std::runtime_error("H0F1 Failed to Converge"));
 }
 
@@ -399,8 +402,11 @@
    ui_type n;
    T term;
 
+   static const unsigned series_limit = 
+      boost::multiprecision::detail::digits2<number<T, et_on> >::value < 100
+      ? 100 : boost::multiprecision::detail::digits2<number<T, et_on> >::value;
    // Series expansion of hyperg_2f1(a, b; c; x).
-   for(n = 2; n < 300; ++n)
+   for(n = 2; n < series_limit; ++n)
    {
       eval_multiply(x_pow_n_div_n_fact, x);
       eval_divide(x_pow_n_div_n_fact, n);
@@ -422,7 +428,7 @@
       if(lim.compare(term) >= 0)
          break;
    }
-   if(n > 300)
+   if(n > series_limit)
       BOOST_THROW_EXCEPTION(std::runtime_error("H2F1 failed to converge."));
 }
 

Modified: branches/release/boost/multiprecision/detail/generic_interconvert.hpp
==============================================================================
--- branches/release/boost/multiprecision/detail/generic_interconvert.hpp	(original)
+++ branches/release/boost/multiprecision/detail/generic_interconvert.hpp	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -114,7 +114,7 @@
 #endif
    //
    // The code here only works when the radix of "From" is 2, we could try shifting by other
-   // radixes but it would complicate things.... use a string convertion when the radix is other
+   // radixes but it would complicate things.... use a string conversion when the radix is other
    // than 2:
    //
    if(std::numeric_limits<number<From> >::radix != 2)

Modified: branches/release/boost/multiprecision/number.hpp
==============================================================================
--- branches/release/boost/multiprecision/number.hpp	(original)
+++ branches/release/boost/multiprecision/number.hpp	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -355,7 +355,7 @@
    // even if the result of the operator *is never used*.
    // Possibly we could modify our expression wrapper to
    // execute the increment/decrement on destruction, but
-   // correct implemetation will be tricky, so defered for now...
+   // correct implementation will be tricky, so defered for now...
    //
    BOOST_MP_FORCEINLINE number& operator++()
    {
@@ -1687,7 +1687,7 @@
    a.swap(b);
 }
 
-}  // namespace multipreciion
+}  // namespace multiprecision
 
 template <class T>
 class rational;

Modified: branches/release/boost/multiprecision/random.hpp
==============================================================================
--- branches/release/boost/multiprecision/random.hpp	(original)
+++ branches/release/boost/multiprecision/random.hpp	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -523,7 +523,7 @@
                 static_cast<range_type>(range/mult),
                 boost::mpl::true_());
         if(std::numeric_limits<range_type>::is_bounded && ((std::numeric_limits<range_type>::max)() / mult < result_increment)) {
-          // The multiplcation would overflow.  Reject immediately.
+          // The multiplication would overflow.  Reject immediately.
           continue;
         }
         result_increment *= mult;

Modified: branches/release/doc/pdf/build
==============================================================================
--- branches/release/doc/pdf/build	(original)
+++ branches/release/doc/pdf/build	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -8,7 +8,7 @@
 (cd ../../libs/geometry/doc/src/docutils/tools/doxygen_xml2qbk && bjam release) 2>&1 | tee -a build.log
 (cd ../../libs/functional/overloaded_function/doc && rm -rf *.pdf && bjam -a pdfinstall && cp *.pdf ../../../../doc/pdf) 2>&1 | tee -a build.log
 (cd ../../libs/local_function/doc && rm -rf *.pdf && bjam -a pdfinstall && cp *.pdf ../../../doc/pdf) 2>&1 | tee -a build.log
-(cd ../../libs/utility/identity_type/doc && rm -rf *.pdf && bjam -a pdfinstall && cp *.pdf ../../../../doc/pdf) 2>&1 | tee -a build.log
+(cd ../../libs/utility/identity_type/doc && rm -rf *.pdf && bjam -a pdf_doc_install && cp *.pdf ../../../../doc/pdf) 2>&1 | tee -a build.log
 cp ../../dist/bin/doxygen_xml2qbk* /usr/local/bin
 (cd ../../libs/geometry/doc && rm -rf *.pdf && ./make_qbk.py && bjam pdfinstall -a xsl:param=fop1.extensions=1 xsl:param=xep.extensions=0 && cp *.pdf ../../../doc/pdf) 2>&1 | tee -a build.log
 bjam -a --enable-index pdf -d2 xsl:param=fop1.extensions=0 xsl:param=xep.extensions=1 2>&1 | tee -a build.log
@@ -18,3 +18,4 @@
 
 
 
+

Modified: branches/release/libs/multiprecision/config/Jamfile.v2
==============================================================================
--- branches/release/libs/multiprecision/config/Jamfile.v2	(original)
+++ branches/release/libs/multiprecision/config/Jamfile.v2	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -24,6 +24,8 @@
    # We set these to make it easier to set up and test GMP and MPFR under Win32:
    <toolset>msvc:<runtime-link>static
    <toolset>msvc:<link>static
+   <toolset>intel-win:<runtime-link>static
+   <toolset>intel-win:<link>static
    <toolset>msvc:<warnings>all
    <toolset>gcc:<cxxflags>-Wall
    <toolset>gcc:<cxxflags>-Wextra

Modified: branches/release/libs/multiprecision/doc/html/boost_multiprecision/indexes/s01.html
==============================================================================
--- branches/release/libs/multiprecision/doc/html/boost_multiprecision/indexes/s01.html	(original)
+++ branches/release/libs/multiprecision/doc/html/boost_multiprecision/indexes/s01.html	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -22,9 +22,9 @@
 <div class="spirit-nav">
 <a accesskey="p" href="../indexes.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../indexes.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="s02.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section id965458">
+<div class="section id1011701">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="id965458"></a>Function Index</h3></div></div></div>
+<a name="id1011701"></a>Function Index</h3></div></div></div>
 <p><a class="link" href="s01.html#idx_id_0">A</a> <a class="link" href="s01.html#idx_id_1">B</a> <a class="link" href="s01.html#idx_id_2">C</a> <a class="link" href="s01.html#idx_id_3">D</a> <a class="link" href="s01.html#idx_id_4">E</a> <a class="link" href="s01.html#idx_id_5">F</a> <a class="link" href="s01.html#idx_id_7">I</a> <a class="link" href="s01.html#idx_id_8">L</a> <a class="link" href="s01.html#idx_id_9">M</a> <a class="link" href="s01.html#idx_id_12">P</a> <a class="link" href="s01.html#idx_id_13">R</a> <a class="link" href="s01.html#idx_id_14">S</a> <a class="link" href="s01.html#idx_id_15">T</a> <a class="link" href="s01.html#idx_id_17">Z</a></p>
 <div class="variablelist"><dl class="variablelist">
 <dt>

Modified: branches/release/libs/multiprecision/doc/html/boost_multiprecision/indexes/s02.html
==============================================================================
--- branches/release/libs/multiprecision/doc/html/boost_multiprecision/indexes/s02.html	(original)
+++ branches/release/libs/multiprecision/doc/html/boost_multiprecision/indexes/s02.html	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -22,9 +22,9 @@
 <div class="spirit-nav">
 <a accesskey="p" href="s01.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../indexes.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="s03.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section id971044">
+<div class="section id1017270">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="id971044"></a>Class Index</h3></div></div></div>
+<a name="id1017270"></a>Class Index</h3></div></div></div>
 <p><a class="link" href="s02.html#idx_id_20">C</a> <a class="link" href="s02.html#idx_id_22">E</a> <a class="link" href="s02.html#idx_id_24">G</a> <a class="link" href="s02.html#idx_id_25">I</a> <a class="link" href="s02.html#idx_id_27">M</a> <a class="link" href="s02.html#idx_id_28">N</a> <a class="link" href="s02.html#idx_id_33">T</a></p>
 <div class="variablelist"><dl class="variablelist">
 <dt>

Modified: branches/release/libs/multiprecision/doc/html/boost_multiprecision/indexes/s03.html
==============================================================================
--- branches/release/libs/multiprecision/doc/html/boost_multiprecision/indexes/s03.html	(original)
+++ branches/release/libs/multiprecision/doc/html/boost_multiprecision/indexes/s03.html	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -22,9 +22,9 @@
 <div class="spirit-nav">
 <a accesskey="p" href="s02.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../indexes.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="s04.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section id971462">
+<div class="section id1017687">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="id971462"></a>Typedef Index</h3></div></div></div>
+<a name="id1017687"></a>Typedef Index</h3></div></div></div>
 <p><a class="link" href="s03.html#idx_id_38">C</a> <a class="link" href="s03.html#idx_id_43">I</a> <a class="link" href="s03.html#idx_id_44">L</a> <a class="link" href="s03.html#idx_id_45">M</a> <a class="link" href="s03.html#idx_id_50">S</a> <a class="link" href="s03.html#idx_id_51">T</a> <a class="link" href="s03.html#idx_id_52">U</a></p>
 <div class="variablelist"><dl class="variablelist">
 <dt>

Modified: branches/release/libs/multiprecision/doc/html/boost_multiprecision/indexes/s04.html
==============================================================================
--- branches/release/libs/multiprecision/doc/html/boost_multiprecision/indexes/s04.html	(original)
+++ branches/release/libs/multiprecision/doc/html/boost_multiprecision/indexes/s04.html	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -21,9 +21,9 @@
 <div class="spirit-nav">
 <a accesskey="p" href="s03.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../indexes.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a>
 </div>
-<div class="section id973008">
+<div class="section id1018687">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="id973008"></a>Index</h3></div></div></div>
+<a name="id1018687"></a>Index</h3></div></div></div>
 <p><a class="link" href="s04.html#idx_id_54">A</a> <a class="link" href="s04.html#idx_id_55">B</a> <a class="link" href="s04.html#idx_id_56">C</a> <a class="link" href="s04.html#idx_id_57">D</a> <a class="link" href="s04.html#idx_id_58">E</a> <a class="link" href="s04.html#idx_id_59">F</a> <a class="link" href="s04.html#idx_id_60">G</a> <a class="link" href="s04.html#idx_id_61">I</a> <a class="link" href="s04.html#idx_id_62">L</a> <a class="link" href="s04.html#idx_id_63">M</a> <a class="link" href="s04.html#idx_id_64">N</a> <a class="link" href="s04.html#idx_id_65">O</a> <a class="link" href="s04.html#idx_id_66">P</a> <a class="link" href="s04.html#idx_id_67">R</a> <a class="link" href="s04.html#idx_id_68">S</a> <a class="link" href="s04.html#idx_id_69">T</a> <a class="link" href="s04.html#idx_id_70">U</a> <a class="link" href="s04.html#idx_id_71">Z</a></p>
 <div class="variablelist"><dl class="variablelist">
 <dt>

Modified: branches/release/libs/multiprecision/doc/html/boost_multiprecision/map/faq.html
==============================================================================
--- branches/release/libs/multiprecision/doc/html/boost_multiprecision/map/faq.html	(original)
+++ branches/release/libs/multiprecision/doc/html/boost_multiprecision/map/faq.html	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -98,7 +98,7 @@
             </p></dd>
 <dt><span class="term">Why not abstract out addition/multiplication algorithms?</span></dt>
 <dd><p>
-              This was deamed not to be practical: these algorithms are intimately
+              This was deemed not to be practical: these algorithms are intimately
               tied to the actual data representation used.
             </p></dd>
 </dl>

Modified: branches/release/libs/multiprecision/doc/html/boost_multiprecision/map/todo.html
==============================================================================
--- branches/release/libs/multiprecision/doc/html/boost_multiprecision/map/todo.html	(original)
+++ branches/release/libs/multiprecision/doc/html/boost_multiprecision/map/todo.html	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -47,12 +47,12 @@
             Add assembly level routines to cpp_int_backend.
           </li>
 <li class="listitem">
-            Add an all C++ Boost licenced binary floating point type.
+            Add an all C++ Boost licensed binary floating point type.
           </li>
 <li class="listitem">
             Can ring types (exact floating point types) be supported? The answer
             should be yes, but someone needs to write it, the hard part is IO and
-            binary-decimal convertion.
+            binary-decimal conversion.
           </li>
 <li class="listitem">
             Should there be a choice of rounding mode (probably MPFR specific)?
@@ -114,8 +114,8 @@
             scheduled for inclusion: it's deliberately an implementation detail,
             and "optional" requirements are optimisations which can't be
             detected by the user). Not done: this is an implementation detail, the
-            exact list of requirements satisfied is purely an optimimization, not
-            something the user can detect.
+            exact list of requirements satisfied is purely an optimization, not something
+            the user can detect.
           </li>
 <li class="listitem">
             A backend for an overflow aware integers (done 2012/10/31).
@@ -148,7 +148,7 @@
           </li>
 <li class="listitem">
             It is unfortunate that the generic mp_number front end can not make use
-            contexpr as not all the backends can ensure this (done - we can go quite
+            constexpr as not all the backends can ensure this (done - we can go quite
             a way).
           </li>
 <li class="listitem">
@@ -185,7 +185,7 @@
             to TODO list.
           </li>
 <li class="listitem">
-            Make the exponent type for cpp_dec_float a templare parameter, maybe
+            Make the exponent type for cpp_dec_float a template parameter, maybe
             include support for big-integer exponents. Open question - what should
             be the default - int32_t or int64_t? (done 2012/09/06)
           </li>

Modified: branches/release/libs/multiprecision/doc/html/boost_multiprecision/perf/integer_performance.html
==============================================================================
--- branches/release/libs/multiprecision/doc/html/boost_multiprecision/perf/integer_performance.html	(original)
+++ branches/release/libs/multiprecision/doc/html/boost_multiprecision/perf/integer_performance.html	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -82,22 +82,22 @@
               </td>
 <td>
                 <p>
-                  1.22306 (0.0279933s)
+                  1.23704 (0.0274266s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.15878 (0.038341s)
+                  1.09358 (0.0383278s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.24006 (0.0562258s)
+                  1.26645 (0.0558828s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.32055 (0.0925091s)
+                  1.32188 (0.0916899s)
                 </p>
               </td>
 </tr>
@@ -109,22 +109,22 @@
               </td>
 <td>
                 <p>
-                  1.56093 (0.0357264s)
+                  1.62044 (0.0359271s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.71757 (0.05683s)
+                  1.5277 (0.053543s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.66497 (0.0754916s)
+                  1.73059 (0.076363s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.70376 (0.119354s)
+                  1.71537 (0.118983s)
                 </p>
               </td>
 </tr>
@@ -136,22 +136,22 @@
               </td>
 <td>
                 <p>
-                  1.98788 (0.0454986s)
+                  1.87515 (0.0415741s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.37882 (0.0456216s)
+                  1.21699 (0.042653s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.14898 (0.0520959s)
+                  1.15599 (0.0510088s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0700532s)
+                  <span class="bold"><strong>1</strong></span> (0.0693631s)
                 </p>
               </td>
 </tr>
@@ -163,22 +163,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.022888s)
+                  <span class="bold"><strong>1</strong></span> (0.0221711s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0330875s)
+                  <span class="bold"><strong>1</strong></span> (0.035048s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0453411s)
+                  <span class="bold"><strong>1</strong></span> (0.0441255s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.07021 (0.074972s)
+                  1.04441 (0.0724435s)
                 </p>
               </td>
 </tr>
@@ -231,22 +231,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0162581s)
+                  <span class="bold"><strong>1</strong></span> (0.0155377s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0196602s)
+                  <span class="bold"><strong>1</strong></span> (0.0209523s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0305476s)
+                  <span class="bold"><strong>1</strong></span> (0.0306377s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0421105s)
+                  <span class="bold"><strong>1</strong></span> (0.043125s)
                 </p>
               </td>
 </tr>
@@ -258,22 +258,22 @@
               </td>
 <td>
                 <p>
-                  1.3852 (0.0225207s)
+                  1.31904 (0.0204948s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.84835 (0.036339s)
+                  1.76211 (0.0369203s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.6111 (0.0492153s)
+                  1.52941 (0.0468577s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.63014 (0.068646s)
+                  1.60412 (0.0691778s)
                 </p>
               </td>
 </tr>
@@ -285,22 +285,22 @@
               </td>
 <td>
                 <p>
-                  1.95525 (0.0317886s)
+                  1.96204 (0.0304855s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.2217 (0.0436791s)
+                  2.02569 (0.0424428s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.21508 (0.0676653s)
+                  2.11505 (0.0648002s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.58759 (0.108965s)
+                  2.65993 (0.114709s)
                 </p>
               </td>
 </tr>
@@ -312,22 +312,22 @@
               </td>
 <td>
                 <p>
-                  13.603 (0.221158s)
+                  14.0654 (0.218543s)
                 </p>
               </td>
 <td>
                 <p>
-                  11.5797 (0.227659s)
+                  10.8239 (0.226786s)
                 </p>
               </td>
 <td>
                 <p>
-                  7.86674 (0.24031s)
+                  7.76691 (0.23796s)
                 </p>
               </td>
 <td>
                 <p>
-                  6.36923 (0.268212s)
+                  6.10039 (0.263079s)
                 </p>
               </td>
 </tr>
@@ -380,22 +380,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0269712s)
+                  <span class="bold"><strong>1</strong></span> (0.026624s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0296213s)
+                  <span class="bold"><strong>1</strong></span> (0.0291407s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0380242s)
+                  <span class="bold"><strong>1</strong></span> (0.0373209s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.045841s)
+                  <span class="bold"><strong>1</strong></span> (0.0464919s)
                 </p>
               </td>
 </tr>
@@ -407,22 +407,22 @@
               </td>
 <td>
                 <p>
-                  1.38342 (0.0373126s)
+                  1.31378 (0.034978s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.51165 (0.0447769s)
+                  1.54897 (0.045138s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.54533 (0.05876s)
+                  1.53649 (0.0573431s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.3971 (0.0640443s)
+                  1.27833 (0.0594319s)
                 </p>
               </td>
 </tr>
@@ -434,22 +434,22 @@
               </td>
 <td>
                 <p>
-                  26.7163 (0.72057s)
+                  25.5775 (0.680974s)
                 </p>
               </td>
 <td>
                 <p>
-                  24.0631 (0.712781s)
+                  24.0117 (0.699717s)
                 </p>
               </td>
 <td>
                 <p>
-                  19.6009 (0.745307s)
+                  19.5633 (0.730121s)
                 </p>
               </td>
 <td>
                 <p>
-                  17.6547 (0.809308s)
+                  16.8939 (0.785432s)
                 </p>
               </td>
 </tr>
@@ -461,22 +461,22 @@
               </td>
 <td>
                 <p>
-                  19.7493 (0.532664s)
+                  19.4694 (0.518354s)
                 </p>
               </td>
 <td>
                 <p>
-                  18.2944 (0.541905s)
+                  18.4246 (0.536907s)
                 </p>
               </td>
 <td>
                 <p>
-                  14.9127 (0.567043s)
+                  14.7715 (0.551288s)
                 </p>
               </td>
 <td>
                 <p>
-                  12.9059 (0.591619s)
+                  12.3637 (0.574812s)
                 </p>
               </td>
 </tr>
@@ -529,22 +529,22 @@
               </td>
 <td>
                 <p>
-                  1.16166 (0.020334s)
+                  1.18405 (0.0196905s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.15312 (0.0204789s)
+                  1.22304 (0.0206476s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.21086 (0.0216179s)
+                  1.25861 (0.0217397s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.28088 (0.0229569s)
+                  1.29525 (0.0220829s)
                 </p>
               </td>
 </tr>
@@ -556,22 +556,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0175043s)
+                  <span class="bold"><strong>1</strong></span> (0.0166298s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0177595s)
+                  <span class="bold"><strong>1</strong></span> (0.0168822s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0178534s)
+                  <span class="bold"><strong>1</strong></span> (0.0172728s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0179228s)
+                  <span class="bold"><strong>1</strong></span> (0.0170492s)
                 </p>
               </td>
 </tr>
@@ -583,22 +583,22 @@
               </td>
 <td>
                 <p>
-                  39.0852 (0.684159s)
+                  39.9082 (0.663668s)
                 </p>
               </td>
 <td>
                 <p>
-                  38.7246 (0.68773s)
+                  39.4584 (0.666147s)
                 </p>
               </td>
 <td>
                 <p>
-                  38.2555 (0.68299s)
+                  38.5504 (0.665873s)
                 </p>
               </td>
 <td>
                 <p>
-                  37.6736 (0.675217s)
+                  39.2231 (0.668722s)
                 </p>
               </td>
 </tr>
@@ -610,22 +610,22 @@
               </td>
 <td>
                 <p>
-                  30.5872 (0.535408s)
+                  30.6219 (0.509238s)
                 </p>
               </td>
 <td>
                 <p>
-                  29.371 (0.521614s)
+                  30.4135 (0.513447s)
                 </p>
               </td>
 <td>
                 <p>
-                  30.3387 (0.541648s)
+                  30.9077 (0.533863s)
                 </p>
               </td>
 <td>
                 <p>
-                  31.8346 (0.570565s)
+                  32.3086 (0.550835s)
                 </p>
               </td>
 </tr>
@@ -678,22 +678,22 @@
               </td>
 <td>
                 <p>
-                  1.12975 (0.0308979s)
+                  1.06986 (0.0296064s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0392305s)
+                  <span class="bold"><strong>1</strong></span> (0.0381508s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.05392 (0.0543957s)
+                  1.05932 (0.053186s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.18166 (0.0860767s)
+                  1.1766 (0.0844721s)
                 </p>
               </td>
 </tr>
@@ -705,22 +705,22 @@
               </td>
 <td>
                 <p>
-                  1.36853 (0.0374283s)
+                  1.3304 (0.0368163s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.45987 (0.0572717s)
+                  1.44506 (0.0551303s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.44606 (0.0746349s)
+                  1.4431 (0.0724545s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.55935 (0.11359s)
+                  1.57255 (0.112898s)
                 </p>
               </td>
 </tr>
@@ -732,22 +732,22 @@
               </td>
 <td>
                 <p>
-                  1.53173 (0.0418917s)
+                  1.48072 (0.0409761s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.17956 (0.0462749s)
+                  1.19003 (0.0454007s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.13609 (0.0586365s)
+                  1.0794 (0.0541942s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0728442s)
+                  <span class="bold"><strong>1</strong></span> (0.0717934s)
                 </p>
               </td>
 </tr>
@@ -759,22 +759,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0273493s)
+                  <span class="bold"><strong>1</strong></span> (0.0276731s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.07293 (0.0420917s)
+                  1.10891 (0.0423057s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0516126s)
+                  <span class="bold"><strong>1</strong></span> (0.0502076s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.0985 (0.0800191s)
+                  1.08479 (0.0778811s)
                 </p>
               </td>
 </tr>
@@ -827,22 +827,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0146171s)
+                  <span class="bold"><strong>1</strong></span> (0.0147372s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0172176s)
+                  <span class="bold"><strong>1</strong></span> (0.0170001s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.023655s)
+                  <span class="bold"><strong>1</strong></span> (0.0232882s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0313105s)
+                  <span class="bold"><strong>1</strong></span> (0.0310734s)
                 </p>
               </td>
 </tr>
@@ -854,22 +854,22 @@
               </td>
 <td>
                 <p>
-                  1.49086 (0.021792s)
+                  1.4267 (0.0210256s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.94917 (0.03356s)
+                  1.98887 (0.0338109s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.89657 (0.0448632s)
+                  1.83788 (0.0428009s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.82658 (0.057191s)
+                  1.81269 (0.0563264s)
                 </p>
               </td>
 </tr>
@@ -881,22 +881,22 @@
               </td>
 <td>
                 <p>
-                  2.16301 (0.0316169s)
+                  2.07504 (0.0305803s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.55059 (0.0439151s)
+                  2.40928 (0.0409579s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.67983 (0.0633913s)
+                  2.58711 (0.0602493s)
                 </p>
               </td>
 <td>
                 <p>
-                  3.27949 (0.102682s)
+                  3.26438 (0.101435s)
                 </p>
               </td>
 </tr>
@@ -908,22 +908,22 @@
               </td>
 <td>
                 <p>
-                  14.0691 (0.20565s)
+                  13.5424 (0.199577s)
                 </p>
               </td>
 <td>
                 <p>
-                  12.527 (0.215684s)
+                  12.1793 (0.207048s)
                 </p>
               </td>
 <td>
                 <p>
-                  9.43355 (0.22315s)
+                  9.28855 (0.216314s)
                 </p>
               </td>
 <td>
                 <p>
-                  7.64671 (0.239422s)
+                  7.49327 (0.232842s)
                 </p>
               </td>
 </tr>
@@ -976,22 +976,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0265242s)
+                  <span class="bold"><strong>1</strong></span> (0.0277377s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0295275s)
+                  <span class="bold"><strong>1</strong></span> (0.0296807s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0377737s)
+                  <span class="bold"><strong>1</strong></span> (0.0372392s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0450106s)
+                  <span class="bold"><strong>1</strong></span> (0.0455855s)
                 </p>
               </td>
 </tr>
@@ -1003,22 +1003,22 @@
               </td>
 <td>
                 <p>
-                  1.2627 (0.033492s)
+                  1.19867 (0.0332484s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.47472 (0.0435449s)
+                  1.48639 (0.0441169s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.47468 (0.055704s)
+                  1.43253 (0.0533464s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.40667 (0.0633151s)
+                  1.27697 (0.0582111s)
                 </p>
               </td>
 </tr>
@@ -1030,22 +1030,22 @@
               </td>
 <td>
                 <p>
-                  26.0595 (0.691208s)
+                  24.1794 (0.670683s)
                 </p>
               </td>
 <td>
                 <p>
-                  23.3957 (0.690817s)
+                  22.9073 (0.679904s)
                 </p>
               </td>
 <td>
                 <p>
-                  18.9344 (0.715223s)
+                  18.8758 (0.702922s)
                 </p>
               </td>
 <td>
                 <p>
-                  16.9593 (0.763349s)
+                  16.5837 (0.755975s)
                 </p>
               </td>
 </tr>
@@ -1057,22 +1057,22 @@
               </td>
 <td>
                 <p>
-                  19.26 (0.510855s)
+                  18.149 (0.503413s)
                 </p>
               </td>
 <td>
                 <p>
-                  17.6236 (0.52038s)
+                  17.4116 (0.516787s)
                 </p>
               </td>
 <td>
                 <p>
-                  13.9134 (0.52556s)
+                  14.0411 (0.52288s)
                 </p>
               </td>
 <td>
                 <p>
-                  12.2359 (0.550746s)
+                  11.8237 (0.538987s)
                 </p>
               </td>
 </tr>
@@ -1125,22 +1125,22 @@
               </td>
 <td>
                 <p>
-                  1.28589 (0.0210146s)
+                  1.26896 (0.0203467s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.3505 (0.0222463s)
+                  1.25722 (0.0206147s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.34427 (0.0237863s)
+                  1.36108 (0.0225485s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.22787 (0.0230902s)
+                  1.18351 (0.0226161s)
                 </p>
               </td>
 </tr>
@@ -1152,22 +1152,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0163425s)
+                  <span class="bold"><strong>1</strong></span> (0.0160342s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0164727s)
+                  <span class="bold"><strong>1</strong></span> (0.0163971s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0176946s)
+                  <span class="bold"><strong>1</strong></span> (0.0165667s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0188051s)
+                  <span class="bold"><strong>1</strong></span> (0.0191094s)
                 </p>
               </td>
 </tr>
@@ -1179,22 +1179,22 @@
               </td>
 <td>
                 <p>
-                  41.0201 (0.670371s)
+                  41.1339 (0.659547s)
                 </p>
               </td>
 <td>
                 <p>
-                  41.4726 (0.683165s)
+                  40.3982 (0.662411s)
                 </p>
               </td>
 <td>
                 <p>
-                  37.9503 (0.671514s)
+                  39.925 (0.661425s)
                 </p>
               </td>
 <td>
                 <p>
-                  35.6021 (0.669502s)
+                  34.636 (0.661874s)
                 </p>
               </td>
 </tr>
@@ -1206,22 +1206,22 @@
               </td>
 <td>
                 <p>
-                  32.6952 (0.534322s)
+                  31.1543 (0.499533s)
                 </p>
               </td>
 <td>
                 <p>
-                  31.4882 (0.518695s)
+                  31.0303 (0.508806s)
                 </p>
               </td>
 <td>
                 <p>
-                  29.3988 (0.5202s)
+                  30.7699 (0.509756s)
                 </p>
               </td>
 <td>
                 <p>
-                  29.1175 (0.547558s)
+                  27.7054 (0.529434s)
                 </p>
               </td>
 </tr>
@@ -1274,22 +1274,22 @@
               </td>
 <td>
                 <p>
-                  1.13172 (0.0766099s)
+                  1.11839 (0.0757577s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.59509 (0.20993s)
+                  1.61061 (0.207951s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.40998 (0.70643s)
+                  1.4501 (0.696912s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.70758 (2.66895s)
+                  1.72796 (2.64108s)
                 </p>
               </td>
 </tr>
@@ -1301,22 +1301,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.067693s)
+                  1.01115 (0.0684934s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.27132 (0.167319s)
+                  1.28687 (0.166152s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.50102s)
+                  <span class="bold"><strong>1</strong></span> (0.480595s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (1.563s)
+                  <span class="bold"><strong>1</strong></span> (1.52844s)
                 </p>
               </td>
 </tr>
@@ -1328,22 +1328,22 @@
               </td>
 <td>
                 <p>
-                  1.01718 (0.0688559s)
+                  <span class="bold"><strong>1</strong></span> (0.0677384s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.13161s)
+                  <span class="bold"><strong>1</strong></span> (0.129113s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.13221 (0.567258s)
+                  1.09011 (0.523902s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.02292 (1.59883s)
+                  1.03374 (1.58s)
                 </p>
               </td>
 </tr>
@@ -1355,22 +1355,22 @@
               </td>
 <td>
                 <p>
-                  1.6793 (0.113677s)
+                  1.6322 (0.110562s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.66959 (0.351345s)
+                  2.71751 (0.350866s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.01091 (1.00751s)
+                  2.05222 (0.986288s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.05812 (3.21684s)
+                  2.0644 (3.15531s)
                 </p>
               </td>
 </tr>
@@ -1423,22 +1423,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0228822s)
+                  1.01611 (0.0229536s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.19988 (0.0332404s)
+                  1.12175 (0.0298152s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.13882 (0.0416226s)
+                  1.16413 (0.0416439s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.2711 (0.0665655s)
+                  1.31747 (0.0666043s)
                 </p>
               </td>
 </tr>
@@ -1450,22 +1450,22 @@
               </td>
 <td>
                 <p>
-                  1.33157 (0.0304692s)
+                  1.30215 (0.0294152s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.6546 (0.0458376s)
+                  1.669 (0.0443606s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.72684 (0.063114s)
+                  1.72395 (0.0616701s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.83178 (0.0959269s)
+                  1.88315 (0.095202s)
                 </p>
               </td>
 </tr>
@@ -1477,22 +1477,22 @@
               </td>
 <td>
                 <p>
-                  1.00858 (0.0230786s)
+                  <span class="bold"><strong>1</strong></span> (0.0225897s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0277032s)
+                  <span class="bold"><strong>1</strong></span> (0.0265791s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0365488s)
+                  <span class="bold"><strong>1</strong></span> (0.0357725s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0523682s)
+                  <span class="bold"><strong>1</strong></span> (0.0505547s)
                 </p>
               </td>
 </tr>
@@ -1504,22 +1504,22 @@
               </td>
 <td>
                 <p>
-                  10.8491 (0.248252s)
+                  10.8281 (0.244603s)
                 </p>
               </td>
 <td>
                 <p>
-                  9.88511 (0.273849s)
+                  10.1516 (0.26982s)
                 </p>
               </td>
 <td>
                 <p>
-                  8.95509 (0.327298s)
+                  8.76424 (0.313519s)
                 </p>
               </td>
 <td>
                 <p>
-                  8.04172 (0.421131s)
+                  8.04364 (0.406644s)
                 </p>
               </td>
 </tr>
@@ -1572,22 +1572,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0574926s)
+                  <span class="bold"><strong>1</strong></span> (0.0570721s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0876613s)
+                  <span class="bold"><strong>1</strong></span> (0.0856141s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.146194s)
+                  <span class="bold"><strong>1</strong></span> (0.143279s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.258556s)
+                  <span class="bold"><strong>1</strong></span> (0.252785s)
                 </p>
               </td>
 </tr>
@@ -1599,22 +1599,22 @@
               </td>
 <td>
                 <p>
-                  1.12247 (0.0645337s)
+                  1.10857 (0.0632686s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.24471 (0.109113s)
+                  1.2951 (0.110878s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.19748 (0.175065s)
+                  1.20827 (0.173121s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.17442 (0.303653s)
+                  1.18463 (0.299456s)
                 </p>
               </td>
 </tr>
@@ -1626,22 +1626,22 @@
               </td>
 <td>
                 <p>
-                  12.271 (0.705488s)
+                  12.0605 (0.68832s)
                 </p>
               </td>
 <td>
                 <p>
-                  8.23054 (0.7215s)
+                  8.13434 (0.696415s)
                 </p>
               </td>
 <td>
                 <p>
-                  5.28668 (0.772883s)
+                  5.21762 (0.747577s)
                 </p>
               </td>
 <td>
                 <p>
-                  3.09816 (0.801047s)
+                  3.11601 (0.787681s)
                 </p>
               </td>
 </tr>
@@ -1653,22 +1653,22 @@
               </td>
 <td>
                 <p>
-                  10.2751 (0.590743s)
+                  10.0524 (0.57371s)
                 </p>
               </td>
 <td>
                 <p>
-                  7.36707 (0.645807s)
+                  7.33116 (0.627651s)
                 </p>
               </td>
 <td>
                 <p>
-                  4.88979 (0.71486s)
+                  4.85202 (0.695193s)
                 </p>
               </td>
 <td>
                 <p>
-                  3.43724 (0.888719s)
+                  3.35808 (0.848871s)
                 </p>
               </td>
 </tr>
@@ -1721,22 +1721,22 @@
               </td>
 <td>
                 <p>
-                  114.922 (7.57662s)
+                  111.27 (7.43118s)
                 </p>
               </td>
 <td>
                 <p>
-                  70.5882 (7.61458s)
+                  67.7078 (7.34138s)
                 </p>
               </td>
 <td>
                 <p>
-                  44.3157 (7.67791s)
+                  43.3851 (7.4075s)
                 </p>
               </td>
 <td>
                 <p>
-                  26.2881 (7.81595s)
+                  25.3089 (7.55455s)
                 </p>
               </td>
 </tr>
@@ -1748,22 +1748,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0659286s)
+                  <span class="bold"><strong>1</strong></span> (0.0667848s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.107873s)
+                  <span class="bold"><strong>1</strong></span> (0.108427s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.173255s)
+                  <span class="bold"><strong>1</strong></span> (0.170738s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.297319s)
+                  <span class="bold"><strong>1</strong></span> (0.298493s)
                 </p>
               </td>
 </tr>
@@ -1775,22 +1775,22 @@
               </td>
 <td>
                 <p>
-                  47.9828 (3.16344s)
+                  46.3718 (3.09693s)
                 </p>
               </td>
 <td>
                 <p>
-                  29.4972 (3.18196s)
+                  28.4639 (3.08626s)
                 </p>
               </td>
 <td>
                 <p>
-                  18.1719 (3.14838s)
+                  18.1719 (3.10264s)
                 </p>
               </td>
 <td>
                 <p>
-                  10.6941 (3.17956s)
+                  10.5223 (3.14083s)
                 </p>
               </td>
 </tr>
@@ -1802,22 +1802,22 @@
               </td>
 <td>
                 <p>
-                  284.199 (18.7368s)
+                  276.674 (18.4776s)
                 </p>
               </td>
 <td>
                 <p>
-                  173.129 (18.676s)
+                  169.146 (18.34s)
                 </p>
               </td>
 <td>
                 <p>
-                  109.052 (18.8938s)
+                  108.491 (18.5236s)
                 </p>
               </td>
 <td>
                 <p>
-                  64.5866 (19.2028s)
+                  63.3261 (18.9024s)
                 </p>
               </td>
 </tr>
@@ -1870,22 +1870,22 @@
               </td>
 <td>
                 <p>
-                  2.71618 (0.616086s)
+                  2.68035 (0.595251s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.09988 (0.737246s)
+                  2.04702 (0.707471s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.65898 (0.94343s)
+                  1.62314 (0.921536s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.49441 (1.44418s)
+                  1.43112 (1.38811s)
                 </p>
               </td>
 </tr>
@@ -1897,22 +1897,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.226821s)
+                  <span class="bold"><strong>1</strong></span> (0.222079s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.35109s)
+                  <span class="bold"><strong>1</strong></span> (0.34561s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.56868s)
+                  <span class="bold"><strong>1</strong></span> (0.567748s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.966385s)
+                  <span class="bold"><strong>1</strong></span> (0.969945s)
                 </p>
               </td>
 </tr>
@@ -1924,22 +1924,22 @@
               </td>
 <td>
                 <p>
-                  3.82134 (0.866761s)
+                  3.79283 (0.842308s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.75998 (0.969001s)
+                  2.73668 (0.945824s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.93226 (1.09884s)
+                  1.86649 (1.05969s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.34132 (1.29623s)
+                  1.32141 (1.2817s)
                 </p>
               </td>
 </tr>
@@ -1951,22 +1951,22 @@
               </td>
 <td>
                 <p>
-                  13.2978 (3.01622s)
+                  13.2531 (2.94324s)
                 </p>
               </td>
 <td>
                 <p>
-                  11.3314 (3.97833s)
+                  11.2054 (3.87271s)
                 </p>
               </td>
 <td>
                 <p>
-                  9.94138 (5.65347s)
+                  9.83293 (5.58262s)
                 </p>
               </td>
 <td>
                 <p>
-                  13.3423 (12.8938s)
+                  13.0164 (12.6252s)
                 </p>
               </td>
 </tr>
@@ -2019,22 +2019,22 @@
               </td>
 <td>
                 <p>
-                  4.15094 (0.23911s)
+                  4.06026 (0.225473s)
                 </p>
               </td>
 <td>
                 <p>
-                  3.57962 (0.356615s)
+                  3.45732 (0.340049s)
                 </p>
               </td>
 <td>
                 <p>
-                  3.11624 (0.578256s)
+                  3.00195 (0.547957s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.82967 (1.00414s)
+                  2.80587 (0.978029s)
                 </p>
               </td>
 </tr>
@@ -2046,22 +2046,22 @@
               </td>
 <td>
                 <p>
-                  2.42806 (0.139865s)
+                  2.43766 (0.135367s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.54164 (0.253208s)
+                  2.56264 (0.252052s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.43025 (0.450962s)
+                  2.44011 (0.445402s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.37209 (0.841768s)
+                  2.38009 (0.829617s)
                 </p>
               </td>
 </tr>
@@ -2073,22 +2073,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0576038s)
+                  <span class="bold"><strong>1</strong></span> (0.0555316s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0996238s)
+                  <span class="bold"><strong>1</strong></span> (0.0983563s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.185562s)
+                  <span class="bold"><strong>1</strong></span> (0.182534s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.354863s)
+                  <span class="bold"><strong>1</strong></span> (0.348566s)
                 </p>
               </td>
 </tr>
@@ -2100,22 +2100,22 @@
               </td>
 <td>
                 <p>
-                  36.3133 (2.09179s)
+                  35.9988 (1.99907s)
                 </p>
               </td>
 <td>
                 <p>
-                  28.2731 (2.81668s)
+                  27.1024 (2.66569s)
                 </p>
               </td>
 <td>
                 <p>
-                  21.8589 (4.05618s)
+                  21.8333 (3.98531s)
                 </p>
               </td>
 <td>
                 <p>
-                  25.8061 (9.15762s)
+                  25.8066 (8.99528s)
                 </p>
               </td>
 </tr>
@@ -2168,22 +2168,22 @@
               </td>
 <td>
                 <p>
-                  1.53953 (0.716927s)
+                  1.50505 (0.705756s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.40156 (1.65075s)
+                  1.39347 (1.58556s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.59584 (3.57744s)
+                  2.63348 (3.57438s)
                 </p>
               </td>
 <td>
                 <p>
-                  4.58524 (8.3789s)
+                  4.75451 (8.52733s)
                 </p>
               </td>
 </tr>
@@ -2195,22 +2195,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.465679s)
+                  <span class="bold"><strong>1</strong></span> (0.468925s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.09556 (1.29034s)
+                  1.12378 (1.27869s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.2858 (3.15016s)
+                  2.29966 (3.12128s)
                 </p>
               </td>
 <td>
                 <p>
-                  4.40115 (8.0425s)
+                  4.4844 (8.04288s)
                 </p>
               </td>
 </tr>
@@ -2222,22 +2222,22 @@
               </td>
 <td>
                 <p>
-                  2.25405 (1.04967s)
+                  2.17234 (1.01866s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (1.17779s)
+                  <span class="bold"><strong>1</strong></span> (1.13785s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (1.37814s)
+                  <span class="bold"><strong>1</strong></span> (1.35728s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (1.82736s)
+                  <span class="bold"><strong>1</strong></span> (1.79352s)
                 </p>
               </td>
 </tr>
@@ -2249,22 +2249,22 @@
               </td>
 <td>
                 <p>
-                  5.03884 (2.34648s)
+                  4.74612 (2.22557s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.63459 (3.103s)
+                  2.70088 (3.07319s)
                 </p>
               </td>
 <td>
                 <p>
-                  3.67287 (5.06174s)
+                  3.65634 (4.96268s)
                 </p>
               </td>
 <td>
                 <p>
-                  6.77479 (12.38s)
+                  6.79408 (12.1853s)
                 </p>
               </td>
 </tr>
@@ -2317,22 +2317,22 @@
               </td>
 <td>
                 <p>
-                  1.78744 (0.0586752s)
+                  1.76281 (0.0574966s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.74065 (0.0616578s)
+                  1.76471 (0.0604224s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.66814 (0.0740436s)
+                  1.56085 (0.0716403s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.36231 (0.126362s)
+                  1.31422 (0.124043s)
                 </p>
               </td>
 </tr>
@@ -2344,22 +2344,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0328264s)
+                  <span class="bold"><strong>1</strong></span> (0.0326164s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0354222s)
+                  <span class="bold"><strong>1</strong></span> (0.0342393s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0443871s)
+                  <span class="bold"><strong>1</strong></span> (0.0458981s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0927553s)
+                  <span class="bold"><strong>1</strong></span> (0.0943852s)
                 </p>
               </td>
 </tr>
@@ -2371,22 +2371,22 @@
               </td>
 <td>
                 <p>
-                  21.2392 (0.697207s)
+                  20.2862 (0.661664s)
                 </p>
               </td>
 <td>
                 <p>
-                  19.3517 (0.68548s)
+                  19.4043 (0.664389s)
                 </p>
               </td>
 <td>
                 <p>
-                  15.2936 (0.678837s)
+                  14.4881 (0.664976s)
                 </p>
               </td>
 <td>
                 <p>
-                  7.37138 (0.683734s)
+                  7.14238 (0.674135s)
                 </p>
               </td>
 </tr>
@@ -2398,22 +2398,22 @@
               </td>
 <td>
                 <p>
-                  32.8142 (1.07717s)
+                  32.9555 (1.07489s)
                 </p>
               </td>
 <td>
                 <p>
-                  30.5556 (1.08235s)
+                  30.1525 (1.0324s)
                 </p>
               </td>
 <td>
                 <p>
-                  24.7236 (1.09741s)
+                  22.8324 (1.04796s)
                 </p>
               </td>
 <td>
                 <p>
-                  12.4072 (1.15084s)
+                  11.7456 (1.10861s)
                 </p>
               </td>
 </tr>
@@ -2466,22 +2466,22 @@
               </td>
 <td>
                 <p>
-                  1.86833 (0.37472s)
+                  1.8501 (0.364131s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.43076 (0.491332s)
+                  1.46527 (0.476653s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.30757 (0.708055s)
+                  1.27509 (0.689738s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.2528 (1.15842s)
+                  1.20064 (1.11769s)
                 </p>
               </td>
 </tr>
@@ -2493,22 +2493,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.200565s)
+                  <span class="bold"><strong>1</strong></span> (0.196817s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.343407s)
+                  <span class="bold"><strong>1</strong></span> (0.325301s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.541503s)
+                  <span class="bold"><strong>1</strong></span> (0.540932s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.924662s)
+                  <span class="bold"><strong>1</strong></span> (0.930916s)
                 </p>
               </td>
 </tr>
@@ -2520,22 +2520,22 @@
               </td>
 <td>
                 <p>
-                  3.22603 (0.647027s)
+                  3.2533 (0.640305s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.08249 (0.715143s)
+                  2.15441 (0.700832s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.5148 (0.82027s)
+                  1.47898 (0.800029s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.09519 (1.01268s)
+                  1.07439 (1.00016s)
                 </p>
               </td>
 </tr>
@@ -2547,22 +2547,22 @@
               </td>
 <td>
                 <p>
-                  15.4642 (3.10158s)
+                  15.3501 (3.02116s)
                 </p>
               </td>
 <td>
                 <p>
-                  11.5534 (3.9675s)
+                  12.1106 (3.9396s)
                 </p>
               </td>
 <td>
                 <p>
-                  10.5164 (5.69467s)
+                  11.0689 (5.98752s)
                 </p>
               </td>
 <td>
                 <p>
-                  13.8962 (12.8493s)
+                  13.5535 (12.6172s)
                 </p>
               </td>
 </tr>
@@ -2615,22 +2615,22 @@
               </td>
 <td>
                 <p>
-                  1.80079 (0.106617s)
+                  1.82761 (0.104331s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.96413 (0.207216s)
+                  2.01496 (0.202512s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.09096 (0.395682s)
+                  2.10004 (0.389523s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.14767 (0.776873s)
+                  2.17252 (0.768097s)
                 </p>
               </td>
 </tr>
@@ -2642,22 +2642,22 @@
               </td>
 <td>
                 <p>
-                  1.73532 (0.10274s)
+                  1.78851 (0.102099s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.92036 (0.202599s)
+                  1.96844 (0.197838s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.02172 (0.382579s)
+                  2.02956 (0.376451s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.07328 (0.749963s)
+                  2.07257 (0.73276s)
                 </p>
               </td>
 </tr>
@@ -2669,22 +2669,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0592053s)
+                  <span class="bold"><strong>1</strong></span> (0.057086s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.1055s)
+                  <span class="bold"><strong>1</strong></span> (0.100505s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.189234s)
+                  <span class="bold"><strong>1</strong></span> (0.185483s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.361727s)
+                  <span class="bold"><strong>1</strong></span> (0.353552s)
                 </p>
               </td>
 </tr>
@@ -2696,22 +2696,22 @@
               </td>
 <td>
                 <p>
-                  35.6993 (2.11359s)
+                  36.3018 (2.07233s)
                 </p>
               </td>
 <td>
                 <p>
-                  25.3086 (2.67007s)
+                  26.3075 (2.64402s)
                 </p>
               </td>
 <td>
                 <p>
-                  21.2701 (4.02504s)
+                  21.9525 (4.07183s)
                 </p>
               </td>
 <td>
                 <p>
-                  25.8662 (9.3565s)
+                  25.6759 (9.07775s)
                 </p>
               </td>
 </tr>
@@ -2764,22 +2764,22 @@
               </td>
 <td>
                 <p>
-                  1.17135 (0.00274853s)
+                  1.40211 (0.0026854s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.00275161s)
+                  <span class="bold"><strong>1</strong></span> (0.00278639s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.00275161s)
+                  <span class="bold"><strong>1</strong></span> (0.00322813s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.00344359s)
+                  <span class="bold"><strong>1</strong></span> (0.0027185s)
                 </p>
               </td>
 </tr>
@@ -2791,22 +2791,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.00234646s)
+                  <span class="bold"><strong>1</strong></span> (0.00191526s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.54518 (0.00425173s)
+                  1.40721 (0.00392103s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.2494 (0.00618947s)
+                  1.90346 (0.00614463s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.73247 (0.00596591s)
+                  2.14621 (0.00583447s)
                 </p>
               </td>
 </tr>
@@ -2818,22 +2818,22 @@
               </td>
 <td>
                 <p>
-                  85.6802 (0.201045s)
+                  98.705 (0.189046s)
                 </p>
               </td>
 <td>
                 <p>
-                  72.6635 (0.199941s)
+                  68.9726 (0.192184s)
                 </p>
               </td>
 <td>
                 <p>
-                  78.1286 (0.214979s)
+                  58.8994 (0.190135s)
                 </p>
               </td>
 <td>
                 <p>
-                  58.3553 (0.200952s)
+                  70.0525 (0.190438s)
                 </p>
               </td>
 </tr>
@@ -2845,22 +2845,22 @@
               </td>
 <td>
                 <p>
-                  87.9831 (0.206449s)
+                  105.602 (0.202255s)
                 </p>
               </td>
 <td>
                 <p>
-                  74.8522 (0.205964s)
+                  74.1994 (0.206748s)
                 </p>
               </td>
 <td>
                 <p>
-                  74.8918 (0.206073s)
+                  63.6455 (0.205456s)
                 </p>
               </td>
 <td>
                 <p>
-                  63.4572 (0.218521s)
+                  76.8935 (0.209035s)
                 </p>
               </td>
 </tr>
@@ -2913,22 +2913,22 @@
               </td>
 <td>
                 <p>
-                  1.43934 (0.00268554s)
+                  1.73436 (0.00348927s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.00286887s)
+                  <span class="bold"><strong>1</strong></span> (0.00263476s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.00283465s)
+                  <span class="bold"><strong>1</strong></span> (0.0027009s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.00290638s)
+                  <span class="bold"><strong>1</strong></span> (0.00318651s)
                 </p>
               </td>
 </tr>
@@ -2940,22 +2940,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.00186581s)
+                  <span class="bold"><strong>1</strong></span> (0.00201185s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.7597 (0.00504834s)
+                  1.36851 (0.0036057s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.07419 (0.00587959s)
+                  2.07362 (0.00560064s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.89871 (0.00551837s)
+                  1.66856 (0.00531688s)
                 </p>
               </td>
 </tr>
@@ -2967,22 +2967,22 @@
               </td>
 <td>
                 <p>
-                  125.861 (0.234832s)
+                  97.2414 (0.195635s)
                 </p>
               </td>
 <td>
                 <p>
-                  72.7068 (0.208586s)
+                  76.3759 (0.201232s)
                 </p>
               </td>
 <td>
                 <p>
-                  75.5147 (0.214058s)
+                  72.7396 (0.196462s)
                 </p>
               </td>
 <td>
                 <p>
-                  71.2679 (0.207131s)
+                  63.8129 (0.20334s)
                 </p>
               </td>
 </tr>
@@ -2994,22 +2994,22 @@
               </td>
 <td>
                 <p>
-                  240.568 (0.448854s)
+                  210.112 (0.422713s)
                 </p>
               </td>
 <td>
                 <p>
-                  155.552 (0.446257s)
+                  162.652 (0.42855s)
                 </p>
               </td>
 <td>
                 <p>
-                  157.598 (0.446734s)
+                  158.33 (0.427634s)
                 </p>
               </td>
 <td>
                 <p>
-                  160.728 (0.467137s)
+                  134.626 (0.428987s)
                 </p>
               </td>
 </tr>
@@ -3062,22 +3062,22 @@
               </td>
 <td>
                 <p>
-                  2.3528 (0.00771495s)
+                  2.34403 (0.00739542s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.61678 (0.00717424s)
+                  1.66376 (0.00713834s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.12087 (0.00715985s)
+                  1.22989 (0.0074969s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.2104 (0.0078878s)
+                  1.23708 (0.00711417s)
                 </p>
               </td>
 </tr>
@@ -3089,22 +3089,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.00327905s)
+                  <span class="bold"><strong>1</strong></span> (0.00315501s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.00443737s)
+                  <span class="bold"><strong>1</strong></span> (0.00429049s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.00638775s)
+                  <span class="bold"><strong>1</strong></span> (0.00609561s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.00651668s)
+                  <span class="bold"><strong>1</strong></span> (0.0057508s)
                 </p>
               </td>
 </tr>
@@ -3116,22 +3116,22 @@
               </td>
 <td>
                 <p>
-                  222.775 (0.730489s)
+                  222.866 (0.703144s)
                 </p>
               </td>
 <td>
                 <p>
-                  165.447 (0.734148s)
+                  164.331 (0.705059s)
                 </p>
               </td>
 <td>
                 <p>
-                  114.708 (0.732725s)
+                  115.363 (0.70321s)
                 </p>
               </td>
 <td>
                 <p>
-                  112.162 (0.730926s)
+                  122.347 (0.703596s)
                 </p>
               </td>
 </tr>
@@ -3143,22 +3143,22 @@
               </td>
 <td>
                 <p>
-                  215.962 (0.70815s)
+                  218.681 (0.689941s)
                 </p>
               </td>
 <td>
                 <p>
-                  157.945 (0.700858s)
+                  163.796 (0.702765s)
                 </p>
               </td>
 <td>
                 <p>
-                  109.582 (0.699985s)
+                  114.57 (0.698376s)
                 </p>
               </td>
 <td>
                 <p>
-                  111.909 (0.729275s)
+                  122.422 (0.704027s)
                 </p>
               </td>
 </tr>
@@ -3166,8 +3166,8 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_str"></a><p class="title"><b>Table&#160;1.51.&#160;Operator str</b></p>
-<div class="table-contents"><table class="table" summary="Operator str">
+<a name="boost_multiprecision.perf.integer_performance.operator_gcd"></a><p class="title"><b>Table&#160;1.51.&#160;Operator gcd</b></p>
+<div class="table-contents"><table class="table" summary="Operator gcd">
 <colgroup>
 <col>
 <col>
@@ -3211,22 +3211,22 @@
               </td>
 <td>
                 <p>
-                  1.46938 (0.00196575s)
+                  1.16358 (2.74442s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.37205 (0.00331355s)
+                  1.39847 (8.11559s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.5689 (0.00862952s)
+                  1.64677 (22.2518s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.57176 (0.0237239s)
+                  1.95096 (64.4961s)
                 </p>
               </td>
 </tr>
@@ -3238,22 +3238,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.00133781s)
+                  <span class="bold"><strong>1</strong></span> (2.35859s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.00241504s)
+                  1.30986 (7.60133s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.00550035s)
+                  1.67681 (22.6577s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.20619 (0.0182059s)
+                  2.0895 (69.0758s)
                 </p>
               </td>
 </tr>
@@ -3265,22 +3265,22 @@
               </td>
 <td>
                 <p>
-                  1.65482 (0.00221383s)
+                  1.03392 (2.4386s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.38972 (0.00335622s)
+                  <span class="bold"><strong>1</strong></span> (5.80319s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.13845 (0.0062619s)
+                  <span class="bold"><strong>1</strong></span> (13.5124s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0150938s)
+                  <span class="bold"><strong>1</strong></span> (33.0586s)
                 </p>
               </td>
 </tr>
@@ -3292,22 +3292,22 @@
               </td>
 <td>
                 <p>
-                  13.9845 (0.0187087s)
+                  5.25978 (12.4057s)
                 </p>
               </td>
 <td>
                 <p>
-                  18.3179 (0.0442384s)
+                  4.4619 (25.8932s)
                 </p>
               </td>
 <td>
                 <p>
-                  23.3489 (0.128427s)
+                  4.15577 (56.1542s)
                 </p>
               </td>
 <td>
                 <p>
-                  25.3273 (0.382285s)
+                  3.91192 (129.323s)
                 </p>
               </td>
 </tr>
@@ -3315,8 +3315,8 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_gcd"></a><p class="title"><b>Table&#160;1.52.&#160;Operator gcd</b></p>
-<div class="table-contents"><table class="table" summary="Operator gcd">
+<a name="boost_multiprecision.perf.integer_performance.operator_powm"></a><p class="title"><b>Table&#160;1.52.&#160;Operator powm</b></p>
+<div class="table-contents"><table class="table" summary="Operator powm">
 <colgroup>
 <col>
 <col>
@@ -3360,22 +3360,22 @@
               </td>
 <td>
                 <p>
-                  2.03241 (5.06795s)
+                  2.50722 (2.91621s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.89904 (11.3002s)
+                  3.5561 (13.406s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.99735 (27.4027s)
+                  4.37066 (73.483s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.20708 (73.7574s)
+                  4.88831 (473.91s)
                 </p>
               </td>
 </tr>
@@ -3387,22 +3387,22 @@
               </td>
 <td>
                 <p>
-                  1.67874 (4.18605s)
+                  1.93385 (2.24931s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.70044 (10.1184s)
+                  3.18107 (11.9922s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.96475 (26.9554s)
+                  4.20753 (70.7403s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.28347 (76.31s)
+                  4.8158 (466.88s)
                 </p>
               </td>
 </tr>
@@ -3414,22 +3414,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (2.49357s)
+                  <span class="bold"><strong>1</strong></span> (1.16313s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (5.95047s)
+                  <span class="bold"><strong>1</strong></span> (3.76986s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (13.7195s)
+                  <span class="bold"><strong>1</strong></span> (16.8128s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (33.4185s)
+                  <span class="bold"><strong>1</strong></span> (96.9476s)
                 </p>
               </td>
 </tr>
@@ -3441,22 +3441,22 @@
               </td>
 <td>
                 <p>
-                  5.01832 (12.5135s)
+                  1.44081 (1.67584s)
                 </p>
               </td>
 <td>
                 <p>
-                  4.41659 (26.2808s)
+                  1.8794 (7.08507s)
                 </p>
               </td>
 <td>
                 <p>
-                  4.08042 (55.9814s)
+                  2.19115 (36.8394s)
                 </p>
               </td>
 <td>
                 <p>
-                  3.97901 (132.972s)
+                  2.17186 (210.557s)
                 </p>
               </td>
 </tr>
@@ -3464,8 +3464,8 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator4"></a><p class="title"><b>Table&#160;1.53.&#160;Operator &amp;</b></p>
-<div class="table-contents"><table class="table" summary="Operator &amp;">
+<a name="boost_multiprecision.perf.integer_performance.operator_str"></a><p class="title"><b>Table&#160;1.53.&#160;Operator str</b></p>
+<div class="table-contents"><table class="table" summary="Operator str">
 <colgroup>
 <col>
 <col>
@@ -3509,22 +3509,22 @@
               </td>
 <td>
                 <p>
-                  1.00344 (0.0315529s)
+                  1.17175 (0.00160006s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0426295s)
+                  1.41999 (0.00329476s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0543214s)
+                  1.40856 (0.00813784s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.06624 (0.0835064s)
+                  1.52964 (0.0229767s)
                 </p>
               </td>
 </tr>
@@ -3536,22 +3536,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0314446s)
+                  <span class="bold"><strong>1</strong></span> (0.00136554s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.0808 (0.046074s)
+                  <span class="bold"><strong>1</strong></span> (0.00232027s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.06116 (0.0576436s)
+                  <span class="bold"><strong>1</strong></span> (0.00577741s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0783186s)
+                  1.14754 (0.0172372s)
                 </p>
               </td>
 </tr>
@@ -3563,22 +3563,22 @@
               </td>
 <td>
                 <p>
-                  1.78372 (0.0560885s)
+                  1.50501 (0.00205515s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.58661 (0.0676363s)
+                  1.52968 (0.00354926s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.5738 (0.0854908s)
+                  1.01989 (0.0058923s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.83409 (0.143644s)
+                  <span class="bold"><strong>1</strong></span> (0.015021s)
                 </p>
               </td>
 </tr>
@@ -3590,22 +3590,22 @@
               </td>
 <td>
                 <p>
-                  4.08054 (0.128311s)
+                  12.2161 (0.0166816s)
                 </p>
               </td>
 <td>
                 <p>
-                  3.50852 (0.149567s)
+                  16.9577 (0.0393463s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.88826 (0.156894s)
+                  18.7474 (0.108311s)
                 </p>
               </td>
 <td>
                 <p>
-                  4.45879 (0.349206s)
+                  22.7368 (0.341528s)
                 </p>
               </td>
 </tr>
@@ -3613,8 +3613,8 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_int4"></a><p class="title"><b>Table&#160;1.54.&#160;Operator &amp;(int)</b></p>
-<div class="table-contents"><table class="table" summary="Operator &amp;(int)">
+<a name="boost_multiprecision.perf.integer_performance.operator4"></a><p class="title"><b>Table&#160;1.54.&#160;Operator |</b></p>
+<div class="table-contents"><table class="table" summary="Operator |">
 <colgroup>
 <col>
 <col>
@@ -3658,22 +3658,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0367605s)
+                  <span class="bold"><strong>1</strong></span> (0.0301617s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0485394s)
+                  <span class="bold"><strong>1</strong></span> (0.0423404s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0650023s)
+                  <span class="bold"><strong>1</strong></span> (0.0522358s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.099751s)
+                  <span class="bold"><strong>1</strong></span> (0.0813156s)
                 </p>
               </td>
 </tr>
@@ -3685,22 +3685,22 @@
               </td>
 <td>
                 <p>
-                  1.00324 (0.0368795s)
+                  1.0638 (0.0320861s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.06734 (0.0518081s)
+                  1.22566 (0.0518951s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.05192 (0.0683771s)
+                  1.28515 (0.0671305s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.05296 (0.105034s)
+                  1.16118 (0.094422s)
                 </p>
               </td>
 </tr>
@@ -3712,22 +3712,22 @@
               </td>
 <td>
                 <p>
-                  4.00058 (0.147063s)
+                  1.76553 (0.0532514s)
                 </p>
               </td>
 <td>
                 <p>
-                  3.02928 (0.147039s)
+                  1.51489 (0.0641408s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.22221 (0.144449s)
+                  1.70708 (0.0891706s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.45749 (0.145386s)
+                  1.77346 (0.14421s)
                 </p>
               </td>
 </tr>
@@ -3739,22 +3739,22 @@
               </td>
 <td>
                 <p>
-                  8.83732 (0.324864s)
+                  4.37637 (0.131999s)
                 </p>
               </td>
 <td>
                 <p>
-                  6.95191 (0.337442s)
+                  3.46212 (0.146587s)
                 </p>
               </td>
 <td>
                 <p>
-                  5.42556 (0.352674s)
+                  2.91875 (0.152463s)
                 </p>
               </td>
 <td>
                 <p>
-                  6.10829 (0.609309s)
+                  4.19621 (0.341217s)
                 </p>
               </td>
 </tr>
@@ -3762,8 +3762,8 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator5"></a><p class="title"><b>Table&#160;1.55.&#160;Operator |</b></p>
-<div class="table-contents"><table class="table" summary="Operator |">
+<a name="boost_multiprecision.perf.integer_performance.operator_int4"></a><p class="title"><b>Table&#160;1.55.&#160;Operator |(int)</b></p>
+<div class="table-contents"><table class="table" summary="Operator |(int)">
 <colgroup>
 <col>
 <col>
@@ -3807,22 +3807,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0312723s)
+                  <span class="bold"><strong>1</strong></span> (0.0289129s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0428385s)
+                  <span class="bold"><strong>1</strong></span> (0.0351119s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0528083s)
+                  <span class="bold"><strong>1</strong></span> (0.0406779s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0827344s)
+                  <span class="bold"><strong>1</strong></span> (0.0525891s)
                 </p>
               </td>
 </tr>
@@ -3834,22 +3834,22 @@
               </td>
 <td>
                 <p>
-                  1.0311 (0.0322449s)
+                  1.06091 (0.030674s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.20267 (0.0515207s)
+                  1.25979 (0.0442336s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.27028 (0.0670814s)
+                  1.36194 (0.0554009s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.19432 (0.0988112s)
+                  1.37438 (0.0722772s)
                 </p>
               </td>
 </tr>
@@ -3861,22 +3861,22 @@
               </td>
 <td>
                 <p>
-                  1.55273 (0.0485576s)
+                  4.92854 (0.142498s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.4656 (0.0627839s)
+                  4.34687 (0.152627s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.66721 (0.0880424s)
+                  3.71442 (0.151095s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.67004 (0.13817s)
+                  2.981 (0.156768s)
                 </p>
               </td>
 </tr>
@@ -3888,22 +3888,22 @@
               </td>
 <td>
                 <p>
-                  4.15311 (0.129877s)
+                  10.9847 (0.317598s)
                 </p>
               </td>
 <td>
                 <p>
-                  3.39008 (0.145226s)
+                  9.37065 (0.329021s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.88739 (0.152478s)
+                  8.53651 (0.347248s)
                 </p>
               </td>
 <td>
                 <p>
-                  4.20575 (0.34796s)
+                  11.2155 (0.589813s)
                 </p>
               </td>
 </tr>
@@ -3911,8 +3911,8 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_int5"></a><p class="title"><b>Table&#160;1.56.&#160;Operator |(int)</b></p>
-<div class="table-contents"><table class="table" summary="Operator |(int)">
+<a name="boost_multiprecision.perf.integer_performance.operator5"></a><p class="title"><b>Table&#160;1.56.&#160;Operator ^</b></p>
+<div class="table-contents"><table class="table" summary="Operator ^">
 <colgroup>
 <col>
 <col>
@@ -3956,22 +3956,22 @@
               </td>
 <td>
                 <p>
-                  1.01685 (0.030066s)
+                  <span class="bold"><strong>1</strong></span> (0.0305149s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0360965s)
+                  <span class="bold"><strong>1</strong></span> (0.04217s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0402109s)
+                  <span class="bold"><strong>1</strong></span> (0.0525977s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0527074s)
+                  <span class="bold"><strong>1</strong></span> (0.0816632s)
                 </p>
               </td>
 </tr>
@@ -3983,22 +3983,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0295677s)
+                  1.01544 (0.0309861s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.50234 (0.0542292s)
+                  1.24872 (0.0526585s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.52609 (0.0613656s)
+                  1.26661 (0.066621s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.37526 (0.0724863s)
+                  1.15965 (0.0947007s)
                 </p>
               </td>
 </tr>
@@ -4010,22 +4010,22 @@
               </td>
 <td>
                 <p>
-                  4.84414 (0.14323s)
+                  1.64675 (0.0502505s)
                 </p>
               </td>
 <td>
                 <p>
-                  3.99297 (0.144132s)
+                  1.47181 (0.0620663s)
                 </p>
               </td>
 <td>
                 <p>
-                  3.85375 (0.154963s)
+                  1.66038 (0.0873322s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.91129 (0.153447s)
+                  1.67895 (0.137108s)
                 </p>
               </td>
 </tr>
@@ -4037,22 +4037,22 @@
               </td>
 <td>
                 <p>
-                  10.8218 (0.319975s)
+                  4.30668 (0.131418s)
                 </p>
               </td>
 <td>
                 <p>
-                  9.05203 (0.326747s)
+                  3.45859 (0.145849s)
                 </p>
               </td>
 <td>
                 <p>
-                  8.32597 (0.334795s)
+                  2.91462 (0.153303s)
                 </p>
               </td>
 <td>
                 <p>
-                  10.948 (0.577039s)
+                  4.15538 (0.339342s)
                 </p>
               </td>
 </tr>
@@ -4060,8 +4060,8 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator6"></a><p class="title"><b>Table&#160;1.57.&#160;Operator ^</b></p>
-<div class="table-contents"><table class="table" summary="Operator ^">
+<a name="boost_multiprecision.perf.integer_performance.operator_int5"></a><p class="title"><b>Table&#160;1.57.&#160;Operator ^(int)</b></p>
+<div class="table-contents"><table class="table" summary="Operator ^(int)">
 <colgroup>
 <col>
 <col>
@@ -4105,22 +4105,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0311003s)
+                  1.01566 (0.0296088s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0430909s)
+                  <span class="bold"><strong>1</strong></span> (0.0356634s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0530915s)
+                  <span class="bold"><strong>1</strong></span> (0.0401898s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0842599s)
+                  <span class="bold"><strong>1</strong></span> (0.0514097s)
                 </p>
               </td>
 </tr>
@@ -4132,22 +4132,22 @@
               </td>
 <td>
                 <p>
-                  1.04721 (0.0325686s)
+                  <span class="bold"><strong>1</strong></span> (0.0291524s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.18557 (0.0510874s)
+                  1.2393 (0.0441976s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.25714 (0.0667433s)
+                  1.38556 (0.0556856s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.14462 (0.0964459s)
+                  1.38899 (0.0714075s)
                 </p>
               </td>
 </tr>
@@ -4159,22 +4159,22 @@
               </td>
 <td>
                 <p>
-                  1.59277 (0.0495356s)
+                  4.68027 (0.136441s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.47967 (0.0637601s)
+                  4.15243 (0.14809s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.73243 (0.0919772s)
+                  3.74237 (0.150405s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.68499 (0.141977s)
+                  3.0483 (0.156712s)
                 </p>
               </td>
 </tr>
@@ -4186,22 +4186,22 @@
               </td>
 <td>
                 <p>
-                  4.17425 (0.12982s)
+                  10.919 (0.318314s)
                 </p>
               </td>
 <td>
                 <p>
-                  3.41013 (0.146946s)
+                  9.16311 (0.326788s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.8988 (0.153902s)
+                  8.62554 (0.346659s)
                 </p>
               </td>
 <td>
                 <p>
-                  4.17074 (0.351426s)
+                  11.6212 (0.597442s)
                 </p>
               </td>
 </tr>
@@ -4209,8 +4209,157 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator_int6"></a><p class="title"><b>Table&#160;1.58.&#160;Operator ^(int)</b></p>
-<div class="table-contents"><table class="table" summary="Operator ^(int)">
+<a name="boost_multiprecision.perf.integer_performance.operator6"></a><p class="title"><b>Table&#160;1.58.&#160;Operator &amp;</b></p>
+<div class="table-contents"><table class="table" summary="Operator &amp;">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+                <p>
+                  Backend
+                </p>
+              </th>
+<th>
+                <p>
+                  128 Bits
+                </p>
+              </th>
+<th>
+                <p>
+                  256 Bits
+                </p>
+              </th>
+<th>
+                <p>
+                  512 Bits
+                </p>
+              </th>
+<th>
+                <p>
+                  1024 Bits
+                </p>
+              </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+                <p>
+                  cpp_int
+                </p>
+              </td>
+<td>
+                <p>
+                  1.0346 (0.0303431s)
+                </p>
+              </td>
+<td>
+                <p>
+                  <span class="bold"><strong>1</strong></span> (0.0427309s)
+                </p>
+              </td>
+<td>
+                <p>
+                  <span class="bold"><strong>1</strong></span> (0.0535587s)
+                </p>
+              </td>
+<td>
+                <p>
+                  1.06945 (0.0828084s)
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  cpp_int(fixed)
+                </p>
+              </td>
+<td>
+                <p>
+                  <span class="bold"><strong>1</strong></span> (0.0293284s)
+                </p>
+              </td>
+<td>
+                <p>
+                  1.10435 (0.04719s)
+                </p>
+              </td>
+<td>
+                <p>
+                  1.05262 (0.0563769s)
+                </p>
+              </td>
+<td>
+                <p>
+                  <span class="bold"><strong>1</strong></span> (0.0774309s)
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  gmp_int
+                </p>
+              </td>
+<td>
+                <p>
+                  1.86057 (0.0545675s)
+                </p>
+              </td>
+<td>
+                <p>
+                  1.58432 (0.0676995s)
+                </p>
+              </td>
+<td>
+                <p>
+                  1.69164 (0.0906018s)
+                </p>
+              </td>
+<td>
+                <p>
+                  1.86625 (0.144505s)
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  tommath_int
+                </p>
+              </td>
+<td>
+                <p>
+                  4.4157 (0.129506s)
+                </p>
+              </td>
+<td>
+                <p>
+                  3.60396 (0.154s)
+                </p>
+              </td>
+<td>
+                <p>
+                  2.95985 (0.158525s)
+                </p>
+              </td>
+<td>
+                <p>
+                  4.4032 (0.340944s)
+                </p>
+              </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break"><div class="table">
+<a name="boost_multiprecision.perf.integer_performance.operator_int6"></a><p class="title"><b>Table&#160;1.59.&#160;Operator &amp;(int)</b></p>
+<div class="table-contents"><table class="table" summary="Operator &amp;(int)">
 <colgroup>
 <col>
 <col>
@@ -4254,22 +4403,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0290428s)
+                  1.05874 (0.038946s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0360261s)
+                  <span class="bold"><strong>1</strong></span> (0.0483903s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0409722s)
+                  <span class="bold"><strong>1</strong></span> (0.063842s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0541785s)
+                  <span class="bold"><strong>1</strong></span> (0.100361s)
                 </p>
               </td>
 </tr>
@@ -4281,22 +4430,22 @@
               </td>
 <td>
                 <p>
-                  1.01484 (0.0294736s)
+                  <span class="bold"><strong>1</strong></span> (0.0367853s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.4898 (0.0536716s)
+                  1.05827 (0.0512099s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.34782 (0.0552234s)
+                  1.09114 (0.0696605s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.35054 (0.0731703s)
+                  1.09432 (0.109826s)
                 </p>
               </td>
 </tr>
@@ -4308,22 +4457,22 @@
               </td>
 <td>
                 <p>
-                  4.94574 (0.143638s)
+                  3.92298 (0.144308s)
                 </p>
               </td>
 <td>
                 <p>
-                  4.05569 (0.146111s)
+                  2.99447 (0.144903s)
                 </p>
               </td>
 <td>
                 <p>
-                  3.65257 (0.149654s)
+                  2.228 (0.14224s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.89039 (0.156597s)
+                  1.42296 (0.142809s)
                 </p>
               </td>
 </tr>
@@ -4335,22 +4484,22 @@
               </td>
 <td>
                 <p>
-                  10.8939 (0.316389s)
+                  8.79208 (0.323419s)
                 </p>
               </td>
 <td>
                 <p>
-                  9.21322 (0.331916s)
+                  7.02288 (0.339839s)
                 </p>
               </td>
 <td>
                 <p>
-                  8.17995 (0.335151s)
+                  5.65271 (0.36088s)
                 </p>
               </td>
 <td>
                 <p>
-                  10.6902 (0.579178s)
+                  6.27104 (0.629365s)
                 </p>
               </td>
 </tr>
@@ -4358,7 +4507,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator___"></a><p class="title"><b>Table&#160;1.59.&#160;Operator &lt;&lt;</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator___"></a><p class="title"><b>Table&#160;1.60.&#160;Operator &lt;&lt;</b></p>
 <div class="table-contents"><table class="table" summary="Operator &lt;&lt;">
 <colgroup>
 <col>
@@ -4403,22 +4552,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0253777s)
+                  <span class="bold"><strong>1</strong></span> (0.0248801s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.04239 (0.034484s)
+                  1.23196 (0.04s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0420979s)
+                  <span class="bold"><strong>1</strong></span> (0.0424149s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0623485s)
+                  <span class="bold"><strong>1</strong></span> (0.060157s)
                 </p>
               </td>
 </tr>
@@ -4430,22 +4579,22 @@
               </td>
 <td>
                 <p>
-                  1.05039 (0.0266563s)
+                  1.08931 (0.027102s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.40679 (0.0465388s)
+                  1.40572 (0.0456418s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.34077 (0.0564434s)
+                  1.3475 (0.0571542s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.20319 (0.0750171s)
+                  1.24573 (0.0749397s)
                 </p>
               </td>
 </tr>
@@ -4457,22 +4606,22 @@
               </td>
 <td>
                 <p>
-                  1.0359 (0.0262888s)
+                  1.05561 (0.0262636s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0330815s)
+                  <span class="bold"><strong>1</strong></span> (0.0324686s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.1625 (0.0489388s)
+                  1.09914 (0.0466199s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.16511 (0.0726428s)
+                  1.16315 (0.0699719s)
                 </p>
               </td>
 </tr>
@@ -4484,22 +4633,22 @@
               </td>
 <td>
                 <p>
-                  1.65904 (0.0421025s)
+                  1.60497 (0.0399319s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.11201 (0.0698686s)
+                  2.13048 (0.0691737s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.36727 (0.0996572s)
+                  2.31219 (0.0980712s)
                 </p>
               </td>
 <td>
                 <p>
-                  2.701 (0.168403s)
+                  2.74695 (0.165248s)
                 </p>
               </td>
 </tr>
@@ -4507,7 +4656,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.integer_performance.operator7"></a><p class="title"><b>Table&#160;1.60.&#160;Operator &gt;&gt;</b></p>
+<a name="boost_multiprecision.perf.integer_performance.operator7"></a><p class="title"><b>Table&#160;1.61.&#160;Operator &gt;&gt;</b></p>
 <div class="table-contents"><table class="table" summary="Operator &gt;&gt;">
 <colgroup>
 <col>
@@ -4552,22 +4701,22 @@
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0221035s)
+                  <span class="bold"><strong>1</strong></span> (0.0213349s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.0337 (0.0313761s)
+                  1.02127 (0.0295019s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.03419 (0.0355718s)
+                  <span class="bold"><strong>1</strong></span> (0.0327116s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.20366 (0.0453508s)
+                  1.13168 (0.0433804s)
                 </p>
               </td>
 </tr>
@@ -4579,22 +4728,22 @@
               </td>
 <td>
                 <p>
-                  1.1036 (0.0243933s)
+                  1.13514 (0.0242181s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.12323 (0.0340936s)
+                  1.16938 (0.0337803s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.40181 (0.0482162s)
+                  1.46999 (0.0480859s)
                 </p>
               </td>
 <td>
                 <p>
-                  1.69985 (0.0640463s)
+                  1.60077 (0.061362s)
                 </p>
               </td>
 </tr>
@@ -4606,22 +4755,22 @@
               </td>
 <td>
                 <p>
-                  1.30456 (0.0288354s)
+                  1.26614 (0.0270129s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0303532s)
+                  <span class="bold"><strong>1</strong></span> (0.0288873s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0343958s)
+                  1.42219 (0.0465221s)
                 </p>
               </td>
 <td>
                 <p>
-                  <span class="bold"><strong>1</strong></span> (0.0376776s)
+                  <span class="bold"><strong>1</strong></span> (0.0383329s)
                 </p>
               </td>
 </tr>
@@ -4633,22 +4782,22 @@
               </td>
 <td>
                 <p>
-                  10.5766 (0.233779s)
+                  12.0066 (0.25616s)
                 </p>
               </td>
 <td>
                 <p>
-                  9.0959 (0.27609s)
+                  10.2837 (0.297067s)
                 </p>
               </td>
 <td>
                 <p>
-                  8.6249 (0.29666s)
+                  9.99696 (0.327017s)
                 </p>
               </td>
 <td>
                 <p>
-                  13.6818 (0.515498s)
+                  16.0943 (0.616942s)
                 </p>
               </td>
 </tr>

Modified: branches/release/libs/multiprecision/doc/html/boost_multiprecision/perf/rational_performance.html
==============================================================================
--- branches/release/libs/multiprecision/doc/html/boost_multiprecision/perf/rational_performance.html	(original)
+++ branches/release/libs/multiprecision/doc/html/boost_multiprecision/perf/rational_performance.html	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -37,7 +37,7 @@
         for 500000 operations.
       </p>
 <div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator__"></a><p class="title"><b>Table&#160;1.61.&#160;Operator +</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator__"></a><p class="title"><b>Table&#160;1.62.&#160;Operator +</b></p>
 <div class="table-contents"><table class="table" summary="Operator +">
 <colgroup>
 <col>
@@ -132,7 +132,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator___int_"></a><p class="title"><b>Table&#160;1.62.&#160;Operator +(int)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator___int_"></a><p class="title"><b>Table&#160;1.63.&#160;Operator +(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator +(int)">
 <colgroup>
 <col>
@@ -227,7 +227,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator___unsigned_long_long_"></a><p class="title"><b>Table&#160;1.63.&#160;Operator +(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator___unsigned_long_long_"></a><p class="title"><b>Table&#160;1.64.&#160;Operator +(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator +(unsigned long long)">
 <colgroup>
 <col>
@@ -322,7 +322,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator____unsigned_long_long_"></a><p class="title"><b>Table&#160;1.64.&#160;Operator +=(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator____unsigned_long_long_"></a><p class="title"><b>Table&#160;1.65.&#160;Operator +=(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator +=(unsigned long long)">
 <colgroup>
 <col>
@@ -417,7 +417,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator0"></a><p class="title"><b>Table&#160;1.65.&#160;Operator -</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator0"></a><p class="title"><b>Table&#160;1.66.&#160;Operator -</b></p>
 <div class="table-contents"><table class="table" summary="Operator -">
 <colgroup>
 <col>
@@ -512,7 +512,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_int0"></a><p class="title"><b>Table&#160;1.66.&#160;Operator -(int)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_int0"></a><p class="title"><b>Table&#160;1.67.&#160;Operator -(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator -(int)">
 <colgroup>
 <col>
@@ -607,7 +607,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long0"></a><p class="title"><b>Table&#160;1.67.&#160;Operator -(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long0"></a><p class="title"><b>Table&#160;1.68.&#160;Operator -(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator -(unsigned long long)">
 <colgroup>
 <col>
@@ -702,7 +702,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long1"></a><p class="title"><b>Table&#160;1.68.&#160;Operator -=(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long1"></a><p class="title"><b>Table&#160;1.69.&#160;Operator -=(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator -=(unsigned long long)">
 <colgroup>
 <col>
@@ -797,7 +797,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator1"></a><p class="title"><b>Table&#160;1.69.&#160;Operator *</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator1"></a><p class="title"><b>Table&#160;1.70.&#160;Operator *</b></p>
 <div class="table-contents"><table class="table" summary="Operator *">
 <colgroup>
 <col>
@@ -892,7 +892,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_int1"></a><p class="title"><b>Table&#160;1.70.&#160;Operator *(int)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_int1"></a><p class="title"><b>Table&#160;1.71.&#160;Operator *(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator *(int)">
 <colgroup>
 <col>
@@ -987,7 +987,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long2"></a><p class="title"><b>Table&#160;1.71.&#160;Operator *(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long2"></a><p class="title"><b>Table&#160;1.72.&#160;Operator *(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator *(unsigned long long)">
 <colgroup>
 <col>
@@ -1082,7 +1082,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long3"></a><p class="title"><b>Table&#160;1.72.&#160;Operator *=(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long3"></a><p class="title"><b>Table&#160;1.73.&#160;Operator *=(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator *=(unsigned long long)">
 <colgroup>
 <col>
@@ -1177,7 +1177,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator2"></a><p class="title"><b>Table&#160;1.73.&#160;Operator /</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator2"></a><p class="title"><b>Table&#160;1.74.&#160;Operator /</b></p>
 <div class="table-contents"><table class="table" summary="Operator /">
 <colgroup>
 <col>
@@ -1272,7 +1272,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_int2"></a><p class="title"><b>Table&#160;1.74.&#160;Operator /(int)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_int2"></a><p class="title"><b>Table&#160;1.75.&#160;Operator /(int)</b></p>
 <div class="table-contents"><table class="table" summary="Operator /(int)">
 <colgroup>
 <col>
@@ -1367,7 +1367,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long4"></a><p class="title"><b>Table&#160;1.75.&#160;Operator /(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long4"></a><p class="title"><b>Table&#160;1.76.&#160;Operator /(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator /(unsigned long long)">
 <colgroup>
 <col>
@@ -1462,7 +1462,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long5"></a><p class="title"><b>Table&#160;1.76.&#160;Operator /=(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_unsigned_long_long5"></a><p class="title"><b>Table&#160;1.77.&#160;Operator /=(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator /=(unsigned long long)">
 <colgroup>
 <col>
@@ -1557,7 +1557,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_construct"></a><p class="title"><b>Table&#160;1.77.&#160;Operator construct</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_construct"></a><p class="title"><b>Table&#160;1.78.&#160;Operator construct</b></p>
 <div class="table-contents"><table class="table" summary="Operator construct">
 <colgroup>
 <col>
@@ -1652,7 +1652,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_construct_unsigned_"></a><p class="title"><b>Table&#160;1.78.&#160;Operator construct(unsigned)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_construct_unsigned_"></a><p class="title"><b>Table&#160;1.79.&#160;Operator construct(unsigned)</b></p>
 <div class="table-contents"><table class="table" summary="Operator construct(unsigned)">
 <colgroup>
 <col>
@@ -1747,7 +1747,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_construct_unsigned_long_long_"></a><p class="title"><b>Table&#160;1.79.&#160;Operator construct(unsigned long long)</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_construct_unsigned_long_long_"></a><p class="title"><b>Table&#160;1.80.&#160;Operator construct(unsigned long long)</b></p>
 <div class="table-contents"><table class="table" summary="Operator construct(unsigned long long)">
 <colgroup>
 <col>
@@ -1842,7 +1842,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_multiprecision.perf.rational_performance.operator_str"></a><p class="title"><b>Table&#160;1.80.&#160;Operator str</b></p>
+<a name="boost_multiprecision.perf.rational_performance.operator_str"></a><p class="title"><b>Table&#160;1.81.&#160;Operator str</b></p>
 <div class="table-contents"><table class="table" summary="Operator str">
 <colgroup>
 <col>

Modified: branches/release/libs/multiprecision/doc/html/boost_multiprecision/ref/backendconc.html
==============================================================================
--- branches/release/libs/multiprecision/doc/html/boost_multiprecision/ref/backendconc.html	(original)
+++ branches/release/libs/multiprecision/doc/html/boost_multiprecision/ref/backendconc.html	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -297,7 +297,7 @@
 <td>
                 <p>
                   Throws a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code> if the string could
-                  not be interpretted as a valid number.
+                  not be interpreted as a valid number.
                 </p>
               </td>
 </tr>
@@ -2006,7 +2006,7 @@
                   all arguments of type <code class="computeroutput"><span class="identifier">B</span></code>
                   is shown here, but you can replace up to any 2 of <code class="computeroutput"><span class="identifier">cb</span></code>, <code class="computeroutput"><span class="identifier">cb2</span></code>
                   and <code class="computeroutput"><span class="identifier">cb3</span></code> with any
-                  type type listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
+                  type listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                   <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>.
                 </p>
               </td>
@@ -2037,7 +2037,7 @@
                   all arguments of type <code class="computeroutput"><span class="identifier">B</span></code>
                   is shown here, but you can replace up to any 2 of <code class="computeroutput"><span class="identifier">cb</span></code>, <code class="computeroutput"><span class="identifier">cb2</span></code>
                   and <code class="computeroutput"><span class="identifier">cb3</span></code> with any
-                  type type listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
+                  type listed in one of the type lists <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">signed_types</span></code>,
                   <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">unsigned_types</span></code> or <code class="computeroutput"><span class="identifier">B</span><span class="special">::</span><span class="identifier">float_types</span></code>.
                 </p>
               </td>

Modified: branches/release/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_dec_ref.html
==============================================================================
--- branches/release/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_dec_ref.html	(original)
+++ branches/release/libs/multiprecision/doc/html/boost_multiprecision/ref/cpp_dec_ref.html	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -28,7 +28,7 @@
 </h3></div></div></div>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>
 
-<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">&gt;</span>
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="identifier">Digits10</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExponentType</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int32_t</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">&gt;</span>
 <span class="keyword">class</span> <span class="identifier">cpp_dec_float</span><span class="special">;</span>
 
 <span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float</span><span class="special">&lt;</span><span class="number">50</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">cpp_dec_float_50</span><span class="special">;</span>
@@ -43,13 +43,32 @@
         these are considered implementation details that are subject to change.
       </p>
 <p>
-        The class takes a single template parameter - <code class="computeroutput"><span class="identifier">Digits10</span></code>
-        - which is the number of decimal digits precision the type should support.
-        Note that this type does not ever perform any dynamic memory allocation,
-        as a result the <code class="computeroutput"><span class="identifier">Digits10</span></code>
-        template argument should not be set too high or the class's size will grow
-        unreasonably large.
+        The class takes three template parameters:
       </p>
+<div class="variablelist">
+<p class="title"><b></b></p>
+<dl class="variablelist">
+<dt><span class="term">Digits10</span></dt>
+<dd><p>
+              The number of decimal digits precision the type should support. Note
+              that this type does not normally perform any dynamic memory allocation,
+              and as a result the <code class="computeroutput"><span class="identifier">Digits10</span></code>
+              template argument should not be set too high or the class's size will
+              grow unreasonably large.
+            </p></dd>
+<dt><span class="term">ExponentType</span></dt>
+<dd><p>
+              A signed integer type that represents the exponent of the number
+            </p></dd>
+<dt><span class="term">Allocator</span></dt>
+<dd><p>
+              The allocator used: defaults to type <code class="computeroutput"><span class="keyword">void</span></code>,
+              meaning all storage is within the class, and no dynamic allocation
+              is performed, but can be set to a standard library allocator if dynamic
+              allocation makes more sense.
+            </p></dd>
+</dl>
+</div>
 <p>
         The type of <code class="computeroutput"><span class="identifier">number_category</span><span class="special">&lt;</span><span class="identifier">cpp_int</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">...&gt;</span> <span class="special">&gt;::</span><span class="identifier">type</span></code> is <code class="computeroutput"><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">int_</span><span class="special">&lt;</span><span class="identifier">number_kind_floating_point</span><span class="special">&gt;</span></code>.
       </p>

Modified: branches/release/libs/multiprecision/doc/html/boost_multiprecision/ref/headers.html
==============================================================================
--- branches/release/libs/multiprecision/doc/html/boost_multiprecision/ref/headers.html	(original)
+++ branches/release/libs/multiprecision/doc/html/boost_multiprecision/ref/headers.html	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -168,7 +168,7 @@
               </td>
 <td>
                 <p>
-                  Defines a backend concept architypes for testing use.
+                  Defines a backend concept archetypes for testing use.
                 </p>
               </td>
 </tr>

Modified: branches/release/libs/multiprecision/doc/html/boost_multiprecision/ref/number.html
==============================================================================
--- branches/release/libs/multiprecision/doc/html/boost_multiprecision/ref/number.html	(original)
+++ branches/release/libs/multiprecision/doc/html/boost_multiprecision/ref/number.html	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -673,11 +673,10 @@
         types).
       </p>
 <p>
-        The precision of these functions is generally deterimined by the backend
-        implementation. For example the precision of these functions when used with
-        <a class="link" href="../tut/floats/mpfr_float.html" title="mpfr_float">mpfr_float</a>
+        The precision of these functions is generally determined by the backend implementation.
+        For example the precision of these functions when used with <a class="link" href="../tut/floats/mpfr_float.html" title="mpfr_float">mpfr_float</a>
         is determined entirely by MPFR.
-        When these functions use our own implementations, the accuracy of the transcendal
+        When these functions use our own implementations, the accuracy of the transcendental
         functions is generally a few epsilon. Note however, that the trigonmetrical
         functions incur the usual accuracy loss when reducing arguments by large
         multiples of &#960;. Also note that both <a class="link" href="../tut/floats/gmp_float.html" title="gmp_float">gmp_float</a>

Modified: branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/conversions.html
==============================================================================
--- branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/conversions.html	(original)
+++ branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/conversions.html	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -120,7 +120,7 @@
           </li></ul></div>
 <pre class="programlisting"><span class="identifier">int128_t</span>     <span class="identifier">i128</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
 <span class="identifier">int266_t</span>     <span class="identifier">i256</span> <span class="special">=</span> <span class="identifier">i128</span><span class="special">;</span>  <span class="comment">// OK implicit widening conversion</span>
-<span class="identifier">i128_t</span>            <span class="special">=</span> <span class="identifier">i256</span><span class="special">;</span>  <span class="comment">// Error, no assignment operator found, narrowing conversion is explict</span>
+<span class="identifier">i128_t</span>            <span class="special">=</span> <span class="identifier">i256</span><span class="special">;</span>  <span class="comment">// Error, no assignment operator found, narrowing conversion is explicit</span>
 <span class="identifier">i128_t</span>            <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">int128_t</span><span class="special">&gt;(</span><span class="identifier">i256</span><span class="special">);</span> <span class="comment">// OK, explicit narrowing conversion</span>
 
 <span class="identifier">mpz_int</span>      <span class="identifier">z</span>    <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
@@ -157,7 +157,7 @@
 <p>
         More information on what additional types a backend supports conversions
         from are given in the tutorial for each backend. The converting constructor
-        will be implict if the backend's converting constructor is also implicit,
+        will be implicit if the backend's converting constructor is also implicit,
         and explicit if the backends converting constructor is also explicit.
       </p>
 </div>

Modified: branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_dec_float.html
==============================================================================
--- branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_dec_float.html	(original)
+++ branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/cpp_dec_float.html	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -56,7 +56,8 @@
           to a 32-bit integer type which is more than large enough for the vast majority
           of use cases, but larger types such as <code class="computeroutput"><span class="keyword">long</span>
           <span class="keyword">long</span></code> can also be specified if you
-          need a truely huge exponent range.
+          need a truly huge exponent range. In any case the ExponentType must be
+          a built in signed integer type at least 2 bytes and 16-bits wide.
         </p>
 <p>
           Normally <code class="computeroutput"><span class="identifier">cpp_dec_float</span></code>

Modified: branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/jel.html
==============================================================================
--- branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/jel.html	(original)
+++ branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/jel.html	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -160,7 +160,7 @@
 <pre class="programlisting"><span class="identifier">JEL</span><span class="special">(</span><span class="identifier">cpp_dec_float_50</span><span class="special">(</span><span class="identifier">v</span> <span class="special">+</span> <span class="number">0.5</span><span class="special">),</span> <span class="identifier">z</span><span class="special">);</span>
 </pre>
 <p>
-            However, if we want the function JEL to be truely reusable, then a better
+            However, if we want the function JEL to be truly reusable, then a better
             solution might be preferred. To achieve this we can borrow some code
             from Boost.Math which calculates the return type of mixed-argument functions,
             here's how the new code looks now:

Modified: branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/nd.html
==============================================================================
--- branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/nd.html	(original)
+++ branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/fp_eg/nd.html	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -126,7 +126,7 @@
    <span class="comment">// to handle expression templates etc.  As a result it's hard to take its</span>
    <span class="comment">// address without knowing about its implementation details.  We'll use a </span>
    <span class="comment">// C++11 lambda expression to capture the call.</span>
-   <span class="comment">// We also need a typecast on the first argument so we don't accidently pass</span>
+   <span class="comment">// We also need a typecast on the first argument so we don't accidentally pass</span>
    <span class="comment">// an expression template to a template function:</span>
    <span class="comment">//</span>
    <span class="keyword">const</span> <span class="identifier">cpp_dec_float_50</span> <span class="identifier">d_mp</span> <span class="special">=</span> <span class="identifier">derivative</span><span class="special">(</span>

Modified: branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/mpfr_float.html
==============================================================================
--- branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/mpfr_float.html	(original)
+++ branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/mpfr_float.html	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -77,7 +77,7 @@
           The latter option can result in significantly faster code, at the expense
           of growing the size of <code class="computeroutput"><span class="identifier">mpfr_float_backend</span></code>.
           It can only be used at fixed precision, and should only be used for lower
-          digit counts. Note that we can not guarentee that using <code class="computeroutput"><span class="identifier">allocate_stack</span></code>
+          digit counts. Note that we can not guarantee that using <code class="computeroutput"><span class="identifier">allocate_stack</span></code>
           won't cause any calls to mpfr's allocation routines, as mpfr may call these
           inside it's own code. The following table gives an idea of the performance
           tradeoff's at 50 decimal digits precision[2]</sup></a>:

Modified: branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/cpp_int.html
==============================================================================
--- branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/cpp_int.html	(original)
+++ branches/release/libs/multiprecision/doc/html/boost_multiprecision/tut/ints/cpp_int.html	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -314,7 +314,7 @@
               stores both the sign, and how many machine words in the integer are
               actually in use. The latter is an optimisation for larger fixed precision
               integers, so that a 1024-bit integer has almost the same performance
-              characterists as a 128-bit integer, rather than being 4 times slower
+              characteristics as a 128-bit integer, rather than being 4 times slower
               for addition and 16 times slower for multiplication (assuming the values
               involved would always fit in 128 bits). Typically this means you can
               use an integer type wide enough for the "worst case senario"

Modified: branches/release/libs/multiprecision/doc/html/index.html
==============================================================================
--- branches/release/libs/multiprecision/doc/html/index.html	(original)
+++ branches/release/libs/multiprecision/doc/html/index.html	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -136,7 +136,7 @@
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: December 06, 2012 at 11:21:55 GMT</small></p></td>
+<td align="left"><p><small>Last revised: December 18, 2012 at 11:25:53 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>

Modified: branches/release/libs/multiprecision/doc/html4_symbols.qbk
==============================================================================
--- branches/release/libs/multiprecision/doc/html4_symbols.qbk	(original)
+++ branches/release/libs/multiprecision/doc/html4_symbols.qbk	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -10,7 +10,7 @@
 [/ http://www.htmlhelp.com/reference/html40/entities/latin1.html]
 [/Unicode Latin extended http://www.unicode.org/charts/U0080.pdf]
 
-[/ Also some miscellaneous math charaters added to this list - see the end.]
+[/ Also some miscellaneous math characters added to this list - see the end.]
 [/ For others see also math_symbols.qbk]
 
 [/ To use, enclose the template name in square brackets.]

Modified: branches/release/libs/multiprecision/doc/multiprecision.qbk
==============================================================================
--- branches/release/libs/multiprecision/doc/multiprecision.qbk	(original)
+++ branches/release/libs/multiprecision/doc/multiprecision.qbk	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -510,7 +510,7 @@
 * When used at fixed precision, the size of this type is always one machine word larger than you would expect for an N-bit integer: 
 the extra word stores both the sign, and how many machine words in the integer are actually in use.  
 The latter is an optimisation for larger fixed precision integers, so that a 1024-bit integer has almost the same performance
-characterists as a 128-bit integer, rather than being 4 times slower for addition and 16 times slower for multiplication
+characteristics as a 128-bit integer, rather than being 4 times slower for addition and 16 times slower for multiplication
  (assuming the values involved would always fit in 128 bits).
 Typically this means you can use
 an integer type wide enough for the "worst case senario" with only minor performance degradation even if most of the time
@@ -655,7 +655,8 @@
 The typedefs `cpp_dec_float_50` and `cpp_dec_float_100` provide arithmetic types at 50 and 100 decimal digits precision
 respectively.  Optionally, you can specify an integer type to use for the exponent, this defaults to a 32-bit integer type
 which is more than large enough for the vast majority of use cases, but larger types such as `long long` can also be specified
-if you need a truely huge exponent range.
+if you need a truly huge exponent range.  In any case the ExponentType must be a built in signed integer type at least 2 bytes 
+and 16-bits wide.
 
 Normally `cpp_dec_float` allocates no memory: all of the space required for its digits are allocated
 directly within the class.  As a result care should be taken not to use the class with too high a digit count
@@ -796,7 +797,7 @@
 or stack allocation (where all the memory required for the underlying data types is stored
 within `mpfr_float_backend`).  The latter option can result in significantly faster code, at the
 expense of growing the size of `mpfr_float_backend`.  It can only be used at fixed precision, and
-should only be used for lower digit counts.  Note that we can not guarentee that using `allocate_stack`
+should only be used for lower digit counts.  Note that we can not guarantee that using `allocate_stack`
 won't cause any calls to mpfr's allocation routines, as mpfr may call these inside it's own code.
 The following table gives an idea of the performance tradeoff's at 50 decimal digits 
 precision[footnote Compiled with VC++10 and /Ox, with MPFR-3.0.0 and MPIR-2.3.0]:
@@ -1134,7 +1135,7 @@
 
    int128_t     i128 = 0;
    int266_t     i256 = i128;  // OK implicit widening conversion
-   i128_t            = i256;  // Error, no assignment operator found, narrowing conversion is explict
+   i128_t            = i256;  // Error, no assignment operator found, narrowing conversion is explicit
    i128_t            = static_cast<int128_t>(i256); // OK, explicit narrowing conversion
 
    mpz_int      z    = 0;
@@ -1165,7 +1166,7 @@
    mpf_float i(m);        // copies the value of the native type.
 
 More information on what additional types a backend supports conversions from are given in the tutorial for each backend.
-The converting constructor will be implict if the backend's converting constructor is also implicit, and explicit if the
+The converting constructor will be implicit if the backend's converting constructor is also implicit, and explicit if the
 backends converting constructor is also explicit.
 
 [endsect]
@@ -1838,9 +1839,9 @@
 Also note that with the exception of `abs` that these functions can only be used with floating-point Backend types (if any other types
 such as fixed precision or complex types are added to the library later, then these functions may be extended to support those number types).
 
-The precision of these functions is generally deterimined by the backend implementation.  For example the precision
+The precision of these functions is generally determined by the backend implementation.  For example the precision
 of these functions when used with __mpfr_float_backend is determined entirely by [mpfr].  When these functions use our own
-implementations, the accuracy of the transcendal functions is generally a few epsilon.  Note however, that the trigonmetrical
+implementations, the accuracy of the transcendental functions is generally a few epsilon.  Note however, that the trigonmetrical
 functions incur the usual accuracy loss when reducing arguments by large multiples of [pi].  Also note that both __mpf_float
 and __cpp_dec_float have a number of guard digits beyond their stated precision, so the error rates listed for these
 are in some sense artificially low.
@@ -2196,7 +2197,7 @@
 
    namespace boost{ namespace multiprecision{
 
-   template <unsigned Digits10>
+   template <unsigned Digits10, class ExponentType = boost::int32_t, class Allocator = void>
    class cpp_dec_float;
 
    typedef number<cpp_dec_float<50> > cpp_dec_float_50;
@@ -2208,9 +2209,16 @@
 Its members and non-member functions are deliberately not documented: these are considered implementation details that are subject 
 to change.
 
-The class takes a single template parameter - `Digits10` - which is the number of decimal digits precision the type
-should support.  Note that this type does not ever perform any dynamic memory allocation, as a result the `Digits10`
-template argument should not be set too high or the class's size will grow unreasonably large.
+The class takes three template parameters:
+
+[variablelist
+[[Digits10][The number of decimal digits precision the type
+should support.  Note that this type does not normally perform any dynamic memory allocation, and as a result the `Digits10`
+template argument should not be set too high or the class's size will grow unreasonably large.]]
+[[ExponentType][A signed integer type that represents the exponent of the number]]
+[[Allocator][The allocator used: defaults to type `void`, meaning all storage is within the class, and no dynamic
+allocation is performed, but can be set to a standard library allocator if dynamic allocation makes more sense.]]
+]
 
 The type of `number_category<cpp_int<Args...> >::type` is `mpl::int_<number_kind_floating_point>`.
 
@@ -2303,7 +2311,7 @@
 [[`b = b`][`B&`][Assignment operator.][[space]]]
 [[`b = a`][`B&`][Assignment from an Arithmetic type.  The type of `a` shall be listed in one of the type lists
             `B::signed_types`, `B::unsigned_types` or `B::float_types`.][[space]]]
-[[`b = s`][`B&`][Assignment from a string.][Throws a `std::runtime_error` if the string could not be interpretted as a valid number.]]
+[[`b = s`][`B&`][Assignment from a string.][Throws a `std::runtime_error` if the string could not be interpreted as a valid number.]]
 [[`b.swap(b)`][`void`][Swaps the contents of its arguments.][`noexcept`]]
 [[`cb.str(ui, bb)`][`std::string`][Returns the string representation of `b` with `ui` digits and in scientific format if `bb` is `true`.
                   If `ui` is zero, then returns as many digits as are required to reconstruct the original value.][[space]]]
@@ -2464,13 +2472,13 @@
             When not provided does the equivalent of `eval_multiply(b, cb, cb2)` followed by
             `eval_add(b, cb3)`.
             For brevity, only a version showing all arguments of type `B` is shown here, but you can replace up to any 2 of
-            `cb`, `cb2` and `cb3` with any type type listed in one of the type lists
+            `cb`, `cb2` and `cb3` with any type listed in one of the type lists
             `B::signed_types`, `B::unsigned_types` or `B::float_types`.][[space]]]
 [[`eval_multiply_subtract(b, cb, cb2, cb3)`][`void`][Multiplies `cb` by `cb2` and subtracts from the result `cb3` storing the result in `b`.
             When not provided does the equivalent of `eval_multiply(b, cb, cb2)` followed by
             `eval_subtract(b, cb3)`.
             For brevity, only a version showing all arguments of type `B` is shown here, but you can replace up to any 2 of
-            `cb`, `cb2` and `cb3` with any type type listed in one of the type lists
+            `cb`, `cb2` and `cb3` with any type listed in one of the type lists
             `B::signed_types`, `B::unsigned_types` or `B::float_types`.][[space]]]
 [[`eval_divide(b, a)`][`void`][Divides `b` by `a`.  The type of `a` shall be listed in one of the type lists
             `B::signed_types`, `B::unsigned_types` or `B::float_types`.
@@ -2669,7 +2677,7 @@
 [[rational_adapter.hpp][Defines the `rational_adapter` backend.]]
 [[cpp_dec_float.hpp][Defines the `cpp_dec_float` backend.]]
 [[tommath.hpp][Defines the `tommath_int` backend.]]
-[[concepts/number_archetypes.hpp][Defines a backend concept architypes for testing use.]]
+[[concepts/number_archetypes.hpp][Defines a backend concept archetypes for testing use.]]
 ]
 
 [table Implementation Headers]
@@ -2976,220 +2984,227 @@
 
 [table Operator +
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][1.22306 (0.0279933s)][1.15878 (0.038341s)][1.24006 (0.0562258s)][1.32055 (0.0925091s)]]
-[[cpp_int(fixed)][1.56093 (0.0357264s)][1.71757 (0.05683s)][1.66497 (0.0754916s)][1.70376 (0.119354s)]]
-[[gmp_int][1.98788 (0.0454986s)][1.37882 (0.0456216s)][1.14898 (0.0520959s)][[*1] (0.0700532s)]]
-[[tommath_int][[*1] (0.022888s)][[*1] (0.0330875s)][[*1] (0.0453411s)][1.07021 (0.074972s)]]
+[[cpp_int][1.23704 (0.0274266s)][1.09358 (0.0383278s)][1.26645 (0.0558828s)][1.32188 (0.0916899s)]]
+[[cpp_int(fixed)][1.62044 (0.0359271s)][1.5277 (0.053543s)][1.73059 (0.076363s)][1.71537 (0.118983s)]]
+[[gmp_int][1.87515 (0.0415741s)][1.21699 (0.042653s)][1.15599 (0.0510088s)][[*1] (0.0693631s)]]
+[[tommath_int][[*1] (0.0221711s)][[*1] (0.035048s)][[*1] (0.0441255s)][1.04441 (0.0724435s)]]
 ]
 [table Operator +(int)
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][[*1] (0.0162581s)][[*1] (0.0196602s)][[*1] (0.0305476s)][[*1] (0.0421105s)]]
-[[cpp_int(fixed)][1.3852 (0.0225207s)][1.84835 (0.036339s)][1.6111 (0.0492153s)][1.63014 (0.068646s)]]
-[[gmp_int][1.95525 (0.0317886s)][2.2217 (0.0436791s)][2.21508 (0.0676653s)][2.58759 (0.108965s)]]
-[[tommath_int][13.603 (0.221158s)][11.5797 (0.227659s)][7.86674 (0.24031s)][6.36923 (0.268212s)]]
+[[cpp_int][[*1] (0.0155377s)][[*1] (0.0209523s)][[*1] (0.0306377s)][[*1] (0.043125s)]]
+[[cpp_int(fixed)][1.31904 (0.0204948s)][1.76211 (0.0369203s)][1.52941 (0.0468577s)][1.60412 (0.0691778s)]]
+[[gmp_int][1.96204 (0.0304855s)][2.02569 (0.0424428s)][2.11505 (0.0648002s)][2.65993 (0.114709s)]]
+[[tommath_int][14.0654 (0.218543s)][10.8239 (0.226786s)][7.76691 (0.23796s)][6.10039 (0.263079s)]]
 ]
 [table Operator +(unsigned long long)
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][[*1] (0.0269712s)][[*1] (0.0296213s)][[*1] (0.0380242s)][[*1] (0.045841s)]]
-[[cpp_int(fixed)][1.38342 (0.0373126s)][1.51165 (0.0447769s)][1.54533 (0.05876s)][1.3971 (0.0640443s)]]
-[[gmp_int][26.7163 (0.72057s)][24.0631 (0.712781s)][19.6009 (0.745307s)][17.6547 (0.809308s)]]
-[[tommath_int][19.7493 (0.532664s)][18.2944 (0.541905s)][14.9127 (0.567043s)][12.9059 (0.591619s)]]
+[[cpp_int][[*1] (0.026624s)][[*1] (0.0291407s)][[*1] (0.0373209s)][[*1] (0.0464919s)]]
+[[cpp_int(fixed)][1.31378 (0.034978s)][1.54897 (0.045138s)][1.53649 (0.0573431s)][1.27833 (0.0594319s)]]
+[[gmp_int][25.5775 (0.680974s)][24.0117 (0.699717s)][19.5633 (0.730121s)][16.8939 (0.785432s)]]
+[[tommath_int][19.4694 (0.518354s)][18.4246 (0.536907s)][14.7715 (0.551288s)][12.3637 (0.574812s)]]
 ]
 [table Operator +=(unsigned long long)
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][1.16166 (0.020334s)][1.15312 (0.0204789s)][1.21086 (0.0216179s)][1.28088 (0.0229569s)]]
-[[cpp_int(fixed)][[*1] (0.0175043s)][[*1] (0.0177595s)][[*1] (0.0178534s)][[*1] (0.0179228s)]]
-[[gmp_int][39.0852 (0.684159s)][38.7246 (0.68773s)][38.2555 (0.68299s)][37.6736 (0.675217s)]]
-[[tommath_int][30.5872 (0.535408s)][29.371 (0.521614s)][30.3387 (0.541648s)][31.8346 (0.570565s)]]
+[[cpp_int][1.18405 (0.0196905s)][1.22304 (0.0206476s)][1.25861 (0.0217397s)][1.29525 (0.0220829s)]]
+[[cpp_int(fixed)][[*1] (0.0166298s)][[*1] (0.0168822s)][[*1] (0.0172728s)][[*1] (0.0170492s)]]
+[[gmp_int][39.9082 (0.663668s)][39.4584 (0.666147s)][38.5504 (0.665873s)][39.2231 (0.668722s)]]
+[[tommath_int][30.6219 (0.509238s)][30.4135 (0.513447s)][30.9077 (0.533863s)][32.3086 (0.550835s)]]
 ]
 [table Operator -
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][1.12975 (0.0308979s)][[*1] (0.0392305s)][1.05392 (0.0543957s)][1.18166 (0.0860767s)]]
-[[cpp_int(fixed)][1.36853 (0.0374283s)][1.45987 (0.0572717s)][1.44606 (0.0746349s)][1.55935 (0.11359s)]]
-[[gmp_int][1.53173 (0.0418917s)][1.17956 (0.0462749s)][1.13609 (0.0586365s)][[*1] (0.0728442s)]]
-[[tommath_int][[*1] (0.0273493s)][1.07293 (0.0420917s)][[*1] (0.0516126s)][1.0985 (0.0800191s)]]
+[[cpp_int][1.06986 (0.0296064s)][[*1] (0.0381508s)][1.05932 (0.053186s)][1.1766 (0.0844721s)]]
+[[cpp_int(fixed)][1.3304 (0.0368163s)][1.44506 (0.0551303s)][1.4431 (0.0724545s)][1.57255 (0.112898s)]]
+[[gmp_int][1.48072 (0.0409761s)][1.19003 (0.0454007s)][1.0794 (0.0541942s)][[*1] (0.0717934s)]]
+[[tommath_int][[*1] (0.0276731s)][1.10891 (0.0423057s)][[*1] (0.0502076s)][1.08479 (0.0778811s)]]
 ]
 [table Operator -(int)
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][[*1] (0.0146171s)][[*1] (0.0172176s)][[*1] (0.023655s)][[*1] (0.0313105s)]]
-[[cpp_int(fixed)][1.49086 (0.021792s)][1.94917 (0.03356s)][1.89657 (0.0448632s)][1.82658 (0.057191s)]]
-[[gmp_int][2.16301 (0.0316169s)][2.55059 (0.0439151s)][2.67983 (0.0633913s)][3.27949 (0.102682s)]]
-[[tommath_int][14.0691 (0.20565s)][12.527 (0.215684s)][9.43355 (0.22315s)][7.64671 (0.239422s)]]
+[[cpp_int][[*1] (0.0147372s)][[*1] (0.0170001s)][[*1] (0.0232882s)][[*1] (0.0310734s)]]
+[[cpp_int(fixed)][1.4267 (0.0210256s)][1.98887 (0.0338109s)][1.83788 (0.0428009s)][1.81269 (0.0563264s)]]
+[[gmp_int][2.07504 (0.0305803s)][2.40928 (0.0409579s)][2.58711 (0.0602493s)][3.26438 (0.101435s)]]
+[[tommath_int][13.5424 (0.199577s)][12.1793 (0.207048s)][9.28855 (0.216314s)][7.49327 (0.232842s)]]
 ]
 [table Operator -(unsigned long long)
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][[*1] (0.0265242s)][[*1] (0.0295275s)][[*1] (0.0377737s)][[*1] (0.0450106s)]]
-[[cpp_int(fixed)][1.2627 (0.033492s)][1.47472 (0.0435449s)][1.47468 (0.055704s)][1.40667 (0.0633151s)]]
-[[gmp_int][26.0595 (0.691208s)][23.3957 (0.690817s)][18.9344 (0.715223s)][16.9593 (0.763349s)]]
-[[tommath_int][19.26 (0.510855s)][17.6236 (0.52038s)][13.9134 (0.52556s)][12.2359 (0.550746s)]]
+[[cpp_int][[*1] (0.0277377s)][[*1] (0.0296807s)][[*1] (0.0372392s)][[*1] (0.0455855s)]]
+[[cpp_int(fixed)][1.19867 (0.0332484s)][1.48639 (0.0441169s)][1.43253 (0.0533464s)][1.27697 (0.0582111s)]]
+[[gmp_int][24.1794 (0.670683s)][22.9073 (0.679904s)][18.8758 (0.702922s)][16.5837 (0.755975s)]]
+[[tommath_int][18.149 (0.503413s)][17.4116 (0.516787s)][14.0411 (0.52288s)][11.8237 (0.538987s)]]
 ]
 [table Operator -=(unsigned long long)
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][1.28589 (0.0210146s)][1.3505 (0.0222463s)][1.34427 (0.0237863s)][1.22787 (0.0230902s)]]
-[[cpp_int(fixed)][[*1] (0.0163425s)][[*1] (0.0164727s)][[*1] (0.0176946s)][[*1] (0.0188051s)]]
-[[gmp_int][41.0201 (0.670371s)][41.4726 (0.683165s)][37.9503 (0.671514s)][35.6021 (0.669502s)]]
-[[tommath_int][32.6952 (0.534322s)][31.4882 (0.518695s)][29.3988 (0.5202s)][29.1175 (0.547558s)]]
+[[cpp_int][1.26896 (0.0203467s)][1.25722 (0.0206147s)][1.36108 (0.0225485s)][1.18351 (0.0226161s)]]
+[[cpp_int(fixed)][[*1] (0.0160342s)][[*1] (0.0163971s)][[*1] (0.0165667s)][[*1] (0.0191094s)]]
+[[gmp_int][41.1339 (0.659547s)][40.3982 (0.662411s)][39.925 (0.661425s)][34.636 (0.661874s)]]
+[[tommath_int][31.1543 (0.499533s)][31.0303 (0.508806s)][30.7699 (0.509756s)][27.7054 (0.529434s)]]
 ]
 [table Operator *
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][1.13172 (0.0766099s)][1.59509 (0.20993s)][1.40998 (0.70643s)][1.70758 (2.66895s)]]
-[[cpp_int(fixed)][[*1] (0.067693s)][1.27132 (0.167319s)][[*1] (0.50102s)][[*1] (1.563s)]]
-[[gmp_int][1.01718 (0.0688559s)][[*1] (0.13161s)][1.13221 (0.567258s)][1.02292 (1.59883s)]]
-[[tommath_int][1.6793 (0.113677s)][2.66959 (0.351345s)][2.01091 (1.00751s)][2.05812 (3.21684s)]]
+[[cpp_int][1.11839 (0.0757577s)][1.61061 (0.207951s)][1.4501 (0.696912s)][1.72796 (2.64108s)]]
+[[cpp_int(fixed)][1.01115 (0.0684934s)][1.28687 (0.166152s)][[*1] (0.480595s)][[*1] (1.52844s)]]
+[[gmp_int][[*1] (0.0677384s)][[*1] (0.129113s)][1.09011 (0.523902s)][1.03374 (1.58s)]]
+[[tommath_int][1.6322 (0.110562s)][2.71751 (0.350866s)][2.05222 (0.986288s)][2.0644 (3.15531s)]]
 ]
 [table Operator *(int)
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][[*1] (0.0228822s)][1.19988 (0.0332404s)][1.13882 (0.0416226s)][1.2711 (0.0665655s)]]
-[[cpp_int(fixed)][1.33157 (0.0304692s)][1.6546 (0.0458376s)][1.72684 (0.063114s)][1.83178 (0.0959269s)]]
-[[gmp_int][1.00858 (0.0230786s)][[*1] (0.0277032s)][[*1] (0.0365488s)][[*1] (0.0523682s)]]
-[[tommath_int][10.8491 (0.248252s)][9.88511 (0.273849s)][8.95509 (0.327298s)][8.04172 (0.421131s)]]
+[[cpp_int][1.01611 (0.0229536s)][1.12175 (0.0298152s)][1.16413 (0.0416439s)][1.31747 (0.0666043s)]]
+[[cpp_int(fixed)][1.30215 (0.0294152s)][1.669 (0.0443606s)][1.72395 (0.0616701s)][1.88315 (0.095202s)]]
+[[gmp_int][[*1] (0.0225897s)][[*1] (0.0265791s)][[*1] (0.0357725s)][[*1] (0.0505547s)]]
+[[tommath_int][10.8281 (0.244603s)][10.1516 (0.26982s)][8.76424 (0.313519s)][8.04364 (0.406644s)]]
 ]
 [table Operator *(unsigned long long)
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][[*1] (0.0574926s)][[*1] (0.0876613s)][[*1] (0.146194s)][[*1] (0.258556s)]]
-[[cpp_int(fixed)][1.12247 (0.0645337s)][1.24471 (0.109113s)][1.19748 (0.175065s)][1.17442 (0.303653s)]]
-[[gmp_int][12.271 (0.705488s)][8.23054 (0.7215s)][5.28668 (0.772883s)][3.09816 (0.801047s)]]
-[[tommath_int][10.2751 (0.590743s)][7.36707 (0.645807s)][4.88979 (0.71486s)][3.43724 (0.888719s)]]
+[[cpp_int][[*1] (0.0570721s)][[*1] (0.0856141s)][[*1] (0.143279s)][[*1] (0.252785s)]]
+[[cpp_int(fixed)][1.10857 (0.0632686s)][1.2951 (0.110878s)][1.20827 (0.173121s)][1.18463 (0.299456s)]]
+[[gmp_int][12.0605 (0.68832s)][8.13434 (0.696415s)][5.21762 (0.747577s)][3.11601 (0.787681s)]]
+[[tommath_int][10.0524 (0.57371s)][7.33116 (0.627651s)][4.85202 (0.695193s)][3.35808 (0.848871s)]]
 ]
 [table Operator *=(unsigned long long)
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][114.922 (7.57662s)][70.5882 (7.61458s)][44.3157 (7.67791s)][26.2881 (7.81595s)]]
-[[cpp_int(fixed)][[*1] (0.0659286s)][[*1] (0.107873s)][[*1] (0.173255s)][[*1] (0.297319s)]]
-[[gmp_int][47.9828 (3.16344s)][29.4972 (3.18196s)][18.1719 (3.14838s)][10.6941 (3.17956s)]]
-[[tommath_int][284.199 (18.7368s)][173.129 (18.676s)][109.052 (18.8938s)][64.5866 (19.2028s)]]
+[[cpp_int][111.27 (7.43118s)][67.7078 (7.34138s)][43.3851 (7.4075s)][25.3089 (7.55455s)]]
+[[cpp_int(fixed)][[*1] (0.0667848s)][[*1] (0.108427s)][[*1] (0.170738s)][[*1] (0.298493s)]]
+[[gmp_int][46.3718 (3.09693s)][28.4639 (3.08626s)][18.1719 (3.10264s)][10.5223 (3.14083s)]]
+[[tommath_int][276.674 (18.4776s)][169.146 (18.34s)][108.491 (18.5236s)][63.3261 (18.9024s)]]
 ]
 [table Operator /
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][2.71618 (0.616086s)][2.09988 (0.737246s)][1.65898 (0.94343s)][1.49441 (1.44418s)]]
-[[cpp_int(fixed)][[*1] (0.226821s)][[*1] (0.35109s)][[*1] (0.56868s)][[*1] (0.966385s)]]
-[[gmp_int][3.82134 (0.866761s)][2.75998 (0.969001s)][1.93226 (1.09884s)][1.34132 (1.29623s)]]
-[[tommath_int][13.2978 (3.01622s)][11.3314 (3.97833s)][9.94138 (5.65347s)][13.3423 (12.8938s)]]
+[[cpp_int][2.68035 (0.595251s)][2.04702 (0.707471s)][1.62314 (0.921536s)][1.43112 (1.38811s)]]
+[[cpp_int(fixed)][[*1] (0.222079s)][[*1] (0.34561s)][[*1] (0.567748s)][[*1] (0.969945s)]]
+[[gmp_int][3.79283 (0.842308s)][2.73668 (0.945824s)][1.86649 (1.05969s)][1.32141 (1.2817s)]]
+[[tommath_int][13.2531 (2.94324s)][11.2054 (3.87271s)][9.83293 (5.58262s)][13.0164 (12.6252s)]]
 ]
 [table Operator /(int)
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][4.15094 (0.23911s)][3.57962 (0.356615s)][3.11624 (0.578256s)][2.82967 (1.00414s)]]
-[[cpp_int(fixed)][2.42806 (0.139865s)][2.54164 (0.253208s)][2.43025 (0.450962s)][2.37209 (0.841768s)]]
-[[gmp_int][[*1] (0.0576038s)][[*1] (0.0996238s)][[*1] (0.185562s)][[*1] (0.354863s)]]
-[[tommath_int][36.3133 (2.09179s)][28.2731 (2.81668s)][21.8589 (4.05618s)][25.8061 (9.15762s)]]
+[[cpp_int][4.06026 (0.225473s)][3.45732 (0.340049s)][3.00195 (0.547957s)][2.80587 (0.978029s)]]
+[[cpp_int(fixed)][2.43766 (0.135367s)][2.56264 (0.252052s)][2.44011 (0.445402s)][2.38009 (0.829617s)]]
+[[gmp_int][[*1] (0.0555316s)][[*1] (0.0983563s)][[*1] (0.182534s)][[*1] (0.348566s)]]
+[[tommath_int][35.9988 (1.99907s)][27.1024 (2.66569s)][21.8333 (3.98531s)][25.8066 (8.99528s)]]
 ]
 [table Operator /(unsigned long long)
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][1.53953 (0.716927s)][1.40156 (1.65075s)][2.59584 (3.57744s)][4.58524 (8.3789s)]]
-[[cpp_int(fixed)][[*1] (0.465679s)][1.09556 (1.29034s)][2.2858 (3.15016s)][4.40115 (8.0425s)]]
-[[gmp_int][2.25405 (1.04967s)][[*1] (1.17779s)][[*1] (1.37814s)][[*1] (1.82736s)]]
-[[tommath_int][5.03884 (2.34648s)][2.63459 (3.103s)][3.67287 (5.06174s)][6.77479 (12.38s)]]
+[[cpp_int][1.50505 (0.705756s)][1.39347 (1.58556s)][2.63348 (3.57438s)][4.75451 (8.52733s)]]
+[[cpp_int(fixed)][[*1] (0.468925s)][1.12378 (1.27869s)][2.29966 (3.12128s)][4.4844 (8.04288s)]]
+[[gmp_int][2.17234 (1.01866s)][[*1] (1.13785s)][[*1] (1.35728s)][[*1] (1.79352s)]]
+[[tommath_int][4.74612 (2.22557s)][2.70088 (3.07319s)][3.65634 (4.96268s)][6.79408 (12.1853s)]]
 ]
 [table Operator /=(unsigned long long)
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][1.78744 (0.0586752s)][1.74065 (0.0616578s)][1.66814 (0.0740436s)][1.36231 (0.126362s)]]
-[[cpp_int(fixed)][[*1] (0.0328264s)][[*1] (0.0354222s)][[*1] (0.0443871s)][[*1] (0.0927553s)]]
-[[gmp_int][21.2392 (0.697207s)][19.3517 (0.68548s)][15.2936 (0.678837s)][7.37138 (0.683734s)]]
-[[tommath_int][32.8142 (1.07717s)][30.5556 (1.08235s)][24.7236 (1.09741s)][12.4072 (1.15084s)]]
+[[cpp_int][1.76281 (0.0574966s)][1.76471 (0.0604224s)][1.56085 (0.0716403s)][1.31422 (0.124043s)]]
+[[cpp_int(fixed)][[*1] (0.0326164s)][[*1] (0.0342393s)][[*1] (0.0458981s)][[*1] (0.0943852s)]]
+[[gmp_int][20.2862 (0.661664s)][19.4043 (0.664389s)][14.4881 (0.664976s)][7.14238 (0.674135s)]]
+[[tommath_int][32.9555 (1.07489s)][30.1525 (1.0324s)][22.8324 (1.04796s)][11.7456 (1.10861s)]]
 ]
 [table Operator %
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][1.86833 (0.37472s)][1.43076 (0.491332s)][1.30757 (0.708055s)][1.2528 (1.15842s)]]
-[[cpp_int(fixed)][[*1] (0.200565s)][[*1] (0.343407s)][[*1] (0.541503s)][[*1] (0.924662s)]]
-[[gmp_int][3.22603 (0.647027s)][2.08249 (0.715143s)][1.5148 (0.82027s)][1.09519 (1.01268s)]]
-[[tommath_int][15.4642 (3.10158s)][11.5534 (3.9675s)][10.5164 (5.69467s)][13.8962 (12.8493s)]]
+[[cpp_int][1.8501 (0.364131s)][1.46527 (0.476653s)][1.27509 (0.689738s)][1.20064 (1.11769s)]]
+[[cpp_int(fixed)][[*1] (0.196817s)][[*1] (0.325301s)][[*1] (0.540932s)][[*1] (0.930916s)]]
+[[gmp_int][3.2533 (0.640305s)][2.15441 (0.700832s)][1.47898 (0.800029s)][1.07439 (1.00016s)]]
+[[tommath_int][15.3501 (3.02116s)][12.1106 (3.9396s)][11.0689 (5.98752s)][13.5535 (12.6172s)]]
 ]
 [table Operator %(int)
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][1.80079 (0.106617s)][1.96413 (0.207216s)][2.09096 (0.395682s)][2.14767 (0.776873s)]]
-[[cpp_int(fixed)][1.73532 (0.10274s)][1.92036 (0.202599s)][2.02172 (0.382579s)][2.07328 (0.749963s)]]
-[[gmp_int][[*1] (0.0592053s)][[*1] (0.1055s)][[*1] (0.189234s)][[*1] (0.361727s)]]
-[[tommath_int][35.6993 (2.11359s)][25.3086 (2.67007s)][21.2701 (4.02504s)][25.8662 (9.3565s)]]
+[[cpp_int][1.82761 (0.104331s)][2.01496 (0.202512s)][2.10004 (0.389523s)][2.17252 (0.768097s)]]
+[[cpp_int(fixed)][1.78851 (0.102099s)][1.96844 (0.197838s)][2.02956 (0.376451s)][2.07257 (0.73276s)]]
+[[gmp_int][[*1] (0.057086s)][[*1] (0.100505s)][[*1] (0.185483s)][[*1] (0.353552s)]]
+[[tommath_int][36.3018 (2.07233s)][26.3075 (2.64402s)][21.9525 (4.07183s)][25.6759 (9.07775s)]]
 ]
 [table Operator construct
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][1.17135 (0.00274853s)][[*1] (0.00275161s)][[*1] (0.00275161s)][[*1] (0.00344359s)]]
-[[cpp_int(fixed)][[*1] (0.00234646s)][1.54518 (0.00425173s)][2.2494 (0.00618947s)][1.73247 (0.00596591s)]]
-[[gmp_int][85.6802 (0.201045s)][72.6635 (0.199941s)][78.1286 (0.214979s)][58.3553 (0.200952s)]]
-[[tommath_int][87.9831 (0.206449s)][74.8522 (0.205964s)][74.8918 (0.206073s)][63.4572 (0.218521s)]]
+[[cpp_int][1.40211 (0.0026854s)][[*1] (0.00278639s)][[*1] (0.00322813s)][[*1] (0.0027185s)]]
+[[cpp_int(fixed)][[*1] (0.00191526s)][1.40721 (0.00392103s)][1.90346 (0.00614463s)][2.14621 (0.00583447s)]]
+[[gmp_int][98.705 (0.189046s)][68.9726 (0.192184s)][58.8994 (0.190135s)][70.0525 (0.190438s)]]
+[[tommath_int][105.602 (0.202255s)][74.1994 (0.206748s)][63.6455 (0.205456s)][76.8935 (0.209035s)]]
 ]
 [table Operator construct(unsigned)
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][1.43934 (0.00268554s)][[*1] (0.00286887s)][[*1] (0.00283465s)][[*1] (0.00290638s)]]
-[[cpp_int(fixed)][[*1] (0.00186581s)][1.7597 (0.00504834s)][2.07419 (0.00587959s)][1.89871 (0.00551837s)]]
-[[gmp_int][125.861 (0.234832s)][72.7068 (0.208586s)][75.5147 (0.214058s)][71.2679 (0.207131s)]]
-[[tommath_int][240.568 (0.448854s)][155.552 (0.446257s)][157.598 (0.446734s)][160.728 (0.467137s)]]
+[[cpp_int][1.73436 (0.00348927s)][[*1] (0.00263476s)][[*1] (0.0027009s)][[*1] (0.00318651s)]]
+[[cpp_int(fixed)][[*1] (0.00201185s)][1.36851 (0.0036057s)][2.07362 (0.00560064s)][1.66856 (0.00531688s)]]
+[[gmp_int][97.2414 (0.195635s)][76.3759 (0.201232s)][72.7396 (0.196462s)][63.8129 (0.20334s)]]
+[[tommath_int][210.112 (0.422713s)][162.652 (0.42855s)][158.33 (0.427634s)][134.626 (0.428987s)]]
 ]
 [table Operator construct(unsigned long long)
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][2.3528 (0.00771495s)][1.61678 (0.00717424s)][1.12087 (0.00715985s)][1.2104 (0.0078878s)]]
-[[cpp_int(fixed)][[*1] (0.00327905s)][[*1] (0.00443737s)][[*1] (0.00638775s)][[*1] (0.00651668s)]]
-[[gmp_int][222.775 (0.730489s)][165.447 (0.734148s)][114.708 (0.732725s)][112.162 (0.730926s)]]
-[[tommath_int][215.962 (0.70815s)][157.945 (0.700858s)][109.582 (0.699985s)][111.909 (0.729275s)]]
-]
-[table Operator str
-[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][1.46938 (0.00196575s)][1.37205 (0.00331355s)][1.5689 (0.00862952s)][1.57176 (0.0237239s)]]
-[[cpp_int(fixed)][[*1] (0.00133781s)][[*1] (0.00241504s)][[*1] (0.00550035s)][1.20619 (0.0182059s)]]
-[[gmp_int][1.65482 (0.00221383s)][1.38972 (0.00335622s)][1.13845 (0.0062619s)][[*1] (0.0150938s)]]
-[[tommath_int][13.9845 (0.0187087s)][18.3179 (0.0442384s)][23.3489 (0.128427s)][25.3273 (0.382285s)]]
+[[cpp_int][2.34403 (0.00739542s)][1.66376 (0.00713834s)][1.22989 (0.0074969s)][1.23708 (0.00711417s)]]
+[[cpp_int(fixed)][[*1] (0.00315501s)][[*1] (0.00429049s)][[*1] (0.00609561s)][[*1] (0.0057508s)]]
+[[gmp_int][222.866 (0.703144s)][164.331 (0.705059s)][115.363 (0.70321s)][122.347 (0.703596s)]]
+[[tommath_int][218.681 (0.689941s)][163.796 (0.702765s)][114.57 (0.698376s)][122.422 (0.704027s)]]
 ]
 [table Operator gcd
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][2.03241 (5.06795s)][1.89904 (11.3002s)][1.99735 (27.4027s)][2.20708 (73.7574s)]]
-[[cpp_int(fixed)][1.67874 (4.18605s)][1.70044 (10.1184s)][1.96475 (26.9554s)][2.28347 (76.31s)]]
-[[gmp_int][[*1] (2.49357s)][[*1] (5.95047s)][[*1] (13.7195s)][[*1] (33.4185s)]]
-[[tommath_int][5.01832 (12.5135s)][4.41659 (26.2808s)][4.08042 (55.9814s)][3.97901 (132.972s)]]
-]
-[table Operator &
-[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][1.00344 (0.0315529s)][[*1] (0.0426295s)][[*1] (0.0543214s)][1.06624 (0.0835064s)]]
-[[cpp_int(fixed)][[*1] (0.0314446s)][1.0808 (0.046074s)][1.06116 (0.0576436s)][[*1] (0.0783186s)]]
-[[gmp_int][1.78372 (0.0560885s)][1.58661 (0.0676363s)][1.5738 (0.0854908s)][1.83409 (0.143644s)]]
-[[tommath_int][4.08054 (0.128311s)][3.50852 (0.149567s)][2.88826 (0.156894s)][4.45879 (0.349206s)]]
+[[cpp_int][1.16358 (2.74442s)][1.39847 (8.11559s)][1.64677 (22.2518s)][1.95096 (64.4961s)]]
+[[cpp_int(fixed)][[*1] (2.35859s)][1.30986 (7.60133s)][1.67681 (22.6577s)][2.0895 (69.0758s)]]
+[[gmp_int][1.03392 (2.4386s)][[*1] (5.80319s)][[*1] (13.5124s)][[*1] (33.0586s)]]
+[[tommath_int][5.25978 (12.4057s)][4.4619 (25.8932s)][4.15577 (56.1542s)][3.91192 (129.323s)]]
+]
+[table Operator powm
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][2.50722 (2.91621s)][3.5561 (13.406s)][4.37066 (73.483s)][4.88831 (473.91s)]]
+[[cpp_int(fixed)][1.93385 (2.24931s)][3.18107 (11.9922s)][4.20753 (70.7403s)][4.8158 (466.88s)]]
+[[gmp_int][[*1] (1.16313s)][[*1] (3.76986s)][[*1] (16.8128s)][[*1] (96.9476s)]]
+[[tommath_int][1.44081 (1.67584s)][1.8794 (7.08507s)][2.19115 (36.8394s)][2.17186 (210.557s)]]
 ]
-[table Operator &(int)
+[table Operator str
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][[*1] (0.0367605s)][[*1] (0.0485394s)][[*1] (0.0650023s)][[*1] (0.099751s)]]
-[[cpp_int(fixed)][1.00324 (0.0368795s)][1.06734 (0.0518081s)][1.05192 (0.0683771s)][1.05296 (0.105034s)]]
-[[gmp_int][4.00058 (0.147063s)][3.02928 (0.147039s)][2.22221 (0.144449s)][1.45749 (0.145386s)]]
-[[tommath_int][8.83732 (0.324864s)][6.95191 (0.337442s)][5.42556 (0.352674s)][6.10829 (0.609309s)]]
+[[cpp_int][1.17175 (0.00160006s)][1.41999 (0.00329476s)][1.40856 (0.00813784s)][1.52964 (0.0229767s)]]
+[[cpp_int(fixed)][[*1] (0.00136554s)][[*1] (0.00232027s)][[*1] (0.00577741s)][1.14754 (0.0172372s)]]
+[[gmp_int][1.50501 (0.00205515s)][1.52968 (0.00354926s)][1.01989 (0.0058923s)][[*1] (0.015021s)]]
+[[tommath_int][12.2161 (0.0166816s)][16.9577 (0.0393463s)][18.7474 (0.108311s)][22.7368 (0.341528s)]]
 ]
 [table Operator |
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][[*1] (0.0312723s)][[*1] (0.0428385s)][[*1] (0.0528083s)][[*1] (0.0827344s)]]
-[[cpp_int(fixed)][1.0311 (0.0322449s)][1.20267 (0.0515207s)][1.27028 (0.0670814s)][1.19432 (0.0988112s)]]
-[[gmp_int][1.55273 (0.0485576s)][1.4656 (0.0627839s)][1.66721 (0.0880424s)][1.67004 (0.13817s)]]
-[[tommath_int][4.15311 (0.129877s)][3.39008 (0.145226s)][2.88739 (0.152478s)][4.20575 (0.34796s)]]
+[[cpp_int][[*1] (0.0301617s)][[*1] (0.0423404s)][[*1] (0.0522358s)][[*1] (0.0813156s)]]
+[[cpp_int(fixed)][1.0638 (0.0320861s)][1.22566 (0.0518951s)][1.28515 (0.0671305s)][1.16118 (0.094422s)]]
+[[gmp_int][1.76553 (0.0532514s)][1.51489 (0.0641408s)][1.70708 (0.0891706s)][1.77346 (0.14421s)]]
+[[tommath_int][4.37637 (0.131999s)][3.46212 (0.146587s)][2.91875 (0.152463s)][4.19621 (0.341217s)]]
 ]
 [table Operator |(int)
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][1.01685 (0.030066s)][[*1] (0.0360965s)][[*1] (0.0402109s)][[*1] (0.0527074s)]]
-[[cpp_int(fixed)][[*1] (0.0295677s)][1.50234 (0.0542292s)][1.52609 (0.0613656s)][1.37526 (0.0724863s)]]
-[[gmp_int][4.84414 (0.14323s)][3.99297 (0.144132s)][3.85375 (0.154963s)][2.91129 (0.153447s)]]
-[[tommath_int][10.8218 (0.319975s)][9.05203 (0.326747s)][8.32597 (0.334795s)][10.948 (0.577039s)]]
+[[cpp_int][[*1] (0.0289129s)][[*1] (0.0351119s)][[*1] (0.0406779s)][[*1] (0.0525891s)]]
+[[cpp_int(fixed)][1.06091 (0.030674s)][1.25979 (0.0442336s)][1.36194 (0.0554009s)][1.37438 (0.0722772s)]]
+[[gmp_int][4.92854 (0.142498s)][4.34687 (0.152627s)][3.71442 (0.151095s)][2.981 (0.156768s)]]
+[[tommath_int][10.9847 (0.317598s)][9.37065 (0.329021s)][8.53651 (0.347248s)][11.2155 (0.589813s)]]
 ]
 [table Operator ^
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][[*1] (0.0311003s)][[*1] (0.0430909s)][[*1] (0.0530915s)][[*1] (0.0842599s)]]
-[[cpp_int(fixed)][1.04721 (0.0325686s)][1.18557 (0.0510874s)][1.25714 (0.0667433s)][1.14462 (0.0964459s)]]
-[[gmp_int][1.59277 (0.0495356s)][1.47967 (0.0637601s)][1.73243 (0.0919772s)][1.68499 (0.141977s)]]
-[[tommath_int][4.17425 (0.12982s)][3.41013 (0.146946s)][2.8988 (0.153902s)][4.17074 (0.351426s)]]
+[[cpp_int][[*1] (0.0305149s)][[*1] (0.04217s)][[*1] (0.0525977s)][[*1] (0.0816632s)]]
+[[cpp_int(fixed)][1.01544 (0.0309861s)][1.24872 (0.0526585s)][1.26661 (0.066621s)][1.15965 (0.0947007s)]]
+[[gmp_int][1.64675 (0.0502505s)][1.47181 (0.0620663s)][1.66038 (0.0873322s)][1.67895 (0.137108s)]]
+[[tommath_int][4.30668 (0.131418s)][3.45859 (0.145849s)][2.91462 (0.153303s)][4.15538 (0.339342s)]]
 ]
 [table Operator ^(int)
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][[*1] (0.0290428s)][[*1] (0.0360261s)][[*1] (0.0409722s)][[*1] (0.0541785s)]]
-[[cpp_int(fixed)][1.01484 (0.0294736s)][1.4898 (0.0536716s)][1.34782 (0.0552234s)][1.35054 (0.0731703s)]]
-[[gmp_int][4.94574 (0.143638s)][4.05569 (0.146111s)][3.65257 (0.149654s)][2.89039 (0.156597s)]]
-[[tommath_int][10.8939 (0.316389s)][9.21322 (0.331916s)][8.17995 (0.335151s)][10.6902 (0.579178s)]]
+[[cpp_int][1.01566 (0.0296088s)][[*1] (0.0356634s)][[*1] (0.0401898s)][[*1] (0.0514097s)]]
+[[cpp_int(fixed)][[*1] (0.0291524s)][1.2393 (0.0441976s)][1.38556 (0.0556856s)][1.38899 (0.0714075s)]]
+[[gmp_int][4.68027 (0.136441s)][4.15243 (0.14809s)][3.74237 (0.150405s)][3.0483 (0.156712s)]]
+[[tommath_int][10.919 (0.318314s)][9.16311 (0.326788s)][8.62554 (0.346659s)][11.6212 (0.597442s)]]
+]
+[table Operator &
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][1.0346 (0.0303431s)][[*1] (0.0427309s)][[*1] (0.0535587s)][1.06945 (0.0828084s)]]
+[[cpp_int(fixed)][[*1] (0.0293284s)][1.10435 (0.04719s)][1.05262 (0.0563769s)][[*1] (0.0774309s)]]
+[[gmp_int][1.86057 (0.0545675s)][1.58432 (0.0676995s)][1.69164 (0.0906018s)][1.86625 (0.144505s)]]
+[[tommath_int][4.4157 (0.129506s)][3.60396 (0.154s)][2.95985 (0.158525s)][4.4032 (0.340944s)]]
+]
+[table Operator &(int)
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][1.05874 (0.038946s)][[*1] (0.0483903s)][[*1] (0.063842s)][[*1] (0.100361s)]]
+[[cpp_int(fixed)][[*1] (0.0367853s)][1.05827 (0.0512099s)][1.09114 (0.0696605s)][1.09432 (0.109826s)]]
+[[gmp_int][3.92298 (0.144308s)][2.99447 (0.144903s)][2.228 (0.14224s)][1.42296 (0.142809s)]]
+[[tommath_int][8.79208 (0.323419s)][7.02288 (0.339839s)][5.65271 (0.36088s)][6.27104 (0.629365s)]]
 ]
 [table Operator <<
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][[*1] (0.0253777s)][1.04239 (0.034484s)][[*1] (0.0420979s)][[*1] (0.0623485s)]]
-[[cpp_int(fixed)][1.05039 (0.0266563s)][1.40679 (0.0465388s)][1.34077 (0.0564434s)][1.20319 (0.0750171s)]]
-[[gmp_int][1.0359 (0.0262888s)][[*1] (0.0330815s)][1.1625 (0.0489388s)][1.16511 (0.0726428s)]]
-[[tommath_int][1.65904 (0.0421025s)][2.11201 (0.0698686s)][2.36727 (0.0996572s)][2.701 (0.168403s)]]
+[[cpp_int][[*1] (0.0248801s)][1.23196 (0.04s)][[*1] (0.0424149s)][[*1] (0.060157s)]]
+[[cpp_int(fixed)][1.08931 (0.027102s)][1.40572 (0.0456418s)][1.3475 (0.0571542s)][1.24573 (0.0749397s)]]
+[[gmp_int][1.05561 (0.0262636s)][[*1] (0.0324686s)][1.09914 (0.0466199s)][1.16315 (0.0699719s)]]
+[[tommath_int][1.60497 (0.0399319s)][2.13048 (0.0691737s)][2.31219 (0.0980712s)][2.74695 (0.165248s)]]
 ]
 [table Operator >>
 [[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
-[[cpp_int][[*1] (0.0221035s)][1.0337 (0.0313761s)][1.03419 (0.0355718s)][1.20366 (0.0453508s)]]
-[[cpp_int(fixed)][1.1036 (0.0243933s)][1.12323 (0.0340936s)][1.40181 (0.0482162s)][1.69985 (0.0640463s)]]
-[[gmp_int][1.30456 (0.0288354s)][[*1] (0.0303532s)][[*1] (0.0343958s)][[*1] (0.0376776s)]]
-[[tommath_int][10.5766 (0.233779s)][9.0959 (0.27609s)][8.6249 (0.29666s)][13.6818 (0.515498s)]]
+[[cpp_int][[*1] (0.0213349s)][1.02127 (0.0295019s)][[*1] (0.0327116s)][1.13168 (0.0433804s)]]
+[[cpp_int(fixed)][1.13514 (0.0242181s)][1.16938 (0.0337803s)][1.46999 (0.0480859s)][1.60077 (0.061362s)]]
+[[gmp_int][1.26614 (0.0270129s)][[*1] (0.0288873s)][1.42219 (0.0465221s)][[*1] (0.0383329s)]]
+[[tommath_int][12.0066 (0.25616s)][10.2837 (0.297067s)][9.99696 (0.327017s)][16.0943 (0.616942s)]]
 ]
 
 Test code was compiled with Microsoft Visual Studio 2010 with all optimisations
@@ -3364,9 +3379,9 @@
 * Add a back-end for MPFR interval arithmetic.
 * Add better multiplication routines (Karatsuba, FFT etc) to cpp_int_backend.
 * Add assembly level routines to cpp_int_backend.
-* Add an all C++ Boost licenced binary floating point type.
+* Add an all C++ Boost licensed binary floating point type.
 * Can ring types (exact floating point types) be supported?  The answer should be yes, but someone needs to write it, 
-the hard part is IO and binary-decimal convertion.
+the hard part is IO and binary-decimal conversion.
 * Should there be a choice of rounding mode (probably MPFR specific)?
 * We can reuse temporaries in multiple subtrees (temporary caching).
 * cpp_dec_float should round to nearest.
@@ -3390,7 +3405,7 @@
 * Each back-end should document the requirements it satisfies (not currently scheduled for inclusion: it's
 deliberately an implementation detail, and "optional" requirements are optimisations which can't be detected
 by the user).  Not done: this is an implementation detail, the exact list of requirements satisfied is purely
-an optimimization, not something the user can detect.
+an optimization, not something the user can detect.
 * A backend for an overflow aware integers (done 2012/10/31).
 * IIUC convert_to is used to emulate in c++98 compilers C++11 explicit 
 conversions. Could the explicit conversion operator be added on 
@@ -3406,7 +3421,7 @@
 * The library interface should use the noexcept (BOOST_NOEXCEPT, ...) 
 facilities (Done 2012/09/15).
 * It is unfortunate that the generic mp_number front end can not make use 
-contexpr as not all the backends can ensure this (done - we can go quite a way).
+constexpr as not all the backends can ensure this (done - we can go quite a way).
 * literals: The library doesn't provide some kind of literals. I think that the 
 mp_number class should provide a way to create literals if the backend 
 is able to.  (Done 2012/09/15).
@@ -3421,7 +3436,7 @@
 template argument that defaults to 0 (meaning keep going till no more space/memory).  Done.
 * Can ring types (exact floating point types) be supported?  The answer should be yes, but someone needs to write it (Moved to TODO list).
 * Should there be a choice of rounding mode (probably MPFR specific)?  Moved to TODO list.
-* Make the exponent type for cpp_dec_float a templare parameter, maybe include support for big-integer exponents.
+* Make the exponent type for cpp_dec_float a template parameter, maybe include support for big-integer exponents.
 Open question - what should be the default - int32_t or int64_t?  (done 2012/09/06)
 * Document the size requirements of fixed precision ints (done 2012/09/15).
 * Document std lib function accuracy (done 2012/09/15).
@@ -3473,7 +3488,7 @@
    proto has to offer anyway, a lightweight expression template mechanism was used instead.
    Compile times are still too slow...]]
 [[Why not abstract out addition/multiplication algorithms?]
-   [This was deamed not to be practical: these algorithms are intimately
+   [This was deemed not to be practical: these algorithms are intimately
    tied to the actual data representation used.]]
 ]
 

Modified: branches/release/libs/multiprecision/example/floating_point_examples.cpp
==============================================================================
--- branches/release/libs/multiprecision/example/floating_point_examples.cpp	(original)
+++ branches/release/libs/multiprecision/example/floating_point_examples.cpp	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -163,7 +163,7 @@
 
    JEL(cpp_dec_float_50(v + 0.5), z);
 
-However, if we want the function JEL to be truely reusable, then a better solution might be preferred.
+However, if we want the function JEL to be truly reusable, then a better solution might be preferred.
 To achieve this we can borrow some code from Boost.Math which calculates the return type of mixed-argument
 functions, here's how the new code looks now:
 
@@ -543,7 +543,7 @@
    // to handle expression templates etc.  As a result it's hard to take its
    // address without knowing about its implementation details.  We'll use a 
    // C++11 lambda expression to capture the call.
-   // We also need a typecast on the first argument so we don't accidently pass
+   // We also need a typecast on the first argument so we don't accidentally pass
    // an expression template to a template function:
    //
    const cpp_dec_float_50 d_mp = derivative(

Modified: branches/release/libs/multiprecision/test/Jamfile.v2
==============================================================================
--- branches/release/libs/multiprecision/test/Jamfile.v2	(original)
+++ branches/release/libs/multiprecision/test/Jamfile.v2	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -26,6 +26,8 @@
    <toolset>msvc:<runtime-link>static
    <toolset>msvc:<link>static
    <toolset>msvc:<warnings>all
+   <toolset>intel-win:<runtime-link>static
+   <toolset>intel-win:<link>static
    # Speed up compiles:
    <toolset>msvc:<debug-symbols>off
    <toolset>intel:<debug-symbols>off

Modified: branches/release/libs/multiprecision/test/test_cpp_int.cpp
==============================================================================
--- branches/release/libs/multiprecision/test/test_cpp_int.cpp	(original)
+++ branches/release/libs/multiprecision/test/test_cpp_int.cpp	2012-12-20 12:42:14 EST (Thu, 20 Dec 2012)
@@ -325,13 +325,14 @@
       if(!std::numeric_limits<test_type>::is_modulo)
       {
          // We have to take care that our powers don't grow too large, otherwise this takes "forever",
-         // also don't test for modulo types, as these may give a diffferent result from arbitrary
+         // also don't test for modulo types, as these may give a different result from arbitrary
          // precision types:
          BOOST_CHECK_EQUAL(mpz_int(pow(d, ui % 19)).str(), test_type(pow(d1, ui % 19)).str());
          BOOST_CHECK_EQUAL(mpz_int(powm(a, b, c)).str(), test_type(powm(a1, b1, c1)).str());
          BOOST_CHECK_EQUAL(mpz_int(powm(a, b, ui)).str(), test_type(powm(a1, b1, ui)).str());
          BOOST_CHECK_EQUAL(mpz_int(powm(a, ui, c)).str(), test_type(powm(a1, ui, c1)).str());
       }
+      BOOST_CHECK_EQUAL(lsb(a), lsb(a1));
    }
 
    void test()