Enable one more noexcept test

Merge branch 'bugfix/bitwise-not-and-gcc6' of https://github.com/Flast/boost-integer into cpp14
Add tests for C++14 support.
2017-03-28 19:30:48 +01:00 · 2017-03-28 19:28:51 +01:00 · 2017-03-28 19:06:13 +01:00 · 2017-03-28 18:57:50 +01:00 · 2016-10-07 23:07:34 -05:00 · 2016-07-30 16:12:07 +09:00
54 changed files with 4953 additions and 2209 deletions
--- a/cstdint.htm
+++ b/cstdint.htm
@ -1,81 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
-<meta name="ProgId" content="FrontPage.Editor.Document">
-<title>Header boost/cstdint.hpp</title>
-</head>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-<h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align="center" width="277" height="86">Header
-boost/cstdint.hpp&nbsp;</h1>
-<p>The header <code><a href="../../boost/cstdint.hpp">&lt;boost/cstdint.hpp&gt;</a></code>
-provides the typedef's useful for
-writing portable code that requires certain integer widths.  All typedef's are in namespace boost.</p>
-<p>The specifications are based on the ISO/IEC 9899:1999 C Language standard
-header &lt;stdint.h&gt;.&nbsp; The 64-bit types required by the C standard are not
-required in the boost header, and may not be supplied in all implementations,
-because <code>long long</code> is not [yet] included in the C++ standard.</p>
-<p>See <a href="cstdint_test.cpp">cstdint_test.cpp</a> for a test program.</p>
-<h2>Exact-width integer types</h2>
-<p>The typedef <code>int#_t</code>, with # replaced by the width, designates a
-signed integer type of exactly # bits; <code>int8_t</code> denotes an 8-bit
-signed integer type.&nbsp; Similarly, the typedef <code>uint#_t</code>
-designates and unsigned integer type of exactly # bits.</p>
-<p>These types are optional. However, if an implementation provides integer
-types with widths of 8, 16, 32, or 64 bits, it shall define the corresponding
-typedef names.</p>
-<h2>Minimum-width integer types</h2>
-<p>The typedef <code>int_least#_t</code>, with # replaced by the width,&nbsp;
-designates a signed integer type with a width of at least # bits, such that no
-signed integer type with lesser size has at least the specified width. Thus, <code>int_least32_t</code>
-denotes a signed integer type with a width of at least 32 bits. Similarly, the
-typedef name <code>uint_least#_t</code> designates an unsigned integer type with
-a width of at least # bits, such that no unsigned integer type with lesser size
-has at least the specified width.</p>
-<p>Required minimum-width integer types:</p>
-<ul>
-  <li><code>int_least8_t</code></li>
-  <li><code>int_least16_t</code></li>
-  <li><code>int_least32_t</code></li>
-  <li><code>uint_least8_t</code></li>
-  <li><code>uint_least16_t</code></li>
-  <li><code>uint_least32_t</code></li>
-</ul>
-<p>All other minimum-width integer types are optional.</p>
-<h2>Fastest minimum-width integer types</h2>
-<p>The typedef <code>int_fast#_t</code>, with # replaced by the width,
-designates the fastest signed integer type with a width of at least # bits.
-Similarly, the typedef name <code>uint_fast#_t</code> designates the fastest
-unsigned integer type with a width of at least # bits.</p>
-<p>There is no guarantee that these types are fastest for all purposes.&nbsp; In
-any case, however, they satisfy&nbsp; the signedness and width requirements.</p>
-<p>Required fastest minimum-width integer types:</p>
-<ul>
-  <li><code>int_fast8_t</code></li>
-  <li><code>int_fast16_t</code></li>
-  <li><code>int_fast32_t</code></li>
-  <li><code>uint_fast8_t</code></li>
-  <li><code>uint_fast16_t</code></li>
-  <li><code>uint_fast32_t</code></li>
-</ul>
-<p>All other fastest minimum-width integer types are optional.</p>
-<h2>Greatest-width integer types</h2>
-<p>The typedef <code>intmax_t </code>designates a signed integer type capable of
-representing any value of any signed integer type.</p>
-<p>The typedef <code>uintmax_t</code> designates an unsigned integer type
-capable of representing any value of any unsigned integer type.</p>
-<p>These types are required.</p>
-<hr>
-<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->06 Nov 2007<!--webbot bot="Timestamp" endspan i-checksum="15272" -->
-</p>
-<p><EFBFBD> Copyright Beman Dawes 2000</p>
-
-<p>Distributed under the Boost Software License, Version 1.0. See
-<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
-
-</body>
-
-</html>
--- a/cstdint_test.cpp
+++ b/cstdint_test.cpp
@ -1,233 +0,0 @@
-//  boost cstdint.hpp test program  ------------------------------------------//
-
-//  Copyright Beman Dawes 2000.  Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-
-//  See http://www.boost.org/libs/integer for documentation.
-
-//  Revision History
-//   11 Sep 01  Adapted to work with macros defined in native stdint.h (John Maddock)
-//   12 Nov 00  Adapted to merged <boost/cstdint.hpp>
-//   23 Sep 00  Added INTXX_C constant macro support + int64_t support (John Maddock).
-//   28 Jun 00  Initial version
-#define __STDC_CONSTANT_MACROS
-#include <cassert>
-#include <iostream>
-#include <boost/cstdint.hpp>
-
-#ifdef NDEBUG
-int main()
-{
-  std::cout << "This test makes no sense with NDEBUG defined.\n";
-  return 0;
-}
-#else
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-//
-// the following class is designed to verify
-// that the various INTXX_C macros can be used
-// in integral constant expressions:
-//
-struct integral_constant_checker
-{
-  static const boost::int8_t          int8          = INT8_C(-127);
-  static const boost::int_least8_t    int_least8    = INT8_C(-127);
-  static const boost::int_fast8_t     int_fast8     = INT8_C(-127);
-
-  static const boost::uint8_t         uint8         = UINT8_C(255);
-  static const boost::uint_least8_t   uint_least8   = UINT8_C(255);
-  static const boost::uint_fast8_t    uint_fast8    = UINT8_C(255);
-
-  static const boost::int16_t         int16         = INT16_C(-32767);
-  static const boost::int_least16_t   int_least16   = INT16_C(-32767);
-  static const boost::int_fast16_t    int_fast16    = INT16_C(-32767);
-
-  static const boost::uint16_t        uint16         = UINT16_C(65535);
-  static const boost::uint_least16_t  uint_least16   = UINT16_C(65535);
-  static const boost::uint_fast16_t   uint_fast16    = UINT16_C(65535);
-
-  static const boost::int32_t         int32         = INT32_C(-2147483647);
-  static const boost::int_least32_t   int_least32   = INT32_C(-2147483647);
-  static const boost::int_fast32_t    int_fast32    = INT32_C(-2147483647);
-
-  static const boost::uint32_t        uint32        = UINT32_C(4294967295);
-  static const boost::uint_least32_t  uint_least32  = UINT32_C(4294967295);
-  static const boost::uint_fast32_t   uint_fast32   = UINT32_C(4294967295);
-
-  static void check();
-};
-
-void integral_constant_checker::check()
-{
-  assert( int8 == -127 );
-  assert( int_least8 == -127 );
-  assert( int_fast8 == -127 );
-  assert( uint8 == 255u );
-  assert( uint_least8 == 255u );
-  assert( uint_fast8 == 255u );
-  assert( int16 == -32767 );
-  assert( int_least16 == -32767 );
-  assert( int_fast16 == -32767 );
-  assert( uint16 == 65535u );
-  assert( uint_least16 == 65535u );
-  assert( uint_fast16 == 65535u );
-  assert( int32 == -2147483647 );
-  assert( int_least32 == -2147483647 );
-  assert( int_fast32 == -2147483647 );
-  assert( uint32 == 4294967295u );
-  assert( uint_least32 == 4294967295u );
-  assert( uint_fast32 == 4294967295u );
-}
-#endif // BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-
-//
-// the following function simply verifies that the type
-// of an integral constant is correctly defined:
-//
-#ifdef __BORLANDC__
-#pragma option -w-8008
-#pragma option -w-8066
-#endif
-template <class T1, class T2>
-void integral_constant_type_check(T1, T2)
-{
-   //
-   // the types T1 and T2 may not be exactly
-   // the same type, but they should be the
-   // same size and signedness. We could use
-   // numeric_limits to verify this, but
-   // numeric_limits implementations currently
-   // vary too much, or are incomplete or missing.
-   //
-   T1 t1 = static_cast<T1>(-1);  // cast suppresses warnings
-   T2 t2 = static_cast<T2>(-1);  // ditto
-#if defined(BOOST_HAS_STDINT_H)
-   // if we have a native stdint.h
-   // then the INTXX_C macros may define
-   // a type that's wider than required:
-   assert(sizeof(T1) <= sizeof(T2));
-#else
-   assert(sizeof(T1) == sizeof(T2));
-   assert(t1 == t2);
-#endif
-#if defined(BOOST_HAS_STDINT_H)
-   // native headers are permitted to promote small
-   // unsigned types to type int:
-   if(sizeof(T1) >= sizeof(int))
-   {
-      if(t1 > 0)
-        assert(t2 > 0);
-      else
-        assert(!(t2 > 0));
-   }
-   else if(t1 < 0)
-      assert(!(t2 > 0));
-#else
-   if(t1 > 0)
-     assert(t2 > 0);
-   else
-     assert(!(t2 > 0));
-#endif
-}
-
-
-int main()
-{
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-  integral_constant_checker::check();
-#endif
-  //
-  // verify the types of the integral constants:
-  //
-  integral_constant_type_check(boost::int8_t(0), INT8_C(0));
-  integral_constant_type_check(boost::uint8_t(0), UINT8_C(0));
-  integral_constant_type_check(boost::int16_t(0), INT16_C(0));
-  integral_constant_type_check(boost::uint16_t(0), UINT16_C(0));
-  integral_constant_type_check(boost::int32_t(0), INT32_C(0));
-  integral_constant_type_check(boost::uint32_t(0), UINT32_C(0));
-#ifndef BOOST_NO_INT64_T
-  integral_constant_type_check(boost::int64_t(0), INT64_C(0));
-  integral_constant_type_check(boost::uint64_t(0), UINT64_C(0));
-#endif
-  //
-  boost::int8_t          int8          = INT8_C(-127);
-  boost::int_least8_t    int_least8    = INT8_C(-127);
-  boost::int_fast8_t     int_fast8     = INT8_C(-127);
-
-  boost::uint8_t         uint8         = UINT8_C(255);
-  boost::uint_least8_t   uint_least8   = UINT8_C(255);
-  boost::uint_fast8_t    uint_fast8    = UINT8_C(255);
-
-  boost::int16_t         int16         = INT16_C(-32767);
-  boost::int_least16_t   int_least16   = INT16_C(-32767);
-  boost::int_fast16_t    int_fast16    = INT16_C(-32767);
-
-  boost::uint16_t        uint16         = UINT16_C(65535);
-  boost::uint_least16_t  uint_least16   = UINT16_C(65535);
-  boost::uint_fast16_t   uint_fast16    = UINT16_C(65535);
-
-  boost::int32_t         int32         = INT32_C(-2147483647);
-  boost::int_least32_t   int_least32   = INT32_C(-2147483647);
-  boost::int_fast32_t    int_fast32    = INT32_C(-2147483647);
-
-  boost::uint32_t        uint32        = UINT32_C(4294967295);
-  boost::uint_least32_t  uint_least32  = UINT32_C(4294967295);
-  boost::uint_fast32_t   uint_fast32   = UINT32_C(4294967295);
-
-#ifndef BOOST_NO_INT64_T
-  boost::int64_t         int64         = INT64_C(-9223372036854775807);
-  boost::int_least64_t   int_least64   = INT64_C(-9223372036854775807);
-  boost::int_fast64_t    int_fast64    = INT64_C(-9223372036854775807);
-
-  boost::uint64_t        uint64        = UINT64_C(18446744073709551615);
-  boost::uint_least64_t  uint_least64  = UINT64_C(18446744073709551615);
-  boost::uint_fast64_t   uint_fast64   = UINT64_C(18446744073709551615);
-
-  boost::intmax_t        intmax        = INTMAX_C(-9223372036854775807);
-  boost::uintmax_t       uintmax       = UINTMAX_C(18446744073709551615);
-#else
-  boost::intmax_t        intmax        = INTMAX_C(-2147483647);
-  boost::uintmax_t       uintmax       = UINTMAX_C(4294967295);
-#endif
-
-  assert( int8 == -127 );
-  assert( int_least8 == -127 );
-  assert( int_fast8 == -127 );
-  assert( uint8 == 255u );
-  assert( uint_least8 == 255u );
-  assert( uint_fast8 == 255u );
-  assert( int16 == -32767 );
-  assert( int_least16 == -32767 );
-  assert( int_fast16 == -32767 );
-  assert( uint16 == 65535u );
-  assert( uint_least16 == 65535u );
-  assert( uint_fast16 == 65535u );
-  assert( int32 == -2147483647 );
-  assert( int_least32 == -2147483647 );
-  assert( int_fast32 == -2147483647 );
-  assert( uint32 == 4294967295u );
-  assert( uint_least32 == 4294967295u );
-  assert( uint_fast32 == 4294967295u );
-
-#ifndef BOOST_NO_INT64_T
-  assert( int64 == INT64_C(-9223372036854775807) );
-  assert( int_least64 == INT64_C(-9223372036854775807) );
-  assert( int_fast64 == INT64_C(-9223372036854775807) );
-  assert( uint64 == UINT64_C(18446744073709551615) );
-  assert( uint_least64 == UINT64_C(18446744073709551615) );
-  assert( uint_fast64 == UINT64_C(18446744073709551615) );
-  assert( intmax == INT64_C(-9223372036854775807) );
-  assert( uintmax == UINT64_C(18446744073709551615) );
-#else
-  assert( intmax == -2147483647 );
-  assert( uintmax == 4294967295u );
-#endif
-
-
-  std::cout << "OK\n";
-  return 0;
-}
-#endif
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@ -0,0 +1,60 @@
+
+
+# Copyright John Maddock 2005. Use, modification, and distribution are
+# subject to the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+using quickbook ;
+
+xml integer : integer.qbk ;
+boostbook standalone
+    :
+        integer
+    :
+        # HTML options first:
+        # Use graphics not text for navigation:
+        <xsl:param>navig.graphics=1
+        # How far down we chunk nested sections, basically all of them:
+        <xsl:param>chunk.section.depth=1
+        # Don't put the first section on the same page as the TOC:
+        <xsl:param>chunk.first.sections=0
+        # How far down sections get TOC's
+        <xsl:param>toc.section.depth=1
+        # Max depth in each TOC:
+        <xsl:param>toc.max.depth=1
+        # How far down we go with TOC's
+        <xsl:param>generate.section.toc.level=4
+        # Path for links to Boost:
+        <xsl:param>boost.root=../../../..
+        
+        # PDF Options:
+        # TOC Generation: this is needed for FOP-0.9 and later:
+        <xsl:param>fop1.extensions=0
+        # Or enable this if you're using XEP:
+        <xsl:param>xep.extensions=1
+        # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
+        <xsl:param>fop.extensions=0
+        # No indent on body text:
+        <xsl:param>body.start.indent=0pt
+        # Margin size:
+        <xsl:param>page.margin.inner=0.5in
+        # Margin size:
+        <xsl:param>page.margin.outer=0.5in
+        # Yes, we want graphics for admonishments:
+        <xsl:param>admon.graphics=1
+        # Set this one for PDF generation *only*:
+        # default pnd graphics are awful in PDF form,
+        # better use SVG's instead:
+        <format>pdf:<xsl:param>admon.graphics.extension=".svg"
+        <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
+        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/regex/doc/html
+    ;
+
+install pdfinstall : standalone/<format>pdf : <location>. <install-type>PDF ;
+explicit pdfinstall ;
+
+###############################################################################
+alias boostdoc ;
+explicit boostdoc ;
+alias boostrelease : standalone ;
+explicit boostrelease ;
--- a/doc/gcd/math-gcd.qbk
+++ b/doc/gcd/math-gcd.qbk
@ -0,0 +1,258 @@
+
+[mathpart gcd_lcm Integer Utilities (Greatest Common Divisor and Least Common Multiple)]
+
+[section Introduction]
+
+The class and function templates in <boost/math/common_factor.hpp>
+provide run-time and compile-time evaluation of the greatest common divisor
+(GCD) or least common multiple (LCM) of two integers.
+These facilities are useful for many numeric-oriented generic
+programming problems.
+
+[endsect]
+
+[section Synopsis]
+
+   namespace boost
+   {
+   namespace math
+   {
+
+   template < typename IntegerType >
+      class gcd_evaluator;
+   template < typename IntegerType >
+      class lcm_evaluator;
+
+   template < typename IntegerType >
+      constexpr IntegerType  gcd( IntegerType const &a, IntegerType const &b );
+   template < typename IntegerType >
+      constexpr IntegerType  lcm( IntegerType const &a, IntegerType const &b );
+
+   typedef ``['see-below]`` static_gcd_type;
+
+   template < static_gcd_type Value1, static_gcd_type Value2 >
+      struct static_gcd;
+   template < static_gcd_type Value1, static_gcd_type Value2 >
+      struct static_lcm;
+
+   }
+   }
+
+[endsect]
+
+[section GCD Function Object]
+
+[*Header: ] [@../../../../boost/math/common_factor_rt.hpp <boost/math/common_factor_rt.hpp>]
+
+   template < typename IntegerType >
+   class boost::math::gcd_evaluator
+   {
+   public:
+      // Types
+      typedef IntegerType  result_type;
+      typedef IntegerType  first_argument_type;
+      typedef IntegerType  second_argument_type;
+
+      // Function object interface
+      constexpr result_type  operator ()( 
+	     first_argument_type const &a,
+         second_argument_type const &b ) const;
+   };
+
+The boost::math::gcd_evaluator class template defines a function object
+class to return the greatest common divisor of two integers.
+The template is parameterized by a single type, called IntegerType here.
+This type should be a numeric type that represents integers.
+The result of the function object is always nonnegative, even if either of
+the operator arguments is negative.
+
+This function object class template is used in the corresponding version of
+the GCD function template. If a numeric type wants to customize evaluations
+of its greatest common divisors, then the type should specialize on the
+gcd_evaluator class template.
+
+Note that these function objects are `constexpr` in C++14 and later only.  
+They are also declared `noexcept` when appropriate.
+
+[endsect]
+
+[section LCM Function Object]
+
+[*Header: ] [@../../../../boost/math/common_factor_rt.hpp <boost/math/common_factor_rt.hpp>]
+
+   template < typename IntegerType >
+   class boost::math::lcm_evaluator
+   {
+   public:
+      // Types
+      typedef IntegerType  result_type;
+      typedef IntegerType  first_argument_type;
+      typedef IntegerType  second_argument_type;
+
+      // Function object interface
+      constexpr result_type  operator ()( 
+		first_argument_type const &a,
+		second_argument_type const &b ) const;
+   };
+
+The boost::math::lcm_evaluator class template defines a function object
+class to return the least common multiple of two integers. The template
+is parameterized by a single type, called IntegerType here. This type
+should be a numeric type that represents integers. The result of the
+function object is always nonnegative, even if either of the operator
+arguments is negative. If the least common multiple is beyond the range
+of the integer type, the results are undefined.
+
+This function object class template is used in the corresponding version
+of the LCM function template. If a numeric type wants to customize
+evaluations of its least common multiples, then the type should
+specialize on the lcm_evaluator class template.
+
+Note that these function objects are constexpr in C++14 and later only.
+They are also declared `noexcept` when appropriate.
+
+[endsect]
+
+[section:run_time Run-time GCD & LCM Determination]
+
+[*Header: ] [@../../../../boost/math/common_factor_rt.hpp <boost/math/common_factor_rt.hpp>]
+
+   template < typename IntegerType >
+   constexpr IntegerType  boost::math::gcd( IntegerType const &a, IntegerType const &b );
+
+   template < typename IntegerType >
+   constexpr IntegerType  boost::math::lcm( IntegerType const &a, IntegerType const &b );
+
+The boost::math::gcd function template returns the greatest common
+(nonnegative) divisor of the two integers passed to it.
+The boost::math::lcm function template returns the least common
+(nonnegative) multiple of the two integers passed to it.
+The function templates are parameterized on the function arguments'
+IntegerType, which is also the return type. Internally, these function
+templates use an object of the corresponding version of the
+gcd_evaluator and lcm_evaluator class templates, respectively.
+
+Note that these functions are constexpr in C++14 and later only.
+They are also declared `noexcept` when appropriate.
+
+[endsect]
+
+[section:compile_time Compile time GCD and LCM determination]
+
+[*Header: ] [@../../../../boost/math/common_factor_ct.hpp <boost/math/common_factor_ct.hpp>]
+
+   typedef ``['unspecified]`` static_gcd_type;
+
+   template < static_gcd_type Value1, static_gcd_type Value2 >
+   struct boost::math::static_gcd : public mpl::integral_c<static_gcd_type, implementation_defined>
+   {
+   };
+
+   template < static_gcd_type Value1, static_gcd_type Value2 >
+   struct boost::math::static_lcm : public mpl::integral_c<static_gcd_type, implementation_defined>
+   {
+   };
+
+The type `static_gcd_type` is the widest unsigned-integer-type that is supported
+for use in integral-constant-expressions by the compiler.  Usually this
+the same type as `boost::uintmax_t`, but may fall back to being `unsigned long`
+for some older compilers.
+
+The boost::math::static_gcd and boost::math::static_lcm class templates
+take two value-based template parameters of the ['static_gcd_type] type
+and inherit from the type `boost::mpl::integral_c`.
+Inherited from the base class, they have a member /value/
+that is the greatest common factor or least
+common multiple, respectively, of the template arguments.
+A compile-time error will occur if the least common multiple
+is beyond the range of `static_gcd_type`.
+
+[h3 Example]
+
+   #include <boost/math/common_factor.hpp>
+   #include <algorithm>
+   #include <iterator>
+   #include <iostream>
+
+   int main()
+   {
+      using std::cout;
+      using std::endl;
+
+      cout << "The GCD and LCM of 6 and 15 are "
+      << boost::math::gcd(6, 15) << " and "
+      << boost::math::lcm(6, 15) << ", respectively."
+      << endl;
+
+      cout << "The GCD and LCM of 8 and 9 are "
+      << boost::math::static_gcd<8, 9>::value
+      << " and "
+      << boost::math::static_lcm<8, 9>::value
+      << ", respectively." << endl;
+
+      int  a[] = { 4, 5, 6 }, b[] = { 7, 8, 9 }, c[3];
+      std::transform( a, a + 3, b, c, boost::math::gcd_evaluator<int>() );
+      std::copy( c, c + 3, std::ostream_iterator<int>(cout, " ") );
+   }
+
+[endsect]
+
+[section:gcd_header Header <boost/math/common_factor.hpp>]
+
+This header simply includes the headers
+[@../../../../boost/math/common_factor_ct.hpp <boost/math/common_factor_ct.hpp>]
+and [@../../../../boost/math/common_factor_rt.hpp <boost/math/common_factor_rt.hpp>].
+
+Note this is a legacy header: it used to contain the actual implementation,
+but the compile-time and run-time facilities
+were moved to separate headers (since they were independent of each other).
+
+[endsect]
+
+[section:demo Demonstration Program]
+
+The program [@../../../../libs/math/test/common_factor_test.cpp common_factor_test.cpp] is a demonstration of the results from
+instantiating various examples of the run-time GCD and LCM function
+templates and the compile-time GCD and LCM class templates.
+(The run-time GCD and LCM class templates are tested indirectly through
+the run-time function templates.)
+
+[endsect]
+
+[section Rationale]
+
+The greatest common divisor and least common multiple functions are
+greatly used in some numeric contexts, including some of the other
+Boost libraries. Centralizing these functions to one header improves
+code factoring and eases maintainence.
+
+[endsect]
+
+[section:gcd_history History]
+
+* 13 May 2013 Moved into main Boost.Math Quickbook documentation.
+* 17 Dec 2005: Converted documentation to Quickbook Format.
+* 2 Jul 2002: Compile-time and run-time items separated to new headers.
+* 7 Nov 2001: Initial version
+
+[endsect]
+
+[section:gcd_credits Credits]
+
+The author of the Boost compilation of GCD and LCM computations is
+Daryle Walker. The code was prompted by existing code hiding in the
+implementations of Paul Moore's rational library and Steve Cleary's
+pool library. The code had updates by Helmut Zeisel.
+
+[endsect]
+
+[endmathpart]
+
+[/
+Copyright 2005, 2013 Daryle Walker.
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt).
+]
+
+
--- a/doc/html/boost_integer/cstdint.html
+++ b/doc/html/boost_integer/cstdint.html
@ -0,0 +1,49 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Removed from library: Standard Integer Types</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<link rel="home" href="../index.html" title="Boost.Integer">
+<link rel="up" href="../index.html" title="Boost.Integer">
+<link rel="prev" href="history.html" title="History">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="history.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.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">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_integer.cstdint"></a><a class="link" href="cstdint.html" title="Removed from library: Standard Integer Types">Removed from library: Standard Integer
+    Types</a>
+</h2></div></div></div>
+<p>
+      The <a href="../../../../../libs/config/doc/html/boost_config/cstdint.html" target="_top">Boost.Config</a>
+      module provides the typedefs useful for writing portable code that requires
+      certain integer widths.
+    </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2001-2009 Beman
+      Dawes, Daryle Walker, Gennaro Prota, John Maddock<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="history.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.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>
+</body>
+</html>
--- a/doc/html/boost_integer/history.html
+++ b/doc/html/boost_integer/history.html
@ -0,0 +1,90 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>History</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<link rel="home" href="../index.html" title="Boost.Integer">
+<link rel="up" href="../index.html" title="Boost.Integer">
+<link rel="prev" href="minmax.html" title="Compile time min/max calculation">
+<link rel="next" href="cstdint.html" title="Removed from library: Standard Integer Types">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="minmax.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.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="cstdint.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_integer.history"></a><a class="link" href="history.html" title="History">History</a>
+</h2></div></div></div>
+<h5>
+<a name="boost_integer.history.h0"></a>
+      <span class="phrase"><a name="boost_integer.history.1_56_0"></a></span><a class="link" href="history.html#boost_integer.history.1_56_0">1.56.0</a>
+    </h5>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+          Moved <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">cstdint</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> into <a href="../../../../../libs/config/index.html" target="_top">Boost.Config</a>.
+        </li></ul></div>
+<h5>
+<a name="boost_integer.history.h1"></a>
+      <span class="phrase"><a name="boost_integer.history.1_42_0"></a></span><a class="link" href="history.html#boost_integer.history.1_42_0">1.42.0</a>
+    </h5>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+          Reverted Trunk to release branch state (i.e. a "known good state").
+        </li>
+<li class="listitem">
+          Fixed issues: <a href="https://svn.boost.org/trac/boost/ticket/653" target="_top">653</a>,
+          <a href="https://svn.boost.org/trac/boost/ticket/3084" target="_top">3084</a>,
+          <a href="https://svn.boost.org/trac/boost/ticket/3177" target="_top">3177</a>,
+          <a href="https://svn.boost.org/trac/boost/ticket/3180" target="_top">3180</a>,
+          <a href="https://svn.boost.org/trac/boost/ticket/3548" target="_top">3568</a>,
+          <a href="https://svn.boost.org/trac/boost/ticket/3657" target="_top">3657</a>,
+          <a href="https://svn.boost.org/trac/boost/ticket/2134" target="_top">2134</a>.
+        </li>
+<li class="listitem">
+          Added long long support to <code class="literal">boost::static_log2</code>, <code class="literal">boost::static_signed_min</code>,
+          <code class="literal">boost::static_signed_max</code>, <code class="literal">boost::static_unsigned_min</code><code class="literal">boost::static_unsigned_max</code>,
+          when available.
+        </li>
+<li class="listitem">
+          The argument type and the result type of <code class="literal">boost::static_signed_min</code>
+          etc are now typedef'd. Formerly, they were hardcoded as <code class="literal">unsigned
+          long</code> and <code class="literal">int</code> respectively. Please, use the
+          provided typedefs in new code (and update old code as soon as possible).
+        </li>
+</ul></div>
+<h5>
+<a name="boost_integer.history.h2"></a>
+      <span class="phrase"><a name="boost_integer.history.1_32_0"></a></span><a class="link" href="history.html#boost_integer.history.1_32_0">1.32.0</a>
+    </h5>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+          The argument type and the result type of <code class="literal">boost::static_log2</code>
+          are now typedef'd. Formerly, they were hardcoded as <code class="literal">unsigned long</code>
+          and <code class="literal">int</code> respectively. Please, use the provided typedefs
+          in new code (and update old code as soon as possible).
+        </li></ul></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2001-2009 Beman
+      Dawes, Daryle Walker, Gennaro Prota, John Maddock<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="minmax.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.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="cstdint.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
--- a/doc/html/boost_integer/integer.html
+++ b/doc/html/boost_integer/integer.html
@ -0,0 +1,432 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Integer Type Selection</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<link rel="home" href="../index.html" title="Boost.Integer">
+<link rel="up" href="../index.html" title="Boost.Integer">
+<link rel="prev" href="traits.html" title="Integer Traits">
+<link rel="next" href="mask.html" title="Integer Masks">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="traits.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.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="mask.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_integer.integer"></a><a class="link" href="integer.html" title="Integer Type Selection">Integer Type Selection</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="integer.html#boost_integer.integer.synopsis">Synopsis</a></span></dt>
+<dt><span class="section"><a href="integer.html#boost_integer.integer.easiest">Easiest-to-Manipulate
+      Types</a></span></dt>
+<dt><span class="section"><a href="integer.html#boost_integer.integer.sized">Sized Types</a></span></dt>
+<dt><span class="section"><a href="integer.html#boost_integer.integer.example">Example</a></span></dt>
+<dt><span class="section"><a href="integer.html#boost_integer.integer.demonstration_program">Demonstration
+      Program</a></span></dt>
+<dt><span class="section"><a href="integer.html#boost_integer.integer.rationale">Rationale</a></span></dt>
+<dt><span class="section"><a href="integer.html#boost_integer.integer.alternative">Alternative</a></span></dt>
+<dt><span class="section"><a href="integer.html#boost_integer.integer.credits">Credits</a></span></dt>
+</dl></div>
+<p>
+      The <a href="../../../../../boost/integer.hpp" target="_top">&lt;boost/integer.hpp&gt;</a>
+      type selection templates allow integer types to be selected based on desired
+      characteristics such as number of bits or maximum value. This facility is particularly
+      useful for solving generic programming problems.
+    </p>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.integer.synopsis"></a><a class="link" href="integer.html#boost_integer.integer.synopsis" title="Synopsis">Synopsis</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
+<span class="special">{</span>
+  <span class="comment">//  fast integers from least integers</span>
+  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">LeastInt</span><span class="special">&gt;</span>
+  <span class="keyword">struct</span> <span class="identifier">int_fast_t</span>
+  <span class="special">{</span>
+      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">type</span><span class="special">;</span>
+  <span class="special">};</span>
+
+  <span class="comment">//  signed</span>
+  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="identifier">Bits</span><span class="special">&gt;</span>
+  <span class="keyword">struct</span> <span class="identifier">int_t</span>
+  <span class="special">{</span>
+      <span class="comment">/* Member exact may or may not be defined depending upon Bits */</span>
+      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">exact</span><span class="special">;</span>
+      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
+      <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special">&lt;</span><span class="identifier">least</span><span class="special">&gt;::</span><span class="identifier">fast</span>      <span class="identifier">fast</span><span class="special">;</span>
+  <span class="special">};</span>
+
+  <span class="comment">//  unsigned</span>
+  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="identifier">Bits</span><span class="special">&gt;</span>
+  <span class="keyword">struct</span> <span class="identifier">uint_t</span>
+  <span class="special">{</span>
+      <span class="comment">/* Member exact may or may not be defined depending upon Bits */</span>
+      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">exact</span><span class="special">;</span>
+      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
+      <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special">&lt;</span><span class="identifier">least</span><span class="special">&gt;::</span><span class="identifier">fast</span>      <span class="identifier">fast</span><span class="special">;</span>
+  <span class="special">};</span>
+
+  <span class="comment">//  signed</span>
+  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">MaxValue</span><span class="special">&gt;</span>
+  <span class="keyword">struct</span> <span class="identifier">int_max_value_t</span>
+  <span class="special">{</span>
+      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
+      <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special">&lt;</span><span class="identifier">least</span><span class="special">&gt;::</span><span class="identifier">fast</span>      <span class="identifier">fast</span><span class="special">;</span>
+  <span class="special">};</span>
+
+  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">MinValue</span><span class="special">&gt;</span>
+  <span class="keyword">struct</span> <span class="identifier">int_min_value_t</span>
+  <span class="special">{</span>
+      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
+      <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special">&lt;</span><span class="identifier">least</span><span class="special">&gt;::</span><span class="identifier">fast</span>      <span class="identifier">fast</span><span class="special">;</span>
+  <span class="special">};</span>
+
+  <span class="comment">//  unsigned</span>
+  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">Value</span><span class="special">&gt;</span>
+  <span class="keyword">struct</span> <span class="identifier">uint_value_t</span>
+  <span class="special">{</span>
+      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
+      <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special">&lt;</span><span class="identifier">least</span><span class="special">&gt;::</span><span class="identifier">fast</span>      <span class="identifier">fast</span><span class="special">;</span>
+  <span class="special">};</span>
+<span class="special">}</span> <span class="comment">// namespace boost</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.integer.easiest"></a><a class="link" href="integer.html#boost_integer.integer.easiest" title="Easiest-to-Manipulate Types">Easiest-to-Manipulate
+      Types</a>
+</h3></div></div></div>
+<p>
+        The <code class="literal">int_fast_t</code> class template maps its input type to the
+        next-largest type that the processor can manipulate the easiest, or to itself
+        if the input type is already an easy-to-manipulate type. For instance, processing
+        a bunch of <code class="literal">char</code> objects may go faster if they were converted
+        to <code class="literal">int</code> objects before processing. The input type, passed
+        as the only template parameter, must be a built-in integral type, except
+        <code class="literal">bool</code>. Unsigned integral types can be used, as well as
+        signed integral types. The output type is given as the nested type <code class="literal">fast</code>.
+      </p>
+<p>
+        <span class="bold"><strong>Implementation Notes:</strong></span> By default, the output
+        type is identical to the input type. Eventually, this code's implementation
+        should be customized for each platform to give accurate mappings between
+        the built-in types and the easiest-to-manipulate built-in types. Also, there
+        is no guarantee that the output type actually is easier to manipulate than
+        the input type.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.integer.sized"></a><a class="link" href="integer.html#boost_integer.integer.sized" title="Sized Types">Sized Types</a>
+</h3></div></div></div>
+<p>
+        The <code class="literal">int_t</code>, <code class="literal">uint_t</code>, <code class="literal">int_max_value_t</code>,
+        <code class="literal">int_min_value_t</code>, and <code class="literal">uint_value_t</code> class
+        templates find the most appropiate built-in integral type for the given template
+        parameter. This type is given by the nested type <code class="literal">least</code>.
+        The easiest-to-manipulate version of that type is given by the nested type
+        <code class="literal">fast</code>. The following table describes each template's criteria.
+      </p>
+<div class="table">
+<a name="boost_integer.integer.sized.criteria_for_the_sized_type_class_templates"></a><p class="title"><b>Table&#160;1.&#160;Criteria for the Sized Type Class Templates</b></p>
+<div class="table-contents"><table class="table" summary="Criteria for the Sized Type Class Templates">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+                <p>
+                  Class Template
+                </p>
+              </th>
+<th>
+                <p>
+                  Template Parameter Mapping
+                </p>
+              </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+                <p>
+                  <code class="literal">boost::int_t&lt;N&gt;::least</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  The smallest, built-in, signed integral type with at least <span class="emphasis"><em>N</em></span>
+                  bits, including the sign bit. The parameter should be a positive
+                  number. A compile-time error results if the parameter is larger
+                  than the number of bits in the largest integer type.
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">boost::int_t&lt;N&gt;::fast</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  The easiest-to-manipulate, built-in, signed integral type with
+                  at least <span class="emphasis"><em>N</em></span> bits, including the sign bit. The
+                  parameter should be a positive number. A compile-time error results
+                  if the parameter is larger than the number of bits in the largest
+                  integer type.
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">boost::int_t&lt;N&gt;::exact</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  A built-in, signed integral type with exactly <span class="emphasis"><em>N</em></span>
+                  bits, including the sign bit. The parameter should be a positive
+                  number. Note that the member <span class="emphasis"><em>exact</em></span> is defined
+                  <span class="bold"><strong>only</strong></span> if there exists a type with
+                  exactly <span class="emphasis"><em>N</em></span> bits.
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">boost::uint_t&lt;N&gt;::least</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  The smallest, built-in, unsigned integral type with at least <span class="emphasis"><em>N</em></span>
+                  bits. The parameter should be a positive number. A compile-time
+                  error results if the parameter is larger than the number of bits
+                  in the largest integer type.
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">boost::uint_t&lt;N&gt;::fast</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  The easiest-to-manipulate, built-in, unsigned integral type with
+                  at least <span class="emphasis"><em>N</em></span> bits. The parameter should be a
+                  positive number. A compile-time error results if the parameter
+                  is larger than the number of bits in the largest integer type.
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">boost::uint_t&lt;N&gt;::exact</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  A built-in, unsigned integral type with exactly <span class="emphasis"><em>N</em></span>
+                  bits. The parameter should be a positive number. A compile-time
+                  error results if the parameter is larger than the number of bits
+                  in the largest integer type. Note that the member <span class="emphasis"><em>exact</em></span>
+                  is defined <span class="bold"><strong>only</strong></span> if there exists
+                  a type with exactly N bits.
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">boost::int_max_value_t&lt;V&gt;::last</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  The smallest, built-in, signed integral type that can hold all
+                  the values in the inclusive range <span class="emphasis"><em>0 - V</em></span>. The
+                  parameter should be a positive number.
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">boost::int_max_value_t&lt;V&gt;::fast</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  The easiest-to-manipulate, built-in, signed integral type that
+                  can hold all the values in the inclusive range <span class="emphasis"><em>0 - V</em></span>.
+                  The parameter should be a positive number.
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">boost::int_min_value_t&lt;V&gt;::least</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  The smallest, built-in, signed integral type that can hold all
+                  the values in the inclusive range <span class="emphasis"><em>V - 0</em></span>. The
+                  parameter should be a negative number.
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">boost::int_min_value_t&lt;V&gt;::fast</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  The easiest-to-manipulate, built-in, signed integral type that
+                  can hold all the values in the inclusive range <span class="emphasis"><em>V - 0</em></span>.
+                  The parameter should be a negative number.
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">boost::uint_value_t&lt;V&gt;::least</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  The smallest, built-in, unsigned integral type that can hold all
+                  positive values up to and including <span class="emphasis"><em>V</em></span>. The
+                  parameter should be a positive number.
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">boost::uint_value_t&lt;V&gt;::fast</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  The easiest-to-manipulate, built-in, unsigned integral type that
+                  can hold all positive values up to and including <span class="emphasis"><em>V</em></span>.
+                  The parameter should be a positive number.
+                </p>
+              </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break">
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.integer.example"></a><a class="link" href="integer.html#boost_integer.integer.example" title="Example">Example</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+
+<span class="comment">//...</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+    <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int_t</span><span class="special">&lt;</span><span class="number">24</span><span class="special">&gt;::</span><span class="identifier">least</span> <span class="identifier">my_var</span><span class="special">;</span>  <span class="comment">// my_var has at least 24-bits</span>
+    <span class="comment">//...</span>
+    <span class="comment">// This one is guarenteed not to be truncated:</span>
+    <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int_max_value_t</span><span class="special">&lt;</span><span class="number">1000</span><span class="special">&gt;::</span><span class="identifier">least</span> <span class="identifier">my1000</span> <span class="special">=</span> <span class="number">1000</span><span class="special">;</span>
+    <span class="comment">//...</span>
+    <span class="comment">// This one is guarenteed not to be truncated, and as fast</span>
+    <span class="comment">// to manipulate as possible, its size may be greater than</span>
+    <span class="comment">// that of my1000:</span>
+    <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int_max_value_t</span><span class="special">&lt;</span><span class="number">1000</span><span class="special">&gt;::</span><span class="identifier">fast</span> <span class="identifier">my_fast1000</span> <span class="special">=</span> <span class="number">1000</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.integer.demonstration_program"></a><a class="link" href="integer.html#boost_integer.integer.demonstration_program" title="Demonstration Program">Demonstration
+      Program</a>
+</h3></div></div></div>
+<p>
+        The program <a href="../../../test/integer_test.cpp" target="_top">integer_test.cpp</a>
+        is a simplistic demonstration of the results from instantiating various examples
+        of the sized type class templates.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.integer.rationale"></a><a class="link" href="integer.html#boost_integer.integer.rationale" title="Rationale">Rationale</a>
+</h3></div></div></div>
+<p>
+        The rationale for the design of the templates in this header includes:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+            Avoid recursion because of concern about C++'s limited guaranteed recursion
+            depth (17).
+          </li>
+<li class="listitem">
+            Avoid macros on general principles.
+          </li>
+<li class="listitem">
+            Try to keep the design as simple as possible.
+          </li>
+</ul></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.integer.alternative"></a><a class="link" href="integer.html#boost_integer.integer.alternative" title="Alternative">Alternative</a>
+</h3></div></div></div>
+<p>
+        If the number of bits required is known beforehand, it may be more appropriate
+        to use the types supplied in <a href="../../../../../boost/cstdint.hpp" target="_top">&lt;boost/cstdint.hpp&gt;</a>.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.integer.credits"></a><a class="link" href="integer.html#boost_integer.integer.credits" title="Credits">Credits</a>
+</h3></div></div></div>
+<p>
+        The author of most of the Boost integer type choosing templates is <a href="http://www.boost.org/people/beman_dawes.html" target="_top">Beman Dawes</a>. He
+        gives thanks to Valentin Bonnard and <a href="http://www.boost.org/people/kevlin_henney.htm" target="_top">Kevlin
+        Henney</a> for sharing their designs for similar templates. <a href="http://www.boost.org/people/daryle_walker.html" target="_top">Daryle
+        Walker</a> designed the value-based sized templates.
+      </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2001-2009 Beman
+      Dawes, Daryle Walker, Gennaro Prota, John Maddock<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="traits.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.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="mask.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
--- a/doc/html/boost_integer/log2.html
+++ b/doc/html/boost_integer/log2.html
@ -0,0 +1,151 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Compile Time log2 Calculation</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<link rel="home" href="../index.html" title="Boost.Integer">
+<link rel="up" href="../index.html" title="Boost.Integer">
+<link rel="prev" href="mask.html" title="Integer Masks">
+<link rel="next" href="minmax.html" title="Compile time min/max calculation">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="mask.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.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="minmax.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_integer.log2"></a><a class="link" href="log2.html" title="Compile Time log2 Calculation">Compile Time log2 Calculation</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="log2.html#boost_integer.log2.synopsis">Synopsis</a></span></dt>
+<dt><span class="section"><a href="log2.html#boost_integer.log2.usage">Usage</a></span></dt>
+<dt><span class="section"><a href="log2.html#boost_integer.log2.demonstration_program">Demonstration
+      Program</a></span></dt>
+<dt><span class="section"><a href="log2.html#boost_integer.log2.rationale">Rationale</a></span></dt>
+<dt><span class="section"><a href="log2.html#boost_integer.log2.credits">Credits</a></span></dt>
+</dl></div>
+<p>
+      The class template in <a href="../../../../../boost/integer/static_log2.hpp" target="_top">&lt;boost/integer/static_log2.hpp&gt;</a>
+      determines the position of the highest bit in a given value. This facility
+      is useful for solving generic programming problems.
+    </p>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.log2.synopsis"></a><a class="link" href="log2.html#boost_integer.log2.synopsis" title="Synopsis">Synopsis</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
+<span class="special">{</span>
+
+  <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">static_log2_argument_type</span><span class="special">;</span>
+  <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">static_log2_result_type</span><span class="special">;</span>
+
+  <span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">static_log2_argument_type</span> <span class="identifier">arg</span><span class="special">&gt;</span>
+  <span class="keyword">struct</span> <span class="identifier">static_log2</span>
+  <span class="special">{</span>
+    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">static_log2_result_type</span> <span class="identifier">value</span> <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
+  <span class="special">};</span>
+
+
+  <span class="keyword">template</span> <span class="special">&lt;</span> <span class="special">&gt;</span>
+  <span class="keyword">struct</span> <span class="identifier">static_log2</span><span class="special">&lt;</span> <span class="number">0</span> <span class="special">&gt;</span>
+  <span class="special">{</span>
+    <span class="comment">// The logarithm of zero is undefined.</span>
+  <span class="special">};</span>
+
+
+<span class="special">}</span>  <span class="comment">// namespace boost</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.log2.usage"></a><a class="link" href="log2.html#boost_integer.log2.usage" title="Usage">Usage</a>
+</h3></div></div></div>
+<p>
+        The <code class="literal">boost::static_log2</code> class template takes one template
+        parameter, a value of type <code class="literal">static_log2_argument_type</code>.
+        The template only defines one member, <code class="literal">value</code>, which gives
+        the truncated, base-two logarithm of the template argument.
+      </p>
+<p>
+        Since the logarithm of zero, for any base, is undefined, there is a specialization
+        of <code class="literal">static_log2</code> for a template argument of zero. This specialization
+        has no members, so an attempt to use the base-two logarithm of zero results
+        in a compile-time error.
+      </p>
+<p>
+        Note:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+            <code class="literal">static_log2_argument_type</code> is an <span class="emphasis"><em>unsigned
+            integer type</em></span> (C++ standard, 3.9.1p3).
+          </li>
+<li class="listitem">
+            <code class="literal">static_log2_result_type</code> is an <span class="emphasis"><em>integer type</em></span>
+            (C++ standard, 3.9.1p7).
+          </li>
+</ul></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.log2.demonstration_program"></a><a class="link" href="log2.html#boost_integer.log2.demonstration_program" title="Demonstration Program">Demonstration
+      Program</a>
+</h3></div></div></div>
+<p>
+        The program <a href="../../../test/static_log2_test.cpp" target="_top">static_log2_test.cpp</a>
+        is a simplistic demonstration of the results from instantiating various examples
+        of the binary logarithm class template.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.log2.rationale"></a><a class="link" href="log2.html#boost_integer.log2.rationale" title="Rationale">Rationale</a>
+</h3></div></div></div>
+<p>
+        The base-two (binary) logarithm, abbreviated lb, function is occasionally
+        used to give order-estimates of computer algorithms. The truncated logarithm
+        can be considered the highest power-of-two in a value, which corresponds
+        to the value's highest set bit (for binary integers). Sometimes the highest-bit
+        position could be used in generic programming, which requires the position
+        to be available statically (<span class="emphasis"><em>i.e.</em></span> at compile-time).
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.log2.credits"></a><a class="link" href="log2.html#boost_integer.log2.credits" title="Credits">Credits</a>
+</h3></div></div></div>
+<p>
+        The original version of the Boost binary logarithm class template was written
+        by <a href="http://www.boost.org/people/daryle_walker.html" target="_top">Daryle Walker</a>
+        and then enhanced by Giovanni Bajo with support for compilers without partial
+        template specialization. The current version was suggested, together with
+        a reference implementation, by Vesa Karvonen. Gennaro Prota wrote the actual
+        source file.
+      </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2001-2009 Beman
+      Dawes, Daryle Walker, Gennaro Prota, John Maddock<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="mask.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.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="minmax.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
--- a/doc/html/boost_integer/mask.html
+++ b/doc/html/boost_integer/mask.html
@ -0,0 +1,380 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Integer Masks</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<link rel="home" href="../index.html" title="Boost.Integer">
+<link rel="up" href="../index.html" title="Boost.Integer">
+<link rel="prev" href="integer.html" title="Integer Type Selection">
+<link rel="next" href="log2.html" title="Compile Time log2 Calculation">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="integer.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.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="log2.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_integer.mask"></a><a class="link" href="mask.html" title="Integer Masks">Integer Masks</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="mask.html#boost_integer.mask.overview">Overview</a></span></dt>
+<dt><span class="section"><a href="mask.html#boost_integer.mask.synopsis">Synopsis</a></span></dt>
+<dt><span class="section"><a href="mask.html#boost_integer.mask.single_bit_mask_class_template">Single
+      Bit-Mask Class Template</a></span></dt>
+<dt><span class="section"><a href="mask.html#boost_integer.mask.group_bit_mask_class_template">Group
+      Bit-Mask Class Template</a></span></dt>
+<dt><span class="section"><a href="mask.html#boost_integer.mask.implementation_notes">Implementation
+      Notes</a></span></dt>
+<dt><span class="section"><a href="mask.html#boost_integer.mask.example">Example</a></span></dt>
+<dt><span class="section"><a href="mask.html#boost_integer.mask.demonstration_program">Demonstration
+      Program</a></span></dt>
+<dt><span class="section"><a href="mask.html#boost_integer.mask.rationale">Rationale</a></span></dt>
+<dt><span class="section"><a href="mask.html#boost_integer.mask.credits">Credits</a></span></dt>
+</dl></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.mask.overview"></a><a class="link" href="mask.html#boost_integer.mask.overview" title="Overview">Overview</a>
+</h3></div></div></div>
+<p>
+        The class templates in <a href="../../../../../boost/integer/integer_mask.hpp" target="_top">&lt;boost/integer/integer_mask.hpp&gt;</a>
+        provide bit masks for a certain bit position or a contiguous-bit pack of
+        a certain size. The types of the masking constants come from the <a class="link" href="integer.html" title="Integer Type Selection">integer
+        type selection templates</a> header.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.mask.synopsis"></a><a class="link" href="mask.html#boost_integer.mask.synopsis" title="Synopsis">Synopsis</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">cstddef</span><span class="special">&gt;</span>  <span class="comment">// for std::size_t</span>
+
+<span class="keyword">namespace</span> <span class="identifier">boost</span>
+<span class="special">{</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Bit</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">high_bit_mask_t</span>
+<span class="special">{</span>
+    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
+    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">fast</span><span class="special">;</span>
+
+    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">least</span>       <span class="identifier">high_bit</span>       <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
+    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">fast</span>        <span class="identifier">high_bit_fast</span>  <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
+
+    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">bit_position</span>   <span class="special">=</span> <span class="identifier">Bit</span><span class="special">;</span>
+<span class="special">};</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Bits</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">low_bits_mask_t</span>
+<span class="special">{</span>
+    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
+    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">fast</span><span class="special">;</span>
+
+    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">least</span>       <span class="identifier">sig_bits</span>       <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
+    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">fast</span>        <span class="identifier">sig_bits_fast</span>  <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
+
+    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">bit_count</span>      <span class="special">=</span> <span class="identifier">Bits</span><span class="special">;</span>
+<span class="special">};</span>
+
+<span class="comment">// Specializations for low_bits_mask_t exist for certain bit counts.</span>
+
+<span class="special">}</span>  <span class="comment">// namespace boost</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.mask.single_bit_mask_class_template"></a><a class="link" href="mask.html#boost_integer.mask.single_bit_mask_class_template" title="Single Bit-Mask Class Template">Single
+      Bit-Mask Class Template</a>
+</h3></div></div></div>
+<p>
+        The <code class="literal">boost::high_bit_mask_t</code> class template provides constants
+        for bit masks representing the bit at a certain position. The masks are equivalent
+        to the value 2<sup>Bit</sup>, where <code class="literal">Bit</code> is the template parameter.
+        The bit position must be a nonnegative number from zero to <span class="emphasis"><em>Max</em></span>,
+        where Max is one less than the number of bits supported by the largest unsigned
+        built-in integral type. The following table describes the members of an instantiation
+        of <code class="literal">high_bit_mask_t</code>.
+      </p>
+<div class="table">
+<a name="boost_integer.mask.single_bit_mask_class_template.members_of_the__boost__high_bit_mask_t__class_template"></a><p class="title"><b>Table&#160;2.&#160;Members of the <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">high_bit_mask_t</span></code>
+        Class Template</b></p>
+<div class="table-contents"><table class="table" summary="Members of the boost::high_bit_mask_t
+        Class Template">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+                <p>
+                  Member
+                </p>
+              </th>
+<th>
+                <p>
+                  Meaning
+                </p>
+              </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+                <p>
+                  <code class="literal">least</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  The smallest, unsigned, built-in type that supports the given bit
+                  position.
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">fast</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  The easiest-to-manipulate analog of <code class="literal">least</code>.
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">high_bit</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  A <code class="literal">least</code> constant of the value 2<sup>Bit</sup>.
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">high_bit_fast</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  A <code class="literal">fast</code> analog of <code class="literal">high_bit</code>.
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">bit_position</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  The value of the template parameter, in case its needed from a
+                  renamed instantiation of the class template.
+                </p>
+              </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break">
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.mask.group_bit_mask_class_template"></a><a class="link" href="mask.html#boost_integer.mask.group_bit_mask_class_template" title="Group Bit-Mask Class Template">Group
+      Bit-Mask Class Template</a>
+</h3></div></div></div>
+<p>
+        The <code class="literal">boost::low_bits_mask_t</code> class template provides constants
+        for bit masks equivalent to the value (2<sup>Bits</sup> - 1), where <code class="literal">Bits</code>
+        is the template parameter. The parameter <code class="literal">Bits</code> must be
+        a non-negative integer from zero to <span class="emphasis"><em>Max</em></span>, where Max is
+        the number of bits supported by the largest, unsigned, built-in integral
+        type. The following table describes the members of <code class="literal">low_bits_mask_t</code>.
+      </p>
+<div class="table">
+<a name="boost_integer.mask.group_bit_mask_class_template.members_of_the___boost__low_bits_mask_t__class_template"></a><p class="title"><b>Table&#160;3.&#160;Members of the <code class="literal">boost::low_bits_mask_t</code> Class Template</b></p>
+<div class="table-contents"><table class="table" summary="Members of the boost::low_bits_mask_t Class Template">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+                <p>
+                  Member
+                </p>
+              </th>
+<th>
+                <p>
+                  Meaning
+                </p>
+              </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+                <p>
+                  <code class="literal">least</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  The smallest, unsigned built-in type that supports the given bit
+                  count.
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">fast</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  The easiest-to-manipulate analog of <code class="literal">least</code>.
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">sig_bits</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  A <code class="literal">least</code> constant of the desired bit-masking
+                  value.
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">sig_bits_fast</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  A <code class="literal">fast</code> analog of <code class="literal">sig_bits</code>.
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">bit_count</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  The value of the template parameter, in case its needed from a
+                  renamed instantiation of the class template.
+                </p>
+              </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break">
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.mask.implementation_notes"></a><a class="link" href="mask.html#boost_integer.mask.implementation_notes" title="Implementation Notes">Implementation
+      Notes</a>
+</h3></div></div></div>
+<p>
+        When <code class="literal">Bits</code> is the exact size of a built-in unsigned type,
+        the implementation has to change to prevent undefined behavior. Therefore,
+        there are specializations of <code class="literal">low_bits_mask_t</code> at those
+        bit counts.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.mask.example"></a><a class="link" href="mask.html#boost_integer.mask.example" title="Example">Example</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">/</span><span class="identifier">integer_mask</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+
+<span class="comment">//...</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+    <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">high_bit_mask_t</span><span class="special">&lt;</span><span class="number">29</span><span class="special">&gt;</span>  <span class="identifier">mask1_type</span><span class="special">;</span>
+    <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">low_bits_mask_t</span><span class="special">&lt;</span><span class="number">15</span><span class="special">&gt;</span>  <span class="identifier">mask2_type</span><span class="special">;</span>
+
+    <span class="identifier">mask1_type</span><span class="special">::</span><span class="identifier">least</span>  <span class="identifier">my_var1</span><span class="special">;</span>
+    <span class="identifier">mask2_type</span><span class="special">::</span><span class="identifier">fast</span>   <span class="identifier">my_var2</span><span class="special">;</span>
+    <span class="comment">//...</span>
+
+    <span class="identifier">my_var1</span> <span class="special">|=</span> <span class="identifier">mask1_type</span><span class="special">::</span><span class="identifier">high_bit</span><span class="special">;</span>
+    <span class="identifier">my_var2</span> <span class="special">&amp;=</span> <span class="identifier">mask2_type</span><span class="special">::</span><span class="identifier">sig_bits_fast</span><span class="special">;</span>
+
+    <span class="comment">//...</span>
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.mask.demonstration_program"></a><a class="link" href="mask.html#boost_integer.mask.demonstration_program" title="Demonstration Program">Demonstration
+      Program</a>
+</h3></div></div></div>
+<p>
+        The program <a href="../../../test/integer_mask_test.cpp" target="_top">integer_mask_test.cpp</a>
+        is a simplistic demonstration of the results from instantiating various examples
+        of the bit mask class templates.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.mask.rationale"></a><a class="link" href="mask.html#boost_integer.mask.rationale" title="Rationale">Rationale</a>
+</h3></div></div></div>
+<p>
+        The class templates in this header are an extension of the <a class="link" href="integer.html" title="Integer Type Selection">integer
+        type selection class templates</a>. The new class templates provide the
+        same sized types, but also convenient masks to use when extracting the highest
+        or all the significant bits when the containing built-in type contains more
+        bits. This prevents contamination of values by the higher, unused bits.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.mask.credits"></a><a class="link" href="mask.html#boost_integer.mask.credits" title="Credits">Credits</a>
+</h3></div></div></div>
+<p>
+        The author of the Boost bit mask class templates is <a href="http://www.boost.org/people/daryle_walker.html" target="_top">Daryle
+        Walker</a>.
+      </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2001-2009 Beman
+      Dawes, Daryle Walker, Gennaro Prota, John Maddock<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="integer.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.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="log2.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
--- a/doc/html/boost_integer/minmax.html
+++ b/doc/html/boost_integer/minmax.html
@ -0,0 +1,160 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Compile time min/max calculation</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<link rel="home" href="../index.html" title="Boost.Integer">
+<link rel="up" href="../index.html" title="Boost.Integer">
+<link rel="prev" href="log2.html" title="Compile Time log2 Calculation">
+<link rel="next" href="history.html" title="History">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="log2.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.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="history.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_integer.minmax"></a><a class="link" href="minmax.html" title="Compile time min/max calculation">Compile time min/max calculation</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="minmax.html#boost_integer.minmax.synopsis">Synopsis</a></span></dt>
+<dt><span class="section"><a href="minmax.html#boost_integer.minmax.usage">Usage</a></span></dt>
+<dt><span class="section"><a href="minmax.html#boost_integer.minmax.example">Example</a></span></dt>
+<dt><span class="section"><a href="minmax.html#boost_integer.minmax.demonstration_program">Demonstration
+      Program</a></span></dt>
+<dt><span class="section"><a href="minmax.html#boost_integer.minmax.rationale">Rationale</a></span></dt>
+<dt><span class="section"><a href="minmax.html#boost_integer.minmax.credits">Credits</a></span></dt>
+</dl></div>
+<p>
+      The class templates in <a href="../../../../../boost/integer/static_min_max.hpp" target="_top">&lt;boost/integer/static_min_max.hpp&gt;</a>
+      provide a compile-time evaluation of the minimum or maximum of two integers.
+      These facilities are useful for generic programming problems.
+    </p>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.minmax.synopsis"></a><a class="link" href="minmax.html#boost_integer.minmax.synopsis" title="Synopsis">Synopsis</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
+<span class="special">{</span>
+
+<span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">static_min_max_signed_type</span><span class="special">;</span>
+<span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">static_min_max_unsigned_type</span><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">static_min_max_signed_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_min_max_signed_type</span> <span class="identifier">Value2</span> <span class="special">&gt;</span>
+    <span class="keyword">struct</span> <span class="identifier">static_signed_min</span><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">static_min_max_signed_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_min_max_signed_type</span> <span class="identifier">Value2</span><span class="special">&gt;</span>
+    <span class="keyword">struct</span> <span class="identifier">static_signed_max</span><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">static_min_max_unsigned_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_min_max_unsigned_type</span> <span class="identifier">Value2</span><span class="special">&gt;</span>
+    <span class="keyword">struct</span> <span class="identifier">static_unsigned_min</span><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">static_min_max_unsigned_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_min_max_unsigned_type</span> <span class="identifier">Value2</span><span class="special">&gt;</span>
+    <span class="keyword">struct</span> <span class="identifier">static_unsigned_max</span><span class="special">;</span>
+
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.minmax.usage"></a><a class="link" href="minmax.html#boost_integer.minmax.usage" title="Usage">Usage</a>
+</h3></div></div></div>
+<p>
+        The four class templates provide the combinations for finding the minimum
+        or maximum of two <code class="literal">signed</code> or <code class="literal">unsigned</code>
+        (<code class="literal">long</code>) parameters, <span class="emphasis"><em>Value1</em></span> and <span class="emphasis"><em>Value2</em></span>,
+        at compile-time. Each template has a single static data member, <code class="literal">value</code>,
+        which is set to the respective minimum or maximum of the template's parameters.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.minmax.example"></a><a class="link" href="minmax.html#boost_integer.minmax.example" title="Example">Example</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">/</span><span class="identifier">static_min_max</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="identifier">AddendSize1</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="identifier">AddendSize2</span> <span class="special">&gt;</span>
+<span class="keyword">class</span> <span class="identifier">adder</span>
+<span class="special">{</span>
+<span class="keyword">public</span><span class="special">:</span>
+    <span class="keyword">static</span>  <span class="keyword">unsigned</span> <span class="keyword">long</span>  <span class="keyword">const</span>  <span class="identifier">addend1_size</span> <span class="special">=</span> <span class="identifier">AddendSize1</span><span class="special">;</span>
+    <span class="keyword">static</span>  <span class="keyword">unsigned</span> <span class="keyword">long</span>  <span class="keyword">const</span>  <span class="identifier">addend2_size</span> <span class="special">=</span> <span class="identifier">AddendSize2</span><span class="special">;</span>
+    <span class="keyword">static</span>  <span class="keyword">unsigned</span> <span class="keyword">long</span>  <span class="keyword">const</span>  <span class="identifier">sum_size</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">static_unsigned_max</span><span class="special">&lt;</span><span class="identifier">AddendSize1</span><span class="special">,</span> <span class="identifier">AddendSize2</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="special">+</span> <span class="number">1</span><span class="special">;</span>
+
+    <span class="keyword">typedef</span> <span class="keyword">int</span>  <span class="identifier">addend1_type</span><span class="special">[</span> <span class="identifier">addend1_size</span> <span class="special">];</span>
+    <span class="keyword">typedef</span> <span class="keyword">int</span>  <span class="identifier">addend2_type</span><span class="special">[</span> <span class="identifier">addend2_size</span> <span class="special">];</span>
+    <span class="keyword">typedef</span> <span class="keyword">int</span>  <span class="identifier">sum_type</span><span class="special">[</span> <span class="identifier">sum_size</span> <span class="special">];</span>
+
+    <span class="keyword">void</span>  <span class="keyword">operator</span> <span class="special">()(</span> <span class="identifier">addend1_type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">a1</span><span class="special">,</span> <span class="identifier">addend2_type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">a2</span><span class="special">,</span> <span class="identifier">sum_type</span> <span class="special">&amp;</span><span class="identifier">s</span> <span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="special">};</span>
+
+<span class="comment">//...</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+    <span class="keyword">int</span> <span class="keyword">const</span>   <span class="identifier">a1</span><span class="special">[]</span> <span class="special">=</span> <span class="special">{</span> <span class="number">0</span><span class="special">,</span> <span class="number">4</span><span class="special">,</span> <span class="number">3</span> <span class="special">};</span>  <span class="comment">// 340</span>
+    <span class="keyword">int</span> <span class="keyword">const</span>   <span class="identifier">a2</span><span class="special">[]</span> <span class="special">=</span> <span class="special">{</span> <span class="number">9</span><span class="special">,</span> <span class="number">8</span> <span class="special">};</span>     <span class="comment">//  89</span>
+    <span class="keyword">int</span>         <span class="identifier">s</span><span class="special">[</span> <span class="number">4</span> <span class="special">];</span>
+    <span class="identifier">adder</span><span class="special">&lt;</span><span class="number">3</span><span class="special">,</span><span class="number">2</span><span class="special">&gt;</span>  <span class="identifier">obj</span><span class="special">;</span>
+
+    <span class="identifier">obj</span><span class="special">(</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">a2</span><span class="special">,</span> <span class="identifier">s</span> <span class="special">);</span>  <span class="comment">// 's' should be 429 or { 9, 2, 4, 0 }</span>
+    <span class="comment">//...</span>
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.minmax.demonstration_program"></a><a class="link" href="minmax.html#boost_integer.minmax.demonstration_program" title="Demonstration Program">Demonstration
+      Program</a>
+</h3></div></div></div>
+<p>
+        The program <a href="../../../test/static_min_max_test.cpp" target="_top">static_min_max_test.cpp</a>
+        is a simplistic demonstration of various comparisons using the compile-time
+        extrema class templates.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.minmax.rationale"></a><a class="link" href="minmax.html#boost_integer.minmax.rationale" title="Rationale">Rationale</a>
+</h3></div></div></div>
+<p>
+        Sometimes the minimum or maximum of several values needs to be found for
+        later compile-time processing, <span class="emphasis"><em>e.g.</em></span> for a bound for
+        another class template.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.minmax.credits"></a><a class="link" href="minmax.html#boost_integer.minmax.credits" title="Credits">Credits</a>
+</h3></div></div></div>
+<p>
+        The author of the Boost compile-time extrema class templates is <a href="http://www.boost.org/people/daryle_walker.html" target="_top">Daryle
+        Walker</a>.
+      </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2001-2009 Beman
+      Dawes, Daryle Walker, Gennaro Prota, John Maddock<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="log2.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.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="history.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
--- a/doc/html/boost_integer/traits.html
+++ b/doc/html/boost_integer/traits.html
@ -0,0 +1,215 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Integer Traits</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<link rel="home" href="../index.html" title="Boost.Integer">
+<link rel="up" href="../index.html" title="Boost.Integer">
+<link rel="prev" href="../index.html" title="Boost.Integer">
+<link rel="next" href="integer.html" title="Integer Type Selection">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.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="integer.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_integer.traits"></a><a class="link" href="traits.html" title="Integer Traits">Integer Traits</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="traits.html#boost_integer.traits.motivation">Motivation</a></span></dt>
+<dt><span class="section"><a href="traits.html#boost_integer.traits.synopsis">Synopsis</a></span></dt>
+<dt><span class="section"><a href="traits.html#boost_integer.traits.description">Description</a></span></dt>
+<dt><span class="section"><a href="traits.html#boost_integer.traits.test_program">Test Program</a></span></dt>
+<dt><span class="section"><a href="traits.html#boost_integer.traits.acknowledgements">Acknowledgements</a></span></dt>
+</dl></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.traits.motivation"></a><a class="link" href="traits.html#boost_integer.traits.motivation" title="Motivation">Motivation</a>
+</h3></div></div></div>
+<p>
+        The C++ Standard Library &lt;limits&gt; header supplies a class template
+        <code class="computeroutput"><span class="identifier">numeric_limits</span><span class="special">&lt;&gt;</span></code>
+        with specializations for each fundamental type.
+      </p>
+<p>
+        For integer types, the interesting members of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;&gt;</span></code> are:
+      </p>
+<pre class="programlisting"><span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">is_specialized</span><span class="special">;</span>      <span class="comment">// Will be true for integer types.</span>
+<span class="keyword">static</span> <span class="identifier">T</span> <span class="identifier">min</span><span class="special">()</span> <span class="keyword">throw</span><span class="special">();</span>                <span class="comment">// Smallest representable value.</span>
+<span class="keyword">static</span> <span class="identifier">T</span> <span class="identifier">max</span><span class="special">()</span> <span class="keyword">throw</span><span class="special">();</span>                <span class="comment">// Largest representable value.</span>
+<span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">digits</span><span class="special">;</span>               <span class="comment">// For integers, the number of value bits.</span>
+<span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">digits10</span><span class="special">;</span>             <span class="comment">// The number of base 10 digits that can be represented.</span>
+<span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">is_signed</span><span class="special">;</span>           <span class="comment">// True if the type is signed.</span>
+<span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">is_integer</span><span class="special">;</span>          <span class="comment">// Will be true for all integer types.</span>
+</pre>
+<p>
+        For many uses, these are sufficient. But min() and max() are problematical
+        because they are not constant expressions (std::5.19), yet some usages require
+        constant expressions.
+      </p>
+<p>
+        The template class <code class="literal">integer_traits</code> addresses this problem.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.traits.synopsis"></a><a class="link" href="traits.html#boost_integer.traits.synopsis" title="Synopsis">Synopsis</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
+  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+  <span class="keyword">class</span> <span class="identifier">integer_traits</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span>
+  <span class="special">{</span>
+  <span class="keyword">public</span><span class="special">:</span>
+     <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">is_integral</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">;</span>
+     <span class="comment">//</span>
+     <span class="comment">// These members are defined only if T is a built-in</span>
+     <span class="comment">// integal type:</span>
+     <span class="comment">//</span>
+     <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">T</span> <span class="identifier">const_min</span> <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
+     <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">T</span> <span class="identifier">const_max</span> <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
+  <span class="special">};</span>
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.traits.description"></a><a class="link" href="traits.html#boost_integer.traits.description" title="Description">Description</a>
+</h3></div></div></div>
+<p>
+        Template class <code class="literal">integer_traits</code> is derived from <code class="literal">std::numeric_limits</code>.
+        The primary specialization adds the single <code class="literal">bool</code> member
+        <code class="literal">is_integral</code> with the compile-time constant value <code class="literal">false</code>.
+        However, for all integral types <code class="literal">T</code> (std::3.9.1/7 [basic.fundamental]),
+        there are specializations provided with the following compile-time constants
+        defined:
+      </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+                <p>
+                  member
+                </p>
+              </th>
+<th>
+                <p>
+                  type
+                </p>
+              </th>
+<th>
+                <p>
+                  value
+                </p>
+              </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+                <p>
+                  <code class="literal">is_integral</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  bool
+                </p>
+              </td>
+<td>
+                <p>
+                  <code class="literal">true</code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">const_min</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  <code class="literal">T</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  equivalent to <code class="literal">std::numeric_limits&lt;T&gt;::min()</code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="literal">const_max</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  <code class="literal">T</code>
+                </p>
+              </td>
+<td>
+                <p>
+                  equivalent to <code class="literal">std::numeric_limits&lt;T&gt;::max()</code>
+                </p>
+              </td>
+</tr>
+</tbody>
+</table></div>
+<p>
+        Note: The <span class="emphasis"><em>is_integral</em></span> flag is provided, because a user-defined
+        integer class should specialize <code class="literal">std::numeric_limits&lt;&gt;::is_integer
+        = true</code>, while compile-time constants <code class="literal">const_min</code>
+        and <code class="literal">const_max</code> are not provided for that user-defined class,
+        unless boost::integer_traits is also specialized.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.traits.test_program"></a><a class="link" href="traits.html#boost_integer.traits.test_program" title="Test Program">Test Program</a>
+</h3></div></div></div>
+<p>
+        The program <code class="literal"><a href="../../../test/integer_traits_test.cpp" target="_top">integer_traits_test.cpp</a></code>
+        exercises the <code class="literal">integer_traits</code> class.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_integer.traits.acknowledgements"></a><a class="link" href="traits.html#boost_integer.traits.acknowledgements" title="Acknowledgements">Acknowledgements</a>
+</h3></div></div></div>
+<p>
+        Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers discussed the integer
+        traits idea on the boost mailing list in August 1999.
+      </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2001-2009 Beman
+      Dawes, Daryle Walker, Gennaro Prota, John Maddock<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.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="integer.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
--- a/doc/html/index.html
+++ b/doc/html/index.html
@ -0,0 +1,228 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Boost.Integer</title>
+<link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<link rel="home" href="index.html" title="Boost.Integer">
+<link rel="next" href="boost_integer/traits.html" title="Integer Traits">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
+<td align="center"><a href="../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav"><a accesskey="n" href="boost_integer/traits.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
+<div class="article">
+<div class="titlepage">
+<div>
+<div><h2 class="title">
+<a name="boost_integer"></a>Boost.Integer</h2></div>
+<div><div class="authorgroup">
+<div class="author"><h3 class="author">
+<span class="firstname">Beman</span> <span class="surname">Dawes</span>
+</h3></div>
+<div class="author"><h3 class="author">
+<span class="firstname">Daryle</span> <span class="surname">Walker</span>
+</h3></div>
+<div class="author"><h3 class="author">
+<span class="firstname">Gennaro</span> <span class="surname">Prota</span>
+</h3></div>
+<div class="author"><h3 class="author">
+<span class="firstname">John</span> <span class="surname">Maddock</span>
+</h3></div>
+</div></div>
+<div><p class="copyright">Copyright &#169; 2001-2009 Beman
+      Dawes, Daryle Walker, Gennaro Prota, John Maddock</p></div>
+<div><div class="legalnotice">
+<a name="boost_integer.legal"></a><p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></div>
+</div>
+<hr>
+</div>
+<div class="toc">
+<p><b>Table of Contents</b></p>
+<dl>
+<dt><span class="section"><a href="index.html#boost_integer.overview">Overview</a></span></dt>
+<dt><span class="section"><a href="boost_integer/traits.html">Integer Traits</a></span></dt>
+<dt><span class="section"><a href="boost_integer/integer.html">Integer Type Selection</a></span></dt>
+<dt><span class="section"><a href="boost_integer/mask.html">Integer Masks</a></span></dt>
+<dt><span class="section"><a href="boost_integer/log2.html">Compile Time log2 Calculation</a></span></dt>
+<dt><span class="section"><a href="boost_integer/minmax.html">Compile time min/max calculation</a></span></dt>
+<dt><span class="section"><a href="boost_integer/history.html">History</a></span></dt>
+<dt><span class="section"><a href="boost_integer/cstdint.html">Removed from library: Standard Integer
+    Types</a></span></dt>
+</dl>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_integer.overview"></a><a class="link" href="index.html#boost_integer.overview" title="Overview">Overview</a>
+</h2></div></div></div>
+<p>
+      Boost.Integer provides integer type support, particularly helpful in generic
+      programming. It provides the means to select an integer type based upon its
+      properties, like the number of bits or the maximum supported value, as well
+      as compile-time bit mask selection. There is a derivative of std::numeric_limits
+      that provides integral constant expressions for <code class="computeroutput"><span class="identifier">min</span></code>
+      and <code class="computeroutput"><span class="identifier">max</span></code>. Finally, it provides
+      two compile-time algorithms: determining the highest power of two in a compile-time
+      value; and computing min and max of constant expressions.
+    </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+              <p>
+                Component
+              </p>
+            </th>
+<th>
+              <p>
+                Header
+              </p>
+            </th>
+<th>
+              <p>
+                Purpose
+              </p>
+            </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+              <p>
+                Forward Declarations.
+              </p>
+            </td>
+<td>
+              <p>
+                <code class="literal"><a href="../../../../boost/integer_fwd.hpp" target="_top">&lt;boost/integer_fwd.hpp&gt;</a></code>
+              </p>
+            </td>
+<td>
+              <p>
+                Forward declarations of classes and class templates - for use when
+                just the name of a class is needed.
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                <a class="link" href="boost_integer/traits.html" title="Integer Traits">Integer Traits</a>.
+              </p>
+            </td>
+<td>
+              <p>
+                <code class="literal"><a href="../../../../boost/integer_traits.hpp" target="_top">&lt;boost/integer_traits.hpp&gt;</a></code>
+              </p>
+            </td>
+<td>
+              <p>
+                Class template <code class="literal">boost::integer_traits</code>, derives
+                from <code class="literal">std::numeric_limits</code> and adds <code class="literal">const_min</code>
+                and <code class="literal">const_max</code> members.
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                <a class="link" href="boost_integer/integer.html" title="Integer Type Selection">Integer Type Selection</a>.
+              </p>
+            </td>
+<td>
+              <p>
+                <code class="literal"><a href="../../../../boost/integer.hpp" target="_top">&lt;boost/integer.hpp&gt;</a></code>
+              </p>
+            </td>
+<td>
+              <p>
+                Templates for integer type selection based on properties such as
+                maximum value or number of bits: Use to select the type of an integer
+                when some property such as maximum value or number of bits is known.
+                Useful for generic programming.
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                <a class="link" href="boost_integer/mask.html" title="Integer Masks">Integer Masks</a>.
+              </p>
+            </td>
+<td>
+              <p>
+                <code class="literal"><a href="../../../../boost/integer/integer_mask.hpp" target="_top">&lt;boost/integer/integer_mask.hpp&gt;</a></code>
+              </p>
+            </td>
+<td>
+              <p>
+                Templates for the selection of integer masks, single or lowest group,
+                based on the number of bits: Use to select a particular mask when
+                the bit position(s) are based on a compile-time variable. Useful
+                for generic programming.
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                <a class="link" href="boost_integer/log2.html" title="Compile Time log2 Calculation">Compile time log2 Calculation</a>.
+              </p>
+            </td>
+<td>
+              <p>
+                <code class="literal"><a href="../../../../boost/integer/static_log2.hpp" target="_top">&lt;boost/integer/static_log2.hpp&gt;</a></code>
+              </p>
+            </td>
+<td>
+              <p>
+                Template for finding the highest power of two in a number: Use to
+                find the bit-size/range based on a maximum value. Useful for generic
+                programming.
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                <a class="link" href="boost_integer/minmax.html" title="Compile time min/max calculation">Compile time min/max calculation</a>.
+              </p>
+            </td>
+<td>
+              <p>
+                <code class="literal"><a href="../../../../boost/integer/static_min_max.hpp" target="_top">&lt;boost/integer/static_min_max.hpp&gt;</a></code>
+              </p>
+            </td>
+<td>
+              <p>
+                Templates for finding the extrema of two numbers: Use to find a bound
+                based on a minimum or maximum value. Useful for generic programming.
+              </p>
+            </td>
+</tr>
+</tbody>
+</table></div>
+</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: March 28, 2017 at 17:56:42 GMT</small></p></td>
+<td align="right"><div class="copyright-footer"></div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav"><a accesskey="n" href="boost_integer/traits.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
+</body>
+</html>
--- a/doc/integer.qbk
+++ b/doc/integer.qbk
@ -0,0 +1,706 @@
+[article Boost.Integer
+    [quickbook 1.6]
+    [compatibility-mode 1.5]
+    [copyright 2001-2009 Beman Dawes, Daryle Walker, Gennaro Prota, John Maddock]
+    [purpose Integer Type Selection]
+    [license
+        Distributed under the Boost Software License, Version 1.0.
+        (See accompanying file LICENSE_1_0.txt or copy at
+        [@http://www.boost.org/LICENSE_1_0.txt])
+    ]
+    [authors [Dawes, Beman], [Walker, Daryle], [Prota, Gennaro], [Maddock, John]]
+    [/last-revision $Date: 2008-02-21 12:58:15 +0000 (Thu, 21 Feb 2008) $]
+]
+
+[template super[x]'''<superscript>'''[x]'''</superscript>''']
+
+[section:overview Overview]
+
+Boost.Integer provides integer type support, particularly helpful in generic programming.
+It provides the means to select an integer type based upon its properties, like the number of bits or 
+the maximum supported value, as well as compile-time bit mask selection.  There is a derivative of
+std::numeric_limits that provides integral constant expressions for `min` and `max`.  
+Finally, it provides two compile-time algorithms: determining the highest power of two in a 
+compile-time value; and computing min and max of constant expressions.
+
+[table 
+   [[Component][Header][Purpose]]
+   [
+      [Forward Declarations.]
+      [[^[@../../../../boost/integer_fwd.hpp <boost/integer_fwd.hpp>]]]
+      [Forward declarations of classes and class templates - for use when just the name of a class is needed.]
+   ]
+   [
+      [[link boost_integer.traits Integer Traits].]
+      [[^[@../../../../boost/integer_traits.hpp <boost/integer_traits.hpp>]]]
+      [Class template [^boost::integer_traits], derives from [^std::numeric_limits] and adds [^const_min] and [^const_max] members.]
+   ]
+   [
+      [[link boost_integer.integer Integer Type Selection].]
+      [[^[@../../../../boost/integer.hpp <boost/integer.hpp>]]]
+      [Templates for integer type selection based on properties such as maximum value or number of bits: 
+      Use to select the type of an integer when some property such as maximum value or number of bits is known. 
+      Useful for generic programming. ]
+   ]
+   [
+      [[link boost_integer.mask Integer Masks].]
+      [[^[@../../../../boost/integer/integer_mask.hpp <boost/integer/integer_mask.hpp>]]]
+      [Templates for the selection of integer masks, single or lowest group, based on the number of bits: 
+      Use to select a particular mask when the bit position(s) are based on a compile-time variable. Useful for generic programming. ]
+   ]
+   [
+      [[link boost_integer.log2 Compile time log2 Calculation].]
+      [[^[@../../../../boost/integer/static_log2.hpp <boost/integer/static_log2.hpp>]]]
+      [Template for finding the highest power of two in a number: 
+      Use to find the bit-size/range based on a maximum value. Useful for generic programming. ]
+   ]
+   [
+      [[link boost_integer.minmax Compile time min/max calculation].]
+      [[^[@../../../../boost/integer/static_min_max.hpp <boost/integer/static_min_max.hpp>]]]
+      [Templates for finding the extrema of two numbers: 
+      Use to find a bound based on a minimum or maximum value. Useful for generic programming. ]
+   ]
+]
+
+[endsect]
+
+[section:traits Integer Traits]
+
+[section Motivation]
+
+The C++ Standard Library <limits> header supplies a class template `numeric_limits<>` with specializations for each fundamental type.
+
+For integer types, the interesting members of `std::numeric_limits<>` are: 
+
+   static const bool is_specialized;      // Will be true for integer types.
+   static T min() throw();                // Smallest representable value.
+   static T max() throw();                // Largest representable value.
+   static const int digits;               // For integers, the number of value bits.
+   static const int digits10;             // The number of base 10 digits that can be represented.
+   static const bool is_signed;           // True if the type is signed.
+   static const bool is_integer;          // Will be true for all integer types.
+
+For many uses, these are sufficient. 
+But min() and max() are problematical because they are not constant expressions (std::5.19), 
+yet some usages require constant expressions. 
+
+The template class [^integer_traits] addresses this problem. 
+
+[endsect] 
+
+[section Synopsis]
+
+   namespace boost {
+     template<class T>
+     class integer_traits : public std::numeric_limits<T>
+     {
+     public:
+        static const bool is_integral = false;
+        //
+        // These members are defined only if T is a built-in
+        // integal type:
+        //
+        static const T const_min = ``['implementation-defined]``;
+        static const T const_max = ``['implementation-defined]``;
+     };
+   }
+
+[endsect] 
+
+[section Description]
+
+Template class [^integer_traits] is derived from [^std::numeric_limits]. The primary specialization adds the single 
+[^bool] member [^is_integral] with the compile-time constant value [^false]. 
+However, for all integral types [^T] (std::3.9.1/7 [basic.fundamental]), there are specializations 
+provided with the following compile-time constants defined: 
+
+[table 
+   [[member][type][value]]
+   [[[^is_integral]][bool][[^true]]]
+   [[[^const_min]][[^T]][equivalent to [^std::numeric_limits<T>::min()]]]
+   [[[^const_max]][[^T]][equivalent to [^std::numeric_limits<T>::max()]]]
+]
+
+Note: The /is_integral/ flag is provided, because a user-defined integer class should specialize 
+[^std::numeric_limits<>::is_integer = true], while compile-time constants 
+[^const_min] and [^const_max] are not provided for that user-defined class, unless boost::integer_traits is also specialized. 
+
+[endsect] 
+
+[section Test Program]
+
+The program [^[@../../test/integer_traits_test.cpp integer_traits_test.cpp]] exercises the [^integer_traits] class. 
+
+[endsect] 
+
+[section Acknowledgements]
+
+Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers discussed the integer traits idea on the boost mailing list in August 1999.
+
+[endsect]
+[endsect]
+
+[section:integer Integer Type Selection]
+
+The [@../../../../boost/integer.hpp <boost/integer.hpp>] type selection templates allow 
+integer types to be selected based on desired characteristics such as number of bits or maximum value. 
+This facility is particularly useful for solving generic programming problems.
+
+[section:synopsis Synopsis]
+
+   namespace boost
+   {
+     //  fast integers from least integers
+     template<typename LeastInt>
+     struct int_fast_t
+     {
+         typedef ``['implementation-defined-type]``  type;
+     };
+
+     //  signed
+     template<int Bits>
+     struct int_t 
+     {
+         /* Member exact may or may not be defined depending upon Bits */
+         typedef ``['implementation-defined-type]``  exact;
+         typedef ``['implementation-defined-type]``  least;
+         typedef int_fast_t<least>::fast      fast;
+     };
+
+     //  unsigned
+     template<int Bits>
+     struct uint_t 
+     {
+         /* Member exact may or may not be defined depending upon Bits */
+         typedef ``['implementation-defined-type]``  exact;
+         typedef ``['implementation-defined-type]``  least;
+         typedef int_fast_t<least>::fast      fast;
+     };
+
+     //  signed
+     template<long long MaxValue>
+     struct int_max_value_t 
+     {
+         typedef ``['implementation-defined-type]``  least;
+         typedef int_fast_t<least>::fast      fast;
+     };
+
+     template<long long MinValue>
+     struct int_min_value_t 
+     {
+         typedef ``['implementation-defined-type]``  least;
+         typedef int_fast_t<least>::fast      fast;
+     };
+
+     //  unsigned
+     template<unsigned long long Value>
+     struct uint_value_t 
+     {
+         typedef ``['implementation-defined-type]``  least;
+         typedef int_fast_t<least>::fast      fast;
+     };
+   } // namespace boost
+
+[endsect]
+
+[section:easiest Easiest-to-Manipulate Types]
+
+The [^int_fast_t] class template maps its input type to the next-largest type that the processor 
+can manipulate the easiest, or to itself if the input type is already an easy-to-manipulate type. 
+For instance, processing a bunch of [^char] objects may go faster if they were converted to [^int] objects before processing. 
+The input type, passed as the only template parameter, must be a built-in integral type, except [^bool]. 
+Unsigned integral types can be used, as well as signed integral types. 
+The output type is given as the nested type [^fast].
+
+[*Implementation Notes:] 
+By default, the output type is identical to the input type. Eventually, this code's implementation should 
+be customized for each platform to give accurate mappings between the built-in types and the easiest-to-manipulate 
+built-in types. Also, there is no guarantee that the output type actually is easier to manipulate than the input type.
+
+[endsect]
+
+[section:sized Sized Types]
+
+The [^int_t], [^uint_t], [^int_max_value_t], [^int_min_value_t], and [^uint_value_t] class templates find 
+the most appropiate built-in integral type for the given template parameter. This type is given by the 
+nested type [^least]. The easiest-to-manipulate version of that type is given by the nested type [^fast]. 
+The following table describes each template's criteria.
+
+[table Criteria for the Sized Type Class Templates
+   [
+      [Class Template][Template Parameter Mapping]
+   ]
+   [
+      [[^boost::int_t<N>::least]]
+      [The smallest, built-in, signed integral type with at least /N/ bits, including the sign bit. 
+      The parameter should be a positive number. A compile-time error results if the parameter is 
+      larger than the number of bits in the largest integer type.]
+   ]
+   [
+      [[^boost::int_t<N>::fast]]
+      [The easiest-to-manipulate, built-in, signed integral type with at least /N/ bits, including the sign bit. 
+      The parameter should be a positive number. A compile-time error results if the parameter is 
+      larger than the number of bits in the largest integer type.]
+   ]
+   [
+      [[^boost::int_t<N>::exact]]
+      [A built-in, signed integral type with exactly /N/ bits, including the sign bit. 
+      The parameter should be a positive number.  Note that the member /exact/ is defined
+      [*only] if there exists a type with exactly /N/ bits.]
+   ]
+   [
+      [[^boost::uint_t<N>::least]]
+      [The smallest, built-in, unsigned integral type with at least /N/ bits. 
+      The parameter should be a positive number. A compile-time error results if the 
+      parameter is larger than the number of bits in the largest integer type.]
+   ]
+   [
+      [[^boost::uint_t<N>::fast]]
+      [The easiest-to-manipulate, built-in, unsigned integral type with at least /N/ bits. 
+      The parameter should be a positive number. A compile-time error results if the 
+      parameter is larger than the number of bits in the largest integer type.]
+   ]
+   [
+      [[^boost::uint_t<N>::exact]]
+      [A built-in, unsigned integral type with exactly /N/ bits. 
+      The parameter should be a positive number. A compile-time error results if the 
+      parameter is larger than the number of bits in the largest integer type.  
+      Note that the member /exact/ is defined
+      [*only] if there exists a type with exactly N bits.]
+   ]
+   [
+      [[^boost::int_max_value_t<V>::last]]
+      [The smallest, built-in, signed integral type that can hold all the values in the inclusive range ['0 - V]. 
+      The parameter should be a positive number.]
+   ]
+   [
+      [[^boost::int_max_value_t<V>::fast]]
+      [The easiest-to-manipulate, built-in, signed integral type that can hold all the values in the inclusive range ['0 - V]. 
+      The parameter should be a positive number.]
+   ]
+   [
+      [[^boost::int_min_value_t<V>::least]]
+      [The smallest, built-in, signed integral type that can hold all the values in the inclusive range ['V - 0]. 
+      The parameter should be a negative number.]
+   ]
+   [
+      [[^boost::int_min_value_t<V>::fast]]
+      [The easiest-to-manipulate, built-in, signed integral type that can hold all the values in the inclusive range ['V - 0]. 
+      The parameter should be a negative number.]
+   ]
+   [
+      [[^boost::uint_value_t<V>::least]]
+      [The smallest, built-in, unsigned integral type that can hold all positive values
+      up to and including /V/. The parameter should be a positive number.]
+   ]
+   [
+      [[^boost::uint_value_t<V>::fast]]
+      [The easiest-to-manipulate, built-in, unsigned integral type that can hold all positive values
+      up to and including /V/. The parameter should be a positive number.]
+   ]
+]
+
+[endsect]
+
+[section Example]
+
+   #include <boost/integer.hpp>
+
+   //...
+
+   int main()
+   {
+       boost::int_t<24>::least my_var;  // my_var has at least 24-bits
+       //...
+       // This one is guarenteed not to be truncated:
+       boost::int_max_value_t<1000>::least my1000 = 1000;
+       //...
+       // This one is guarenteed not to be truncated, and as fast
+       // to manipulate as possible, its size may be greater than
+       // that of my1000:
+       boost::int_max_value_t<1000>::fast my_fast1000 = 1000;
+   }
+
+[endsect]
+
+[section Demonstration Program]
+
+The program [@../../test/integer_test.cpp integer_test.cpp] is a simplistic demonstration of the results from instantiating 
+various examples of the sized type class templates.
+
+[endsect]
+
+[section Rationale]
+
+The rationale for the design of the templates in this header includes:
+
+* Avoid recursion because of concern about C++'s limited guaranteed recursion depth (17).
+* Avoid macros on general principles.
+* Try to keep the design as simple as possible.
+
+[endsect]
+
+[section Alternative]
+
+If the number of bits required is known beforehand, it may be more appropriate to use the types supplied 
+in [@../../../../boost/cstdint.hpp <boost/cstdint.hpp>].
+
+[endsect]
+
+[section Credits]
+
+The author of most of the Boost integer type choosing templates is 
+[@http://www.boost.org/people/beman_dawes.html Beman Dawes]. 
+He gives thanks to Valentin Bonnard and [@http://www.boost.org/people/kevlin_henney.htm Kevlin Henney] 
+for sharing their designs for similar templates. 
+[@http://www.boost.org/people/daryle_walker.html Daryle Walker] designed the value-based sized templates.
+
+[endsect]
+[endsect]
+
+
+
+[section:mask Integer Masks]
+
+[section Overview]
+
+The class templates in [@../../../../boost/integer/integer_mask.hpp <boost/integer/integer_mask.hpp>] 
+provide bit masks for a certain bit position or a contiguous-bit pack of a certain size. 
+The types of the masking constants come from the [link boost_integer.integer integer type selection templates] header.
+
+[endsect]
+
+[section Synopsis]
+
+   #include <cstddef>  // for std::size_t
+
+   namespace boost
+   {
+
+   template <std::size_t Bit>
+   struct high_bit_mask_t
+   {
+       typedef ``['implementation-defined-type]``  least;
+       typedef ``['implementation-defined-type]``  fast;
+
+       static const least       high_bit       = ``['implementation-defined]``;
+       static const fast        high_bit_fast  = ``['implementation-defined]``;
+
+       static const std::size_t bit_position   = Bit;
+   };
+
+   template <std::size_t Bits>
+   struct low_bits_mask_t
+   {
+       typedef ``['implementation-defined-type]``  least;
+       typedef ``['implementation-defined-type]``  fast;
+
+       static const least       sig_bits       = ``['implementation-defined]``;
+       static const fast        sig_bits_fast  = ``['implementation-defined]``;
+
+       static const std::size_t bit_count      = Bits;
+   };
+
+   // Specializations for low_bits_mask_t exist for certain bit counts.
+
+   }  // namespace boost
+
+[endsect] 
+
+[section Single Bit-Mask Class Template]
+
+The [^boost::high_bit_mask_t] class template provides constants for bit masks representing the bit at a 
+certain position. The masks are equivalent to the value 2[super Bit], where [^Bit] is the template parameter. 
+The bit position must be a nonnegative number from zero to ['Max], where Max is one less than the 
+number of bits supported by the largest unsigned built-in integral type. The following table describes 
+the members of an instantiation of [^high_bit_mask_t].
+
+[table Members of the `boost::high_bit_mask_t` Class Template
+   [[Member][Meaning]]
+   [[[^least]][The smallest, unsigned, built-in type that supports the given bit position.]]
+   [[[^fast]][The easiest-to-manipulate analog of [^least].]]
+   [[[^high_bit]][A [^least] constant of the value 2[super Bit].]]
+   [[[^high_bit_fast]][A [^fast] analog of [^high_bit].]]
+   [[[^bit_position]][The value of the template parameter, in case its needed from a renamed instantiation of the class template.]]
+]
+
+[endsect] 
+
+[section Group Bit-Mask Class Template]
+
+The [^boost::low_bits_mask_t] class template provides constants for bit masks 
+equivalent to the value (2[super Bits] - 1), where [^Bits] is the template parameter. 
+The parameter [^Bits] must be a non-negative integer from 
+zero to ['Max], where Max is the number of bits supported by the largest, unsigned, built-in integral type. 
+The following table describes the members of [^low_bits_mask_t].
+
+[table Members of the [^boost::low_bits_mask_t] Class Template
+[[Member][Meaning]]
+[[[^least]][The smallest, unsigned built-in type that supports the given bit count.]]
+[[[^fast]][The easiest-to-manipulate analog of [^least].]]
+[[[^sig_bits]][A [^least] constant of the desired bit-masking value.]]
+[[[^sig_bits_fast]][A [^fast] analog of [^sig_bits].]]
+[[[^bit_count]][The value of the template parameter, in case its needed from a renamed instantiation of the class template.]]
+]
+
+[endsect]
+
+[section Implementation Notes]
+
+When [^Bits] is the exact size of a built-in unsigned type, the implementation has to change to 
+prevent undefined behavior. Therefore, there are specializations of [^low_bits_mask_t] at those bit counts.
+
+[endsect]
+
+[section Example]
+
+   #include <boost/integer/integer_mask.hpp>
+
+   //...
+
+   int main()
+   {
+       typedef boost::high_bit_mask_t<29>  mask1_type;
+       typedef boost::low_bits_mask_t<15>  mask2_type;
+
+       mask1_type::least  my_var1;
+       mask2_type::fast   my_var2;
+       //...
+
+       my_var1 |= mask1_type::high_bit;
+       my_var2 &= mask2_type::sig_bits_fast;
+
+       //...
+   }
+
+[endsect] 
+
+[section Demonstration Program]
+
+The program [@../../test/integer_mask_test.cpp integer_mask_test.cpp] is a simplistic demonstration of the 
+results from instantiating various examples of the bit mask class templates.
+
+[endsect] 
+
+[section Rationale]
+
+The class templates in this header are an extension of the [link boost_integer.integer integer type selection class templates]. 
+The new class templates provide the same sized types, but also convenient masks to use when extracting the 
+highest or all the significant bits when the containing built-in type contains more bits. 
+This prevents contamination of values by the higher, unused bits.
+
+[endsect] 
+
+[section Credits]
+
+The author of the Boost bit mask class templates is [@http://www.boost.org/people/daryle_walker.html Daryle Walker].
+
+[endsect]
+[endsect]
+
+[section:log2 Compile Time log2 Calculation]
+
+The class template in [@../../../../boost/integer/static_log2.hpp <boost/integer/static_log2.hpp>] 
+determines the position of the highest bit in a given value. This facility is useful for solving generic programming problems.
+
+[section Synopsis]
+
+   namespace boost
+   {
+
+     typedef ``['implementation-defined]`` static_log2_argument_type;
+     typedef ``['implementation-defined]`` static_log2_result_type;
+
+     template <static_log2_argument_type arg>
+     struct static_log2
+     {
+       static const static_log2_result_type value = ``['implementation-defined]``;
+     };
+
+
+     template < >
+     struct static_log2< 0 >
+     {
+       // The logarithm of zero is undefined.
+     };
+
+
+   }  // namespace boost
+
+[endsect] 
+
+[section Usage]
+
+The [^boost::static_log2] class template takes one template parameter, a value of type 
+[^static_log2_argument_type]. The template only defines one member, [^value], which gives the 
+truncated, base-two logarithm of the template argument.
+
+Since the logarithm of zero, for any base, is undefined, there is a specialization of [^static_log2] 
+for a template argument of zero. This specialization has no members, so an attempt to use the base-two 
+logarithm of zero results in a compile-time error.
+
+Note: 
+
+* [^static_log2_argument_type] is an ['unsigned integer type] (C++ standard, 3.9.1p3).
+* [^static_log2_result_type] is an ['integer type] (C++ standard, 3.9.1p7).
+
+[endsect] 
+
+[section Demonstration Program]
+
+The program [@../../test/static_log2_test.cpp static_log2_test.cpp] is a simplistic 
+demonstration of the results from instantiating various examples of the binary logarithm class template.
+
+[endsect]
+
+[section Rationale]
+
+The base-two (binary) logarithm, abbreviated lb, function is occasionally used to give order-estimates 
+of computer algorithms. The truncated logarithm can be considered the highest power-of-two in a value, 
+which corresponds to the value's highest set bit (for binary integers). Sometimes the highest-bit position 
+could be used in generic programming, which requires the position to be available statically (['i.e.] at compile-time).
+
+[endsect] 
+
+[section Credits]
+
+The original version of the Boost binary logarithm class template was 
+written by [@http://www.boost.org/people/daryle_walker.html Daryle Walker] and then 
+enhanced by Giovanni Bajo with support for compilers without partial template specialization. 
+The current version was suggested, together with a reference implementation, by Vesa Karvonen. 
+Gennaro Prota wrote the actual source file.
+
+[endsect]
+[endsect]
+
+[section:minmax Compile time min/max calculation]
+
+The class templates in [@../../../../boost/integer/static_min_max.hpp <boost/integer/static_min_max.hpp>] 
+provide a compile-time evaluation of the minimum or maximum of two integers. These facilities are useful 
+for generic programming problems.
+
+[section Synopsis]
+
+   namespace boost
+   {
+   
+   typedef ``['implementation-defined]`` static_min_max_signed_type;
+   typedef ``['implementation-defined]`` static_min_max_unsigned_type;
+
+   template <static_min_max_signed_type Value1, static_min_max_signed_type Value2 >
+       struct static_signed_min;
+
+   template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
+       struct static_signed_max;
+
+   template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
+       struct static_unsigned_min;
+
+   template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
+       struct static_unsigned_max;
+
+   }
+
+[endsect] 
+
+[section Usage]
+
+The four class templates provide the combinations for finding the minimum or maximum of two [^signed] or 
+[^unsigned] ([^long]) parameters, /Value1/ and /Value2/, at compile-time. Each template has a single static data member, 
+[^value], which is set to the respective minimum or maximum of the template's parameters.
+
+[endsect] 
+
+[section Example]
+
+   #include <boost/integer/static_min_max.hpp>
+
+   template < unsigned long AddendSize1, unsigned long AddendSize2 >
+   class adder
+   {
+   public:
+       static  unsigned long  const  addend1_size = AddendSize1;
+       static  unsigned long  const  addend2_size = AddendSize2;
+       static  unsigned long  const  sum_size = boost::static_unsigned_max<AddendSize1, AddendSize2>::value + 1;
+
+       typedef int  addend1_type[ addend1_size ];
+       typedef int  addend2_type[ addend2_size ];
+       typedef int  sum_type[ sum_size ];
+
+       void  operator ()( addend1_type const &a1, addend2_type const &a2, sum_type &s ) const;
+   };
+
+   //...
+
+   int main()
+   {
+       int const   a1[] = { 0, 4, 3 };  // 340
+       int const   a2[] = { 9, 8 };     //  89
+       int         s[ 4 ];
+       adder<3,2>  obj;
+
+       obj( a1, a2, s );  // 's' should be 429 or { 9, 2, 4, 0 }
+       //...
+   }
+
+[endsect]
+
+[section Demonstration Program]
+
+The program [@../../test/static_min_max_test.cpp static_min_max_test.cpp] is a simplistic demonstration of 
+various comparisons using the compile-time extrema class templates.
+
+[endsect] 
+
+[section Rationale]
+
+Sometimes the minimum or maximum of several values needs to be found for later compile-time processing, 
+['e.g.] for a bound for another class template.
+
+[endsect]
+
+[section Credits]
+
+The author of the Boost compile-time extrema class templates is [@http://www.boost.org/people/daryle_walker.html Daryle Walker].
+
+[endsect]
+[endsect]
+
+[section:history History]
+
+[h4 1.56.0]
+
+* Moved `<boost/cstdint.hpp>` into [@boost:/libs/config/index.html
+  Boost.Config].
+
+[h4 1.42.0]
+
+* Reverted Trunk to release branch state (i.e. a "known good state").
+* Fixed issues: [@https://svn.boost.org/trac/boost/ticket/653 653], 
+[@https://svn.boost.org/trac/boost/ticket/3084 3084], 
+[@https://svn.boost.org/trac/boost/ticket/3177 3177], 
+[@https://svn.boost.org/trac/boost/ticket/3180 3180], 
+[@https://svn.boost.org/trac/boost/ticket/3548 3568], 
+[@https://svn.boost.org/trac/boost/ticket/3657 3657], 
+[@https://svn.boost.org/trac/boost/ticket/2134 2134].
+* Added long long support to [^boost::static_log2], [^boost::static_signed_min], [^boost::static_signed_max], 
+[^boost::static_unsigned_min][^boost::static_unsigned_max], when available.
+* The argument type and the result type of [^boost::static_signed_min] etc are now typedef'd. 
+Formerly, they were hardcoded as [^unsigned long] and [^int] respectively. Please, use the 
+provided typedefs in new code (and update old code as soon as possible).
+
+[h4 1.32.0]
+
+* The argument type and the result type of [^boost::static_log2] are now typedef'd. 
+Formerly, they were hardcoded as [^unsigned long] and [^int] respectively. Please, use the 
+provided typedefs in new code (and update old code as soon as possible).
+
+[endsect]
+
+[section:cstdint Removed from library: Standard Integer Types]
+
+The [@boost:/libs/config/doc/html/boost_config/cstdint.html Boost.Config] module provides
+the typedefs useful for writing portable code that requires certain
+integer widths.
+
+[endsect]
--- a/doc/integer_mask.html
+++ b/doc/integer_mask.html
@ -1,210 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
-<html>
-<head>
-<title>Integer Bit Mask Templates</title>
-</head>
-
-<body bgcolor="white" text="black" link="blue" vlink="purple" alink="red">
-<h1><img src="../../../boost.png" alt="boost.png (6897 bytes)"
-align="middle" width="277" height="86">Integer Bit Mask Templates</h1>
-
-<p>The class templates in <cite><a href="../../../boost/integer/integer_mask.hpp">&lt;boost/integer/integer_mask.hpp&gt;</a></cite> provide bit masks for a certain bit position or a contiguous-bit pack of a certain size.  The types of the masking constants come from the <a href="../integer.htm">integer type selection templates</a> header.</p>
-
-<h2><a name="contents">Contents</a></h2>
-
-<ul>
-	<li><a href="#contents">Contents</a></li>
-	<li><a href="#synopsis">Synopsis</a></li>
-	<li><a href="#single">Single Bit-Mask Class Template</a></li>
-	<li><a href="#group">Group Bit-Mask Class Template</a></li>
-	<li><a href="#example">Example</a></li>
-	<li><a href="#demo">Demonstration Program</a></li>
-	<li><a href="#rationale">Rationale</a></li>
-	<li><a href="#credits">Credits</a></li>
-</ul>
-
-<h2><a name="synopsis">Synopsis</a></h2>
-
-<blockquote><pre>
-#include &lt;cstddef&gt;  <i>// for std::size_t</i>
-
-namespace boost
-{
-
-template &lt; std::size_t Bit &gt;
-struct high_bit_mask_t
-{
-    typedef <em>implementation_supplied</em>  least;
-    typedef <em>implementation_supplied</em>   fast;
-
-    static const least  high_bit = <em>implementation_defined</em>;
-    static const fast   high_bit_fast = <em>implementation_defined</em>;
-
-    static const std::size_t  bit_position = Bit;
-
-};
-
-template &lt; std::size_t Bits &gt;
-struct low_bits_mask_t
-{
-    typedef <em>implementation_supplied</em>  least;
-    typedef <em>implementation_supplied</em>   fast;
-
-    static const least  sig_bits = <em>implementation_defined</em>;
-    static const fast   sig_bits_fast = <em>implementation_defined</em>;
-
-    static const std::size_t  bit_count = Bits;
-
-};
-
-// Specializations for low_bits_mask_t exist for certain bit counts.
-
-}  // namespace boost
-</pre></blockquote>
-
-<h2><a name="single">Single Bit-Mask Class Template</a></h2>
-
-<p>The <code>boost::high_bit_mask_t</code> class template provides
-constants for bit masks representing the bit at a certain position.  The
-masks are equivalent to the value 2<sup><code>Bit</code></sup>, where
-<code>Bit</code> is the template parameter.  The bit position must be a
-nonnegative number from zero to <i>Max</i>, where <dfn>Max</dfn> is one
-less than the number of bits supported by the largest unsigned built-in
-integral type.  The following table describes the members of an
-instantiation of <code>high_bit_mask_t</code>.</p>
-
-<table border="1" cellpadding="5">
-	<caption>Members of the <code>boost::high_bit_mask_t</code> Class
-		Template</caption>
-	<tr>
-		<th>Member</th>
-		<th>Meaning</th>
-	</tr>
-	<tr>
-		<td><code>least</code></td>
-		<td>The smallest unsigned built-in type that supports the given
-			bit position.</td>
-	</tr>
-	<tr>
-		<td><code>fast</code></td>
-		<td>The quick-to-manipulate analog of <code>least</code>.</td>
-	</tr>
-	<tr>
-		<td><code>high_bit</code></td>
-		<td>A <code>least</code> constant of the desired bit-masking
-			value.</td>
-	</tr>
-	<tr>
-		<td><code>high_bit_fast</code></td>
-		<td>A <code>fast</code> analog of <code>high_bit</code>.</td>
-	</tr>
-	<tr>
-		<td><code>bit_position</code></td>
-		<td>The value of the template parameter, in case its needed from
-			a renamed instantiation of the class template.</td>
-	</tr>
-</table>
-
-<h2><a name="group">Group Bit-Mask Class Template</a></h2>
-
-<p>The <code>boost::low_bits_mask_t</code> class template provides
-constants for bit masks representing the lowest bits of a certain
-amount.  The masks are equivalent to the value
-(2<sup><code>Bits</code></sup> - 1), where <code>Bits</code> is the
-template parameter.  The bit amount must be a nonnegative number from
-zero to <i>Max</i>, where <dfn>Max</dfn> is the number of bits supported
-by the largest unsigned built-in integral type.  The following table
-describes the members of an instantiation of
-<code>low_bits_mask_t</code>.</p>
-
-<table border="1" cellpadding="5">
-	<caption>Members of the <code>boost::low_bits_mask_t</code> Class
-		Template</caption>
-	<tr>
-		<th>Member</th>
-		<th>Meaning</th>
-	</tr>
-	<tr>
-		<td><code>least</code></td>
-		<td>The smallest unsigned built-in type that supports the given
-			bit count.</td>
-	</tr>
-	<tr>
-		<td><code>fast</code></td>
-		<td>The quick-to-manipulate analog of <code>least</code>.</td>
-	</tr>
-	<tr>
-		<td><code>sig_bits</code></td>
-		<td>A <code>least</code> constant of the desired bit-masking
-			value.</td>
-	</tr>
-	<tr>
-		<td><code>sig_bits_fast</code></td>
-		<td>A <code>fast</code> analog of <code>sig_bits</code>.</td>
-	</tr>
-	<tr>
-		<td><code>bit_count</code></td>
-		<td>The value of the template parameter, in case its needed from
-			a renamed instantiation of the class template.</td>
-	</tr>
-</table>
-
-<p><strong>Implementation Note</strong><br>
-When <code>Bits</code> is the exact size of a built-in unsigned type,
-the implementation has to change to prevent undefined behavior. 
-Therefore, there are specializations of <code>low_bits_mask_t</code> at
-those bit counts.</p>
-
-<h2><a name="example">Example</a></h2>
-
-<blockquote><pre>
-#include &lt;boost/integer/integer_mask.hpp&gt;
-
-//...
-
-int main()
-{
-    typedef boost::high_bit_mask_t&lt;29&gt;  mask1_type;
-    typedef boost::low_bits_mask_t&lt;15&gt;  mask2_type;
-
-    mask1_type::least  my_var1;
-    mask2_type::fast   my_var2;
-    //...
-
-    my_var1 |= mask1_type::high_bit;
-    my_var2 &amp;= mask2_type::sig_bits_fast;
-
-    //...
-}
-</pre></blockquote>
-
-<h2><a name="demo">Demonstration Program</a></h2>
-
-<p>The program <a href="../test/integer_mask_test.cpp">integer_mask_test.cpp</a>
-is a simplistic demonstration of the results from instantiating various
-examples of the bit mask class templates.</p>
-
-<h2><a name="rationale">Rationale</a></h2>
-
-<p>The class templates in this header are an extension of the <a
-href="../integer.htm">integer type selection class templates</a>.  The new
-class templates provide the same sized types, but also convienent masks
-to use when extracting the highest or all the significant bits when the
-containing built-in type contains more bits.  This prevents
-contaimination of values by the higher, unused bits.</p>
-
-<h2><a name="credits">Credits</a></h2>
-
-<p>The author of the Boost bit mask class templates is <a
-href="../../../people/daryle_walker.html">Daryle Walker</a>.</p>
-
-<hr>
-
-<p>Revised September 23, 2001</p>
-
-<p>&copy; Copyright Daryle Walker 2001.  Use, modification, and distribution are
-subject to the Boost Software License, Version 1.0.  (See accompanying file <a
-href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
-href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
-</body>
-</html>
--- a/doc/static_log2.html
+++ b/doc/static_log2.html
@ -1,215 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
-
-<html>
-
-<head>
-
-<title>Binary Logarithm Template</title>
-
-</head>
-
-
-
-<body bgcolor="white" text="black">
-
-<h1><img src="../../../boost.png" alt="boost.png (6897 bytes)"
-align="middle" width="277" height="86">Binary Logarithm Template</h1>
-
-
-<p>The class template in <cite><a href="../../../boost/integer/static_log2.hpp">&lt;boost/integer/static_log2.hpp&gt;</a></cite> determines the position of the highest bit in a given value.  This facility is useful for solving generic programming problems.</p>
-
-
-
-<h2><a name="contents">Contents</a></h2>
-
-
-<ul>
-
-	<li><a href="#contents">Contents</a></li>
-
-	<li><a href="#synopsis">Synopsis</a></li>
-
-	<li><a href="#usage">Usage</a></li>
-
-	<li><a href="#example">Example</a></li>
-
-	<li><a href="#demo">Demonstration Program</a></li>
-
-	<li><a href="#rationale">Rationale</a></li>
-
-	<li><a href="#credits">Credits</a></li>
-
-	<li><a href="#whatsnew"><b>What's new</b></a></li>
-
-</ul>
-
-
-
-<h2><a name="synopsis">Synopsis</a></h2>
-
-
-
-<blockquote><pre>
-
-namespace boost
-{
-
-  typedef <em>implementation-defined</em> static_log2_argument_type;
-  typedef <em>implementation-defined</em> static_log2_result_type;
-
-  template &lt; static_log2_argument_type arg &gt;
-  struct static_log2
-  {
-    static const static_log2_result_type value = <em>implementation-defined</em>;
-  };
-
-
-  template &lt; &gt;
-  struct static_log2&lt; 0 &gt;
-  {
-    // The logarithm of zero is undefined.
-  };
-
-
-}  // namespace boost
-
-</pre></blockquote>
-
-
-
-
-<h2><a name="usage">Usage</a></h2>
-
-
-
-<p>The <code>boost::static_log2</code> class template takes one template
-parameter, a value of type <code>static_log2_argument_type</code>. The template
-only defines one member, <code>value</code>, which gives the truncated
-base-two logarithm of the template argument.</p>
-
-<p>Since the logarithm of zero, for any base, is undefined, there is a
-specialization of <code>static_log2</code> for a template argument
-of zero.  This specialization has no members, so an attempt to use
-the base-two logarithm of zero results in a compile-time error.</p>
-
-<p>Note: <ul>
-
-         <li><code>static_log2_argument_type</code> is an <i>unsigned integer
-         type</i> (C++ standard, 3.9.1p3).</li>
-
-         <li><code>static_log2_result_type</code> is an <i>integer type</i>
-                 (C++ standard, 3.9.1p7).</li>
-
-                 </ul>
-
-
-
-<h2><a name="example">Example</a></h2>
-
-
-
-<blockquote><pre>
-
-#include "boost/integer/static_log2.hpp"
-
-
-template &lt; boost::static_log2_argument_type value &gt;
-bool is_it_what()
-{
-    typedef boost::static_log2&lt;value&gt;  lb_type;
-
-    int  temp = lb_type::value;
-    //...
-    return (temp % 2) != 0;
-}
-
-//...
-
-int main()
-{
-    bool  temp = is_it_what&lt;2000&gt;();
-    //...
-# if 0
-    temp = is_it_what&lt;0&gt;();  // would give an error
-# endif
-    //...
-    temp = is_it_what&lt;24&gt;();
-    //...
-}
-
-</pre></blockquote>
-
-
-
-<h2><a name="demo">Demonstration Program</a></h2>
-
-
-
-<p>The program <a href="../test/static_log2_test.cpp">static_log2_test.cpp</a>
-is a simplistic demonstration of the results from instantiating various
-examples of the binary logarithm class template.</p>
-
-
-
-<h2><a name="rationale">Rationale</a></h2>
-
-
-
-<p>The base-two (binary) logarithm, abbreviated <dfn>lb</dfn>, function
-is occasionally used to give order-estimates of computer algorithms.
-The truncated logarithm can be considered the highest power-of-two in a
-value, which corresponds to the value's highest set bit (for binary
-integers).  Sometimes the highest-bit position could be used in generic
-programming, which requires the position to be statically (<i>i.e.</i>
-at compile-time) available.</p>
-
-
-
-<h2><a name="whatsnew">Changes from previous versions:</a></h2>
-
-
-
-<ul>
-<li><i>New in version 1.32.0:</i><br><br>
-
-The argument type and the result type of <code>boost::static_log2</code>
-are now typedef'd. Formerly, they were hardcoded as <code>unsigned long</code>
-and <code>int</code> respectively. Please, use the provided typedefs in new
-code (and update old code as soon as possible).
-</li>
-</ul>
-
-
-
-<h2><a name="credits">Credits</a></h2>
-
-
-
-<p>The original version of the Boost binary logarithm class template was
-written by <a href="../../../people/daryle_walker.html">Daryle Walker</a>
-and then enhanced by Giovanni Bajo with support for compilers without
-partial template specialization. The current version was suggested,
-together with a reference implementation, by Vesa Karvonen. Gennaro Prota
-wrote the actual source file.
-</p>
-
-<hr>
-
-
-
-<p>Revised July 19, 2004</p>
-
-          <p>&copy; Copyright Daryle Walker 2001.<br>
-             &copy; Copyright Gennaro Prota 2004.</p>
-
-     Distributed under the Boost Software License, Version 1.0.
-        (See accompanying file LICENSE_1_0.txt or copy at
-         <a href="http://www.boost.org/LICENSE_1_0.txt">
-            http://www.boost.org/LICENSE_1_0.txt</a>)
-
-<br>
-
-</body>
-
-</html>
-
--- a/doc/static_min_max.html
+++ b/doc/static_min_max.html
@ -1,120 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
-<html>
-<head>
-<title>Compile-Time Extrema Templates</title>
-</head>
-
-<body bgcolor="white" text="black" link="blue" alink="red" vlink="purple">
-<h1><img src="../../../boost.png" alt="boost.png (6897 bytes)"
-align="middle" width="277" height="86">Compile-Time Extrema
-Templates</h1>
-
-<p>The class templates in <cite><a
-href="../../../boost/integer/static_min_max.hpp">&lt;boost/integer/static_min_max.hpp&gt;</a></cite>
-provide a compile-time evaluation of the minimum or maximum of
-two integers.  These facilities are useful for generic programming problems.</p>
-
-<h2><a name="contents">Contents</a></h2>
-
-<ul>
-	<li><a href="#contents">Contents</a></li>
-	<li><a href="#synopsis">Synopsis</a></li>
-	<li><a href="#usage">Usage</a></li>
-	<li><a href="#example">Example</a></li>
-	<li><a href="#demo">Demonstration Program</a></li>
-	<li><a href="#rationale">Rationale</a></li>
-	<li><a href="#credits">Credits</a></li>
-</ul>
-
-<h2><a name="synopsis">Synopsis</a></h2>
-
-<blockquote><pre>
-namespace boost
-{
-
-template &lt; long Value1, long Value2 &gt;
-    struct static_signed_min;
-
-template &lt; long Value1, long Value2 &gt;
-    struct static_signed_max;
-
-template &lt; unsigned long Value1, unsigned long Value2 &gt;
-    struct static_unsigned_min;
-
-template &lt; unsigned long Value1, unsigned long Value2 &gt;
-    struct static_unsigned_max;
-
-}
-</pre></blockquote>
-
-<h2><a name="usage">Usage</a></h2>
-
-<p>The four class templates provide the combinations for finding the
-minimum or maximum of two signed or <code>unsigned</code>
-(<code>long</code>) parameters, <var>Value1</var> and <var>Value2</var>,
-at compile-time.  Each template has a single static data member,
-<code>value</code>, which is set to the respective minimum or maximum
-of the template's parameters.</p>
-
-<h2><a name="example">Example</a></h2>
-
-<blockquote><pre>
-#include &lt;boost/integer/static_min_max.hpp&gt;
-
-template &lt; unsigned long AddendSize1, unsigned long AddendSize2 &gt;
-class adder
-{
-public:
-    static  unsigned long  const  addend1_size = AddendSize1;
-    static  unsigned long  const  addend2_size = AddendSize2;
-    static  unsigned long  const  sum_size = boost::static_unsigned_max&lt;AddendSize1, AddendSize2&gt;::value + 1;
-
-    typedef int  addend1_type[ addend1_size ];
-    typedef int  addend2_type[ addend2_size ];
-    typedef int  sum_type[ sum_size ];
-
-    void  operator ()( addend1_type const &amp;a1, addend2_type const &amp;a2, sum_type &amp;s ) const;
-};
-
-//...
-
-int main()
-{
-    int const   a1[] = { 0, 4, 3 };  // 340
-    int const   a2[] = { 9, 8 };     //  89
-    int         s[ 4 ];
-    adder&lt;3,2&gt;  obj;
-
-    obj( a1, a2, s );  // 's' should be 429 or { 9, 2, 4, 0 }
-    //...
-}
-</pre></blockquote>
-
-<h2><a name="demo">Demonstration Program</a></h2>
-
-<p>The program <a
-href="../test/static_min_max_test.cpp">static_min_max_test.cpp</a> is a
-simplistic demonstration of various comparisons using the compile-time
-extrema class templates.</p>
-
-<h2><a name="rationale">Rationale</a></h2>
-
-<p>Sometimes the minimum or maximum of several values needs to be found
-for later compile-time processing, <i>e.g.</i> for a bound for another
-class template.</p>
-
-<h2><a name="credits">Credits</a></h2>
-
-<p>The author of the Boost compile-time extrema class templates is <a
-href="../../../people/daryle_walker.html">Daryle Walker</a>.</p>
-
-<hr>
-
-<p>Revised October 12, 2001</p>
-
-<p>&copy; Copyright Daryle Walker 2001.  Use, modification, and distribution are
-subject to the Boost Software License, Version 1.0.  (See accompanying file <a
-href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
-href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
-</body>
-</html>
--- a/include/boost/cstdint.hpp
+++ b/include/boost/cstdint.hpp
@ -1,446 +0,0 @@
-//  boost cstdint.hpp header file  ------------------------------------------//
-
-//  (C) Copyright Beman Dawes 1999. 
-//  (C) Copyright Jens Mauer 2001  
-//  (C) Copyright John Maddock 2001 
-//  Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/libs/integer for documentation.
-
-//  Revision History
-//   31 Oct 01  use BOOST_HAS_LONG_LONG to check for "long long" (Jens M.)
-//   16 Apr 01  check LONGLONG_MAX when looking for "long long" (Jens Maurer)
-//   23 Jan 01  prefer "long" over "int" for int32_t and intmax_t (Jens Maurer)
-//   12 Nov 00  Merged <boost/stdint.h> (Jens Maurer)
-//   23 Sep 00  Added INTXX_C macro support (John Maddock).
-//   22 Sep 00  Better 64-bit support (John Maddock)
-//   29 Jun 00  Reimplement to avoid including stdint.h within namespace boost
-//    8 Aug 99  Initial version (Beman Dawes)
-
-
-#ifndef BOOST_CSTDINT_HPP
-#define BOOST_CSTDINT_HPP
-
-#include <boost/config.hpp>
-
-
-#ifdef BOOST_HAS_STDINT_H
-
-// The following #include is an implementation artifact; not part of interface.
-# ifdef __hpux
-// HP-UX has a vaguely nice <stdint.h> in a non-standard location
-#   include <inttypes.h>
-#   ifdef __STDC_32_MODE__
-      // this is triggered with GCC, because it defines __cplusplus < 199707L
-#     define BOOST_NO_INT64_T
-#   endif 
-# elif defined(__FreeBSD__) || defined(__IBMCPP__)
-#   include <inttypes.h>
-# else
-#   include <stdint.h>
-
-// There is a bug in Cygwin two _C macros
-#   if defined(__STDC_CONSTANT_MACROS) && defined(__CYGWIN__)
-#     undef INTMAX_C
-#     undef UINTMAX_C
-#     define INTMAX_C(c) c##LL
-#     define UINTMAX_C(c) c##ULL
-#   endif
-
-# endif
-
-#ifdef __QNX__
-
-// QNX (Dinkumware stdlib) defines these as non-standard names.
-// Reflect to the standard names.
-
-typedef ::intleast8_t int_least8_t;
-typedef ::intfast8_t int_fast8_t;
-typedef ::uintleast8_t uint_least8_t;
-typedef ::uintfast8_t uint_fast8_t;
-
-typedef ::intleast16_t int_least16_t;
-typedef ::intfast16_t int_fast16_t;
-typedef ::uintleast16_t uint_least16_t;
-typedef ::uintfast16_t uint_fast16_t;
-
-typedef ::intleast32_t int_least32_t;
-typedef ::intfast32_t int_fast32_t;
-typedef ::uintleast32_t uint_least32_t;
-typedef ::uintfast32_t uint_fast32_t;
-
-# ifndef BOOST_NO_INT64_T
-
-typedef ::intleast64_t int_least64_t;
-typedef ::intfast64_t int_fast64_t;
-typedef ::uintleast64_t uint_least64_t;
-typedef ::uintfast64_t uint_fast64_t;
-
-# endif
-
-#endif
-
-namespace boost
-{
-
-  using ::int8_t;             
-  using ::int_least8_t;       
-  using ::int_fast8_t;        
-  using ::uint8_t;            
-  using ::uint_least8_t;      
-  using ::uint_fast8_t;       
-                     
-  using ::int16_t;            
-  using ::int_least16_t;      
-  using ::int_fast16_t;       
-  using ::uint16_t;           
-  using ::uint_least16_t;     
-  using ::uint_fast16_t;      
-                     
-  using ::int32_t;            
-  using ::int_least32_t;      
-  using ::int_fast32_t;       
-  using ::uint32_t;           
-  using ::uint_least32_t;     
-  using ::uint_fast32_t;      
-                     
-# ifndef BOOST_NO_INT64_T
-
-  using ::int64_t;            
-  using ::int_least64_t;      
-  using ::int_fast64_t;       
-  using ::uint64_t;           
-  using ::uint_least64_t;     
-  using ::uint_fast64_t;      
-                     
-# endif
-
-  using ::intmax_t;      
-  using ::uintmax_t;     
-
-} // namespace boost
-
-#elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__)
-// FreeBSD and Tru64 have an <inttypes.h> that contains much of what we need.
-# include <inttypes.h>
-
-namespace boost {
-
-  using ::int8_t;             
-  typedef int8_t int_least8_t;       
-  typedef int8_t int_fast8_t;        
-  using ::uint8_t;            
-  typedef uint8_t uint_least8_t;      
-  typedef uint8_t uint_fast8_t;       
-                     
-  using ::int16_t;            
-  typedef int16_t int_least16_t;      
-  typedef int16_t int_fast16_t;       
-  using ::uint16_t;           
-  typedef uint16_t uint_least16_t;     
-  typedef uint16_t uint_fast16_t;      
-                     
-  using ::int32_t;            
-  typedef int32_t int_least32_t;      
-  typedef int32_t int_fast32_t;       
-  using ::uint32_t;           
-  typedef uint32_t uint_least32_t;     
-  typedef uint32_t uint_fast32_t;      
-         
-# ifndef BOOST_NO_INT64_T          
-
-  using ::int64_t;            
-  typedef int64_t int_least64_t;      
-  typedef int64_t int_fast64_t;       
-  using ::uint64_t;           
-  typedef uint64_t uint_least64_t;     
-  typedef uint64_t uint_fast64_t;      
-
-  typedef int64_t intmax_t;
-  typedef uint64_t uintmax_t;
-
-# else
-
-  typedef int32_t intmax_t;
-  typedef uint32_t uintmax_t;
-
-# endif
-
-} // namespace boost
-
-#else  // BOOST_HAS_STDINT_H
-
-# include <boost/limits.hpp> // implementation artifact; not part of interface
-# include <limits.h>         // needed for limits macros
-
-
-namespace boost
-{
-
-//  These are fairly safe guesses for some 16-bit, and most 32-bit and 64-bit
-//  platforms.  For other systems, they will have to be hand tailored.
-//
-//  Because the fast types are assumed to be the same as the undecorated types,
-//  it may be possible to hand tailor a more efficient implementation.  Such
-//  an optimization may be illusionary; on the Intel x86-family 386 on, for
-//  example, byte arithmetic and load/stores are as fast as "int" sized ones.
-
-//  8-bit types  ------------------------------------------------------------//
-
-# if UCHAR_MAX == 0xff
-     typedef signed char     int8_t;
-     typedef signed char     int_least8_t;
-     typedef signed char     int_fast8_t;
-     typedef unsigned char   uint8_t;
-     typedef unsigned char   uint_least8_t;
-     typedef unsigned char   uint_fast8_t;
-# else
-#    error defaults not correct; you must hand modify boost/cstdint.hpp
-# endif
-
-//  16-bit types  -----------------------------------------------------------//
-
-# if USHRT_MAX == 0xffff
-#  if defined(__crayx1)
-     // The Cray X1 has a 16-bit short, however it is not recommend
-     // for use in performance critical code.
-     typedef short           int16_t;
-     typedef short           int_least16_t;
-     typedef int             int_fast16_t;
-     typedef unsigned short  uint16_t;
-     typedef unsigned short  uint_least16_t;
-     typedef unsigned int    uint_fast16_t;
-#  else
-     typedef short           int16_t;
-     typedef short           int_least16_t;
-     typedef short           int_fast16_t;
-     typedef unsigned short  uint16_t;
-     typedef unsigned short  uint_least16_t;
-     typedef unsigned short  uint_fast16_t;
-#  endif
-# elif (USHRT_MAX == 0xffffffff) && defined(CRAY)
-     // no 16-bit types on Cray:
-     typedef short           int_least16_t;
-     typedef short           int_fast16_t;
-     typedef unsigned short  uint_least16_t;
-     typedef unsigned short  uint_fast16_t;
-# else
-#    error defaults not correct; you must hand modify boost/cstdint.hpp
-# endif
-
-//  32-bit types  -----------------------------------------------------------//
-
-# if ULONG_MAX == 0xffffffff
-     typedef long            int32_t;
-     typedef long            int_least32_t;
-     typedef long            int_fast32_t;
-     typedef unsigned long   uint32_t;
-     typedef unsigned long   uint_least32_t;
-     typedef unsigned long   uint_fast32_t;
-# elif UINT_MAX == 0xffffffff
-     typedef int             int32_t;
-     typedef int             int_least32_t;
-     typedef int             int_fast32_t;
-     typedef unsigned int    uint32_t;
-     typedef unsigned int    uint_least32_t;
-     typedef unsigned int    uint_fast32_t;
-# else
-#    error defaults not correct; you must hand modify boost/cstdint.hpp
-# endif
-
-//  64-bit types + intmax_t and uintmax_t  ----------------------------------//
-
-# if defined(BOOST_HAS_LONG_LONG) && \
-   !defined(BOOST_MSVC) && !defined(__BORLANDC__) && \
-   (!defined(__GLIBCPP__) || defined(_GLIBCPP_USE_LONG_LONG)) && \
-   (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
-#    if defined(__hpux)
-     // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions
-#    elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) || (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) || (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL)
-                                                                 // 2**64 - 1
-#    else
-#       error defaults not correct; you must hand modify boost/cstdint.hpp
-#    endif
-
-     typedef  ::boost::long_long_type            intmax_t;
-     typedef  ::boost::ulong_long_type   uintmax_t;
-     typedef  ::boost::long_long_type            int64_t;
-     typedef  ::boost::long_long_type            int_least64_t;
-     typedef  ::boost::long_long_type            int_fast64_t;
-     typedef  ::boost::ulong_long_type   uint64_t;
-     typedef  ::boost::ulong_long_type   uint_least64_t;
-     typedef  ::boost::ulong_long_type   uint_fast64_t;
-
-# elif ULONG_MAX != 0xffffffff
-
-#    if ULONG_MAX == 18446744073709551615 // 2**64 - 1
-     typedef long                 intmax_t;
-     typedef unsigned long        uintmax_t;
-     typedef long                 int64_t;
-     typedef long                 int_least64_t;
-     typedef long                 int_fast64_t;
-     typedef unsigned long        uint64_t;
-     typedef unsigned long        uint_least64_t;
-     typedef unsigned long        uint_fast64_t;
-#    else
-#       error defaults not correct; you must hand modify boost/cstdint.hpp
-#    endif
-# elif defined(__GNUC__) && defined(BOOST_HAS_LONG_LONG)
-     __extension__ typedef long long            intmax_t;
-     __extension__ typedef unsigned long long   uintmax_t;
-     __extension__ typedef long long            int64_t;
-     __extension__ typedef long long            int_least64_t;
-     __extension__ typedef long long            int_fast64_t;
-     __extension__ typedef unsigned long long   uint64_t;
-     __extension__ typedef unsigned long long   uint_least64_t;
-     __extension__ typedef unsigned long long   uint_fast64_t;
-# elif defined(BOOST_HAS_MS_INT64)
-     //
-     // we have Borland/Intel/Microsoft __int64:
-     //
-     typedef __int64             intmax_t;
-     typedef unsigned __int64    uintmax_t;
-     typedef __int64             int64_t;
-     typedef __int64             int_least64_t;
-     typedef __int64             int_fast64_t;
-     typedef unsigned __int64    uint64_t;
-     typedef unsigned __int64    uint_least64_t;
-     typedef unsigned __int64    uint_fast64_t;
-# else // assume no 64-bit integers
-#  define BOOST_NO_INT64_T
-     typedef int32_t              intmax_t;
-     typedef uint32_t             uintmax_t;
-# endif
-
-} // namespace boost
-
-
-#endif // BOOST_HAS_STDINT_H
-
-#endif // BOOST_CSTDINT_HPP
-
-
-/****************************************************
-
-Macro definition section:
-
-Define various INTXX_C macros only if
-__STDC_CONSTANT_MACROS is defined.
-
-Undefine the macros if __STDC_CONSTANT_MACROS is
-not defined and the macros are (cf <cassert>).
-
-Added 23rd September 2000 (John Maddock).
-Modified 11th September 2001 to be excluded when
-BOOST_HAS_STDINT_H is defined (John Maddock).
-
-******************************************************/
-
-#if defined(__STDC_CONSTANT_MACROS) && !defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && !defined(BOOST_HAS_STDINT_H)
-# define BOOST__STDC_CONSTANT_MACROS_DEFINED
-# if defined(BOOST_HAS_MS_INT64)
-//
-// Borland/Intel/Microsoft compilers have width specific suffixes:
-//
-#  define INT8_C(value)     value##i8
-#  define INT16_C(value)    value##i16
-#  define INT32_C(value)    value##i32
-#  define INT64_C(value)    value##i64
-#  ifdef __BORLANDC__
-    // Borland bug: appending ui8 makes the type a signed char
-#   define UINT8_C(value)    static_cast<unsigned char>(value##u)
-#  else
-#   define UINT8_C(value)    value##ui8
-#  endif
-#  define UINT16_C(value)   value##ui16
-#  define UINT32_C(value)   value##ui32
-#  define UINT64_C(value)   value##ui64
-#  define INTMAX_C(value)   value##i64
-#  define UINTMAX_C(value)  value##ui64
-
-# else
-//  do it the old fashioned way:
-
-//  8-bit types  ------------------------------------------------------------//
-
-#  if UCHAR_MAX == 0xff
-#   define INT8_C(value) static_cast<boost::int8_t>(value)
-#   define UINT8_C(value) static_cast<boost::uint8_t>(value##u)
-#  endif
-
-//  16-bit types  -----------------------------------------------------------//
-
-#  if USHRT_MAX == 0xffff
-#   define INT16_C(value) static_cast<boost::int16_t>(value)
-#   define UINT16_C(value) static_cast<boost::uint16_t>(value##u)
-#  endif
-
-//  32-bit types  -----------------------------------------------------------//
-
-#  if UINT_MAX == 0xffffffff
-#   define INT32_C(value) value
-#   define UINT32_C(value) value##u
-#  elif ULONG_MAX == 0xffffffff
-#   define INT32_C(value) value##L
-#   define UINT32_C(value) value##uL
-#  endif
-
-//  64-bit types + intmax_t and uintmax_t  ----------------------------------//
-
-#  if defined(BOOST_HAS_LONG_LONG) && \
-    (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
-
-#    if defined(__hpux)
-     // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions
-#    elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615U) ||  \
-        (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615U) ||  \
-        (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615U)
-
-#    else
-#       error defaults not correct; you must hand modify boost/cstdint.hpp
-#    endif
-#    define INT64_C(value) value##LL
-#    define UINT64_C(value) value##uLL
-#  elif ULONG_MAX != 0xffffffff
-
-#    if ULONG_MAX == 18446744073709551615 // 2**64 - 1
-#       define INT64_C(value) value##L
-#       define UINT64_C(value) value##uL
-#    else
-#       error defaults not correct; you must hand modify boost/cstdint.hpp
-#    endif
-#  endif
-
-#  ifdef BOOST_NO_INT64_T
-#   define INTMAX_C(value) INT32_C(value)
-#   define UINTMAX_C(value) UINT32_C(value)
-#  else
-#   define INTMAX_C(value) INT64_C(value)
-#   define UINTMAX_C(value) UINT64_C(value)
-#  endif
-
-# endif // Borland/Microsoft specific width suffixes
-
-
-#elif defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && !defined(__STDC_CONSTANT_MACROS) && !defined(BOOST_HAS_STDINT_H)
-//
-// undef all the macros:
-//
-# undef INT8_C
-# undef INT16_C
-# undef INT32_C
-# undef INT64_C
-# undef UINT8_C
-# undef UINT16_C
-# undef UINT32_C
-# undef UINT64_C
-# undef INTMAX_C
-# undef UINTMAX_C
-
-#endif // __STDC_CONSTANT_MACROS_DEFINED etc.
-
-
-
-
--- a/include/boost/integer.hpp
+++ b/include/boost/integer.hpp
@ -17,8 +17,22 @@

 #include <boost/integer_fwd.hpp>  // self include

-#include <boost/integer_traits.hpp>  // for boost::integer_traits
-#include <boost/limits.hpp>          // for std::numeric_limits
+#include <boost/integer_traits.hpp>  // for boost::::boost::integer_traits
+#include <boost/limits.hpp>          // for ::std::numeric_limits
+#include <boost/cstdint.hpp>         // for boost::int64_t and BOOST_NO_INTEGRAL_INT64_T
+#include <boost/static_assert.hpp>
+
+//
+// We simply cannot include this header on gcc without getting copious warnings of the kind:
+//
+// boost/integer.hpp:77:30: warning: use of C99 long long integer constant
+//
+// And yet there is no other reasonable implementation, so we declare this a system header
+// to suppress these warnings.
+//
+#if defined(__GNUC__) && (__GNUC__ >= 4)
+#pragma GCC system_header
+#endif

 namespace boost
 {
@ -28,97 +42,218 @@ namespace boost
  //  fast integers from least integers
  //  int_fast_t<> works correctly for unsigned too, in spite of the name.
  template< typename LeastInt >
-  struct int_fast_t { typedef LeastInt fast; }; // imps may specialize
+  struct int_fast_t
+  {
+     typedef LeastInt fast;
+     typedef fast     type;
+  }; // imps may specialize

-  //  convert category to type 
+  namespace detail{
+
+  //  convert category to type
  template< int Category > struct int_least_helper {}; // default is empty
+  template< int Category > struct uint_least_helper {}; // default is empty

  //  specializatons: 1=long, 2=int, 3=short, 4=signed char,
  //     6=unsigned long, 7=unsigned int, 8=unsigned short, 9=unsigned char
  //  no specializations for 0 and 5: requests for a type > long are in error
-  template<> struct int_least_helper<1> { typedef long least; };
-  template<> struct int_least_helper<2> { typedef int least; };
-  template<> struct int_least_helper<3> { typedef short least; };
-  template<> struct int_least_helper<4> { typedef signed char least; };
-  template<> struct int_least_helper<6> { typedef unsigned long least; };
-  template<> struct int_least_helper<7> { typedef unsigned int least; };
-  template<> struct int_least_helper<8> { typedef unsigned short least; };
-  template<> struct int_least_helper<9> { typedef unsigned char least; };
+#ifdef BOOST_HAS_LONG_LONG
+  template<> struct int_least_helper<1> { typedef boost::long_long_type least; };
+#elif defined(BOOST_HAS_MS_INT64)
+  template<> struct int_least_helper<1> { typedef __int64 least; };
+#endif
+  template<> struct int_least_helper<2> { typedef long least; };
+  template<> struct int_least_helper<3> { typedef int least; };
+  template<> struct int_least_helper<4> { typedef short least; };
+  template<> struct int_least_helper<5> { typedef signed char least; };
+#ifdef BOOST_HAS_LONG_LONG
+  template<> struct uint_least_helper<1> { typedef boost::ulong_long_type least; };
+#elif defined(BOOST_HAS_MS_INT64)
+  template<> struct uint_least_helper<1> { typedef unsigned __int64 least; };
+#endif
+  template<> struct uint_least_helper<2> { typedef unsigned long least; };
+  template<> struct uint_least_helper<3> { typedef unsigned int least; };
+  template<> struct uint_least_helper<4> { typedef unsigned short least; };
+  template<> struct uint_least_helper<5> { typedef unsigned char least; };
+
+  template <int Bits>
+  struct exact_signed_base_helper{};
+  template <int Bits>
+  struct exact_unsigned_base_helper{};
+
+  template <> struct exact_signed_base_helper<sizeof(signed char)* CHAR_BIT> { typedef signed char exact; };
+  template <> struct exact_unsigned_base_helper<sizeof(unsigned char)* CHAR_BIT> { typedef unsigned char exact; };
+#if USHRT_MAX != UCHAR_MAX
+  template <> struct exact_signed_base_helper<sizeof(short)* CHAR_BIT> { typedef short exact; };
+  template <> struct exact_unsigned_base_helper<sizeof(unsigned short)* CHAR_BIT> { typedef unsigned short exact; };
+#endif
+#if UINT_MAX != USHRT_MAX
+  template <> struct exact_signed_base_helper<sizeof(int)* CHAR_BIT> { typedef int exact; };
+  template <> struct exact_unsigned_base_helper<sizeof(unsigned int)* CHAR_BIT> { typedef unsigned int exact; };
+#endif
+#if ULONG_MAX != UINT_MAX && ( !defined __TI_COMPILER_VERSION__ || \
+    ( __TI_COMPILER_VERSION__ >= 7000000 && !defined __TI_40BIT_LONG__ ) )
+  template <> struct exact_signed_base_helper<sizeof(long)* CHAR_BIT> { typedef long exact; };
+  template <> struct exact_unsigned_base_helper<sizeof(unsigned long)* CHAR_BIT> { typedef unsigned long exact; };
+#endif
+#if defined(BOOST_HAS_LONG_LONG) &&\
+   ((defined(ULLONG_MAX) && (ULLONG_MAX != ULONG_MAX)) ||\
+    (defined(ULONG_LONG_MAX) && (ULONG_LONG_MAX != ULONG_MAX)) ||\
+    (defined(ULONGLONG_MAX) && (ULONGLONG_MAX != ULONG_MAX)) ||\
+    (defined(_ULLONG_MAX) && (_ULLONG_MAX != ULONG_MAX)))
+  template <> struct exact_signed_base_helper<sizeof(boost::long_long_type)* CHAR_BIT> { typedef boost::long_long_type exact; };
+  template <> struct exact_unsigned_base_helper<sizeof(boost::ulong_long_type)* CHAR_BIT> { typedef boost::ulong_long_type exact; };
+#endif
+
+
+  } // namespace detail

  //  integer templates specifying number of bits  ---------------------------//

  //  signed
  template< int Bits >   // bits (including sign) required
-  struct int_t 
+  struct int_t : public boost::detail::exact_signed_base_helper<Bits>
  {
-      typedef typename int_least_helper
+      BOOST_STATIC_ASSERT_MSG(Bits <= (int)(sizeof(boost::intmax_t) * CHAR_BIT),
+         "No suitable signed integer type with the requested number of bits is available.");
+      typedef typename boost::detail::int_least_helper
        <
-          (Bits-1 <= std::numeric_limits<long>::digits) +
-          (Bits-1 <= std::numeric_limits<int>::digits) +
-          (Bits-1 <= std::numeric_limits<short>::digits) +
-          (Bits-1 <= std::numeric_limits<signed char>::digits)
+#ifdef BOOST_HAS_LONG_LONG
+          (Bits <= (int)(sizeof(boost::long_long_type) * CHAR_BIT)) +
+#else
+           1 +
+#endif
+          (Bits-1 <= ::std::numeric_limits<long>::digits) +
+          (Bits-1 <= ::std::numeric_limits<int>::digits) +
+          (Bits-1 <= ::std::numeric_limits<short>::digits) +
+          (Bits-1 <= ::std::numeric_limits<signed char>::digits)
        >::least  least;
-      typedef typename int_fast_t<least>::fast  fast;
+      typedef typename int_fast_t<least>::type  fast;
  };

  //  unsigned
  template< int Bits >   // bits required
-  struct uint_t 
+  struct uint_t : public boost::detail::exact_unsigned_base_helper<Bits>
  {
-      typedef typename int_least_helper
-        < 
-          5 +
-          (Bits <= std::numeric_limits<unsigned long>::digits) +
-          (Bits <= std::numeric_limits<unsigned int>::digits) +
-          (Bits <= std::numeric_limits<unsigned short>::digits) +
-          (Bits <= std::numeric_limits<unsigned char>::digits)
+     BOOST_STATIC_ASSERT_MSG(Bits <= (int)(sizeof(boost::uintmax_t) * CHAR_BIT),
+         "No suitable unsigned integer type with the requested number of bits is available.");
+#if (defined(__BORLANDC__) || defined(__CODEGEAR__)) && defined(BOOST_NO_INTEGRAL_INT64_T)
+     // It's really not clear why this workaround should be needed... shrug I guess!  JM
+     BOOST_STATIC_CONSTANT(int, s =
+           6 +
+          (Bits <= ::std::numeric_limits<unsigned long>::digits) +
+          (Bits <= ::std::numeric_limits<unsigned int>::digits) +
+          (Bits <= ::std::numeric_limits<unsigned short>::digits) +
+          (Bits <= ::std::numeric_limits<unsigned char>::digits));
+     typedef typename detail::int_least_helper< ::boost::uint_t<Bits>::s>::least least;
+#else
+      typedef typename boost::detail::uint_least_helper
+        <
+#ifdef BOOST_HAS_LONG_LONG
+          (Bits <= (int)(sizeof(boost::long_long_type) * CHAR_BIT)) +
+#else
+           1 +
+#endif
+          (Bits <= ::std::numeric_limits<unsigned long>::digits) +
+          (Bits <= ::std::numeric_limits<unsigned int>::digits) +
+          (Bits <= ::std::numeric_limits<unsigned short>::digits) +
+          (Bits <= ::std::numeric_limits<unsigned char>::digits)
        >::least  least;
-      typedef typename int_fast_t<least>::fast  fast;
+#endif
+      typedef typename int_fast_t<least>::type  fast;
      // int_fast_t<> works correctly for unsigned too, in spite of the name.
  };

  //  integer templates specifying extreme value  ----------------------------//

  //  signed
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
+  template< boost::long_long_type MaxValue >   // maximum value to require support
+#else
  template< long MaxValue >   // maximum value to require support
-  struct int_max_value_t 
+#endif
+  struct int_max_value_t
  {
-      typedef typename int_least_helper
+      typedef typename boost::detail::int_least_helper
        <
-          (MaxValue <= integer_traits<long>::const_max) +
-          (MaxValue <= integer_traits<int>::const_max) +
-          (MaxValue <= integer_traits<short>::const_max) +
-          (MaxValue <= integer_traits<signed char>::const_max)
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
+          (MaxValue <= ::boost::integer_traits<boost::long_long_type>::const_max) +
+#else
+           1 +
+#endif
+          (MaxValue <= ::boost::integer_traits<long>::const_max) +
+          (MaxValue <= ::boost::integer_traits<int>::const_max) +
+          (MaxValue <= ::boost::integer_traits<short>::const_max) +
+          (MaxValue <= ::boost::integer_traits<signed char>::const_max)
        >::least  least;
-      typedef typename int_fast_t<least>::fast  fast;
+      typedef typename int_fast_t<least>::type  fast;
  };

+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
+  template< boost::long_long_type MinValue >   // minimum value to require support
+#else
  template< long MinValue >   // minimum value to require support
-  struct int_min_value_t 
+#endif
+  struct int_min_value_t
  {
-      typedef typename int_least_helper
+      typedef typename boost::detail::int_least_helper
        <
-          (MinValue >= integer_traits<long>::const_min) +
-          (MinValue >= integer_traits<int>::const_min) +
-          (MinValue >= integer_traits<short>::const_min) +
-          (MinValue >= integer_traits<signed char>::const_min)
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
+          (MinValue >= ::boost::integer_traits<boost::long_long_type>::const_min) +
+#else
+           1 +
+#endif
+          (MinValue >= ::boost::integer_traits<long>::const_min) +
+          (MinValue >= ::boost::integer_traits<int>::const_min) +
+          (MinValue >= ::boost::integer_traits<short>::const_min) +
+          (MinValue >= ::boost::integer_traits<signed char>::const_min)
        >::least  least;
-      typedef typename int_fast_t<least>::fast  fast;
+      typedef typename int_fast_t<least>::type  fast;
  };

  //  unsigned
-  template< unsigned long Value >   // maximum value to require support
-  struct uint_value_t 
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
+  template< boost::ulong_long_type MaxValue >   // minimum value to require support
+#else
+  template< unsigned long MaxValue >   // minimum value to require support
+#endif
+  struct uint_value_t
  {
-      typedef typename int_least_helper
-        < 
-          5 +
-          (Value <= integer_traits<unsigned long>::const_max) +
-          (Value <= integer_traits<unsigned int>::const_max) +
-          (Value <= integer_traits<unsigned short>::const_max) +
-          (Value <= integer_traits<unsigned char>::const_max)
+#if (defined(__BORLANDC__) || defined(__CODEGEAR__))
+     // It's really not clear why this workaround should be needed... shrug I guess!  JM
+#if defined(BOOST_NO_INTEGRAL_INT64_T)
+      BOOST_STATIC_CONSTANT(unsigned, which =
+           1 +
+          (MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned short>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned char>::const_max));
+      typedef typename detail::int_least_helper< ::boost::uint_value_t<MaxValue>::which>::least least;
+#else // BOOST_NO_INTEGRAL_INT64_T
+      BOOST_STATIC_CONSTANT(unsigned, which =
+           1 +
+          (MaxValue <= ::boost::integer_traits<boost::ulong_long_type>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned short>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned char>::const_max));
+      typedef typename detail::uint_least_helper< ::boost::uint_value_t<MaxValue>::which>::least least;
+#endif // BOOST_NO_INTEGRAL_INT64_T
+#else
+      typedef typename boost::detail::uint_least_helper
+        <
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
+          (MaxValue <= ::boost::integer_traits<boost::ulong_long_type>::const_max) +
+#else
+           1 +
+#endif
+          (MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned short>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned char>::const_max)
        >::least  least;
-      typedef typename int_fast_t<least>::fast  fast;
+#endif
+      typedef typename int_fast_t<least>::type  fast;
  };


--- a/include/boost/integer/common_factor.hpp
+++ b/include/boost/integer/common_factor.hpp
@ -0,0 +1,16 @@
+//  Boost common_factor.hpp header file  -------------------------------------//
+
+//  (C) Copyright Daryle Walker 2001-2002.
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history. 
+
+#ifndef BOOST_INTEGER_COMMON_FACTOR_HPP
+#define BOOST_INTEGER_COMMON_FACTOR_HPP
+
+#include <boost/integer/common_factor_ct.hpp>
+#include <boost/integer/common_factor_rt.hpp>
+
+#endif  // BOOST_INTEGER_COMMON_FACTOR_HPP
--- a/include/boost/integer/common_factor_ct.hpp
+++ b/include/boost/integer/common_factor_ct.hpp
@ -0,0 +1,102 @@
+//  Boost common_factor_ct.hpp header file  ----------------------------------//
+
+//  (C) Copyright Daryle Walker and Stephen Cleary 2001-2002.
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history. 
+
+#ifndef BOOST_INTEGER_COMMON_FACTOR_CT_HPP
+#define BOOST_INTEGER_COMMON_FACTOR_CT_HPP
+
+#include <boost/integer_fwd.hpp>  // self include
+#include <boost/config.hpp>  // for BOOST_STATIC_CONSTANT, etc.
+
+namespace boost
+{
+namespace integer
+{
+
+//  Implementation details  --------------------------------------------------//
+
+namespace detail
+{
+    // Build GCD with Euclid's recursive algorithm
+    template < static_gcd_type Value1, static_gcd_type Value2 >
+    struct static_gcd_helper_t
+    {
+    private:
+        BOOST_STATIC_CONSTANT( static_gcd_type, new_value1 = Value2 );
+        BOOST_STATIC_CONSTANT( static_gcd_type, new_value2 = Value1 % Value2 );
+
+        #ifndef __BORLANDC__
+        #define BOOST_DETAIL_GCD_HELPER_VAL(Value) static_cast<static_gcd_type>(Value)
+        #else
+        typedef static_gcd_helper_t  self_type;
+        #define BOOST_DETAIL_GCD_HELPER_VAL(Value)  (self_type:: Value )
+        #endif
+
+        typedef static_gcd_helper_t< BOOST_DETAIL_GCD_HELPER_VAL(new_value1),
+         BOOST_DETAIL_GCD_HELPER_VAL(new_value2) >  next_step_type;
+
+        #undef BOOST_DETAIL_GCD_HELPER_VAL
+
+    public:
+        BOOST_STATIC_CONSTANT( static_gcd_type, value = next_step_type::value );
+    };
+
+    // Non-recursive case
+    template < static_gcd_type Value1 >
+    struct static_gcd_helper_t< Value1, 0UL >
+    {
+        BOOST_STATIC_CONSTANT( static_gcd_type, value = Value1 );
+    };
+
+    // Build the LCM from the GCD
+    template < static_gcd_type Value1, static_gcd_type Value2 >
+    struct static_lcm_helper_t
+    {
+        typedef static_gcd_helper_t<Value1, Value2>  gcd_type;
+
+        BOOST_STATIC_CONSTANT( static_gcd_type, value = Value1 / gcd_type::value
+         * Value2 );
+    };
+
+    // Special case for zero-GCD values
+    template < >
+    struct static_lcm_helper_t< 0UL, 0UL >
+    {
+        BOOST_STATIC_CONSTANT( static_gcd_type, value = 0UL );
+    };
+
+}  // namespace detail
+
+
+//  Compile-time greatest common divisor evaluator class declaration  --------//
+
+template < static_gcd_type Value1, static_gcd_type Value2 > struct static_gcd
+{
+    BOOST_STATIC_CONSTANT( static_gcd_type, value = (detail::static_gcd_helper_t<Value1, Value2>::value) );
+};  // boost::integer::static_gcd
+
+#if !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)
+template< static_gcd_type Value1, static_gcd_type Value2 > static_gcd_type const static_gcd< Value1, Value2 >::value;
+#endif
+
+//  Compile-time least common multiple evaluator class declaration  ----------//
+
+template < static_gcd_type Value1, static_gcd_type Value2 > struct static_lcm
+{
+    BOOST_STATIC_CONSTANT( static_gcd_type, value = (detail::static_lcm_helper_t<Value1, Value2>::value) );
+};  // boost::integer::static_lcm
+
+#if !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)
+template< static_gcd_type Value1, static_gcd_type Value2 > static_gcd_type const static_lcm< Value1, Value2 >::value;
+#endif
+
+}  // namespace integer
+}  // namespace boost
+
+
+#endif  // BOOST_INTEGER_COMMON_FACTOR_CT_HPP
--- a/include/boost/integer/common_factor_rt.hpp
+++ b/include/boost/integer/common_factor_rt.hpp
@ -0,0 +1,465 @@
+//  Boost common_factor_rt.hpp header file  ----------------------------------//
+
+//  (C) Copyright Daryle Walker and Paul Moore 2001-2002.  Permission to copy,
+//  use, modify, sell and distribute this software is granted provided this
+//  copyright notice appears in all copies.  This software is provided "as is"
+//  without express or implied warranty, and with no claim as to its suitability
+//  for any purpose. 
+
+// boostinspect:nolicense (don't complain about the lack of a Boost license)
+// (Paul Moore hasn't been in contact for years, so there's no way to change the
+// license.)
+
+//  See http://www.boost.org for updates, documentation, and revision history. 
+
+#ifndef BOOST_INTEGER_COMMON_FACTOR_RT_HPP
+#define BOOST_INTEGER_COMMON_FACTOR_RT_HPP
+
+#include <boost/integer_fwd.hpp>  // self include
+
+#include <boost/config.hpp>  // for BOOST_NESTED_TEMPLATE, etc.
+#include <boost/limits.hpp>  // for std::numeric_limits
+#include <climits>           // for CHAR_MIN
+#include <boost/detail/workaround.hpp>
+
+#ifndef  BOOST_NO_CXX11_NOEXCEPT
+#include <boost/type_traits/is_arithmetic.hpp>
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127 4244)  // Conditional expression is constant
+#endif
+
+namespace boost
+{
+namespace integer
+{
+
+#define BOOST_INT_NOEXCEPT(T) BOOST_NOEXCEPT_IF(boost::is_arithmetic<T>::value)
+
+//  Forward declarations for function templates  -----------------------------//
+
+template < typename IntegerType >
+BOOST_CXX14_CONSTEXPR IntegerType  gcd( IntegerType const &a, IntegerType const &b )BOOST_INT_NOEXCEPT(IntegerType);
+
+template < typename IntegerType >
+BOOST_CXX14_CONSTEXPR IntegerType  lcm( IntegerType const &a, IntegerType const &b )BOOST_INT_NOEXCEPT(IntegerType);
+
+
+//  Greatest common divisor evaluator class declaration  ---------------------//
+
+template < typename IntegerType >
+class gcd_evaluator
+{
+public:
+    // Types
+    typedef IntegerType  result_type, first_argument_type, second_argument_type;
+
+    // Function object interface
+    BOOST_CXX14_CONSTEXPR result_type  operator ()( first_argument_type const &a,
+     second_argument_type const &b )const BOOST_INT_NOEXCEPT(IntegerType) ;
+
+};  // boost::integer::gcd_evaluator
+
+
+//  Least common multiple evaluator class declaration  -----------------------//
+
+template < typename IntegerType >
+class lcm_evaluator
+{
+public:
+    // Types
+    typedef IntegerType  result_type, first_argument_type, second_argument_type;
+
+    // Function object interface
+    BOOST_CXX14_CONSTEXPR result_type  operator ()( first_argument_type const &a,
+     second_argument_type const &b )const BOOST_INT_NOEXCEPT(IntegerType) ;
+
+};  // boost::integer::lcm_evaluator
+
+
+//  Implementation details  --------------------------------------------------//
+
+namespace detail
+{
+    // Greatest common divisor for rings (including unsigned integers)
+    template < typename RingType >
+    BOOST_CXX14_CONSTEXPR RingType
+    gcd_euclidean
+    (
+        RingType a,
+        RingType b
+    )BOOST_INT_NOEXCEPT(RingType)
+    {
+        // Avoid repeated construction
+        #ifndef __BORLANDC__
+        RingType const  zero = static_cast<RingType>( 0 );
+        #else
+        RingType  zero = static_cast<RingType>( 0 );
+        #endif
+
+        // Reduce by GCD-remainder property [GCD(a,b) == GCD(b,a MOD b)]
+        while ( true )
+        {
+            if ( a == zero )
+                return b;
+            b %= a;
+
+            if ( b == zero )
+                return a;
+            a %= b;
+        }
+    }
+
+    // Greatest common divisor for (signed) integers
+    template < typename IntegerType >
+    inline
+    BOOST_CXX14_CONSTEXPR IntegerType
+    gcd_integer
+    (
+        IntegerType const &  a,
+        IntegerType const &  b
+    )BOOST_INT_NOEXCEPT(IntegerType)
+    {
+        // Avoid repeated construction
+        IntegerType const  zero = static_cast<IntegerType>( 0 );
+        IntegerType const  result = gcd_euclidean( a, b );
+
+        return ( result < zero ) ? static_cast<IntegerType>(-result) : result;
+    }
+
+    // Greatest common divisor for unsigned binary integers
+    template < typename BuiltInUnsigned >
+    BOOST_CXX14_CONSTEXPR BuiltInUnsigned
+    gcd_binary
+    (
+        BuiltInUnsigned  u,
+        BuiltInUnsigned  v
+    )BOOST_INT_NOEXCEPT(BuiltInUnsigned)
+    {
+        if ( u && v )
+        {
+            // Shift out common factors of 2
+            unsigned  shifts = 0;
+
+            while ( !(u & 1u) && !(v & 1u) )
+            {
+                ++shifts;
+                u >>= 1;
+                v >>= 1;
+            }
+
+            // Start with the still-even one, if any
+            BuiltInUnsigned  r[] = { u, v };
+            unsigned         which = static_cast<bool>( u & 1u );
+
+            // Whittle down the values via their differences
+            do
+            {
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
+                while ( !(r[ which ] & 1u) )
+                {
+                    r[ which ] = (r[which] >> 1);
+                }
+#else
+                // Remove factors of two from the even one
+                while ( !(r[ which ] & 1u) )
+                {
+                    r[ which ] >>= 1;
+                }
+#endif
+
+                // Replace the larger of the two with their difference
+                if ( r[!which] > r[which] )
+                {
+                    which ^= 1u;
+                }
+
+                r[ which ] -= r[ !which ];
+            }
+            while ( r[which] );
+
+            // Shift-in the common factor of 2 to the residues' GCD
+            return r[ !which ] << shifts;
+        }
+        else
+        {
+            // At least one input is zero, return the other
+            // (adding since zero is the additive identity)
+            // or zero if both are zero.
+            return u + v;
+        }
+    }
+
+    // Least common multiple for rings (including unsigned integers)
+    template < typename RingType >
+    inline
+    BOOST_CXX14_CONSTEXPR RingType
+    lcm_euclidean
+    (
+        RingType const &  a,
+        RingType const &  b
+    )BOOST_INT_NOEXCEPT(RingType)
+    {
+        RingType const  zero = static_cast<RingType>( 0 );
+        RingType const  temp = gcd_euclidean( a, b );
+
+        return ( temp != zero ) ? ( a / temp * b ) : zero;
+    }
+
+    // Least common multiple for (signed) integers
+    template < typename IntegerType >
+    inline BOOST_CXX14_CONSTEXPR
+    IntegerType
+    lcm_integer
+    (
+        IntegerType const &  a,
+        IntegerType const &  b
+    )BOOST_INT_NOEXCEPT(IntegerType)
+    {
+        // Avoid repeated construction
+        IntegerType const  zero = static_cast<IntegerType>( 0 );
+        IntegerType const  result = lcm_euclidean( a, b );
+
+        return ( result < zero ) ? static_cast<IntegerType>(-result) : result;
+    }
+
+    // Function objects to find the best way of computing GCD or LCM
+#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+    template < typename T, bool IsSpecialized, bool IsSigned >
+    struct gcd_optimal_evaluator_helper_t
+    {
+        BOOST_CXX14_CONSTEXPR T  operator ()( T const &a, T const &b )BOOST_INT_NOEXCEPT(T)
+        {
+            return gcd_euclidean( a, b );
+        }
+    };
+
+    template < typename T >
+    struct gcd_optimal_evaluator_helper_t< T, true, true >
+    {
+        BOOST_CXX14_CONSTEXPR T  operator ()( T const &a, T const &b )BOOST_INT_NOEXCEPT(T)
+        {
+            return gcd_integer( a, b );
+        }
+    };
+
+    template < typename T >
+    struct gcd_optimal_evaluator
+    {
+        BOOST_CXX14_CONSTEXPR T  operator ()( T const &a, T const &b )BOOST_INT_NOEXCEPT(T)
+        {
+            typedef ::std::numeric_limits<T>  limits_type;
+
+            typedef gcd_optimal_evaluator_helper_t<T,
+             limits_type::is_specialized, limits_type::is_signed>  helper_type;
+
+            helper_type  solver;
+
+            return solver( a, b );
+        }
+    };
+#else // BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+    template < typename T >
+    struct gcd_optimal_evaluator
+    {
+        BOOST_CXX14_CONSTEXPR T  operator ()( T const &a, T const &b )BOOST_INT_NOEXCEPT(T)
+        {
+            return gcd_integer( a, b );
+        }
+    };
+#endif
+
+    // Specialize for the built-in integers
+#define BOOST_PRIVATE_GCD_UF( Ut )                  \
+    template < >  struct gcd_optimal_evaluator<Ut>  \
+    {  BOOST_CXX14_CONSTEXPR Ut  operator ()( Ut a, Ut b ) const BOOST_INT_NOEXCEPT(Ut)   { return gcd_binary( a, b ); }  }
+
+    BOOST_PRIVATE_GCD_UF( unsigned char );
+    BOOST_PRIVATE_GCD_UF( unsigned short );
+    BOOST_PRIVATE_GCD_UF( unsigned );
+    BOOST_PRIVATE_GCD_UF( unsigned long );
+
+#ifdef BOOST_HAS_LONG_LONG
+    BOOST_PRIVATE_GCD_UF( boost::ulong_long_type );
+#elif defined(BOOST_HAS_MS_INT64)
+    BOOST_PRIVATE_GCD_UF( unsigned __int64 );
+#endif
+
+#if CHAR_MIN == 0
+    BOOST_PRIVATE_GCD_UF( char ); // char is unsigned
+#endif
+
+#undef BOOST_PRIVATE_GCD_UF
+
+#define BOOST_PRIVATE_GCD_SF( St, Ut )                            \
+    template < >  struct gcd_optimal_evaluator<St>                \
+    {  BOOST_CXX14_CONSTEXPR St  operator ()( St a, St b ) const BOOST_INT_NOEXCEPT(St)   { Ut const  a_abs =   \
+    static_cast<Ut>( a < 0 ? -a : +a ), b_abs = static_cast<Ut>(  \
+    b < 0 ? -b : +b ); return static_cast<St>(                    \
+    gcd_optimal_evaluator<Ut>()(a_abs, b_abs) ); }  }
+
+    BOOST_PRIVATE_GCD_SF( signed char, unsigned char );
+    BOOST_PRIVATE_GCD_SF( short, unsigned short );
+    BOOST_PRIVATE_GCD_SF( int, unsigned );
+    BOOST_PRIVATE_GCD_SF( long, unsigned long );
+
+#if CHAR_MIN < 0
+    BOOST_PRIVATE_GCD_SF( char, unsigned char ); // char is signed
+#endif
+
+#ifdef BOOST_HAS_LONG_LONG
+    BOOST_PRIVATE_GCD_SF( boost::long_long_type, boost::ulong_long_type );
+#elif defined(BOOST_HAS_MS_INT64)
+    BOOST_PRIVATE_GCD_SF( __int64, unsigned __int64 );
+#endif
+
+#undef BOOST_PRIVATE_GCD_SF
+
+#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+    template < typename T, bool IsSpecialized, bool IsSigned >
+    struct lcm_optimal_evaluator_helper_t
+    {
+        BOOST_CXX14_CONSTEXPR T  operator ()( T const &a, T const &b )BOOST_INT_NOEXCEPT(T)
+        {
+            return lcm_euclidean( a, b );
+        }
+    };
+
+    template < typename T >
+    struct lcm_optimal_evaluator_helper_t< T, true, true >
+    {
+        BOOST_CXX14_CONSTEXPR T  operator ()( T const &a, T const &b )BOOST_INT_NOEXCEPT(T)
+        {
+            return lcm_integer( a, b );
+        }
+    };
+
+    template < typename T >
+    struct lcm_optimal_evaluator
+    {
+        BOOST_CXX14_CONSTEXPR T  operator ()( T const &a, T const &b )BOOST_INT_NOEXCEPT(T)
+        {
+            typedef ::std::numeric_limits<T>  limits_type;
+
+            typedef lcm_optimal_evaluator_helper_t<T,
+             limits_type::is_specialized, limits_type::is_signed>  helper_type;
+
+            helper_type  solver;
+
+            return solver( a, b );
+        }
+    };
+#else // BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+    template < typename T >
+    struct lcm_optimal_evaluator
+    {
+        BOOST_CXX14_CONSTEXPR T  operator ()( T const &a, T const &b )BOOST_INT_NOEXCEPT(T)
+        {
+            return lcm_integer( a, b );
+        }
+    };
+#endif
+
+    // Functions to find the GCD or LCM in the best way
+    template < typename T >
+    inline BOOST_CXX14_CONSTEXPR
+    T
+    gcd_optimal
+    (
+        T const &  a,
+        T const &  b
+    )BOOST_INT_NOEXCEPT(T)
+    {
+        gcd_optimal_evaluator<T>  solver;
+
+        return solver( a, b );
+    }
+
+    template < typename T >
+    inline BOOST_CXX14_CONSTEXPR
+    T
+    lcm_optimal
+    (
+        T const &  a,
+        T const &  b
+    )BOOST_INT_NOEXCEPT(T)
+    {
+        lcm_optimal_evaluator<T>  solver;
+
+        return solver( a, b );
+    }
+
+}  // namespace detail
+
+
+//  Greatest common divisor evaluator member function definition  ------------//
+
+template < typename IntegerType >
+inline BOOST_CXX14_CONSTEXPR
+typename gcd_evaluator<IntegerType>::result_type
+gcd_evaluator<IntegerType>::operator ()
+(
+    first_argument_type const &   a,
+    second_argument_type const &  b
+) const BOOST_INT_NOEXCEPT(IntegerType) 
+{
+    return detail::gcd_optimal( a, b );
+}
+
+
+//  Least common multiple evaluator member function definition  --------------//
+
+template < typename IntegerType >
+inline BOOST_CXX14_CONSTEXPR
+typename lcm_evaluator<IntegerType>::result_type
+lcm_evaluator<IntegerType>::operator ()
+(
+    first_argument_type const &   a,
+    second_argument_type const &  b
+) const BOOST_INT_NOEXCEPT(IntegerType) 
+{
+    return detail::lcm_optimal( a, b );
+}
+
+
+//  Greatest common divisor and least common multiple function definitions  --//
+
+template < typename IntegerType >
+inline BOOST_CXX14_CONSTEXPR
+IntegerType
+gcd
+(
+    IntegerType const &  a,
+    IntegerType const &  b
+) BOOST_INT_NOEXCEPT(IntegerType)
+{
+    gcd_evaluator<IntegerType>  solver;
+
+    return solver( a, b );
+}
+
+template < typename IntegerType >
+inline BOOST_CXX14_CONSTEXPR
+IntegerType
+lcm
+(
+    IntegerType const &  a,
+    IntegerType const &  b
+) BOOST_INT_NOEXCEPT(IntegerType)
+{
+    lcm_evaluator<IntegerType>  solver;
+
+    return solver( a, b );
+}
+
+
+}  // namespace integer
+}  // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif  // BOOST_INTEGER_COMMON_FACTOR_RT_HPP
--- a/include/boost/integer/integer_log2.hpp
+++ b/include/boost/integer/integer_log2.hpp
@ -0,0 +1,112 @@
+// -----------------------------------------------------------
+// integer_log2.hpp
+//
+//   Gives the integer part of the logarithm, in base 2, of a
+// given number. Behavior is undefined if the argument is <= 0.
+//
+//         Copyright (c) 2003-2004, 2008 Gennaro Prota
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+// -----------------------------------------------------------
+
+#ifndef BOOST_INTEGER_INTEGER_LOG2_HPP
+#define BOOST_INTEGER_INTEGER_LOG2_HPP
+
+#include <assert.h>
+#ifdef __BORLANDC__
+#include <climits>
+#endif
+#include <boost/limits.hpp>
+#include <boost/config.hpp>
+
+
+namespace boost {
+ namespace detail {
+
+  template <typename T>
+  int integer_log2_impl(T x, int n) {
+
+      int result = 0;
+
+      while (x != 1) {
+
+          const T t = static_cast<T>(x >> n);
+          if (t) {
+              result += n;
+              x = t;
+          }
+          n /= 2;
+
+      }
+
+      return result;
+  }
+
+
+
+  // helper to find the maximum power of two
+  // less than p (more involved than necessary,
+  // to avoid PTS)
+  //
+  template <int p, int n>
+  struct max_pow2_less {
+
+      enum { c = 2*n < p };
+
+      BOOST_STATIC_CONSTANT(int, value =
+          c ? (max_pow2_less< c*p, 2*c*n>::value) : n);
+
+  };
+
+  template <>
+  struct max_pow2_less<0, 0> {
+
+      BOOST_STATIC_CONSTANT(int, value = 0);
+  };
+
+  // this template is here just for Borland :(
+  // we could simply rely on numeric_limits but sometimes
+  // Borland tries to use numeric_limits<const T>, because
+  // of its usual const-related problems in argument deduction
+  // - gps
+  template <typename T>
+  struct width {
+
+#ifdef __BORLANDC__
+      BOOST_STATIC_CONSTANT(int, value = sizeof(T) * CHAR_BIT);
+#else
+      BOOST_STATIC_CONSTANT(int, value = (std::numeric_limits<T>::digits));
+#endif
+
+  };
+
+ } // detail
+
+
+ // ---------
+ // integer_log2
+ // ---------------
+ //
+ template <typename T>
+ int integer_log2(T x) {
+
+     assert(x > 0);
+
+     const int n = detail::max_pow2_less<
+                     detail::width<T> :: value, 4
+                   > :: value;
+
+     return detail::integer_log2_impl(x, n);
+
+ }
+
+
+
+}
+
+
+
+#endif // include guard
--- a/include/boost/integer/integer_mask.hpp
+++ b/include/boost/integer/integer_mask.hpp
@ -20,6 +20,17 @@

 #include <boost/limits.hpp>  // for std::numeric_limits

+//
+// We simply cannot include this header on gcc without getting copious warnings of the kind:
+//
+// boost/integer/integer_mask.hpp:93:35: warning: use of C99 long long integer constant
+//
+// And yet there is no other reasonable implementation, so we declare this a system header
+// to suppress these warnings.
+//
+#if defined(__GNUC__) && (__GNUC__ >= 4)
+#pragma GCC system_header
+#endif

 namespace boost
 {
@ -52,7 +63,7 @@ struct low_bits_mask_t
    typedef typename uint_t<Bits>::least  least;
    typedef typename uint_t<Bits>::fast   fast;

-    BOOST_STATIC_CONSTANT( least, sig_bits = (~( ~(least( 0u )) << Bits )) );
+    BOOST_STATIC_CONSTANT( least, sig_bits = (~(least(~(least( 0u ))) << Bits )) );
    BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );

    BOOST_STATIC_CONSTANT( std::size_t, bit_count = Bits );
@ -70,6 +81,11 @@ struct low_bits_mask_t
      BOOST_STATIC_CONSTANT( std::size_t, bit_count = limits_type::digits );    \
  }

+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4245)  // 'initializing' : conversion from 'int' to 'const boost::low_bits_mask_t<8>::least', signed/unsigned mismatch
+#endif
+
 BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned char );

 #if USHRT_MAX > UCHAR_MAX
@ -84,6 +100,23 @@ BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned int );
 BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned long );
 #endif

+#if defined(BOOST_HAS_LONG_LONG)
+    #if ((defined(ULLONG_MAX) && (ULLONG_MAX > ULONG_MAX)) ||\
+        (defined(ULONG_LONG_MAX) && (ULONG_LONG_MAX > ULONG_MAX)) ||\
+        (defined(ULONGLONG_MAX) && (ULONGLONG_MAX > ULONG_MAX)) ||\
+        (defined(_ULLONG_MAX) && (_ULLONG_MAX > ULONG_MAX)))
+    BOOST_LOW_BITS_MASK_SPECIALIZE( boost::ulong_long_type );
+    #endif
+#elif defined(BOOST_HAS_MS_INT64)
+    #if 18446744073709551615ui64 > ULONG_MAX
+    BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned __int64 );
+    #endif
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
 #undef BOOST_LOW_BITS_MASK_SPECIALIZE


--- a/include/boost/integer/static_log2.hpp
+++ b/include/boost/integer/static_log2.hpp
@ -16,7 +16,7 @@
 #ifndef BOOST_INTEGER_STATIC_LOG2_HPP
 #define BOOST_INTEGER_STATIC_LOG2_HPP

-#include "boost/config.hpp" // for BOOST_STATIC_CONSTANT
+#include "boost/integer_fwd.hpp" // for boost::intmax_t

 namespace boost {

@ -41,14 +41,13 @@ namespace boost {
     // terminates with x = 1 and n = 0 (see the algorithm's
     // invariant).

-     typedef unsigned long argument_type;
-     typedef          int  result_type;
-
+     typedef boost::static_log2_argument_type argument_type;
+     typedef boost::static_log2_result_type result_type;

     template <result_type n>
     struct choose_initial_n {

-         enum { c = (argument_type(1) << n << n) != 0 };
+         BOOST_STATIC_CONSTANT(bool, c = (argument_type(1) << n << n) != 0);
         BOOST_STATIC_CONSTANT(
             result_type,
             value = !c*n + choose_initial_n<2*c*n>::value
@ -85,7 +84,7 @@ namespace boost {
     template <argument_type x, result_type n = initial_n>
     struct static_log2_impl {

-         enum { c = (x >> n) > 0 }; // x >= 2**n ?
+         BOOST_STATIC_CONSTANT(bool, c = (x >> n) > 0); // x >= 2**n ?
         BOOST_STATIC_CONSTANT(
             result_type,
             value = c*n + (static_log2_impl< (x>>c*n), n/2 >::value)
@ -107,10 +106,6 @@ namespace boost {
 // static_log2<x>
 // ----------------------------------------

- typedef detail::static_log2_impl::argument_type static_log2_argument_type;
- typedef detail::static_log2_impl::result_type   static_log2_result_type;
-
-
 template <static_log2_argument_type x>
 struct static_log2 {

--- a/include/boost/integer/static_min_max.hpp
+++ b/include/boost/integer/static_min_max.hpp
@ -12,39 +12,35 @@

 #include <boost/integer_fwd.hpp>  // self include

-#include <boost/config.hpp>  // for BOOST_STATIC_CONSTANT
-
-
 namespace boost
 {

-
 //  Compile-time extrema class declarations  ---------------------------------//
 //  Get the minimum or maximum of two values, signed or unsigned.

-template < long Value1, long Value2 >
+template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
 struct static_signed_min
 {
-    BOOST_STATIC_CONSTANT( long, value = (Value1 > Value2) ? Value2 : Value1 );
+    BOOST_STATIC_CONSTANT(static_min_max_signed_type, value = (Value1 > Value2) ? Value2 : Value1 );
 };

-template < long Value1, long Value2 >
+template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
 struct static_signed_max
 {
-    BOOST_STATIC_CONSTANT( long, value = (Value1 < Value2) ? Value2 : Value1 );
+    BOOST_STATIC_CONSTANT(static_min_max_signed_type, value = (Value1 < Value2) ? Value2 : Value1 );
 };

-template < unsigned long Value1, unsigned long Value2 >
+template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
 struct static_unsigned_min
 {
-    BOOST_STATIC_CONSTANT( unsigned long, value
+    BOOST_STATIC_CONSTANT(static_min_max_unsigned_type, value
     = (Value1 > Value2) ? Value2 : Value1 );
 };

-template < unsigned long Value1, unsigned long Value2 >
+template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
 struct static_unsigned_max
 {
-    BOOST_STATIC_CONSTANT( unsigned long, value
+    BOOST_STATIC_CONSTANT(static_min_max_unsigned_type, value
     = (Value1 < Value2) ? Value2 : Value1 );
 };

--- a/include/boost/integer_fwd.hpp
+++ b/include/boost/integer_fwd.hpp
@ -14,11 +14,23 @@

 #include <boost/config.hpp>  // for BOOST_NO_INTRINSIC_WCHAR_T
 #include <boost/limits.hpp>  // for std::numeric_limits
+#include <boost/cstdint.hpp>  // For intmax_t


 namespace boost
 {

+#ifdef BOOST_NO_INTEGRAL_INT64_T
+     typedef unsigned long static_log2_argument_type;
+     typedef          int  static_log2_result_type;
+     typedef long          static_min_max_signed_type;
+     typedef unsigned long static_min_max_unsigned_type;
+#else
+     typedef boost::uintmax_t static_min_max_unsigned_type;
+     typedef boost::intmax_t  static_min_max_signed_type;
+     typedef boost::uintmax_t static_log2_argument_type;
+     typedef int              static_log2_result_type;
+#endif

 //  From <boost/cstdint.hpp>  ------------------------------------------------//

@ -65,12 +77,18 @@ template <  >
 template <  >
    class integer_traits< unsigned long >;

-#ifdef ULLONG_MAX
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
 template <  >
-    class integer_traits<  ::boost::long_long_type>;
+class integer_traits<  ::boost::long_long_type>;

 template <  >
-    class integer_traits<  ::boost::ulong_long_type >;
+class integer_traits<  ::boost::ulong_long_type >;
+#elif !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_MS_INT64)
+template <  >
+class integer_traits<__int64>;
+
+template <  >
+class integer_traits<unsigned __int64>;
 #endif


@ -85,13 +103,25 @@ template< int Bits >
 template< int Bits >
    struct uint_t;

-template< long MaxValue >
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
+    template< boost::long_long_type MaxValue >   // maximum value to require support
+#else
+  template< long MaxValue >   // maximum value to require support
+#endif
    struct int_max_value_t;

-template< long MinValue >
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
+  template< boost::long_long_type MinValue >   // minimum value to require support
+#else
+  template< long MinValue >   // minimum value to require support
+#endif
    struct int_min_value_t;

-template< unsigned long Value >
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
+  template< boost::ulong_long_type MaxValue >   // maximum value to require support
+#else
+  template< unsigned long MaxValue >   // maximum value to require support
+#endif
    struct uint_value_t;


@ -106,46 +136,54 @@ template < std::size_t Bits >
 template <  >
    struct low_bits_mask_t< ::std::numeric_limits<unsigned char>::digits >;

-#if USHRT_MAX > UCHAR_MAX
-template <  >
-    struct low_bits_mask_t< ::std::numeric_limits<unsigned short>::digits >;
-#endif
-
-#if UINT_MAX > USHRT_MAX
-template <  >
-    struct low_bits_mask_t< ::std::numeric_limits<unsigned int>::digits >;
-#endif
-
-#if ULONG_MAX > UINT_MAX
-template <  >
-    struct low_bits_mask_t< ::std::numeric_limits<unsigned long>::digits >;
-#endif
-
-
 //  From <boost/integer/static_log2.hpp>  ------------------------------------//

-template < unsigned long Value >
+template <static_log2_argument_type Value >
    struct static_log2;

-template <  >
-    struct static_log2< 0ul >;
+template <> struct static_log2<0u>;


 //  From <boost/integer/static_min_max.hpp>  ---------------------------------//

-template < long Value1, long Value2 >
+template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
    struct static_signed_min;

-template < long Value1, long Value2 >
+template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
    struct static_signed_max;

-template < unsigned long Value1, unsigned long Value2 >
+template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
    struct static_unsigned_min;

-template < unsigned long Value1, unsigned long Value2 >
+template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
    struct static_unsigned_max;


+namespace integer
+{
+//  From <boost/integer/common_factor_ct.hpp>
+
+#ifdef BOOST_NO_INTEGRAL_INT64_T
+     typedef unsigned long static_gcd_type;
+#else
+     typedef boost::uintmax_t static_gcd_type;
+#endif
+
+template < static_gcd_type Value1, static_gcd_type Value2 >
+    struct static_gcd;
+template < static_gcd_type Value1, static_gcd_type Value2 >
+    struct static_lcm;
+
+
+//  From <boost/integer/common_factor_rt.hpp>
+
+template < typename IntegerType >
+    class gcd_evaluator;
+template < typename IntegerType >
+    class lcm_evaluator;
+
+} // namespace integer
+
 }  // namespace boost


--- a/include/boost/integer_traits.hpp
+++ b/include/boost/integer_traits.hpp
@ -27,6 +27,17 @@
 #include <wchar.h>
 #endif

+//
+// We simply cannot include this header on gcc without getting copious warnings of the kind:
+//
+// ../../../boost/integer_traits.hpp:164:66: warning: use of C99 long long integer constant
+//
+// And yet there is no other reasonable implementation, so we declare this a system header
+// to suppress these warnings.
+//
+#if defined(__GNUC__) && (__GNUC__ >= 4)
+#pragma GCC system_header
+#endif

 namespace boost {
 template<class T>
@ -108,11 +119,6 @@ class integer_traits<wchar_t>
    //  - Mac OS X with native library
    //  - gcc on FreeBSD, OpenBSD and NetBSD
    public detail::integer_traits_base<wchar_t, INT_MIN, INT_MAX>
-#elif defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 2) && !defined(__SGI_STL_PORT)
-    // No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as unsigned int.
-    //  - gcc 2.95.x on HP-UX
-    // (also, std::numeric_limits<wchar_t> appears to return the wrong values).
-    public detail::integer_traits_base<wchar_t, 0, UINT_MAX>
 #else
 #error No WCHAR_MIN and WCHAR_MAX present, please adjust integer_traits<> for your compiler.
 #endif
@ -216,7 +222,7 @@ class integer_traits< ::boost::ulong_long_type>
 template<>
 class integer_traits< ::boost::long_long_type>
  : public std::numeric_limits< ::boost::long_long_type>,
-    public detail::integer_traits_base< ::boost::long_long_type, (1LL << (sizeof(::boost::long_long_type) - 1)), ~(1LL << (sizeof(::boost::long_long_type) - 1))>
+    public detail::integer_traits_base< ::boost::long_long_type, (1LL << (sizeof(::boost::long_long_type) * CHAR_BIT - 1)), ~(1LL << (sizeof(::boost::long_long_type) * CHAR_BIT - 1))>
 { };

 template<>
@ -225,6 +231,20 @@ class integer_traits< ::boost::ulong_long_type>
    public detail::integer_traits_base< ::boost::ulong_long_type, 0, ~0uLL>
 { };

+#elif defined(BOOST_HAS_MS_INT64)
+
+template<>
+class integer_traits< __int64>
+  : public std::numeric_limits< __int64>,
+    public detail::integer_traits_base< __int64, _I64_MIN, _I64_MAX>
+{ };
+
+template<>
+class integer_traits< unsigned __int64>
+  : public std::numeric_limits< unsigned __int64>,
+    public detail::integer_traits_base< unsigned __int64, 0, _UI64_MAX>
+{ };
+
 #endif
 #endif

--- a/include/boost/pending/integer_log2.hpp
+++ b/include/boost/pending/integer_log2.hpp
@ -0,0 +1,9 @@
+#ifndef BOOST_PENDING_INTEGER_LOG2_HPP
+#define BOOST_PENDING_INTEGER_LOG2_HPP
+
+// The header file at this path is deprecated;
+// use boost/integer/integer_log2.hpp instead.
+
+#include <boost/integer/integer_log2.hpp>
+
+#endif
--- a/index.html
+++ b/index.html
@ -1,133 +1,16 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
 <html>
 <head>
-<title>Boost Integer Library</title>
+<meta http-equiv="refresh" content="0; URL=doc/html/index.html">
 </head>
-
-<body bgcolor="white" text="black">
-<table border="1" bgcolor="teal" cellpadding="2">
-	<tr>
-		<td bgcolor="white"><img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86"></td>
-		<td><a href="../../index.htm"><font face="Arial" color="white"><big>Home</big></font></a></td>
-		<td><a href="../libraries.htm"><font face="Arial" color="white"><big>Libraries</big></font></a></td>
-		<td><a href="../../people/people.htm"><font face="Arial" color="white"><big>People</big></font></a></td>
-		<td><a href="../../more/faq.htm"><font face="Arial" color="white"><big>FAQ</big></font></a></td>
-		<td><a href="../../more/index.htm"><font face="Arial" color="white"><big>More</big></font></a></td>
-	</tr>
-</table>
-
-<h1>Boost Integer Library</h1>
-
-<table border="1" cellpadding="5">
-	<tr>
-		<th>Header / Docs</th>
-		<th>Contents</th>
-		<th>Use</th>
-	</tr>
-	<tr>
-		<td align="center"><cite><a href="../../boost/integer_fwd.hpp">&lt;boost/integer_fwd.hpp&gt;</a></cite></td>
-		<td valign="top">Forward declarations of classes and class templates</td>
-		<td valign="top">When just the name of a class is needed</td>
-	</tr>
-	<tr>
-		<td align="center"><code><a href="../../boost/cstdint.hpp">&lt;boost/cstdint.hpp&gt;<br>
-      </a></code><a href="cstdint.htm"><br>
-      documentation</a>
-    </td>
-		<td valign="top">Typedef's based on the 1999 C Standard header &lt;<code>stdint.h&gt;</code>, wrapped in namespace boost.
-      This implementation may #include the compiler
-      supplied &lt;<code>stdint.h&gt;</code>, if present.  </td>
-		<td valign="top">Supplies typedefs for standard integer types such as <code> int32_t</code> or <code>uint_least16_t</code>.
-      Use in preference to &lt;<code>stdint.h&gt;</code>
-      for enhanced portability.  Furthermore, all names are safely placed in the boost namespace.</td>
-	</tr>
-	<tr>
-		<td align="center"><code><a href="../../boost/integer_traits.hpp">&lt;boost/integer_traits.hpp&gt;</a></code><br>
-    <br>
-    <a href="integer_traits.html">documentation</a>
-    </td>
-		<td valign="top">Template class <code>boost::integer_traits</code>, derived from <code>std::numeric_limits</code>.&nbsp;
-      Adds <code>const_min</code> and <code>const_max</code> members.</td>
-		<td valign="top">Use to obtain the characteristics of a known integer type.</td>
-	</tr>
-	<tr>
-		<td align="center"><code><a href="../../boost/integer.hpp">&lt;boost/integer.hpp&gt;</a><br>
-      <br>
-      </code><a href="integer.htm">documentation</a></td>
-		<td valign="top">Templates for integer type selection based on properties such as
-      maximum value or number of bits.</td>
-		<td valign="top">Use to select the type an integer when some property such as maximum value or number of bits is known.
-      Useful for generic programming. </td>
-	</tr>
-	<tr>
-		<td align="center"><code><a href="../../boost/integer/integer_mask.hpp">&lt;boost/integer/integer_mask.hpp&gt;</a><br>
-      <br>
-      </code><a href="doc/integer_mask.html">documentation</a></td>
-		<td valign="top">Templates for the selection of integer masks, single or lowest group, based on the number of bits.</td>
-		<td valign="top">Use to select a particular mask when the bit position(s) are based on a compile-time variable.
-      Useful for generic programming. </td>
-	</tr>
-	<tr>
-		<td align="center"><code><a href="../../boost/integer/static_log2.hpp">&lt;boost/integer/static_log2.hpp&gt;</a><br>
-      <br>
-      </code><a href="doc/static_log2.html">documentation</a></td>
-		<td valign="top">Template for finding the highest power of two in a number.</td>
-		<td valign="top">Use to find the bit-size/range based on a maximum value.
-      Useful for generic programming. </td>
-	</tr>
-	<tr>
-		<td align="center"><code><a href="../../boost/integer/static_min_max.hpp">&lt;boost/integer/static_min_max.hpp&gt;</a><br>
-      <br>
-      </code><a href="doc/static_min_max.html">documentation</a></td>
-		<td valign="top">Templates for finding the extrema of two numbers.</td>
-		<td valign="top">Use to find a bound based on a minimum or maximum value.
-      Useful for generic programming. </td>
-	</tr>
-</table>
-
-<h2>Rationale</h2>
-
-<p>The organization of boost integer headers and classes is designed to
-take advantage of <cite>&lt;stdint.h&gt;</cite> types from the 1999 C
-standard without resorting to undefined behavior in terms of the 1998
-C++ standard.  The header <cite>&lt;boost/cstdint.hpp&gt;</cite> makes
-the standard integer types safely available in namespace
-<code>boost</code> without placing any names in namespace
-<code>std</code>.  As always, the intension is to complement rather than
-compete with the C++ Standard Library.  Should some future C++ standard
-include <cite>&lt;stdint.h&gt;</cite> and <cite>&lt;cstdint&gt;</cite>,
-then <cite>&lt;boost/cstdint.hpp&gt;</cite> will continue to function,
-but will become redundant and may be safely deprecated.</p>
-
-<p>Because these are boost headers, their names conform to boost header
-naming conventions rather than C++ Standard Library header naming
-conventions.</p>
-
-<h2><i>Caveat emptor</i></h2>
-
-<p>As an implementation artifact, certain C
-<cite>&lt;limits.h&gt;</cite> macro names may possibly be visible to
-users of <cite>&lt;boost/cstdint.hpp&gt;</cite>.  Don't use these
-macros; they are not part of any Boost-specified interface.  Use
-<code>boost::integer_traits&lt;&gt;</code> or
-<code>std::numeric_limits&lt;&gt;</code> instead.</p>
-
-<p>As another implementation artifact, certain C
-<cite>&lt;stdint.h&gt;</cite> typedef names may possibly be visible in
-the global namespace to users of <cite>&lt;boost/cstdint.hpp&gt;</cite>.
- Don't use these names, they are not part of any Boost-specified
-interface.  Use the respective names in namespace <code>boost</code>
-instead.</p>
-
-<hr>
-
-<p>Revised: <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %b %Y" startspan -->06 Nov 2007<!--webbot bot="Timestamp" endspan i-checksum="15272" -->
-</p>
-
-<p><EFBFBD> Copyright Beman Dawes 2003</p>
-
-<p>Distributed under the Boost Software License, Version 1.0. See
-<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
-
+<body>
+Automatic redirection failed, please go to
+<a href="doc/html/index.html">doc/html/index.html</a>.
+      <P>Copyright Beman Dawes, Daryle Walker, Gennaro Prota and John Maddock 2001-2009</P>
+      <P>Distributed under the Boost Software License, Version 1.0. (See accompanying file <A href="../../LICENSE_1_0.txt">
+            LICENSE_1_0.txt</A> or copy at <A href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</A>).</P>
 </body>
-</html>
+</html>
+
+
+
+
--- a/integer.htm
+++ b/integer.htm
@ -1,212 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
-<html>
-<head>
-<title>Integer Type Selection Templates</title>
-</head>
-
-<body bgcolor="white" text="black">
-<h1>
-<img src="../../boost.png" alt="boost.png (6897 bytes)"
-align="middle" width="277" height="86">Integer Type Selection
-Templates</h1>
-
-<p>The <cite><a
-href="../../boost/integer.hpp">&lt;boost/integer.hpp&gt;</a></cite> type
-selection templates allow integer types to be selected based on desired
-characteristics such as number of bits or maximum value.  This facility
-is particularly useful for solving generic programming problems.</p>
-
-<h2><a name="contents">Contents</a></h2>
-
-<ul>
-	<li><a href="#contents">Contents</a></li>
-	<li><a href="#synopsis">Synopsis</a></li>
-	<li><a href="#easy">Easiest-to-Manipulate Types</a></li>
-	<li><a href="#sized">Sized Types</a></li>
-	<li><a href="#example">Example</a></li>
-	<li><a href="#demo">Demonstration Program</a></li>
-	<li><a href="#rationale">Rationale</a></li>
-	<li><a href="#alternative">Alternative</a></li>
-	<li><a href="#credits">Credits</a></li>
-</ul>
-
-<h2><a name="synopsis">Synopsis</a></h2>
-
-<blockquote><pre>namespace boost
-{
-  //  fast integers from least integers
-  template&lt; typename LeastInt &gt;
-  struct int_fast_t
-  {
-      typedef <em>implementation_supplied</em>  fast;
-  };
-
-  //  signed
-  template&lt; int Bits &gt;
-  struct int_t 
-  {
-      typedef <em>implementation_supplied</em>  least;
-      typedef int_fast_t&lt;least&gt;::fast  fast;
-  };
-
-  //  unsigned
-  template&lt; int Bits &gt;
-  struct uint_t 
-  {
-      typedef <em>implementation_supplied</em>  least;
-      typedef int_fast_t&lt;least&gt;::fast  fast;
-  };
-
-  //  signed
-  template&lt; long MaxValue &gt;
-  struct int_max_value_t 
-  {
-      typedef <em>implementation_supplied</em>  least;
-      typedef int_fast_t&lt;least&gt;::fast  fast;
-  };
-
-  template&lt; long MinValue &gt;
-  struct int_min_value_t 
-  {
-      typedef <em>implementation_supplied</em>  least;
-      typedef int_fast_t&lt;least&gt;::fast  fast;
-  };
-
-  //  unsigned
-  template&lt; unsigned long Value &gt;
-  struct uint_value_t 
-  {
-      typedef <em>implementation_supplied</em>  least;
-      typedef int_fast_t&lt;least&gt;::fast  fast;
-  };
-} // namespace boost
-</pre></blockquote>
-
-<h2><a name="easy">Easiest-to-Manipulate Types</a></h2>
-
-<p>The <code>int_fast_t</code> class template maps its input type to the
-next-largest type that the processor can manipulate the easiest, or to
-itself if the input type is already an easy-to-manipulate type.  For
-instance, processing a bunch of <code>char</code> objects may go faster
-if they were converted to <code>int</code> objects before processing. 
-The input type, passed as the only template parameter, must be a
-built-in integral type, except <code>bool</code>.  Unsigned integral
-types can be used, as well as signed integral types, despite the name. 
-The output type is given as the class member <code>fast</code>.</p>
-
-<p><strong>Implementation Notes</strong><br>
-By default, the output type is identical to the input type.  Eventually,
-this code's implementation should be conditionalized for each platform
-to give accurate mappings between the built-in types and the
-easiest-to-manipulate built-in types.  Also, there is no guarantee that
-the output type actually is easier to manipulate than the input
-type.</p>
-
-<h2><a name="sized">Sized Types</a></h2>
-
-<p>The <code>int_t</code>, <code>uint_t</code>,
-<code>int_max_value_t</code>, <code>int_min_value_t</code>, and
-<code>uint_value_t</code> class templates find the most appropiate
-built-in integral type for the given template parameter.  This type is
-given by the class member <code>least</code>.  The easiest-to-manipulate
-version of that type is given by the class member <code>fast</code>. 
-The following table describes each template's criteria.</p>
-
-<table border="1" cellpadding="5">
-	<caption>Criteria for the Sized Type Class Templates</caption>
-	<tr>
-		<th>Class Template</th>
-		<th>Template Parameter Mapping</th>
-	</tr>
-	<tr>
-		<td><code>boost::int_t</code></td>
-		<td>The smallest built-in signed integral type with at least the
-			given number of bits, including the sign bit.  The parameter
-			should be a positive number.  A compile-time error results if
-			the parameter is larger than the number of bits in a
-			<code>long</code>.</td>
-	</tr>
-	<tr>
-		<td><code>boost::uint_t</code></td>
-		<td>The smallest built-in unsigned integral type with at least
-			the given number of bits.  The parameter should be a positive
-			number.  A compile-time error results if the parameter is
-			larger than the number of bits in an <code>unsigned
-			long</code>.</td>
-	</tr>
-	<tr>
-		<td><code>boost::int_max_value_t</code></td>
-		<td>The smallest built-in signed integral type that supports the
-			given value as a maximum.  The parameter should be a
-			positive number.</td>
-	</tr>
-	<tr>
-		<td><code>boost::int_min_value_t</code></td>
-		<td>The smallest built-in signed integral type that supports the
-			given value as a minimum.  The parameter should be a
-			negative number.</td>
-	</tr>
-	<tr>
-		<td><code>boost::uint_value_t</code></td>
-		<td>The smallest built-in unsigned integral type that supports
-			the given value as a maximum.  The parameter should be a
-			positive number.</td>
-	</tr>
-</table>
-
-<h2><a name="example">Example</a></h2>
-
-<blockquote><pre>#include &lt;boost/integer.hpp&gt;
-
-//...
-
-int main()
-{
-    boost::int_t&lt;24&gt;::least my_var;
-    //...
-}
-</pre></blockquote>
-
-<h2><a name="demo">Demonstration Program</a></h2>
-
-<p>The program <a href="integer_test.cpp">integer_test.cpp</a> is a
-simplistic demonstration of the results from instantiating various
-examples of the sized type class templates.</p>
-
-<h2><a name="rationale">Rationale</a></h2>
-
-<p>The rationale for the design of the templates in this header includes:</p>
-
-<ul>
-	<li>Avoid recursion because of concern about C++'s limited
-		guaranteed recursion depth (17).</li>
-	<li>Avoid macros on general principles.</li>
-	<li>Try to keep the design as simple as possible.</li>
-</ul>
-
-<h2><a name="alternative">Alternative</a></h2>
-
-<p>If the number of bits required is known beforehand, it may be more
-appropriate to use the types supplied in <cite><a
-href="../../boost/cstdint.hpp">&lt;boost/cstdint.hpp&gt;</a></cite>.</p>
-
-<h2><a name="credits">Credits</a></h2>
-
-<p>The author of most of the Boost integer type choosing templates is <a
-href="../../people/beman_dawes.html">Beman Dawes</a>.  He gives thanks
-to Valentin Bonnard and
-<a href="../../people/kevlin_henney.htm"> Kevlin Henney</a> for sharing
-their designs for similar templates.  <a
-href="../../people/daryle_walker.html">Daryle Walker</a> designed the
-value-based sized templates.</p>
-
-<hr>
-
-<p>Revised May 20, 2001</p>
-
-<p>&copy; Copyright Beman Dawes 1999.  Use, modification, and distribution are
-subject to the Boost Software License, Version 1.0.  (See accompanying file <a
-href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
-href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
-</body>
-</html>
--- a/integer_test.cpp
+++ b/integer_test.cpp
@ -1,291 +0,0 @@
-//  boost integer.hpp test program  ------------------------------------------//
-
-//  Copyright Beman Dawes 1999.  Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-
-//  See http://www.boost.org/libs/integer for documentation.
-
-//  Revision History
-//   04 Oct 01  Added tests for new templates; rewrote code (Daryle Walker)
-//   10 Mar 01  Boost Test Library now used for tests (Beman Dawes)
-//   31 Aug 99  Initial version
-
-#include <boost/test/minimal.hpp>  // for main, BOOST_CHECK
-
-#include <boost/config.hpp>   // for BOOST_NO_USING_TEMPLATE
-#include <boost/cstdlib.hpp>  // for boost::exit_success
-#include <boost/integer.hpp>  // for boost::int_t, boost::uint_t
-
-#include <climits>   // for ULONG_MAX, LONG_MAX, LONG_MIN
-#include <iostream>  // for std::cout (std::endl indirectly)
-#include <typeinfo>  // for std::type_info
-
-
-// Control if the names of the types for each version
-// of the integer templates will be printed.
-#ifndef CONTROL_SHOW_TYPES
-#define CONTROL_SHOW_TYPES  0
-#endif
-
-
-// If specializations have not already been done, then we can confirm
-// the effects of the "fast" types by making a specialization.
-namespace boost
-{
-    template < >
-    struct int_fast_t< short >
-    {
-        typedef long  fast;
-    };
-}
-
-
-// Show the types of an integer template version
-#if CONTROL_SHOW_TYPES
-#define SHOW_TYPE(Template, Number, Type)  ::std::cout << "Type \"" \
- #Template "<" #Number ">::" #Type "\" is \"" << typeid(Template <  \
- Number > :: Type).name() << ".\"\n"
-#else
-#define SHOW_TYPE(Template, Number, Type)
-#endif
-
-#define SHOW_TYPES(Template, Type)  SHOW_TYPE(Template, 32, Type); \
- SHOW_TYPE(Template, 31, Type); SHOW_TYPE(Template, 30, Type); \
- SHOW_TYPE(Template, 29, Type); SHOW_TYPE(Template, 28, Type); \
- SHOW_TYPE(Template, 27, Type); SHOW_TYPE(Template, 26, Type); \
- SHOW_TYPE(Template, 25, Type); SHOW_TYPE(Template, 24, Type); \
- SHOW_TYPE(Template, 23, Type); SHOW_TYPE(Template, 22, Type); \
- SHOW_TYPE(Template, 21, Type); SHOW_TYPE(Template, 20, Type); \
- SHOW_TYPE(Template, 19, Type); SHOW_TYPE(Template, 18, Type); \
- SHOW_TYPE(Template, 17, Type); SHOW_TYPE(Template, 16, Type); \
- SHOW_TYPE(Template, 15, Type); SHOW_TYPE(Template, 14, Type); \
- SHOW_TYPE(Template, 13, Type); SHOW_TYPE(Template, 12, Type); \
- SHOW_TYPE(Template, 11, Type); SHOW_TYPE(Template, 10, Type); \
- SHOW_TYPE(Template, 9, Type); SHOW_TYPE(Template, 8, Type); \
- SHOW_TYPE(Template, 7, Type); SHOW_TYPE(Template, 6, Type); \
- SHOW_TYPE(Template, 5, Type); SHOW_TYPE(Template, 4, Type); \
- SHOW_TYPE(Template, 3, Type); SHOW_TYPE(Template, 2, Type); \
- SHOW_TYPE(Template, 1, Type); SHOW_TYPE(Template, 0, Type)
-
-#define SHOW_SHIFTED_TYPE(Template, Number, Type)  SHOW_TYPE(Template, (1UL << Number), Type)
-
-#define SHOW_SHIFTED_TYPES(Template, Type)  SHOW_SHIFTED_TYPE(Template, 30, Type); \
- SHOW_SHIFTED_TYPE(Template, 29, Type); SHOW_SHIFTED_TYPE(Template, 28, Type); \
- SHOW_SHIFTED_TYPE(Template, 27, Type); SHOW_SHIFTED_TYPE(Template, 26, Type); \
- SHOW_SHIFTED_TYPE(Template, 25, Type); SHOW_SHIFTED_TYPE(Template, 24, Type); \
- SHOW_SHIFTED_TYPE(Template, 23, Type); SHOW_SHIFTED_TYPE(Template, 22, Type); \
- SHOW_SHIFTED_TYPE(Template, 21, Type); SHOW_SHIFTED_TYPE(Template, 20, Type); \
- SHOW_SHIFTED_TYPE(Template, 19, Type); SHOW_SHIFTED_TYPE(Template, 18, Type); \
- SHOW_SHIFTED_TYPE(Template, 17, Type); SHOW_SHIFTED_TYPE(Template, 16, Type); \
- SHOW_SHIFTED_TYPE(Template, 15, Type); SHOW_SHIFTED_TYPE(Template, 14, Type); \
- SHOW_SHIFTED_TYPE(Template, 13, Type); SHOW_SHIFTED_TYPE(Template, 12, Type); \
- SHOW_SHIFTED_TYPE(Template, 11, Type); SHOW_SHIFTED_TYPE(Template, 10, Type); \
- SHOW_SHIFTED_TYPE(Template, 9, Type); SHOW_SHIFTED_TYPE(Template, 8, Type); \
- SHOW_SHIFTED_TYPE(Template, 7, Type); SHOW_SHIFTED_TYPE(Template, 6, Type); \
- SHOW_SHIFTED_TYPE(Template, 5, Type); SHOW_SHIFTED_TYPE(Template, 4, Type); \
- SHOW_SHIFTED_TYPE(Template, 3, Type); SHOW_SHIFTED_TYPE(Template, 2, Type); \
- SHOW_SHIFTED_TYPE(Template, 1, Type); SHOW_SHIFTED_TYPE(Template, 0, Type)
-
-#define SHOW_POS_SHIFTED_TYPE(Template, Number, Type)  SHOW_TYPE(Template, +(1L << Number), Type)
-
-#define SHOW_POS_SHIFTED_TYPES(Template, Type)  SHOW_POS_SHIFTED_TYPE(Template, 30, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 29, Type); SHOW_POS_SHIFTED_TYPE(Template, 28, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 27, Type); SHOW_POS_SHIFTED_TYPE(Template, 26, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 25, Type); SHOW_POS_SHIFTED_TYPE(Template, 24, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 23, Type); SHOW_POS_SHIFTED_TYPE(Template, 22, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 21, Type); SHOW_POS_SHIFTED_TYPE(Template, 20, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 19, Type); SHOW_POS_SHIFTED_TYPE(Template, 18, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 17, Type); SHOW_POS_SHIFTED_TYPE(Template, 16, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 15, Type); SHOW_POS_SHIFTED_TYPE(Template, 14, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 13, Type); SHOW_POS_SHIFTED_TYPE(Template, 12, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 11, Type); SHOW_POS_SHIFTED_TYPE(Template, 10, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 9, Type); SHOW_POS_SHIFTED_TYPE(Template, 8, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 7, Type); SHOW_POS_SHIFTED_TYPE(Template, 6, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 5, Type); SHOW_POS_SHIFTED_TYPE(Template, 4, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 3, Type); SHOW_POS_SHIFTED_TYPE(Template, 2, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 1, Type); SHOW_POS_SHIFTED_TYPE(Template, 0, Type)
-
-#define SHOW_NEG_SHIFTED_TYPE(Template, Number, Type)  SHOW_TYPE(Template, -(1L << Number), Type)
-
-#define SHOW_NEG_SHIFTED_TYPES(Template, Type)  SHOW_NEG_SHIFTED_TYPE(Template, 30, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 29, Type); SHOW_NEG_SHIFTED_TYPE(Template, 28, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 27, Type); SHOW_NEG_SHIFTED_TYPE(Template, 26, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 25, Type); SHOW_NEG_SHIFTED_TYPE(Template, 24, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 23, Type); SHOW_NEG_SHIFTED_TYPE(Template, 22, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 21, Type); SHOW_NEG_SHIFTED_TYPE(Template, 20, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 19, Type); SHOW_NEG_SHIFTED_TYPE(Template, 18, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 17, Type); SHOW_NEG_SHIFTED_TYPE(Template, 16, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 15, Type); SHOW_NEG_SHIFTED_TYPE(Template, 14, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 13, Type); SHOW_NEG_SHIFTED_TYPE(Template, 12, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 11, Type); SHOW_NEG_SHIFTED_TYPE(Template, 10, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 9, Type); SHOW_NEG_SHIFTED_TYPE(Template, 8, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 7, Type); SHOW_NEG_SHIFTED_TYPE(Template, 6, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 5, Type); SHOW_NEG_SHIFTED_TYPE(Template, 4, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 3, Type); SHOW_NEG_SHIFTED_TYPE(Template, 2, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 1, Type); SHOW_NEG_SHIFTED_TYPE(Template, 0, Type)
-
-
-// Test if a constant can fit within a certain type
-#define PRIVATE_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < Number > :: Type ( Value ) == Value )
-
-#if ULONG_MAX > 0xFFFFFFFFL
-#define PRIVATE_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
- PRIVATE_FIT_TEST(Template, 64, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 63, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 62, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 61, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 60, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 59, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 58, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 57, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 56, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 55, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 54, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 53, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 52, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 51, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 50, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 49, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 48, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 47, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 46, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 45, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 44, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 43, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 42, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 41, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 40, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 39, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 38, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 37, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 36, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 35, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 34, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 33, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 32, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 31, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 30, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 29, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 28, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 27, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 26, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 25, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 24, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 23, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 22, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 21, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 20, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 19, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 18, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 17, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 16, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 15, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 14, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 13, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 12, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 11, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 10, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 9, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 8, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 7, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 6, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 5, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 4, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 3, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 2, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 1, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 0, Type, v); } while ( false )
-#else
-#define PRIVATE_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
- PRIVATE_FIT_TEST(Template, 32, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 31, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 30, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 29, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 28, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 27, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 26, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 25, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 24, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 23, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 22, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 21, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 20, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 19, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 18, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 17, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 16, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 15, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 14, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 13, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 12, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 11, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 10, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 9, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 8, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 7, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 6, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 5, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 4, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 3, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 2, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 1, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 0, Type, v); } while ( false )
-#endif
-
-#define PRIVATE_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < (ULONG_MAX >> Number) > :: Type ( Value ) == Value )
-
-#define PRIVATE_SHIFTED_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
-
-#define PRIVATE_POS_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < (LONG_MAX >> Number) > :: Type ( Value ) == Value )
-
-#define PRIVATE_POS_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
-
-#define PRIVATE_NEG_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < (LONG_MIN >> Number) > :: Type ( Value ) == Value )
-
-#define PRIVATE_NEG_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
-
-
-// Test program
-int
-test_main
-(
-    int,
-    char*[]
-)
-{
-#ifndef BOOST_NO_USING_TEMPLATE
-    using boost::int_t;
-    using boost::uint_t;
-    using boost::int_max_value_t;
-    using boost::int_min_value_t;
-    using boost::uint_value_t;
-#else
-    using namespace boost;
-#endif
-
-    SHOW_TYPES( int_t, least );
-    SHOW_TYPES( int_t, fast );
-    SHOW_TYPES( uint_t, least );
-    SHOW_TYPES( uint_t, fast );
-    SHOW_POS_SHIFTED_TYPES( int_max_value_t, least );
-    SHOW_POS_SHIFTED_TYPES( int_max_value_t, fast );
-    SHOW_NEG_SHIFTED_TYPES( int_min_value_t, least );
-    SHOW_NEG_SHIFTED_TYPES( int_min_value_t, fast );
-    SHOW_SHIFTED_TYPES( uint_value_t, least );
-    SHOW_SHIFTED_TYPES( uint_value_t, fast );
-     
-    PRIVATE_FIT_TESTS( int_t, least, long, LONG_MAX );
-    PRIVATE_FIT_TESTS( int_t, fast, long, LONG_MAX );
-    PRIVATE_FIT_TESTS( uint_t, least, unsigned long, ULONG_MAX );
-    PRIVATE_FIT_TESTS( uint_t, fast, unsigned long, ULONG_MAX );
-    PRIVATE_POS_FIT_TESTS( int_max_value_t, least, long, LONG_MAX );
-    PRIVATE_POS_FIT_TESTS( int_max_value_t, fast, long, LONG_MAX );
-    PRIVATE_NEG_FIT_TESTS( int_min_value_t, least, long, LONG_MIN );
-    PRIVATE_NEG_FIT_TESTS( int_min_value_t, fast, long, LONG_MIN );
-    PRIVATE_SHIFTED_FIT_TESTS( uint_value_t, least, unsigned long, ULONG_MAX );
-    PRIVATE_SHIFTED_FIT_TESTS( uint_value_t, fast, unsigned long, ULONG_MAX );
-        
-    return boost::exit_success;
-}
--- a/integer_traits.html
+++ b/integer_traits.html
@ -1,94 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-
-<title>integer_traits: Compile-Time Limits for Integral Types</title>
-</head>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-<h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align="center" width="277" height="86">Compile-Time Integral
-Type Limits</h1>
-
-<p>
-The C++ Standard Library &lt;limits&gt; header supplies a class template
-numeric_limits&lt;&gt; with specializations for each fundamental
-type.</p>
-<p>
-For integer types, the interesting members of std::numeric_limits&lt;&gt; are:
-<pre>   static const bool is_specialized; // will be true for integers
-   static T min() throw();
-   static T max() throw();
-   static const int digits;     // for integers, # value bits
-   static const int digits10;     
-   static const bool is_signed;
-   static const bool is_integer; // will be true for integers</pre>
-For many uses, these are sufficient.  But min() and max() are problematical because they are not constant expressions
-(std::5.19), yet some usages require constant expressions.
-<p>
-The template class <code>integer_traits</code> addresses this
-problem.
-
-
-<h2>Header <code><a href="../../boost/integer_traits.hpp">integer_traits.hpp</a></code> Synopsis</h2>
-
-<pre>namespace boost {
-  template&lt;class T&gt;
-  class integer_traits : public std::numeric_limits&lt;T&gt;
-  {
-    static const bool is_integral = false;
-  };
-
-  // specializations for all integral types
-}</pre>
-
-
-<h2>Description</h2>
-
-Template class <code>integer_traits</code> is derived from
-<code>std::numeric_limits</code>.  In general, it adds the single
-<code>bool</code> member <code>is_integral</code> with the
-compile-time constant value <code>false</code>.  However, for all
-integral types <code>T</code> (std::3.9.1/7 [basic.fundamental]),
-there are specializations provided with the following compile-time
-constants defined:
-<p>
-<table border=1>
-<tr><th>member</th><th>type</th><th>value</th></tr>
-<tr><td><code>is_integral</code></td><td>bool</td><td><code>true</code></td></tr>
-<tr><td><code>const_min</code></td><td><code>T</code></td><td>equivalent
-to <code>std::numeric_limits&lt;T&gt;::min()</code></td></tr>
-<tr><td><code>const_max</code></td><td><code>T</code></td><td>equivalent
-to <code>std::numeric_limits&lt;T&gt;::max()</code></td></tr>
-</table>
-
-<p>
-
-<em>Note:</em> A flag <code>is_integral</code> is provided, because a
-user-defined integer class should specialize
-<code>std::numeric_limits&lt;&gt;::is_integer = true</code>,
-nonetheless compile-time constants <code>const_min</code> and
-<code>const_max</code> cannot be provided for that user-defined class.
-
-<h2>
-
-Test Program</h2>
-
-<p>
-
-The program <code><a href="integer_traits_test.cpp">integer_traits_test.cpp</a></code>
-exercises the <code>integer_traits</code> class.
-
-<h2>Acknowledgements</h2>
-
-Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers discussed the integer
-traits idea on the boost mailing list in August 1999.
-<hr>
-<p>Revised
-<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan -->06 November 2007<!--webbot bot="Timestamp" endspan i-checksum="40336" --></p>
-<p><EFBFBD> Copyright Beman Dawes 2000</p>
-
-<p>Distributed under the Boost Software License, Version 1.0. See
-<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
-
--- a/meta/libraries.json
+++ b/meta/libraries.json
@ -0,0 +1,12 @@
+{
+    "key": "integer",
+    "name": "Integer",
+    "description": "The organization of boost integer headers and classes is designed to take advantage of <stdint.h> types from the 1999 C standard without resorting to undefined behavior in terms of the 1998 C++ standard. The header <boost/cstdint.hpp> makes the standard integer types safely available in namespace boost without placing any names in namespace std.",
+    "category": [
+        "Math"
+    ],
+    "authors": "",
+    "maintainers": [
+        "Daryle Walker <darylew -at- hotmail.com>"
+    ]
+}
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@ -0,0 +1,31 @@
+#~ Copyright Rene Rivera 2008
+#~ Distributed under the Boost Software License, Version 1.0.
+#~ (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+import testing ;
+
+project : requirements <warnings>all <toolset>gcc:<cxxflags>-Wextra ;
+
+test-suite integer
+    : 
+        [ run integer_traits_test.cpp ]
+        [ run integer_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-long-long <toolset>darwin:<cxxflags>-Wno-long-long <toolset>sun:<cxxflags>"-Qoption ccfe -tmpldepth=128" ]
+        [ run integer_mask_test.cpp ]
+        [ run static_log2_test.cpp ]
+        [ run static_min_max_test.cpp ]
+        [ compile integer_traits_include_test.cpp ]
+        [ compile integer_include_test.cpp ]
+        [ compile integer_mask_include_test.cpp ]
+        [ compile static_log2_include_test.cpp ]
+        [ compile static_min_max_include_test.cpp ]
+        [ compile integer_fwd_include_test.cpp ]
+		[ compile gcd_constexpr14_test.cpp ]
+        [ compile-fail fail_int_exact.cpp ]
+        [ compile-fail fail_int_fast.cpp ]
+        [ compile-fail fail_int_least.cpp ]
+        [ compile-fail fail_uint_exact.cpp ]
+        [ compile-fail fail_uint_fast.cpp ]
+        [ compile-fail fail_uint_least.cpp ]
+        [ compile-fail fail_uint_65.cpp ]
+        [ run common_factor_test.cpp ]
+    ;
--- a/test/common_factor_test.cpp
+++ b/test/common_factor_test.cpp
@ -0,0 +1,473 @@
+//  Boost GCD & LCM common_factor.hpp test program  --------------------------//
+
+//  (C) Copyright Daryle Walker 2001, 2006.
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version including documentation.
+
+//  Revision History
+//  01 Dec 2006  Various fixes for old compilers (Joaquin M Lopez Munoz)
+//  10 Nov 2006  Make long long and __int64 mutually exclusive (Daryle Walker)
+//  04 Nov 2006  Use more built-in numeric types, binary-GCD (Daryle Walker)
+//  03 Nov 2006  Use custom numeric types (Daryle Walker)
+//  02 Nov 2006  Change to Boost.Test's unit test system (Daryle Walker)
+//  07 Nov 2001  Initial version (Daryle Walker)
+
+#define BOOST_TEST_MAIN  "Boost.Math GCD & LCM unit tests"
+
+#include <boost/integer/common_factor.hpp>
+
+#include <boost/config.hpp>                // for BOOST_MSVC, etc.
+#include <boost/detail/workaround.hpp>
+#include <boost/operators.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+#include <istream>  // for std::basic_istream
+#include <limits>   // for std::numeric_limits
+#include <ostream>  // for std::basic_ostream
+
+
+namespace {
+
+// TODO: add polynominal/non-real type; especially after any switch to the
+// binary-GCD algorithm for built-in types
+
+// Custom integer class (template)
+template < typename IntType, int ID = 0 >
+class my_wrapped_integer
+    : private ::boost::shiftable1<my_wrapped_integer<IntType, ID>,
+        ::boost::operators<my_wrapped_integer<IntType, ID> > >
+{
+    // Helper type-aliases
+    typedef my_wrapped_integer    self_type;
+    typedef IntType self_type::*  bool_type;
+
+    // Member data
+    IntType  v_;
+
+public:
+    // Template parameters
+    typedef IntType  int_type;
+
+    BOOST_STATIC_CONSTANT(int,id = ID);
+
+    // Lifetime management (use automatic destructor and copy constructor)
+    my_wrapped_integer( int_type const &v = int_type() )  : v_( v )  {}
+
+    // Accessors
+    int_type  value() const  { return this->v_; }
+
+    // Operators (use automatic copy assignment)
+    operator bool_type() const  { return this->v_ ? &self_type::v_ : 0; }
+
+    self_type &  operator ++()  { ++this->v_; return *this; }
+    self_type &  operator --()  { --this->v_; return *this; }
+
+    self_type  operator ~() const  { return self_type( ~this->v_ ); }
+    self_type  operator !() const  { return self_type( !this->v_ ); }
+    self_type  operator +() const  { return self_type( +this->v_ ); }
+    self_type  operator -() const  { return self_type( -this->v_ ); }
+
+    bool  operator  <( self_type const &r ) const  { return this->v_ < r.v_; }
+    bool  operator ==( self_type const &r ) const  { return this->v_ == r.v_; }
+
+    self_type &operator *=(self_type const &r) {this->v_ *= r.v_; return *this;}
+    self_type &operator /=(self_type const &r) {this->v_ /= r.v_; return *this;}
+    self_type &operator %=(self_type const &r) {this->v_ %= r.v_; return *this;}
+    self_type &operator +=(self_type const &r) {this->v_ += r.v_; return *this;}
+    self_type &operator -=(self_type const &r) {this->v_ -= r.v_; return *this;}
+    self_type &operator<<=(self_type const &r){this->v_ <<= r.v_; return *this;}
+    self_type &operator>>=(self_type const &r){this->v_ >>= r.v_; return *this;}
+    self_type &operator &=(self_type const &r) {this->v_ &= r.v_; return *this;}
+    self_type &operator |=(self_type const &r) {this->v_ |= r.v_; return *this;}
+    self_type &operator ^=(self_type const &r) {this->v_ ^= r.v_; return *this;}
+
+    // Input & output
+    friend std::istream & operator >>( std::istream &i, self_type &x )
+    { return i >> x.v_; }
+
+    friend std::ostream & operator <<( std::ostream &o, self_type const &x )
+    { return o << x.v_; }
+
+};  // my_wrapped_integer
+
+template < typename IntType, int ID >
+my_wrapped_integer<IntType, ID>  abs( my_wrapped_integer<IntType, ID> const &x )
+{ return ( x < my_wrapped_integer<IntType, ID>(0) ) ? -x : +x; }
+
+typedef my_wrapped_integer<int>          MyInt1;
+typedef my_wrapped_integer<unsigned>     MyUnsigned1;
+typedef my_wrapped_integer<int, 1>       MyInt2;
+typedef my_wrapped_integer<unsigned, 1>  MyUnsigned2;
+
+// Without these explicit instantiations, MSVC++ 6.5/7.0 does not find
+// some friend operators in certain contexts.
+MyInt1       dummy1;
+MyUnsigned1  dummy2;
+MyInt2       dummy3;
+MyUnsigned2  dummy4;
+
+}  // namespace
+
+#define BOOST_NO_MACRO_EXPAND /**/
+
+// Specialize numeric_limits for _some_ of our types
+namespace std
+{
+
+template < >
+class numeric_limits< MyInt1 >
+{
+    typedef MyInt1::int_type             int_type;
+    typedef numeric_limits<int_type>  limits_type;
+
+public:
+    BOOST_STATIC_CONSTANT(bool, is_specialized = limits_type::is_specialized);
+
+    static MyInt1 min BOOST_NO_MACRO_EXPAND() throw()  { return (limits_type::min)(); }
+    static MyInt1 max BOOST_NO_MACRO_EXPAND() throw()  { return (limits_type::max)(); }
+
+    BOOST_STATIC_CONSTANT(int, digits      = limits_type::digits);
+    BOOST_STATIC_CONSTANT(int, digits10    = limits_type::digits10);
+#ifndef BOOST_NO_CXX11_NUMERIC_LIMITS
+    BOOST_STATIC_CONSTANT(int, max_digits10    = limits_type::max_digits10);
+#endif
+    BOOST_STATIC_CONSTANT(bool, is_signed  = limits_type::is_signed);
+    BOOST_STATIC_CONSTANT(bool, is_integer = limits_type::is_integer);
+    BOOST_STATIC_CONSTANT(bool, is_exact   = limits_type::is_exact);
+    BOOST_STATIC_CONSTANT(int, radix       = limits_type::radix);
+    static MyInt1 epsilon() throw()      { return limits_type::epsilon(); }
+    static MyInt1 round_error() throw()  { return limits_type::round_error(); }
+
+    BOOST_STATIC_CONSTANT(int, min_exponent   = limits_type::min_exponent);
+    BOOST_STATIC_CONSTANT(int, min_exponent10 = limits_type::min_exponent10);
+    BOOST_STATIC_CONSTANT(int, max_exponent   = limits_type::max_exponent);
+    BOOST_STATIC_CONSTANT(int, max_exponent10 = limits_type::max_exponent10);
+
+    BOOST_STATIC_CONSTANT(bool, has_infinity             = limits_type::has_infinity);
+    BOOST_STATIC_CONSTANT(bool, has_quiet_NaN            = limits_type::has_quiet_NaN);
+    BOOST_STATIC_CONSTANT(bool, has_signaling_NaN        = limits_type::has_signaling_NaN);
+    BOOST_STATIC_CONSTANT(float_denorm_style, has_denorm = limits_type::has_denorm);
+    BOOST_STATIC_CONSTANT(bool, has_denorm_loss          = limits_type::has_denorm_loss);
+
+    static MyInt1 infinity() throw()      { return limits_type::infinity(); }
+    static MyInt1 quiet_NaN() throw()     { return limits_type::quiet_NaN(); }
+    static MyInt1 signaling_NaN() throw() {return limits_type::signaling_NaN();}
+    static MyInt1 denorm_min() throw()    { return limits_type::denorm_min(); }
+
+    BOOST_STATIC_CONSTANT(bool, is_iec559  = limits_type::is_iec559);
+    BOOST_STATIC_CONSTANT(bool, is_bounded = limits_type::is_bounded);
+    BOOST_STATIC_CONSTANT(bool, is_modulo  = limits_type::is_modulo);
+
+    BOOST_STATIC_CONSTANT(bool, traps                    = limits_type::traps);
+    BOOST_STATIC_CONSTANT(bool, tinyness_before          = limits_type::tinyness_before);
+    BOOST_STATIC_CONSTANT(float_round_style, round_style = limits_type::round_style);
+
+};  // std::numeric_limits<MyInt1>
+
+template < >
+class numeric_limits< MyUnsigned1 >
+{
+    typedef MyUnsigned1::int_type        int_type;
+    typedef numeric_limits<int_type>  limits_type;
+
+public:
+    BOOST_STATIC_CONSTANT(bool, is_specialized = limits_type::is_specialized);
+
+    static MyUnsigned1 min BOOST_NO_MACRO_EXPAND() throw()  { return (limits_type::min)(); }
+    static MyUnsigned1 max BOOST_NO_MACRO_EXPAND() throw()  { return (limits_type::max)(); }
+
+    BOOST_STATIC_CONSTANT(int, digits      = limits_type::digits);
+    BOOST_STATIC_CONSTANT(int, digits10    = limits_type::digits10);
+#ifndef BOOST_NO_CXX11_NUMERIC_LIMITS
+    BOOST_STATIC_CONSTANT(int, max_digits10    = limits_type::max_digits10);
+#endif
+    BOOST_STATIC_CONSTANT(bool, is_signed  = limits_type::is_signed);
+    BOOST_STATIC_CONSTANT(bool, is_integer = limits_type::is_integer);
+    BOOST_STATIC_CONSTANT(bool, is_exact   = limits_type::is_exact);
+    BOOST_STATIC_CONSTANT(int, radix       = limits_type::radix);
+    static MyUnsigned1 epsilon() throw()      { return limits_type::epsilon(); }
+    static MyUnsigned1 round_error() throw(){return limits_type::round_error();}
+
+    BOOST_STATIC_CONSTANT(int, min_exponent   = limits_type::min_exponent);
+    BOOST_STATIC_CONSTANT(int, min_exponent10 = limits_type::min_exponent10);
+    BOOST_STATIC_CONSTANT(int, max_exponent   = limits_type::max_exponent);
+    BOOST_STATIC_CONSTANT(int, max_exponent10 = limits_type::max_exponent10);
+
+    BOOST_STATIC_CONSTANT(bool, has_infinity             = limits_type::has_infinity);
+    BOOST_STATIC_CONSTANT(bool, has_quiet_NaN            = limits_type::has_quiet_NaN);
+    BOOST_STATIC_CONSTANT(bool, has_signaling_NaN        = limits_type::has_signaling_NaN);
+    BOOST_STATIC_CONSTANT(float_denorm_style, has_denorm = limits_type::has_denorm);
+    BOOST_STATIC_CONSTANT(bool, has_denorm_loss          = limits_type::has_denorm_loss);
+
+    static MyUnsigned1 infinity() throw()    { return limits_type::infinity(); }
+    static MyUnsigned1 quiet_NaN() throw()  { return limits_type::quiet_NaN(); }
+    static MyUnsigned1 signaling_NaN() throw()
+        { return limits_type::signaling_NaN(); }
+    static MyUnsigned1 denorm_min() throw(){ return limits_type::denorm_min(); }
+
+    BOOST_STATIC_CONSTANT(bool, is_iec559  = limits_type::is_iec559);
+    BOOST_STATIC_CONSTANT(bool, is_bounded = limits_type::is_bounded);
+    BOOST_STATIC_CONSTANT(bool, is_modulo  = limits_type::is_modulo);
+
+    BOOST_STATIC_CONSTANT(bool, traps                    = limits_type::traps);
+    BOOST_STATIC_CONSTANT(bool, tinyness_before          = limits_type::tinyness_before);
+    BOOST_STATIC_CONSTANT(float_round_style, round_style = limits_type::round_style);
+
+};  // std::numeric_limits<MyUnsigned1>
+
+#if BOOST_WORKAROUND(BOOST_MSVC,<1300)
+// MSVC 6.0 lacks operator<< for __int64, see
+// http://support.microsoft.com/default.aspx?scid=kb;en-us;168440
+
+inline ostream& operator<<(ostream& os, __int64 i)
+{
+    char buf[20];
+    sprintf(buf,"%I64d", i);
+    os << buf;
+    return os;
+}
+
+inline ostream& operator<<(ostream& os, unsigned __int64 i)
+{
+    char buf[20];
+    sprintf(buf,"%I64u", i);
+    os << buf;
+    return os;
+}
+#endif
+
+}  // namespace std
+
+// GCD tests
+
+// GCD on signed integer types
+template< class T > void gcd_int_test() // signed_test_types
+{
+    using boost::integer::gcd;
+
+    // Originally from Boost.Rational tests
+    BOOST_TEST_EQ( gcd<T>(  1,  -1), static_cast<T>( 1) );
+    BOOST_TEST_EQ( gcd<T>( -1,   1), static_cast<T>( 1) );
+    BOOST_TEST_EQ( gcd<T>(  1,   1), static_cast<T>( 1) );
+    BOOST_TEST_EQ( gcd<T>( -1,  -1), static_cast<T>( 1) );
+    BOOST_TEST_EQ( gcd<T>(  0,   0), static_cast<T>( 0) );
+    BOOST_TEST_EQ( gcd<T>(  7,   0), static_cast<T>( 7) );
+    BOOST_TEST_EQ( gcd<T>(  0,   9), static_cast<T>( 9) );
+    BOOST_TEST_EQ( gcd<T>( -7,   0), static_cast<T>( 7) );
+    BOOST_TEST_EQ( gcd<T>(  0,  -9), static_cast<T>( 9) );
+    BOOST_TEST_EQ( gcd<T>( 42,  30), static_cast<T>( 6) );
+    BOOST_TEST_EQ( gcd<T>(  6,  -9), static_cast<T>( 3) );
+    BOOST_TEST_EQ( gcd<T>(-10, -10), static_cast<T>(10) );
+    BOOST_TEST_EQ( gcd<T>(-25, -10), static_cast<T>( 5) );
+    BOOST_TEST_EQ( gcd<T>(  3,   7), static_cast<T>( 1) );
+    BOOST_TEST_EQ( gcd<T>(  8,   9), static_cast<T>( 1) );
+    BOOST_TEST_EQ( gcd<T>(  7,  49), static_cast<T>( 7) );
+}
+
+// GCD on unmarked signed integer type
+void gcd_unmarked_int_test()
+{
+    using boost::integer::gcd;
+
+    // The regular signed-integer GCD function performs the unsigned version,
+    // then does an absolute-value on the result.  Signed types that are not
+    // marked as such (due to no std::numeric_limits specialization) may be off
+    // by a sign.
+    BOOST_TEST_EQ( abs(gcd<MyInt2>(   1,  -1 )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(gcd<MyInt2>(  -1,   1 )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(gcd<MyInt2>(   1,   1 )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(gcd<MyInt2>(  -1,  -1 )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(gcd<MyInt2>(   0,   0 )), MyInt2( 0) );
+    BOOST_TEST_EQ( abs(gcd<MyInt2>(   7,   0 )), MyInt2( 7) );
+    BOOST_TEST_EQ( abs(gcd<MyInt2>(   0,   9 )), MyInt2( 9) );
+    BOOST_TEST_EQ( abs(gcd<MyInt2>(  -7,   0 )), MyInt2( 7) );
+    BOOST_TEST_EQ( abs(gcd<MyInt2>(   0,  -9 )), MyInt2( 9) );
+    BOOST_TEST_EQ( abs(gcd<MyInt2>(  42,  30 )), MyInt2( 6) );
+    BOOST_TEST_EQ( abs(gcd<MyInt2>(   6,  -9 )), MyInt2( 3) );
+    BOOST_TEST_EQ( abs(gcd<MyInt2>( -10, -10 )), MyInt2(10) );
+    BOOST_TEST_EQ( abs(gcd<MyInt2>( -25, -10 )), MyInt2( 5) );
+    BOOST_TEST_EQ( abs(gcd<MyInt2>(   3,   7 )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(gcd<MyInt2>(   8,   9 )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(gcd<MyInt2>(   7,  49 )), MyInt2( 7) );
+}
+
+// GCD on unsigned integer types
+template< class T > void gcd_unsigned_test() // unsigned_test_types
+{
+    using boost::integer::gcd;
+
+    // Note that unmarked types (i.e. have no std::numeric_limits
+    // specialization) are treated like non/unsigned types
+    BOOST_TEST_EQ( gcd<T>( 1u,   1u), static_cast<T>( 1u) );
+    BOOST_TEST_EQ( gcd<T>( 0u,   0u), static_cast<T>( 0u) );
+    BOOST_TEST_EQ( gcd<T>( 7u,   0u), static_cast<T>( 7u) );
+    BOOST_TEST_EQ( gcd<T>( 0u,   9u), static_cast<T>( 9u) );
+    BOOST_TEST_EQ( gcd<T>(42u,  30u), static_cast<T>( 6u) );
+    BOOST_TEST_EQ( gcd<T>( 3u,   7u), static_cast<T>( 1u) );
+    BOOST_TEST_EQ( gcd<T>( 8u,   9u), static_cast<T>( 1u) );
+    BOOST_TEST_EQ( gcd<T>( 7u,  49u), static_cast<T>( 7u) );
+}
+
+// GCD at compile-time
+void gcd_static_test()
+{
+    using boost::integer::static_gcd;
+
+    BOOST_TEST_EQ( (static_gcd< 1,  1>::value), 1 );
+    BOOST_TEST_EQ( (static_gcd< 0,  0>::value), 0 );
+    BOOST_TEST_EQ( (static_gcd< 7,  0>::value), 7 );
+    BOOST_TEST_EQ( (static_gcd< 0,  9>::value), 9 );
+    BOOST_TEST_EQ( (static_gcd<42, 30>::value), 6 );
+    BOOST_TEST_EQ( (static_gcd< 3,  7>::value), 1 );
+    BOOST_TEST_EQ( (static_gcd< 8,  9>::value), 1 );
+    BOOST_TEST_EQ( (static_gcd< 7, 49>::value), 7 );
+}
+
+// TODO: non-built-in signed and unsigned integer tests, with and without
+// numeric_limits specialization; polynominal tests; note any changes if
+// built-ins switch to binary-GCD algorithm
+
+
+// LCM tests
+
+// LCM on signed integer types
+template< class T > void lcm_int_test() // signed_test_types
+{
+    using boost::integer::lcm;
+
+    // Originally from Boost.Rational tests
+    BOOST_TEST_EQ( lcm<T>(  1,  -1), static_cast<T>( 1) );
+    BOOST_TEST_EQ( lcm<T>( -1,   1), static_cast<T>( 1) );
+    BOOST_TEST_EQ( lcm<T>(  1,   1), static_cast<T>( 1) );
+    BOOST_TEST_EQ( lcm<T>( -1,  -1), static_cast<T>( 1) );
+    BOOST_TEST_EQ( lcm<T>(  0,   0), static_cast<T>( 0) );
+    BOOST_TEST_EQ( lcm<T>(  6,   0), static_cast<T>( 0) );
+    BOOST_TEST_EQ( lcm<T>(  0,   7), static_cast<T>( 0) );
+    BOOST_TEST_EQ( lcm<T>( -5,   0), static_cast<T>( 0) );
+    BOOST_TEST_EQ( lcm<T>(  0,  -4), static_cast<T>( 0) );
+    BOOST_TEST_EQ( lcm<T>( 18,  30), static_cast<T>(90) );
+    BOOST_TEST_EQ( lcm<T>( -6,   9), static_cast<T>(18) );
+    BOOST_TEST_EQ( lcm<T>(-10, -10), static_cast<T>(10) );
+    BOOST_TEST_EQ( lcm<T>( 25, -10), static_cast<T>(50) );
+    BOOST_TEST_EQ( lcm<T>(  3,   7), static_cast<T>(21) );
+    BOOST_TEST_EQ( lcm<T>(  8,   9), static_cast<T>(72) );
+    BOOST_TEST_EQ( lcm<T>(  7,  49), static_cast<T>(49) );
+}
+
+// LCM on unmarked signed integer type
+void lcm_unmarked_int_test()
+{
+    using boost::integer::lcm;
+
+    // The regular signed-integer LCM function performs the unsigned version,
+    // then does an absolute-value on the result.  Signed types that are not
+    // marked as such (due to no std::numeric_limits specialization) may be off
+    // by a sign.
+    BOOST_TEST_EQ( abs(lcm<MyInt2>(   1,  -1 )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(lcm<MyInt2>(  -1,   1 )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(lcm<MyInt2>(   1,   1 )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(lcm<MyInt2>(  -1,  -1 )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(lcm<MyInt2>(   0,   0 )), MyInt2( 0) );
+    BOOST_TEST_EQ( abs(lcm<MyInt2>(   6,   0 )), MyInt2( 0) );
+    BOOST_TEST_EQ( abs(lcm<MyInt2>(   0,   7 )), MyInt2( 0) );
+    BOOST_TEST_EQ( abs(lcm<MyInt2>(  -5,   0 )), MyInt2( 0) );
+    BOOST_TEST_EQ( abs(lcm<MyInt2>(   0,  -4 )), MyInt2( 0) );
+    BOOST_TEST_EQ( abs(lcm<MyInt2>(  18,  30 )), MyInt2(90) );
+    BOOST_TEST_EQ( abs(lcm<MyInt2>(  -6,   9 )), MyInt2(18) );
+    BOOST_TEST_EQ( abs(lcm<MyInt2>( -10, -10 )), MyInt2(10) );
+    BOOST_TEST_EQ( abs(lcm<MyInt2>(  25, -10 )), MyInt2(50) );
+    BOOST_TEST_EQ( abs(lcm<MyInt2>(   3,   7 )), MyInt2(21) );
+    BOOST_TEST_EQ( abs(lcm<MyInt2>(   8,   9 )), MyInt2(72) );
+    BOOST_TEST_EQ( abs(lcm<MyInt2>(   7,  49 )), MyInt2(49) );
+}
+
+// LCM on unsigned integer types
+template< class T > void lcm_unsigned_test() // unsigned_test_types
+{
+    using boost::integer::lcm;
+
+    // Note that unmarked types (i.e. have no std::numeric_limits
+    // specialization) are treated like non/unsigned types
+    BOOST_TEST_EQ( lcm<T>( 1u,   1u), static_cast<T>( 1u) );
+    BOOST_TEST_EQ( lcm<T>( 0u,   0u), static_cast<T>( 0u) );
+    BOOST_TEST_EQ( lcm<T>( 6u,   0u), static_cast<T>( 0u) );
+    BOOST_TEST_EQ( lcm<T>( 0u,   7u), static_cast<T>( 0u) );
+    BOOST_TEST_EQ( lcm<T>(18u,  30u), static_cast<T>(90u) );
+    BOOST_TEST_EQ( lcm<T>( 3u,   7u), static_cast<T>(21u) );
+    BOOST_TEST_EQ( lcm<T>( 8u,   9u), static_cast<T>(72u) );
+    BOOST_TEST_EQ( lcm<T>( 7u,  49u), static_cast<T>(49u) );
+}
+
+// LCM at compile-time
+void lcm_static_test()
+{
+    using boost::integer::static_lcm;
+
+    BOOST_TEST_EQ( (static_lcm< 1,  1>::value),  1 );
+    BOOST_TEST_EQ( (static_lcm< 0,  0>::value),  0 );
+    BOOST_TEST_EQ( (static_lcm< 6,  0>::value),  0 );
+    BOOST_TEST_EQ( (static_lcm< 0,  7>::value),  0 );
+    BOOST_TEST_EQ( (static_lcm<18, 30>::value), 90 );
+    BOOST_TEST_EQ( (static_lcm< 3,  7>::value), 21 );
+    BOOST_TEST_EQ( (static_lcm< 8,  9>::value), 72 );
+    BOOST_TEST_EQ( (static_lcm< 7, 49>::value), 49 );
+}
+
+// TODO: see GCD to-do
+
+// main
+
+// Various types to test with each GCD/LCM
+
+#define TEST_SIGNED_( test ) \
+    test<signed char>(); \
+    test<short>(); \
+    test<int>(); \
+    test<long>(); \
+    test<MyInt1>();
+
+#ifdef BOOST_HAS_LONG_LONG
+# define TEST_SIGNED( test ) \
+    TEST_SIGNED_( test ) \
+    test<boost::long_long_type>();
+#elif defined(BOOST_HAS_MS_INT64)
+# define TEST_SIGNED( test ) \
+    TEST_SIGNED_( test ) \
+    test<__int64>();
+#endif
+
+#define TEST_UNSIGNED_( test ) \
+    test<unsigned char>(); \
+    test<unsigned short>(); \
+    test<unsigned>(); \
+    test<unsigned long>(); \
+    test<MyUnsigned1>(); \
+    test<MyUnsigned2>();
+
+#ifdef BOOST_HAS_LONG_LONG
+# define TEST_UNSIGNED( test ) \
+    TEST_UNSIGNED_( test ) \
+    test<boost::ulong_long_type>();
+#elif defined(BOOST_HAS_MS_INT64)
+# define TEST_UNSIGNED( test ) \
+    TEST_UNSIGNED_( test ) \
+    test<unsigned __int64>();
+#endif
+
+int main()
+{
+    TEST_SIGNED( gcd_int_test )
+    gcd_unmarked_int_test();
+    TEST_UNSIGNED( gcd_unsigned_test )
+    gcd_static_test();
+
+    TEST_SIGNED( lcm_int_test )
+    lcm_unmarked_int_test();
+    TEST_UNSIGNED( lcm_unsigned_test )
+    lcm_static_test();
+
+    return boost::report_errors();
+}
--- a/test/fail_int_exact.cpp
+++ b/test/fail_int_exact.cpp
@ -0,0 +1,8 @@
+//  Copyright John Maddock 2012.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer.hpp>
+
+typedef boost::int_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::exact fail_int_exact;
--- a/test/fail_int_fast.cpp
+++ b/test/fail_int_fast.cpp
@ -0,0 +1,8 @@
+//  Copyright John Maddock 2012.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer.hpp>
+
+typedef boost::int_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::fast fail_int_fast;
--- a/test/fail_int_least.cpp
+++ b/test/fail_int_least.cpp
@ -0,0 +1,8 @@
+//  Copyright John Maddock 2012.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer.hpp>
+
+typedef boost::int_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::least fail_int_least;
--- a/test/fail_uint_65.cpp
+++ b/test/fail_uint_65.cpp
@ -0,0 +1,13 @@
+//  Copyright John Maddock 2012.
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer.hpp>
+#include <iostream>
+
+int main()
+{
+ std::cout << std::numeric_limits<boost::uint_t<65>::least>::digits;
+ return 0;
+}
--- a/test/fail_uint_exact.cpp
+++ b/test/fail_uint_exact.cpp
@ -0,0 +1,8 @@
+//  Copyright John Maddock 2012.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer.hpp>
+
+typedef boost::uint_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::exact fail_uint_exact;
--- a/test/fail_uint_fast.cpp
+++ b/test/fail_uint_fast.cpp
@ -0,0 +1,8 @@
+//  Copyright John Maddock 2012.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer.hpp>
+
+typedef boost::uint_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::fast fail_uint_fast;
--- a/test/fail_uint_least.cpp
+++ b/test/fail_uint_least.cpp
@ -0,0 +1,8 @@
+//  Copyright John Maddock 2012.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer.hpp>
+
+typedef boost::uint_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::least fail_uint_least;
--- a/test/gcd_constexpr14_test.cpp
+++ b/test/gcd_constexpr14_test.cpp
@ -0,0 +1,42 @@
+
+//  (C) Copyright John Maddock 2017.
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer/common_factor.hpp>
+
+#ifndef BOOST_NO_CXX14_CONSTEXPR
+
+void test_constexpr()
+{
+   constexpr const boost::int64_t i = 347 * 463 * 727;
+   constexpr const boost::int64_t j = 191 * 347 * 281;
+
+   constexpr const boost::int64_t k = boost::integer::gcd(i, j);
+   constexpr const boost::int64_t l = boost::integer::lcm(i, j);
+
+   static_assert(k == 347, "Expected result not found in constexpr gcd.");
+   static_assert(l == 6268802158037, "Expected result not found in constexpr lcm.");
+}
+
+#endif
+
+#ifndef BOOST_NO_CXX11_NOEXCEPT
+
+void test_noexcept()
+{
+   static_assert(noexcept(boost::integer::gcd(static_cast<unsigned char>(2), static_cast<unsigned char>(4))), "Expected a noexcept function.");
+   static_assert(noexcept(boost::integer::gcd(static_cast<char>(2), static_cast<char>(4))), "Expected a noexcept function.");
+   static_assert(noexcept(boost::integer::gcd(static_cast<signed char>(2), static_cast<signed char>(4))), "Expected a noexcept function.");
+   static_assert(noexcept(boost::integer::gcd(static_cast<short>(2), static_cast<short>(4))), "Expected a noexcept function.");
+   static_assert(noexcept(boost::integer::gcd(static_cast<unsigned short>(2), static_cast<unsigned short>(4))), "Expected a noexcept function.");
+   static_assert(noexcept(boost::integer::gcd(static_cast<int>(2), static_cast<int>(4))), "Expected a noexcept function.");
+   static_assert(noexcept(boost::integer::gcd(static_cast<unsigned int>(2), static_cast<unsigned int>(4))), "Expected a noexcept function.");
+   static_assert(noexcept(boost::integer::gcd(static_cast<long>(2), static_cast<long>(4))), "Expected a noexcept function.");
+   static_assert(noexcept(boost::integer::gcd(static_cast<unsigned long>(2), static_cast<unsigned long>(4))), "Expected a noexcept function.");
+   static_assert(noexcept(boost::integer::gcd(static_cast<long long>(2), static_cast<long long>(4))), "Expected a noexcept function.");
+   static_assert(noexcept(boost::integer::gcd(static_cast<unsigned long long>(2), static_cast<unsigned long long>(4))), "Expected a noexcept function.");
+}
+
+#endif
--- a/test/integer_fwd_include_test.cpp
+++ b/test/integer_fwd_include_test.cpp
@ -0,0 +1,22 @@
+//  Copyright John Maddock 2009.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer_fwd.hpp> // must be the only #include!
+
+// just declare some functions that use the incomplete types in the header:
+
+void f1(const boost::integer_traits<char>*);
+void f2(const boost::int_fast_t<char>*);
+void f3(const boost::int_t<12>*);
+void f4(const boost::uint_t<31>*);
+void f5(const boost::int_max_value_t<100>*);
+void f6(const boost::int_min_value_t<-100>*);
+void f7(const boost::uint_value_t<100>*);
+void f8(const boost::high_bit_mask_t<10>*);
+void f9(const boost::low_bits_mask_t<10>*);
+void f10(boost::static_log2_argument_type, boost::static_log2_result_type, boost::static_log2<10>*);
+void f11(boost::static_min_max_signed_type, boost::static_min_max_unsigned_type);
+void f12(boost::static_signed_min<1, 2>*, boost::static_signed_max<1,2>*);
+void f13(boost::static_unsigned_min<1,2>*, boost::static_unsigned_min<1,2>*);
--- a/test/integer_include_test.cpp
+++ b/test/integer_include_test.cpp
@ -0,0 +1,36 @@
+//  Copyright John Maddock 2009.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer.hpp> // must be the only #include!
+
+int main()
+{
+   boost::int_fast_t<char>::fast f = 0;
+   (void)f;
+   boost::int_t<16>::fast f2 = 0;
+   (void)f2;
+   boost::int_t<32>::exact e = 0;
+   (void)e;
+   boost::int_t<12>::least l = 0;
+   (void)l;
+   boost::uint_t<16>::fast uf2 = 0;
+   (void)uf2;
+   boost::uint_t<32>::exact ue = 0;
+   (void)ue;
+   boost::uint_t<12>::least ul = 0;
+   (void)ul;
+   boost::int_max_value_t<200>::fast v1 = 0;
+   (void)v1;
+   boost::int_max_value_t<2000>::least v2 = 0;
+   (void)v2;
+   boost::int_min_value_t<-200>::fast v3 = 0;
+   (void)v3;
+   boost::int_min_value_t<-2000>::least v4 = 0;
+   (void)v4;
+   boost::uint_value_t<200>::fast v5 = 0;
+   (void)v5;
+   boost::uint_value_t<2000>::least v6 = 0;
+   (void)v6;
+}
--- a/test/integer_mask_include_test.cpp
+++ b/test/integer_mask_include_test.cpp
@ -0,0 +1,18 @@
+//  Copyright John Maddock 2009.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer/integer_mask.hpp> // must be the only #include!
+
+int main()
+{
+   boost::high_bit_mask_t<20>::least l = boost::high_bit_mask_t<20>::high_bit;
+   boost::high_bit_mask_t<12>::fast f = boost::high_bit_mask_t<12>::high_bit_fast;
+   l += f + boost::high_bit_mask_t<12>::bit_position;
+   (void)l;
+   boost::low_bits_mask_t<20>::least l2 = boost::low_bits_mask_t<20>::sig_bits;
+   boost::low_bits_mask_t<12>::fast f2 = boost::low_bits_mask_t<12>::sig_bits_fast;
+   l2 += f2 + boost::low_bits_mask_t<12>::bit_count;
+   (void)l2;
+}
--- a/test/integer_mask_test.cpp
+++ b/test/integer_mask_test.cpp
@ -10,36 +10,93 @@
 //  Revision History
 //  23 Sep 2001  Initial version (Daryle Walker)

-#define  BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>  // for main
+#include <boost/detail/lightweight_test.hpp>

 #include <boost/cstdlib.hpp>               // for boost::exit_success
 #include <boost/integer/integer_mask.hpp>  // for boost::high_bit_mask_t, etc.

 #include <iostream>  // for std::cout (std::endl indirectly)

+#ifdef BOOST_MSVC
+#pragma warning(disable:4127) // conditional expression is constant
+#endif

-#define PRIVATE_HIGH_BIT_SLOW_TEST(v)  BOOST_CHECK( ::boost::high_bit_mask_t< \
- (v) >::high_bit == (1ul << (v)) );
-#define PRIVATE_HIGH_BIT_FAST_TEST(v)  BOOST_CHECK( ::boost::high_bit_mask_t< \
- (v) >::high_bit_fast == (1ul << (v)) );
+#if defined(BOOST_HAS_LONG_LONG)
+#define MASK_TYPE ::boost::ulong_long_type
+#elif defined(BOOST_HAS_MS_INT64)
+#define MASK_TYPE unsigned __int64
+#else
+#define MASK_TYPE unsigned long
+#endif
+
+#define ONE (static_cast<MASK_TYPE>(1))
+
+#define PRIVATE_HIGH_BIT_SLOW_TEST(v)  BOOST_TEST( ::boost::high_bit_mask_t< \
+ (v) >::high_bit == (ONE << (v)) );
+#define PRIVATE_HIGH_BIT_FAST_TEST(v)  BOOST_TEST( ::boost::high_bit_mask_t< \
+ (v) >::high_bit_fast == (ONE << (v)) );
 #define PRIVATE_HIGH_BIT_TEST(v)  do { PRIVATE_HIGH_BIT_SLOW_TEST(v); \
 PRIVATE_HIGH_BIT_FAST_TEST(v); } while (false)

-#define PRIVATE_LOW_BITS_SLOW_TEST(v)  BOOST_CHECK( ::boost::low_bits_mask_t< \
- (v) >::sig_bits == ((1ul << (v)) - 1) );
-#define PRIVATE_LOW_BITS_FAST_TEST(v)  BOOST_CHECK( ::boost::low_bits_mask_t< \
- (v) >::sig_bits_fast == ((1ul << (v)) - 1) );
+#define PRIVATE_LOW_BITS_SLOW_TEST(v)  \
+   do{ \
+      MASK_TYPE mask = 0;\
+      if(v > 0)\
+         { mask = ((ONE << (v-1)) - 1); mask <<= 1; mask |= 1; }\
+      BOOST_TEST( ::boost::low_bits_mask_t< (v) >::sig_bits ==  mask); \
+   }while(false);
+#define PRIVATE_LOW_BITS_FAST_TEST(v)  \
+   do{ \
+      MASK_TYPE mask = 0;\
+      if(v > 0)\
+         { mask = ((ONE << (v-1)) - 1); mask <<= 1; mask |= 1; }\
+      BOOST_TEST( ::boost::low_bits_mask_t< (v) >::sig_bits_fast == mask);\
+   }while(false);
 #define PRIVATE_LOW_BITS_TEST(v)  do { PRIVATE_LOW_BITS_SLOW_TEST(v); \
 PRIVATE_LOW_BITS_FAST_TEST(v); } while (false)


-int test_main( int, char*[] )
+int main( int, char*[] )
 {
    using std::cout;
    using std::endl;

    cout << "Doing high_bit_mask_t tests." << endl;
+
+#if defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)
+    PRIVATE_HIGH_BIT_TEST( 63 );
+    PRIVATE_HIGH_BIT_TEST( 62 );
+    PRIVATE_HIGH_BIT_TEST( 61 );
+    PRIVATE_HIGH_BIT_TEST( 60 );
+    PRIVATE_HIGH_BIT_TEST( 59 );
+    PRIVATE_HIGH_BIT_TEST( 58 );
+    PRIVATE_HIGH_BIT_TEST( 57 );
+    PRIVATE_HIGH_BIT_TEST( 56 );
+    PRIVATE_HIGH_BIT_TEST( 55 );
+    PRIVATE_HIGH_BIT_TEST( 54 );
+    PRIVATE_HIGH_BIT_TEST( 53 );
+    PRIVATE_HIGH_BIT_TEST( 52 );
+    PRIVATE_HIGH_BIT_TEST( 51 );
+    PRIVATE_HIGH_BIT_TEST( 50 );
+    PRIVATE_HIGH_BIT_TEST( 49 );
+    PRIVATE_HIGH_BIT_TEST( 48 );
+    PRIVATE_HIGH_BIT_TEST( 47 );
+    PRIVATE_HIGH_BIT_TEST( 46 );
+    PRIVATE_HIGH_BIT_TEST( 45 );
+    PRIVATE_HIGH_BIT_TEST( 44 );
+    PRIVATE_HIGH_BIT_TEST( 43 );
+    PRIVATE_HIGH_BIT_TEST( 42 );
+    PRIVATE_HIGH_BIT_TEST( 41 );
+    PRIVATE_HIGH_BIT_TEST( 40 );
+    PRIVATE_HIGH_BIT_TEST( 39 );
+    PRIVATE_HIGH_BIT_TEST( 38 );
+    PRIVATE_HIGH_BIT_TEST( 37 );
+    PRIVATE_HIGH_BIT_TEST( 36 );
+    PRIVATE_HIGH_BIT_TEST( 35 );
+    PRIVATE_HIGH_BIT_TEST( 34 );
+    PRIVATE_HIGH_BIT_TEST( 33 );
+    PRIVATE_HIGH_BIT_TEST( 32 );
+#endif
    PRIVATE_HIGH_BIT_TEST( 31 );
    PRIVATE_HIGH_BIT_TEST( 30 );
    PRIVATE_HIGH_BIT_TEST( 29 );
@ -74,7 +131,42 @@ int test_main( int, char*[] )
    PRIVATE_HIGH_BIT_TEST(  0 );

    cout << "Doing low_bits_mask_t tests." << endl;
-    PRIVATE_LOW_BITS_TEST( 32 );  // Undefined behavior?  Whoops!
+
+#if defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)
+    PRIVATE_LOW_BITS_TEST( 64 );
+    PRIVATE_LOW_BITS_TEST( 63 );
+    PRIVATE_LOW_BITS_TEST( 62 );
+    PRIVATE_LOW_BITS_TEST( 61 );
+    PRIVATE_LOW_BITS_TEST( 60 );
+    PRIVATE_LOW_BITS_TEST( 59 );
+    PRIVATE_LOW_BITS_TEST( 58 );
+    PRIVATE_LOW_BITS_TEST( 57 );
+    PRIVATE_LOW_BITS_TEST( 56 );
+    PRIVATE_LOW_BITS_TEST( 55 );
+    PRIVATE_LOW_BITS_TEST( 54 );
+    PRIVATE_LOW_BITS_TEST( 53 );
+    PRIVATE_LOW_BITS_TEST( 52 );
+    PRIVATE_LOW_BITS_TEST( 51 );
+    PRIVATE_LOW_BITS_TEST( 50 );
+    PRIVATE_LOW_BITS_TEST( 49 );
+    PRIVATE_LOW_BITS_TEST( 48 );
+    PRIVATE_LOW_BITS_TEST( 47 );
+    PRIVATE_LOW_BITS_TEST( 46 );
+    PRIVATE_LOW_BITS_TEST( 45 );
+    PRIVATE_LOW_BITS_TEST( 44 );
+    PRIVATE_LOW_BITS_TEST( 43 );
+    PRIVATE_LOW_BITS_TEST( 42 );
+    PRIVATE_LOW_BITS_TEST( 41 );
+    PRIVATE_LOW_BITS_TEST( 40 );
+    PRIVATE_LOW_BITS_TEST( 39 );
+    PRIVATE_LOW_BITS_TEST( 38 );
+    PRIVATE_LOW_BITS_TEST( 37 );
+    PRIVATE_LOW_BITS_TEST( 36 );
+    PRIVATE_LOW_BITS_TEST( 35 );
+    PRIVATE_LOW_BITS_TEST( 34 );
+    PRIVATE_LOW_BITS_TEST( 33 );
+#endif
+    PRIVATE_LOW_BITS_TEST( 32 );
    PRIVATE_LOW_BITS_TEST( 31 );
    PRIVATE_LOW_BITS_TEST( 30 );
    PRIVATE_LOW_BITS_TEST( 29 );
@ -107,5 +199,5 @@ int test_main( int, char*[] )
    PRIVATE_LOW_BITS_TEST(  2 );
    PRIVATE_LOW_BITS_TEST(  1 );

-    return boost::exit_success;
+    return boost::report_errors();
 }
--- a/test/integer_test.cpp
+++ b/test/integer_test.cpp
@ -0,0 +1,264 @@
+//  boost integer.hpp test program  ------------------------------------------//
+
+//  Copyright Beman Dawes 1999.  
+//  Copyright Daryle Walker 2001.  
+//  Copyright John Maddock 2009.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+//  See http://www.boost.org/libs/integer for documentation.
+
+//  Revision History
+//   04 Oct 01  Added tests for new templates; rewrote code (Daryle Walker)
+//   10 Mar 01  Boost Test Library now used for tests (Beman Dawes)
+//   31 Aug 99  Initial version
+
+#include <boost/detail/lightweight_test.hpp>  // for main, BOOST_TEST
+#include <boost/integer.hpp>  // for boost::int_t, boost::uint_t
+#include <boost/type_traits/is_same.hpp>
+#include <boost/mpl/bool.hpp> // for mpl::true_ and false_
+
+#include <climits>   // for ULONG_MAX, LONG_MAX, LONG_MIN
+#include <iostream>  // for std::cout (std::endl indirectly)
+#include <typeinfo>  // for std::type_info
+
+#ifdef BOOST_MSVC
+#pragma warning(disable:4127) // conditional expression is constant
+#endif
+#if defined( __BORLANDC__ )
+# pragma option -w-8008 -w-8066 // condition is always true
+#endif
+
+//
+// Keep track of error count, so we can print out detailed
+// info only if we need it:
+//
+int last_error_count = 0;
+//
+// Helpers to print out the name of a type,
+// we use these as typeid(X).name() doesn't always
+// return a human readable string:
+//
+template <class T> const char* get_name_of_type(T){ return typeid(T).name(); }
+const char* get_name_of_type(signed char){ return "signed char"; }
+const char* get_name_of_type(unsigned char){ return "unsigned char"; }
+const char* get_name_of_type(short){ return "short"; }
+const char* get_name_of_type(unsigned short){ return "unsigned short"; }
+const char* get_name_of_type(int){ return "int"; }
+const char* get_name_of_type(unsigned int){ return "unsigned int"; }
+const char* get_name_of_type(long){ return "long"; }
+const char* get_name_of_type(unsigned long){ return "unsigned long"; }
+#ifdef BOOST_HAS_LONG_LONG
+const char* get_name_of_type(boost::long_long_type){ return "boost::long_long_type"; }
+const char* get_name_of_type(boost::ulong_long_type){ return "boost::ulong_long_type"; }
+#endif
+
+template <int Bits>
+void do_test_exact(boost::mpl::true_ const&)
+{
+   // Test the ::exact member:
+   typedef typename boost::int_t<Bits>::exact int_exact;
+   typedef typename boost::uint_t<Bits>::exact uint_exact;
+   typedef typename boost::int_t<Bits>::least least_int;
+   typedef typename boost::uint_t<Bits>::least least_uint;
+
+   BOOST_TEST((boost::is_same<int_exact, least_int>::value));
+   BOOST_TEST((boost::is_same<uint_exact, least_uint>::value));
+}
+template <int Bits>
+void do_test_exact(boost::mpl::false_ const&)
+{
+   // Nothing to do, type does not have an ::extact member.
+}
+
+template <int Bits>
+void do_test_bits()
+{
+   //
+   // Recurse to next smallest number of bits:
+   //
+   do_test_bits<Bits - 1>();
+   //
+   // Test exact types if we have them:
+   //
+   do_test_exact<Bits>(
+      boost::mpl::bool_<
+      (sizeof(unsigned char) * CHAR_BIT == Bits)
+      || (sizeof(unsigned short) * CHAR_BIT == Bits)
+      || (sizeof(unsigned int) * CHAR_BIT == Bits)
+      || (sizeof(unsigned long) * CHAR_BIT == Bits)
+#ifdef BOOST_HAS_LONG_LONG
+      || (sizeof(boost::ulong_long_type) * CHAR_BIT == Bits)
+#endif
+      >());
+   //
+   // We need to check all aspects of the members of int_t<Bits> and uint_t<Bits>:
+   //
+   typedef typename boost::int_t<Bits>::least least_int;
+   typedef typename boost::int_t<Bits>::least fast_int;
+   typedef typename boost::uint_t<Bits>::least least_uint;
+   typedef typename boost::uint_t<Bits>::fast fast_uint;
+
+   if(std::numeric_limits<least_int>::is_specialized)
+   {
+      BOOST_TEST(std::numeric_limits<least_int>::digits + 1 >= Bits);
+   }
+   if(std::numeric_limits<least_uint>::is_specialized)
+   {
+      BOOST_TEST(std::numeric_limits<least_uint>::digits >= Bits);
+   }
+   BOOST_TEST(sizeof(least_int) * CHAR_BIT >= Bits);
+   BOOST_TEST(sizeof(least_uint) * CHAR_BIT >= Bits);
+   BOOST_TEST(sizeof(fast_int) >= sizeof(least_int));
+   BOOST_TEST(sizeof(fast_uint) >= sizeof(least_uint));
+   //
+   // There should be no type smaller than least_* that also has enough bits:
+   //
+   if(!boost::is_same<signed char, least_int>::value)
+   {
+      BOOST_TEST(std::numeric_limits<signed char>::digits < Bits);
+      if(!boost::is_same<short, least_int>::value)
+      {
+         BOOST_TEST(std::numeric_limits<short>::digits < Bits);
+         if(!boost::is_same<int, least_int>::value)
+         {
+            BOOST_TEST(std::numeric_limits<int>::digits < Bits);
+            if(!boost::is_same<long, least_int>::value)
+            {
+               BOOST_TEST(std::numeric_limits<long>::digits < Bits);
+            }
+         }
+      }
+   }
+   // And again, but unsigned:
+   if(!boost::is_same<unsigned char, least_uint>::value)
+   {
+      BOOST_TEST(std::numeric_limits<unsigned char>::digits < Bits);
+      if(!boost::is_same<unsigned short, least_uint>::value)
+      {
+         BOOST_TEST(std::numeric_limits<unsigned short>::digits < Bits);
+         if(!boost::is_same<unsigned int, least_uint>::value)
+         {
+            BOOST_TEST(std::numeric_limits<unsigned int>::digits < Bits);
+            if(!boost::is_same<unsigned long, least_uint>::value)
+            {
+               BOOST_TEST(std::numeric_limits<unsigned long>::digits < Bits);
+            }
+         }
+      }
+   }
+
+   if(boost::detail::test_errors() != last_error_count)
+   {
+      last_error_count = boost::detail::test_errors();
+      std::cout << "Errors occurred while testing with bit count = " << Bits << std::endl;
+      std::cout << "Type int_t<" << Bits << ">::least was " << get_name_of_type(least_int(0)) << std::endl;
+      std::cout << "Type int_t<" << Bits << ">::fast was " << get_name_of_type(fast_int(0)) << std::endl;
+      std::cout << "Type uint_t<" << Bits << ">::least was " << get_name_of_type(least_uint(0)) << std::endl;
+      std::cout << "Type uint_t<" << Bits << ">::fast was " << get_name_of_type(fast_uint(0)) << std::endl;
+   }
+}
+template <>
+void do_test_bits<-1>()
+{
+   // Nothing to do here!!
+}
+
+template <class Traits, class Expected>
+void test_min_max_type(Expected val)
+{
+   typedef typename Traits::least least_type;
+   typedef typename Traits::fast  fast_type;
+   BOOST_TEST((boost::is_same<least_type, Expected>::value));
+   BOOST_TEST(sizeof(fast_type) >= sizeof(least_type));
+   BOOST_TEST((std::numeric_limits<least_type>::min)() <= val);
+   BOOST_TEST((std::numeric_limits<least_type>::max)() >= val);
+
+   if(boost::detail::test_errors() != last_error_count)
+   {
+      last_error_count = boost::detail::test_errors();
+      std::cout << "Traits type is: " << typeid(Traits).name() << std::endl;
+      std::cout << "Least type is: " << get_name_of_type(least_type(0)) << std::endl;
+      std::cout << "Fast type is: " << get_name_of_type(fast_type(0)) << std::endl;
+      std::cout << "Expected type is: " << get_name_of_type(Expected(0)) << std::endl;
+      std::cout << "Required value is: " << val << std::endl;
+   }
+}
+
+// Test program
+int main(int, char*[])
+{
+   // Test int_t and unint_t first:
+   if(std::numeric_limits<boost::intmax_t>::is_specialized)
+      do_test_bits<std::numeric_limits<boost::uintmax_t>::digits>();
+   else
+      do_test_bits<std::numeric_limits<long>::digits>();
+
+   //
+   // Test min and max value types:
+   //
+   test_min_max_type<boost::int_max_value_t<SCHAR_MAX>, signed char>(SCHAR_MAX);
+   test_min_max_type<boost::int_min_value_t<SCHAR_MIN>, signed char>(SCHAR_MIN);
+   test_min_max_type<boost::uint_value_t<UCHAR_MAX>, unsigned char>(UCHAR_MAX);
+#if(USHRT_MAX != UCHAR_MAX)
+      test_min_max_type<boost::int_max_value_t<SCHAR_MAX+1>, short>(SCHAR_MAX+1);
+      test_min_max_type<boost::int_min_value_t<SCHAR_MIN-1>, short>(SCHAR_MIN-1);
+      test_min_max_type<boost::uint_value_t<UCHAR_MAX+1>, unsigned short>(UCHAR_MAX+1);
+      test_min_max_type<boost::int_max_value_t<SHRT_MAX>, short>(SHRT_MAX);
+      test_min_max_type<boost::int_min_value_t<SHRT_MIN>, short>(SHRT_MIN);
+      test_min_max_type<boost::uint_value_t<USHRT_MAX>, unsigned short>(USHRT_MAX);
+#endif
+#if(UINT_MAX != USHRT_MAX)
+      test_min_max_type<boost::int_max_value_t<SHRT_MAX+1>, int>(SHRT_MAX+1);
+      test_min_max_type<boost::int_min_value_t<SHRT_MIN-1>, int>(SHRT_MIN-1);
+      test_min_max_type<boost::uint_value_t<USHRT_MAX+1>, unsigned int>(USHRT_MAX+1);
+      test_min_max_type<boost::int_max_value_t<INT_MAX>, int>(INT_MAX);
+      test_min_max_type<boost::int_min_value_t<INT_MIN>, int>(INT_MIN);
+      test_min_max_type<boost::uint_value_t<UINT_MAX>, unsigned int>(UINT_MAX);
+#endif
+#if(ULONG_MAX != UINT_MAX)
+      test_min_max_type<boost::int_max_value_t<INT_MAX+1L>, long>(INT_MAX+1L);
+      test_min_max_type<boost::int_min_value_t<INT_MIN-1L>, long>(INT_MIN-1L);
+      test_min_max_type<boost::uint_value_t<UINT_MAX+1uL>, unsigned long>(UINT_MAX+1uL);
+      test_min_max_type<boost::int_max_value_t<LONG_MAX>, long>(LONG_MAX);
+      test_min_max_type<boost::int_min_value_t<LONG_MIN>, long>(LONG_MIN);
+      test_min_max_type<boost::uint_value_t<ULONG_MAX>, unsigned long>(ULONG_MAX);
+#endif
+#ifndef BOOST_NO_INTEGRAL_INT64_T
+#if defined(BOOST_HAS_LONG_LONG) && (defined(ULLONG_MAX) && (ULLONG_MAX != ULONG_MAX))
+      test_min_max_type<boost::int_max_value_t<LONG_MAX+1LL>, boost::long_long_type>(LONG_MAX+1LL);
+      test_min_max_type<boost::int_min_value_t<LONG_MIN-1LL>, boost::long_long_type>(LONG_MIN-1LL);
+      test_min_max_type<boost::uint_value_t<ULONG_MAX+1uLL>, boost::ulong_long_type>(ULONG_MAX+1uLL);
+      test_min_max_type<boost::int_max_value_t<LLONG_MAX>, boost::long_long_type>(LLONG_MAX);
+      test_min_max_type<boost::int_min_value_t<LLONG_MIN>, boost::long_long_type>(LLONG_MIN);
+      test_min_max_type<boost::uint_value_t<ULLONG_MAX>, boost::ulong_long_type>(ULLONG_MAX);
+#endif
+#if defined(BOOST_HAS_LONG_LONG) && (defined(ULONG_LONG_MAX) && (ULONG_LONG_MAX != ULONG_MAX))
+      test_min_max_type<boost::int_max_value_t<LONG_MAX+1LL>, boost::long_long_type>(LONG_MAX+1LL);
+      test_min_max_type<boost::int_min_value_t<LONG_MIN-1LL>, boost::long_long_type>(LONG_MIN-1LL);
+      test_min_max_type<boost::uint_value_t<ULONG_MAX+1uLL>, boost::ulong_long_type>(ULONG_MAX+1uLL);
+      test_min_max_type<boost::int_max_value_t<LONG_LONG_MAX>, boost::long_long_type>(LONG_LONG_MAX);
+      test_min_max_type<boost::int_min_value_t<LONG_LONG_MIN>, boost::long_long_type>(LONG_LONG_MIN);
+      test_min_max_type<boost::uint_value_t<ULONG_LONG_MAX>, boost::ulong_long_type>(ULONG_LONG_MAX);
+#endif
+#if defined(BOOST_HAS_LONG_LONG) && (defined(ULONGLONG_MAX) && (ULONGLONG_MAX != ULONG_MAX))
+      test_min_max_type<boost::int_max_value_t<LONG_MAX+1LL>, boost::long_long_type>(LONG_MAX+1LL);
+      test_min_max_type<boost::int_min_value_t<LONG_MIN-1LL>, boost::long_long_type>(LONG_MIN-1LL);
+      test_min_max_type<boost::uint_value_t<ULONG_MAX+1uLL>, boost::ulong_long_type>(ULONG_MAX+1uLL);
+      test_min_max_type<boost::int_max_value_t<LONGLONG_MAX>, boost::long_long_type>(LONGLONG_MAX);
+      test_min_max_type<boost::int_min_value_t<LONGLONG_MIN>, boost::long_long_type>(LONGLONG_MAX);
+      test_min_max_type<boost::uint_value_t<ULONGLONG_MAX>, boost::ulong_long_type>(ULONGLONG_MAX);
+#endif
+#if defined(BOOST_HAS_LONG_LONG) && (defined(_ULLONG_MAX) && defined(_LLONG_MIN) && (_ULLONG_MAX != ULONG_MAX))
+      test_min_max_type<boost::int_max_value_t<LONG_MAX+1LL>, boost::long_long_type>(LONG_MAX+1LL);
+      test_min_max_type<boost::int_min_value_t<LONG_MIN-1LL>, boost::long_long_type>(LONG_MIN-1LL);
+      test_min_max_type<boost::uint_value_t<ULONG_MAX+1uLL>, boost::ulong_long_type>(ULONG_MAX+1uLL);
+      test_min_max_type<boost::int_max_value_t<_LLONG_MAX>, boost::long_long_type>(_LLONG_MAX);
+      test_min_max_type<boost::int_min_value_t<_LLONG_MIN>, boost::long_long_type>(_LLONG_MIN);
+      test_min_max_type<boost::uint_value_t<_ULLONG_MAX>, boost::ulong_long_type>(_ULLONG_MAX);
+#endif // BOOST_HAS_LONG_LONG
+#endif // BOOST_NO_INTEGRAL_INT64_T
+      return boost::report_errors();
+}
--- a/test/integer_traits_include_test.cpp
+++ b/test/integer_traits_include_test.cpp
@ -0,0 +1,37 @@
+//  Copyright John Maddock 2009.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer_traits.hpp> // must be the only #include!
+
+template <class T>
+void check_numeric_limits_derived(const std::numeric_limits<T>&){}
+
+template <class T>
+void check()
+{
+   typedef boost::integer_traits<T> traits;
+   check_numeric_limits_derived(traits());
+   bool b = traits::is_integral;
+   (void)b;
+   T v = traits::const_min + traits::const_max;
+   (void)v;
+}
+
+int main()
+{
+   check<signed char>();
+   check<unsigned char>();
+   check<char>();
+   check<short>();
+   check<unsigned short>();
+   check<int>();
+   check<unsigned int>();
+   check<signed long>();
+   check<unsigned long>();
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
+   check<boost::long_long_type>();
+   check<boost::ulong_long_type>();
+#endif
+}
--- a/test/integer_traits_test.cpp
+++ b/test/integer_traits_test.cpp
@ -17,8 +17,7 @@
 // use int64_t instead of long long for better portability
 #include <boost/cstdint.hpp>

-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
+#include <boost/detail/lightweight_test.hpp>

 /*
 * General portability note:
@ -53,22 +52,22 @@ void runtest(const char * type, T)
            << "; min is " << make_char_numeric_for_streaming((traits::min)())
            << ", max is " << make_char_numeric_for_streaming((traits::max)())
            << std::endl;
-  BOOST_CHECK(traits::is_specialized);
+  BOOST_TEST(traits::is_specialized);
 #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1200)
  // MSVC++ 6.0 issues a LNK1179 error (duplicate comdat) when the compiler
  // generates different symbol names with a very long common prefix:
  // the dummy "&& true" disambiguates between the symbols generated by this
-  // BOOST_CHECK instantiation and the preceding one.
-  BOOST_CHECK(traits::is_integer && true);
+  // BOOST_TEST instantiation and the preceding one.
+  BOOST_TEST(traits::is_integer && true);
 #else
-  BOOST_CHECK(traits::is_integer);
+  BOOST_TEST(traits::is_integer);
 #endif
-  BOOST_CHECK(traits::is_integral == true);
-  BOOST_CHECK(traits::const_min == (traits::min)());
-  BOOST_CHECK(traits::const_max == (traits::max)());
+  BOOST_TEST(traits::is_integral == true);
+  BOOST_TEST(traits::const_min == (traits::min)());
+  BOOST_TEST(traits::const_max == (traits::max)());
 }

-int test_main(int, char*[])
+int main(int, char*[])
 {
  runtest("bool", bool());
  runtest("char", char());
@ -86,7 +85,7 @@ int test_main(int, char*[])
  runtest("long", long());
  typedef unsigned long unsigned_long;
  runtest("unsigned long", unsigned_long());
-#if !defined(BOOST_NO_INT64_T) && (!defined(BOOST_MSVC) || BOOST_MSVC > 1300) && !defined(__BORLANDC__) && !defined(__BEOS__)
+#ifndef BOOST_NO_INTEGRAL_INT64_T
  //
  // MS/Borland compilers can't support 64-bit member constants
  // BeOS doesn't have specialisations for long long in SGI's <limits> header.
@ -97,6 +96,6 @@ int test_main(int, char*[])
 #endif
  // Some compilers don't pay attention to std:3.6.1/5 and issue a
  // warning here if "return 0;" is omitted.
-  return 0;
+  return boost::report_errors();
 }

--- a/test/static_log2_include_test.cpp
+++ b/test/static_log2_include_test.cpp
@ -0,0 +1,14 @@
+//  Copyright John Maddock 2009.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer/static_log2.hpp> // must be the only #include!
+
+int main()
+{
+   boost::static_log2_argument_type arg = 0;
+   (void)arg;
+   boost::static_log2_result_type result = boost::static_log2<30>::value;
+   (void)result;
+}
--- a/test/static_log2_test.cpp
+++ b/test/static_log2_test.cpp
@ -10,8 +10,7 @@
 //  Revision History
 //  01 Oct 2001  Initial version (Daryle Walker)

-#define  BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>  // for main
+#include <boost/detail/lightweight_test.hpp>  // for main

 #include <boost/cstdlib.hpp>              // for boost::exit_success
 #include <boost/integer/static_log2.hpp>  // for boost::static_log2
@ -20,7 +19,7 @@


 // Macros to compact code
-#define PRIVATE_LB_TEST( v, e )  BOOST_CHECK( ::boost::static_log2<v>::value == e )
+#define PRIVATE_LB_TEST( v, e )  BOOST_TEST( ::boost::static_log2<v>::value == e )

 #define PRIVATE_PRINT_LB( v )    ::std::cout << "boost::static_log2<" << (v) \
 << "> = " << ::boost::static_log2< (v) >::value << '.' << ::std::endl
@ -35,7 +34,7 @@

 // Main testing function
 int
-test_main
+main
 (
    int         ,   // "argc" is unused
    char *      []  // "argv" is unused
@ -146,5 +145,5 @@ test_main
    PRIVATE_LB_TEST( 65536, 16 );
    PRIVATE_LB_TEST( 65537, 16 );

-    return boost::exit_success;
+    return boost::report_errors();
 }
--- a/test/static_min_max_include_test.cpp
+++ b/test/static_min_max_include_test.cpp
@ -0,0 +1,14 @@
+//  Copyright John Maddock 2009.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer/static_min_max.hpp> // must be the only #include!
+
+int main()
+{
+   boost::static_min_max_signed_type m = boost::static_signed_min<2, 3>::value + boost::static_signed_max<2, 3>::value;
+   (void)m;
+   boost::static_min_max_unsigned_type u = boost::static_unsigned_min<2, 3>::value + boost::static_unsigned_max<2, 3>::value;
+   (void)u;
+}
--- a/test/static_min_max_test.cpp
+++ b/test/static_min_max_test.cpp
@ -10,8 +10,7 @@
 //  Revision History
 //  23 Sep 2001  Initial version (Daryle Walker)

-#define  BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>  // for main, BOOST_CHECK
+#include <boost/detail/lightweight_test.hpp>  // for main, BOOST_TEST

 #include <boost/cstdlib.hpp>                 // for boost::exit_success
 #include <boost/integer/static_min_max.hpp>  // for boost::static_signed_min, etc.
@ -21,7 +20,7 @@

 // Main testing function
 int
-test_main
+main
 (
    int         ,   // "argc" is unused
    char *      []  // "argv" is unused
@ -37,57 +36,57 @@ test_main
    // Two positives
    cout << "Doing tests with two positive values." << endl;

-    BOOST_CHECK( (static_signed_min< 9, 14>::value) ==  9 );
-    BOOST_CHECK( (static_signed_max< 9, 14>::value) == 14 );
-    BOOST_CHECK( (static_signed_min<14,  9>::value) ==  9 );
-    BOOST_CHECK( (static_signed_max<14,  9>::value) == 14 );
+    BOOST_TEST( (static_signed_min< 9, 14>::value) ==  9 );
+    BOOST_TEST( (static_signed_max< 9, 14>::value) == 14 );
+    BOOST_TEST( (static_signed_min<14,  9>::value) ==  9 );
+    BOOST_TEST( (static_signed_max<14,  9>::value) == 14 );

-    BOOST_CHECK( (static_unsigned_min< 9, 14>::value) ==  9 );
-    BOOST_CHECK( (static_unsigned_max< 9, 14>::value) == 14 );
-    BOOST_CHECK( (static_unsigned_min<14,  9>::value) ==  9 );
-    BOOST_CHECK( (static_unsigned_max<14,  9>::value) == 14 );
+    BOOST_TEST( (static_unsigned_min< 9, 14>::value) ==  9 );
+    BOOST_TEST( (static_unsigned_max< 9, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_min<14,  9>::value) ==  9 );
+    BOOST_TEST( (static_unsigned_max<14,  9>::value) == 14 );

    // Two negatives
    cout << "Doing tests with two negative values." << endl;

-    BOOST_CHECK( (static_signed_min<  -8, -101>::value) == -101 );
-    BOOST_CHECK( (static_signed_max<  -8, -101>::value) ==   -8 );
-    BOOST_CHECK( (static_signed_min<-101,   -8>::value) == -101 );
-    BOOST_CHECK( (static_signed_max<-101,   -8>::value) ==   -8 );
+    BOOST_TEST( (static_signed_min<  -8, -101>::value) == -101 );
+    BOOST_TEST( (static_signed_max<  -8, -101>::value) ==   -8 );
+    BOOST_TEST( (static_signed_min<-101,   -8>::value) == -101 );
+    BOOST_TEST( (static_signed_max<-101,   -8>::value) ==   -8 );

    // With zero
    cout << "Doing tests with zero and a positive or negative value." << endl;

-    BOOST_CHECK( (static_signed_min< 0, 14>::value) ==  0 );
-    BOOST_CHECK( (static_signed_max< 0, 14>::value) == 14 );
-    BOOST_CHECK( (static_signed_min<14,  0>::value) ==  0 );
-    BOOST_CHECK( (static_signed_max<14,  0>::value) == 14 );
+    BOOST_TEST( (static_signed_min< 0, 14>::value) ==  0 );
+    BOOST_TEST( (static_signed_max< 0, 14>::value) == 14 );
+    BOOST_TEST( (static_signed_min<14,  0>::value) ==  0 );
+    BOOST_TEST( (static_signed_max<14,  0>::value) == 14 );

-    BOOST_CHECK( (static_unsigned_min< 0, 14>::value) ==  0 );
-    BOOST_CHECK( (static_unsigned_max< 0, 14>::value) == 14 );
-    BOOST_CHECK( (static_unsigned_min<14,  0>::value) ==  0 );
-    BOOST_CHECK( (static_unsigned_max<14,  0>::value) == 14 );
+    BOOST_TEST( (static_unsigned_min< 0, 14>::value) ==  0 );
+    BOOST_TEST( (static_unsigned_max< 0, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_min<14,  0>::value) ==  0 );
+    BOOST_TEST( (static_unsigned_max<14,  0>::value) == 14 );

-    BOOST_CHECK( (static_signed_min<   0, -101>::value) == -101 );
-    BOOST_CHECK( (static_signed_max<   0, -101>::value) ==    0 );
-    BOOST_CHECK( (static_signed_min<-101,    0>::value) == -101 );
-    BOOST_CHECK( (static_signed_max<-101,    0>::value) ==    0 );
+    BOOST_TEST( (static_signed_min<   0, -101>::value) == -101 );
+    BOOST_TEST( (static_signed_max<   0, -101>::value) ==    0 );
+    BOOST_TEST( (static_signed_min<-101,    0>::value) == -101 );
+    BOOST_TEST( (static_signed_max<-101,    0>::value) ==    0 );

    // With identical
    cout << "Doing tests with two identical values." << endl;

-    BOOST_CHECK( (static_signed_min<0, 0>::value) == 0 );
-    BOOST_CHECK( (static_signed_max<0, 0>::value) == 0 );
-    BOOST_CHECK( (static_unsigned_min<0, 0>::value) == 0 );
-    BOOST_CHECK( (static_unsigned_max<0, 0>::value) == 0 );
+    BOOST_TEST( (static_signed_min<0, 0>::value) == 0 );
+    BOOST_TEST( (static_signed_max<0, 0>::value) == 0 );
+    BOOST_TEST( (static_unsigned_min<0, 0>::value) == 0 );
+    BOOST_TEST( (static_unsigned_max<0, 0>::value) == 0 );

-    BOOST_CHECK( (static_signed_min<14, 14>::value) == 14 );
-    BOOST_CHECK( (static_signed_max<14, 14>::value) == 14 );
-    BOOST_CHECK( (static_unsigned_min<14, 14>::value) == 14 );
-    BOOST_CHECK( (static_unsigned_max<14, 14>::value) == 14 );
+    BOOST_TEST( (static_signed_min<14, 14>::value) == 14 );
+    BOOST_TEST( (static_signed_max<14, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_min<14, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_max<14, 14>::value) == 14 );

-    BOOST_CHECK( (static_signed_min< -101, -101>::value) == -101 );
-    BOOST_CHECK( (static_signed_max< -101, -101>::value) == -101 );
+    BOOST_TEST( (static_signed_min< -101, -101>::value) == -101 );
+    BOOST_TEST( (static_signed_max< -101, -101>::value) == -101 );

-    return boost::exit_success;
+    return boost::report_errors();
 }