diff --git a/cast.htm b/cast.htm
index 12314e4..208b960 100644
--- a/cast.htm
+++ b/cast.htm
@@ -9,7 +9,7 @@
     <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
     <meta name="ProgId" content="FrontPage.Editor.Document">
 
-    <title>Header boost/cast.hpp Documentation</title>
+    <title>Header boost/polymorphic_cast.hpp Documentation</title>
     <style>
        .copyright
         {
@@ -22,11 +22,11 @@
   <body bgcolor="#FFFFFF" text="#000000">
     <h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align=
     "middle" width="277" height="86">Header <a href=
-    "../../boost/cast.hpp">boost/cast.hpp</a></h1>
+    "../../boost/polymorphic_cast.hpp">boost/polymorphic_cast.hpp</a></h1>
 
     <h2><a name="Cast Functions">Cast Functions</a></h2>
 
-    <p>The header <a href="../../boost/cast.hpp">boost/cast.hpp</a> provides <code>
+    <p>The header <a href="../../boost/polymorphic_cast.hpp">boost/polymorphic_cast.hpp</a> provides <code>
     <a href="#Polymorphic_cast">polymorphic_cast</a> and</code> <a href=
     "#Polymorphic_cast"><code>polymorphic_downcast</code></a> function templates designed to
     complement the C++ built-in casts.</p>
@@ -110,7 +110,7 @@ inline Derived polymorphic_downcast(Base* x);
     <h3>polymorphic_downcast example</h3>
 
     <blockquote>
-<pre>#include &lt;boost/cast.hpp&gt;
+<pre>#include &lt;boost/polymorphic_cast.hpp&gt;
 ...
 class Fruit { public: virtual ~Fruit(){}; ... };
 class Banana : public Fruit { ... };
diff --git a/doc/Jamfile.v2 b/doc/Jamfile.v2
deleted file mode 100644
index 0b47ee3..0000000
--- a/doc/Jamfile.v2
+++ /dev/null
@@ -1,16 +0,0 @@
-# Copyright Antony Polukhin 2011. 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 ;
-import boostbook : boostbook ;
-
-xml lexical_cast : lexical_cast.qbk ;
-boostbook standalone
-    :
-    lexical_cast
-    :
-        <xsl:param>boost.root=../../../..
-        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
-    ;
-
diff --git a/doc/lexical_cast.qbk b/doc/lexical_cast.qbk
deleted file mode 100644
index ad9b5f2..0000000
--- a/doc/lexical_cast.qbk
+++ /dev/null
@@ -1,986 +0,0 @@
-[library Boost.Lexical_Cast
-    [quickbook 1.5]
-    [version 1.0]
-    [copyright 2000-2005 Kevlin Henney]
-    [copyright 2006-2010 Alexander Nasonov]
-    [copyright 2011-2014 Antony Polukhin]
-    [category String and text processing]
-    [category Miscellaneous]
-    [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])
-    ]
-]
-
-[def __numericcast__  [@boost:libs/numeric/conversion/doc/html/boost_numericconversion/improved_numeric_cast__.html `boost::numeric_cast`]]
-[def __proposallong__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1973.html Lexical Conversion Library Proposal for TR2, N1973 by Kevlin Henney and Beman Dawes]]
-[def __proposalshort__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1973.html Lexical Conversion Library Proposal for TR2, N1973]]
-
-[section Motivation]
-Sometimes a value must be converted to a literal text form, such as an [c++] `int` represented as a `std::string`, or vice-versa, when a `std::string` is interpreted as an `int`. Such examples are common when converting between data types internal to a program and representation external to a program, such as windows and configuration files.
-
-The standard C and C++ libraries offer a number of facilities for performing such conversions. However, they vary with their ease of use, extensibility, and safety.
-
-For instance, there are a number of limitations with the family of standard C functions typified by `atoi`:
-
-* Conversion is supported in one direction only: from text to internal data type. Converting the other way using the C library requires either the inconvenience and compromised safety of the `sprintf` function, or the loss of portability associated with non-standard functions such as `itoa`.
-* The range of types supported is only a subset of the built-in numeric types, namely `int`, `long`, and `double`.
-* The range of types cannot be extended in a uniform manner. For instance, conversion from string representation to complex or rational.
-
-The standard C functions typified by `strtol` have the same basic limitations, but offer finer control over the conversion process. However, for the common case such control is often either not required or not used. The `scanf` family of functions offer even greater control, but also lack safety and ease of use.
-
-The standard C++ library offers `stringstream` for the kind of in-core formatting being discussed. It offers a great deal of control over the formatting and conversion of I/O to and from arbitrary types through text. However, for simple conversions direct use of `stringstream` can be either clumsy (with the introduction of extra local variables and the loss of infix-expression convenience) or obscure (where `stringstream` objects are created as temporary objects in an expression). Facets provide a comprehensive concept and facility for controlling textual representation, but their perceived complexity and high entry level requires an extreme degree of involvement for simple conversions, and excludes all but a few programmers.
-
-The `lexical_cast` function template offers a convenient and consistent form for supporting common conversions to and from arbitrary types when they are represented as text. The simplification it offers is in expression-level convenience for such conversions. For more involved conversions, such as where precision or formatting need tighter control than is offered by the default behavior of `lexical_cast`, the conventional `std::stringstream` approach is recommended. Where the conversions are numeric to numeric, __numericcast__ may offer more reasonable behavior than `lexical_cast`.
-
-For a good discussion of the options and issues involved in string-based formatting, including comparison of `stringstream`, `lexical_cast`, and others, see Herb Sutter's article, [@http://www.gotw.ca/publications/mill19.htm The String Formatters of Manor Farm]. Also, take a look at the [link boost_lexical_cast.performance Performance] section.
-[endsect]
-
-[section Examples]
-
-[import ../example/args_to_numbers.cpp]
-
-[section Strings to numbers conversion] [lexical_cast_args_example] [endsect]
-
-[import ../example/small_examples.cpp]
-[section Numbers to strings conversion] [lexical_cast_log_errno] [endsect]
-[section Converting to string without dynamic memory allocation] [lexical_cast_fixed_buffer] [endsect]
-[section Converting part of the string] [lexical_cast_substring_conversion] [endsect]
-
-[import ../example/generic_stringize.cpp]
-[section Generic programming (Boost.Fusion)] [lexical_cast_stringize] [endsect]
-
-[import ../example/variant_to_long_double.cpp]
-[section Generic programming (Boost.Variant)] [lexical_cast_variant_to_long_double] [endsect]
-
-[endsect]
-
-[section Synopsis]
-Library features defined in [@boost:boost/lexical_cast.hpp boost/lexical_cast.hpp]:
-``
-    namespace boost
-    {
-        class bad_lexical_cast;
-        
-        template<typename Target, typename Source>
-          Target lexical_cast(const Source& arg);
-
-        template <typename Target>
-          Target lexical_cast(const AnyCharacterType* chars, std::size_t count);
-
-        namespace conversion
-        {
-            template<typename Target, typename Source>
-                bool try_lexical_convert(const Source& arg, Target& result);
-
-            template <typename AnyCharacterType, typename Target>
-                bool try_lexical_convert(const AnyCharacterType* chars, std::size_t count, Target& result);
-
-        } // namespace conversion
-    } // namespace boost
-``
-
-[section lexical_cast]
-``
-    template<typename Target, typename Source>
-      Target lexical_cast(const Source& arg);
-``
-Returns the result of streaming arg into a standard library string-based stream and then out as a Target object. Where Target is either `std::string` or `std::wstring`, stream extraction takes the whole content of the string, including spaces, rather than relying on the default `operator>>` behavior. If the conversion is unsuccessful, a `bad_lexical_cast` exception is thrown.
-
-``
-    template <typename Target>
-      Target lexical_cast(const AnyCharacterType* chars, std::size_t count);
-``
-Takes an array of `count` characters as input parameter and streams them out as a Target object. If the conversion is unsuccessful, a `bad_lexical_cast` exception is thrown. This call may be useful for processing nonzero terminated array of characters or processing just some part of character array.
-
-The requirements on the argument and result types for both functions are:
-
-* Source is OutputStreamable, meaning that an `operator<<` is defined that takes a `std::ostream` or `std::wostream` object on the left hand side and an instance of the argument type on the right.
-* Target is InputStreamable, meaning that an `operator>>` is defined that takes a `std::istream` or `std::wistream` object on the left hand side and an instance of the result type on the right.
-* Target is CopyConstructible [20.1.3].
-* Target is DefaultConstructible, meaning that it is possible to default-initialize an object of that type [8.5, 20.1.4].
-
-The character type of the underlying stream is assumed to be `char` unless either the `Source` or the `Target` requires wide-character streaming, in which case the underlying stream uses `wchar_t`. Following types also can use `char16_t` or `char32_t` for wide-character streaming:
-
-* Single character: `char16_t`, `char32_t`
-* Arrays of characters: `char16_t *`, `char32_t *`, `const char16_t *`, `const char32_t *`
-* Strings: `std::basic_string`, `boost::containers::basic_string`
-* `boost::iterator_range<WideCharPtr>`, where `WideCharPtr` is a pointer to wide-character or pointer to const wide-character
-* `boost::array<CharT, N>` and `std::array<CharT, N>`, `boost::array<const CharT, N>` and `std::array<const CharT, N>` 
-
-[important Many compilers and runtime libraries fail to make conversions using new Unicode characters. Make sure that the following code compiles and outputs nonzero values, before using new types:
-``
-    std::cout
-        << boost::lexical_cast<std::u32string>(1.0).size()
-        << "  "
-        << boost::lexical_cast<std::u16string>(1.0).size();
-``
-]
-
-Where a higher degree of control is required over conversions, `std::stringstream` and `std::wstringstream` offer a more appropriate path. Where non-stream-based conversions are required, `lexical_cast` is the wrong tool for the job and is not special-cased for such scenarios.
-[endsect]
-
-[section bad_lexical_cast]
-``
-    class bad_lexical_cast : public std::bad_cast
-    {
-    public:
-        ... // same member function interface as std::exception
-    };
-``
-Exception used to indicate runtime lexical_cast failure.
-[endsect]
-
-[section try_lexical_convert]
-`boost::lexical_cast` remains the main interface for lexical conversions. It must be used by default in most cases. However
-some developers wish to make their own conversion functions, reusing all the optimizations of the `boost::lexical_cast`.
-That's where the `boost::conversion::try_lexical_convert` function steps in.
-
-`try_lexical_convert` returns `true` if conversion succeeded, otherwise returns `false`. If conversion
-failed and `false` was returned, state of `result` output variable is undefined.
-
-Actually, `boost::lexical_cast` is implemented using `try_lexical_convert`:
-``
-    template <typename Target, typename Source>
-    inline Target lexical_cast(const Source &arg)
-    {
-        Target result;
-
-        if (!conversion::try_lexical_convert(arg, result))
-            throw bad_lexical_cast();
-
-        return result;
-    }
-``
-
-`try_lexical_convert` relaxes the CopyConstructible and DefaultConstructible requirements for `Target` type.
-Following requirements for `Target` and `Source` remain:
-
-* Source must be OutputStreamable, meaning that an `operator<<` is defined that takes a `std::ostream` or `std::wostream` object on the left hand side and an instance of the argument type on the right.
-* Target must be InputStreamable, meaning that an `operator>>` is defined that takes a `std::istream` or `std::wistream` object on the left hand side and an instance of the result type on the right.
-
-[endsect]
-
-
-[endsect]
-
-[section Frequently Asked Questions]
-
-* [*Question:]    Why does `lexical_cast<int8_t>("127")` throw `bad_lexical_cast`?
-  * [*Answer:]      The type `int8_t` is a `typedef` to `char` or `signed char`. Lexical conversion to these types is simply reading a byte from source but since the source has more than one byte, the exception is thrown.
-Please use other integer types such as `int` or `short int`. If bounds checking is important, you can also
-call __numericcast__:
-`numeric_cast<int8_t>(lexical_cast<int>("127"));`
-
-[pre
-]
-
-* [*Question:]    Why does `lexical_cast<unsigned char>("127")` throw `bad_lexical_cast`?
-  * [*Answer:]      Lexical conversion to any char type is simply reading a byte from source. But since the source has more than one byte, the exception is thrown.
-Please use other integer types such as `int` or `short int`. If bounds checking is important, you can also
-call __numericcast__:
-`numeric_cast<unsigned char>(lexical_cast<int>("127"));`
-
-[pre
-]
-
-* [*Question:]    What does `lexical_cast<std::string>` of an `int8_t` or `uint8_t` not do what I expect?
-  * [*Answer:]      As above, note that int8_t and uint8_t are actually chars and are formatted as such. To avoid
-this, cast to an integer type first: `lexical_cast<std::string>(static_cast<int>(n));`
-
-[pre
-]
-
-* [*Question:]    The implementation always resets the `ios_base::skipws` flag of an underlying stream object.
-It breaks my `operator>>` that works only in presence of this flag. Can you remove code that resets the flag?
-  * [*Answer:]      May be in a future version. There is no requirement in
-__proposallong__ to reset the flag but
-remember that __proposalshort__ is not yet accepted by the committee. By the way, it's a great opportunity to
-make your `operator>>` more general.
-Read a good C++ book, study `std::sentry` and [@boost:libs/io/doc/ios_state.html `ios_state_saver`].
-
-[pre
-]
-
-* [*Question:]    Why `std::cout << boost::lexical_cast<unsigned int>("-1");` does not throw, but outputs 4294967295?
-  * [*Answer:]      `boost::lexical_cast` has the behavior of `std::stringstream`, which uses `num_get` functions of
-`std::locale` to convert numbers. If we look at the Programming languages — C++, we'll see, that `num_get` uses
-the rules of `scanf` for conversions. And in the C99 standard for unsigned input value minus sign is optional, so
-if a negative number is read, no errors will arise and the result will be the two's complement.
-
-[pre
-]
-
-* [*Question:]    Why `boost::lexical_cast<int>(L'A');` outputs 65 and `boost::lexical_cast<wchar_t>(L"65");` does not throw?
-  * [*Answer:]      If you are using an old version of Visual Studio or compile code with /Zc:wchar_t- flag,
-`boost::lexical_cast` sees single `wchar_t` character as `unsigned short`. It is not a `boost::lexical_cast` mistake, but a
-limitation of compiler options that you use.
-
-[pre
-]
-
-* [*Question:]    Why `boost::lexical_cast<double>("-1.#IND");` throws `boost::bad_lexical_cast`?
-  * [*Answer:]      `"-1.#IND"` is a compiler extension, that violates standard. You shall input `"-nan"`, `"nan"`, `"inf"`
-, `"-inf"` (case insensitive) strings to get NaN and Inf values. `boost::lexical_cast<string>` outputs `"-nan"`, `"nan"`,
-`"inf"`, `"-inf"` strings, when has NaN or Inf input values.
-
-[pre
-]
-
-* [*Question:]    What is the fastest way to convert a non zero terminated string or a substring using `boost::lexical_cast`?
-  * [*Answer:]      Use `boost::iterator_range` for conversion or `lexical_cast` overload with two parameters. For example, if you whant to convert to `int` two characters from a string `str`, you shall write `lexical_cast<int>(make_iterator_range(str.data(), str.data() + 2));` or `lexical_cast<int>(str.data(), 2);`.
-
-[endsect]
-
-[section Changes]
-
-* [*boost 1.56.0 :]
-
-    * Added `boost::conversion::try_lexical_convert` functions.
-
-* [*boost 1.54.0 :]
-
-    * Fix some issues with `boost::int128_type` and `boost::uint128_type` conversions. Notify user at compile time 
-      if the `std::numeric_limits` are not specialized for 128bit types and `boost::lexical_cast` can not make conversions.
-
-* [*boost 1.54.0 :]
-
-    * Added code to convert `boost::int128_type` and `boost::uint128_type` types (requires GCC 4.7 or higher).
-    * Conversions to pointers will now fail to compile, instead of throwing at runtime.
-    * Restored ability to get pointers to `lexical_cast` function (was broken in 1.53.0).
-
-* [*boost 1.53.0 :]
-
-    * Much better input and output streams detection for user defined types.
-
-* [*boost 1.52.0 :]
-
-    * Restored compilation on MSVC-2003 (was broken in 1.51.0).
-    * Added `lexical_cast(const CharType* chars, std::size_t count)` function overload.
-    
-* [*boost 1.51.0 :]
-
-    * Better performance, less memory usage for `boost::array<character_type, N>` and `std::array<character_type, N>` conversions.
-
-* [*boost 1.50.0 :]
-
-    * `boost::bad_lexical_cast` exception is now globaly visible and can be catched even if code is compiled with -fvisibility=hidden.
-    * Now it is possible to compile library with disabled exceptions.
-    * Better performance, less memory usage and bugfixes for `boost::iterator_range<character_type*>` conversions.
-
-* [*boost 1.49.0 :]
-
-    * Restored work with typedefed wchar_t (compilation flag /Zc:wchar_t- for Visual Studio).
-    * Better performance and less memory usage for `boost::container::basic_string` conversions.
-
-* [*boost 1.48.0 :]
-
-    * Added code to work with Inf and NaN on any platform.
-    * Better performance and less memory usage for conversions to float type (and to double type, if `sizeof(double) < sizeof(long double)`).
-
-* [*boost 1.47.0 :]
-
-    * Optimizations for "C" and other locales without number grouping.
-    * Better performance and less memory usage for unsigned char and signed char conversions.
-    * Better performance and less memory usage for conversions to arithmetic types.
-    * Better performance and less memory usage for conversions from arithmetic type to arithmetic type.
-    * Directly construct Target from Source on some conversions (like conversions from string to string, from char array to string, from char to char and others).
-
-* [*boost 1.34.0 :]
-
-    * Better performance for many combinations of Source and Target types. For more details refer to Alexander Nasonovs article [@http://accu.org/index.php/journals/1375 Fine Tuning for lexical_cast, Overload #74, August 2006] [@http://www.accu.org/var/uploads/journals/overload74.pdf (PDF)].
-
-* [*boost 1.33.0 :]
-
-    * Call-by-const reference for the parameters. This requires partial specialization of class templates, so it doesn't work for MSVC 6, and it uses the original pass by value there.
-    * The MSVC 6 support is deprecated, and will be removed in a future Boost version.
-
-* [*Earlier :]
-
-    * The previous version of lexical_cast used the default stream precision for reading and writing floating-point numbers. For numerics that have a corresponding specialization of `std::numeric_limits`, the current version now chooses a precision to match.
-    * The previous version of lexical_cast did not support conversion to or from any wide-character-based types. For compilers with full language and library support for wide characters, `lexical_cast` now supports conversions from `wchar_t`, `wchar_t *`, and `std::wstring` and to `wchar_t` and `std::wstring`.
-    * The previous version of `lexical_cast` assumed that the conventional stream extractor operators were sufficient for reading values. However, string I/O is asymmetric, with the result that spaces play the role of I/O separators rather than string content. The current version fixes this error for `std::string` and, where supported, `std::wstring`: `lexical_cast<std::string>("Hello, World")` succeeds instead of failing with a `bad_lexical_cast` exception.
-    * The previous version of `lexical_cast` allowed unsafe and meaningless conversions to pointers. The current version now throws a `bad_lexical_cast` for conversions to pointers: `lexical_cast<char *>("Goodbye, World")` now throws an exception instead of causing undefined behavior.
-
-[endsect]
-
-[section Performance]
-
-In most cases `boost::lexical_cast` is faster than `scanf`, `printf`, `std::stringstream`. For more detailed info you can look at the tables below.
-
-[section Tests description]
-All the tests measure execution speed in milliseconds for 10000 iterations of the following code blocks:
-[table:legend Tests source code
-[[Test name] [Code]]
-[[lexical_cast]
-  [``
-            _out = boost::lexical_cast<OUTTYPE>(_in);
-  ``]
-  ]
-[[std::stringstream with construction]
-  [``
-            std::stringstream ss;
-            ss << _in;
-            if (ss.fail()) throw std::logic_error(descr);
-            ss >> _out;
-            if (ss.fail()) throw std::logic_error(descr);
-  ``]
-  ]
-[[std::stringstream without construction]
-  [``
-            ss << _in; // ss is an instance of std::stringstream
-            if (ss.fail()) throw std::logic_error(descr);
-            ss >> _out;
-            if (ss.fail()) throw std::logic_error(descr);
-            /* reseting std::stringstream to use it again */
-            ss.str(std::string());
-            ss.clear();
-  ``]
-  ]
-[[scanf/printf]
-  [``
-            typename OUTTYPE::value_type buffer[500];
-            sprintf( (char*)buffer, conv, _in);
-            _out = buffer;
-  ``]
-  ]
-]
-Fastest results are highlitened with "!!! *x* !!!".
-Do not use this results to compare compilers, because tests were taken on different hardware.
-
-[endsect]
-
-[/ BEGIN of section, generated by performance measuring program ]
-
-
-[section Clang version 3.0 (tags/RELEASE_30/final)]
-[table:id Performance Table ( Clang version 3.0 (tags/RELEASE_30/final))
-[[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
-  [[ string->char ][ !!! *<1* !!! ][ 169 ][ 9 ][ 10 ]]
-  [[ string->signed char ][ !!! *<1* !!! ][ 108 ][ 8 ][ 10 ]]
-  [[ string->unsigned char ][ !!! *<1* !!! ][ 103 ][ 9 ][ 10 ]]
-  [[ string->int ][ !!! *6* !!! ][ 117 ][ 24 ][ 24 ]]
-  [[ string->short ][ !!! *7* !!! ][ 115 ][ 20 ][ 24 ]]
-  [[ string->long int ][ !!! *7* !!! ][ 115 ][ 19 ][ 22 ]]
-  [[ string->long long ][ !!! *8* !!! ][ 116 ][ 21 ][ 23 ]]
-  [[ string->unsigned int ][ !!! *6* !!! ][ 121 ][ 18 ][ 23 ]]
-  [[ string->unsigned short ][ !!! *6* !!! ][ 116 ][ 19 ][ 22 ]]
-  [[ string->unsigned long int ][ !!! *7* !!! ][ 117 ][ 23 ][ 21 ]]
-  [[ string->unsigned long long ][ !!! *8* !!! ][ 118 ][ 19 ][ 34 ]]
-  [[ string->float ][ !!! *13* !!! ][ 201 ][ 55 ][ 41 ]]
-  [[ string->double ][ !!! *14* !!! ][ 151 ][ 54 ][ 41 ]]
-  [[ string->long double ][ 195 ][ 231 ][ 67 ][ !!! *42* !!! ]]
-  [[ string->array<char, 50> ][ !!! *<1* !!! ][ 121 ][ 18 ][ 12 ]]
-  [[ string->string ][ !!! *1* !!! ][ 124 ][ 27 ][ --- ]]
-  [[ string->container::string ][ !!! *3* !!! ][ 114 ][ 25 ][ --- ]]
-  [[ string->char ][ 7 ][ 111 ][ 25 ][ !!! *7* !!! ]]
-  [[ string->signed char ][ !!! *6* !!! ][ 112 ][ 30 ][ 26 ]]
-  [[ string->unsigned char ][ !!! *6* !!! ][ 113 ][ 25 ][ 24 ]]
-  [[ int->string ][ !!! *12* !!! ][ 126 ][ 36 ][ 21 ]]
-  [[ short->string ][ !!! *11* !!! ][ 135 ][ 30 ][ 21 ]]
-  [[ long int->string ][ !!! *11* !!! ][ 128 ][ 28 ][ 21 ]]
-  [[ long long->string ][ !!! *12* !!! ][ 126 ][ 32 ][ 24 ]]
-  [[ unsigned int->string ][ !!! *11* !!! ][ 131 ][ 36 ][ 22 ]]
-  [[ unsigned short->string ][ !!! *11* !!! ][ 130 ][ 28 ][ 22 ]]
-  [[ unsigned long int->string ][ !!! *11* !!! ][ 130 ][ 36 ][ 22 ]]
-  [[ unsigned long long->string ][ !!! *11* !!! ][ 127 ][ 43 ][ 25 ]]
-  [[ float->string ][ 53 ][ 190 ][ 83 ][ !!! *41* !!! ]]
-  [[ double->string ][ 59 ][ 197 ][ 82 ][ !!! *44* !!! ]]
-  [[ long double->string ][ 118 ][ 229 ][ 101 ][ !!! *44* !!! ]]
-  [[ char*->char ][ !!! *1* !!! ][ 105 ][ 9 ][ 9 ]]
-  [[ char*->signed char ][ !!! *1* !!! ][ 107 ][ 10 ][ 10 ]]
-  [[ char*->unsigned char ][ !!! *1* !!! ][ 106 ][ 9 ][ 11 ]]
-  [[ char*->int ][ !!! *7* !!! ][ 149 ][ 25 ][ 24 ]]
-  [[ char*->short ][ !!! *7* !!! ][ 118 ][ 20 ][ 22 ]]
-  [[ char*->long int ][ !!! *9* !!! ][ 117 ][ 20 ][ 28 ]]
-  [[ char*->long long ][ !!! *9* !!! ][ 128 ][ 23 ][ 29 ]]
-  [[ char*->unsigned int ][ !!! *7* !!! ][ 120 ][ 19 ][ 23 ]]
-  [[ char*->unsigned short ][ !!! *7* !!! ][ 125 ][ 20 ][ 22 ]]
-  [[ char*->unsigned long int ][ !!! *8* !!! ][ 125 ][ 21 ][ 24 ]]
-  [[ char*->unsigned long long ][ !!! *8* !!! ][ 130 ][ 19 ][ 22 ]]
-  [[ char*->float ][ !!! *14* !!! ][ 162 ][ 56 ][ 41 ]]
-  [[ char*->double ][ !!! *16* !!! ][ 151 ][ 54 ][ 39 ]]
-  [[ char*->long double ][ 111 ][ 176 ][ 58 ][ !!! *42* !!! ]]
-  [[ char*->array<char, 50> ][ !!! *1* !!! ][ 116 ][ 20 ][ 17 ]]
-  [[ char*->string ][ !!! *8* !!! ][ 125 ][ 27 ][ --- ]]
-  [[ char*->container::string ][ !!! *2* !!! ][ 115 ][ 26 ][ --- ]]
-  [[ unsigned char*->char ][ !!! *1* !!! ][ 101 ][ 9 ][ 9 ]]
-  [[ unsigned char*->signed char ][ !!! *1* !!! ][ 104 ][ 9 ][ 11 ]]
-  [[ unsigned char*->unsigned char ][ !!! *1* !!! ][ 103 ][ 9 ][ 13 ]]
-  [[ unsigned char*->int ][ !!! *8* !!! ][ 116 ][ 20 ][ 24 ]]
-  [[ unsigned char*->short ][ !!! *7* !!! ][ 121 ][ 20 ][ 26 ]]
-  [[ unsigned char*->long int ][ !!! *8* !!! ][ 118 ][ 20 ][ 22 ]]
-  [[ unsigned char*->long long ][ !!! *8* !!! ][ 122 ][ 20 ][ 23 ]]
-  [[ unsigned char*->unsigned int ][ !!! *6* !!! ][ 119 ][ 22 ][ 23 ]]
-  [[ unsigned char*->unsigned short ][ !!! *7* !!! ][ 122 ][ 20 ][ 22 ]]
-  [[ unsigned char*->unsigned long int ][ !!! *8* !!! ][ 125 ][ 21 ][ 22 ]]
-  [[ unsigned char*->unsigned long long ][ !!! *8* !!! ][ 122 ][ 19 ][ 25 ]]
-  [[ unsigned char*->float ][ !!! *14* !!! ][ 162 ][ 62 ][ 37 ]]
-  [[ unsigned char*->double ][ !!! *15* !!! ][ 151 ][ 58 ][ 39 ]]
-  [[ unsigned char*->long double ][ 116 ][ 156 ][ 58 ][ !!! *42* !!! ]]
-  [[ unsigned char*->array<char, 50> ][ !!! *1* !!! ][ 122 ][ 19 ][ 15 ]]
-  [[ unsigned char*->string ][ !!! *8* !!! ][ 124 ][ 27 ][ --- ]]
-  [[ unsigned char*->container::string ][ !!! *4* !!! ][ 119 ][ 25 ][ --- ]]
-  [[ signed char*->char ][ !!! *1* !!! ][ 107 ][ 9 ][ 9 ]]
-  [[ signed char*->signed char ][ !!! *1* !!! ][ 108 ][ 10 ][ 11 ]]
-  [[ signed char*->unsigned char ][ !!! *1* !!! ][ 106 ][ 9 ][ 11 ]]
-  [[ signed char*->int ][ !!! *7* !!! ][ 122 ][ 21 ][ 22 ]]
-  [[ signed char*->short ][ !!! *7* !!! ][ 126 ][ 20 ][ 22 ]]
-  [[ signed char*->long int ][ !!! *8* !!! ][ 119 ][ 20 ][ 23 ]]
-  [[ signed char*->long long ][ !!! *8* !!! ][ 119 ][ 21 ][ 26 ]]
-  [[ signed char*->unsigned int ][ !!! *6* !!! ][ 124 ][ 18 ][ 22 ]]
-  [[ signed char*->unsigned short ][ !!! *7* !!! ][ 124 ][ 21 ][ 23 ]]
-  [[ signed char*->unsigned long int ][ !!! *8* !!! ][ 121 ][ 24 ][ 23 ]]
-  [[ signed char*->unsigned long long ][ !!! *8* !!! ][ 122 ][ 20 ][ 22 ]]
-  [[ signed char*->float ][ !!! *14* !!! ][ 167 ][ 56 ][ 37 ]]
-  [[ signed char*->double ][ !!! *14* !!! ][ 162 ][ 53 ][ 40 ]]
-  [[ signed char*->long double ][ 110 ][ 152 ][ 56 ][ !!! *42* !!! ]]
-  [[ signed char*->array<char, 50> ][ !!! *1* !!! ][ 117 ][ 19 ][ 12 ]]
-  [[ signed char*->string ][ !!! *8* !!! ][ 132 ][ 27 ][ --- ]]
-  [[ signed char*->container::string ][ !!! *4* !!! ][ 116 ][ 26 ][ --- ]]
-  [[ iterator_range<char*>->char ][ !!! *<1* !!! ][ 112 ][ 14 ][ 9 ]]
-  [[ iterator_range<char*>->signed char ][ !!! *<1* !!! ][ 107 ][ 13 ][ 10 ]]
-  [[ iterator_range<char*>->unsigned char ][ !!! *<1* !!! ][ 145 ][ 15 ][ 10 ]]
-  [[ iterator_range<char*>->int ][ !!! *6* !!! ][ 119 ][ 22 ][ 23 ]]
-  [[ iterator_range<char*>->short ][ !!! *6* !!! ][ 115 ][ 22 ][ 23 ]]
-  [[ iterator_range<char*>->long int ][ !!! *7* !!! ][ 115 ][ 25 ][ 22 ]]
-  [[ iterator_range<char*>->long long ][ !!! *7* !!! ][ 117 ][ 21 ][ 23 ]]
-  [[ iterator_range<char*>->unsigned int ][ !!! *6* !!! ][ 118 ][ 22 ][ 22 ]]
-  [[ iterator_range<char*>->unsigned short ][ !!! *6* !!! ][ 117 ][ 24 ][ 22 ]]
-  [[ iterator_range<char*>->unsigned long int ][ !!! *7* !!! ][ 124 ][ 25 ][ 22 ]]
-  [[ iterator_range<char*>->unsigned long long ][ !!! *7* !!! ][ 119 ][ 22 ][ 22 ]]
-  [[ iterator_range<char*>->float ][ !!! *13* !!! ][ 159 ][ 42 ][ 41 ]]
-  [[ iterator_range<char*>->double ][ !!! *14* !!! ][ 152 ][ 40 ][ 40 ]]
-  [[ iterator_range<char*>->long double ][ 113 ][ 155 ][ 58 ][ !!! *54* !!! ]]
-  [[ iterator_range<char*>->array<char, 50> ][ !!! *<1* !!! ][ 127 ][ 23 ][ 13 ]]
-  [[ iterator_range<char*>->string ][ !!! *7* !!! ][ 132 ][ 30 ][ --- ]]
-  [[ iterator_range<char*>->container::string ][ !!! *3* !!! ][ 122 ][ 24 ][ --- ]]
-  [[ array<char, 50>->char ][ !!! *<1* !!! ][ 110 ][ 9 ][ 10 ]]
-  [[ array<char, 50>->signed char ][ !!! *<1* !!! ][ 119 ][ 9 ][ 13 ]]
-  [[ array<char, 50>->unsigned char ][ !!! *<1* !!! ][ 106 ][ 13 ][ 11 ]]
-  [[ array<char, 50>->int ][ !!! *6* !!! ][ 131 ][ 21 ][ 22 ]]
-  [[ array<char, 50>->short ][ !!! *7* !!! ][ 119 ][ 22 ][ 28 ]]
-  [[ array<char, 50>->long int ][ !!! *8* !!! ][ 133 ][ 21 ][ 26 ]]
-  [[ array<char, 50>->long long ][ !!! *8* !!! ][ 115 ][ 22 ][ 23 ]]
-  [[ array<char, 50>->unsigned int ][ !!! *6* !!! ][ 118 ][ 18 ][ 22 ]]
-  [[ array<char, 50>->unsigned short ][ !!! *7* !!! ][ 119 ][ 19 ][ 22 ]]
-  [[ array<char, 50>->unsigned long int ][ !!! *7* !!! ][ 118 ][ 23 ][ 21 ]]
-  [[ array<char, 50>->unsigned long long ][ !!! *7* !!! ][ 117 ][ 20 ][ 22 ]]
-  [[ array<char, 50>->float ][ !!! *15* !!! ][ 156 ][ 53 ][ 36 ]]
-  [[ array<char, 50>->double ][ !!! *15* !!! ][ 148 ][ 55 ][ 39 ]]
-  [[ array<char, 50>->long double ][ 110 ][ 150 ][ 56 ][ !!! *41* !!! ]]
-  [[ array<char, 50>->array<char, 50> ][ !!! *<1* !!! ][ 117 ][ 19 ][ 12 ]]
-  [[ array<char, 50>->string ][ !!! *7* !!! ][ 124 ][ 26 ][ --- ]]
-  [[ array<char, 50>->container::string ][ !!! *4* !!! ][ 115 ][ 26 ][ --- ]]
-  [[ int->int ][ !!! *<1* !!! ][ 117 ][ 24 ][ --- ]]
-  [[ float->double ][ !!! *<1* !!! ][ 245 ][ 125 ][ --- ]]
-  [[ char->signed char ][ !!! *<1* !!! ][ 100 ][ 9 ][ --- ]]
-]
-[endsect]
-
-[section GNU C++ version 4.6.3]
-[table:id Performance Table ( GNU C++ version 4.6.3)
-[[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
-  [[ string->char ][ !!! *<1* !!! ][ 142 ][ 10 ][ 18 ]]
-  [[ string->signed char ][ !!! *<1* !!! ][ 111 ][ 8 ][ 10 ]]
-  [[ string->unsigned char ][ !!! *<1* !!! ][ 101 ][ 8 ][ 10 ]]
-  [[ string->int ][ !!! *7* !!! ][ 110 ][ 20 ][ 24 ]]
-  [[ string->short ][ !!! *6* !!! ][ 109 ][ 20 ][ 25 ]]
-  [[ string->long int ][ !!! *7* !!! ][ 113 ][ 19 ][ 24 ]]
-  [[ string->long long ][ !!! *7* !!! ][ 116 ][ 24 ][ 23 ]]
-  [[ string->unsigned int ][ !!! *6* !!! ][ 110 ][ 19 ][ 23 ]]
-  [[ string->unsigned short ][ !!! *5* !!! ][ 116 ][ 18 ][ 23 ]]
-  [[ string->unsigned long int ][ !!! *7* !!! ][ 111 ][ 22 ][ 23 ]]
-  [[ string->unsigned long long ][ !!! *7* !!! ][ 108 ][ 20 ][ 22 ]]
-  [[ string->float ][ !!! *11* !!! ][ 161 ][ 54 ][ 38 ]]
-  [[ string->double ][ !!! *11* !!! ][ 146 ][ 56 ][ 41 ]]
-  [[ string->long double ][ 113 ][ 151 ][ 59 ][ !!! *43* !!! ]]
-  [[ string->array<char, 50> ][ !!! *<1* !!! ][ 107 ][ 18 ][ 14 ]]
-  [[ string->string ][ !!! *2* !!! ][ 127 ][ 24 ][ --- ]]
-  [[ string->container::string ][ !!! *3* !!! ][ 142 ][ 26 ][ --- ]]
-  [[ string->char ][ !!! *7* !!! ][ 110 ][ 23 ][ 17 ]]
-  [[ string->signed char ][ !!! *7* !!! ][ 114 ][ 23 ][ 24 ]]
-  [[ string->unsigned char ][ !!! *7* !!! ][ 110 ][ 25 ][ 24 ]]
-  [[ int->string ][ !!! *12* !!! ][ 127 ][ 31 ][ 22 ]]
-  [[ short->string ][ !!! *13* !!! ][ 129 ][ 31 ][ 22 ]]
-  [[ long int->string ][ !!! *12* !!! ][ 125 ][ 30 ][ 22 ]]
-  [[ long long->string ][ !!! *13* !!! ][ 127 ][ 34 ][ 24 ]]
-  [[ unsigned int->string ][ !!! *13* !!! ][ 127 ][ 27 ][ 21 ]]
-  [[ unsigned short->string ][ !!! *12* !!! ][ 127 ][ 28 ][ 22 ]]
-  [[ unsigned long int->string ][ !!! *12* !!! ][ 131 ][ 27 ][ 22 ]]
-  [[ unsigned long long->string ][ !!! *12* !!! ][ 125 ][ 28 ][ 24 ]]
-  [[ float->string ][ 51 ][ 200 ][ 81 ][ !!! *40* !!! ]]
-  [[ double->string ][ 56 ][ 194 ][ 82 ][ !!! *48* !!! ]]
-  [[ long double->string ][ 65 ][ 220 ][ 82 ][ !!! *41* !!! ]]
-  [[ char*->char ][ !!! *<1* !!! ][ 104 ][ 10 ][ 9 ]]
-  [[ char*->signed char ][ !!! *<1* !!! ][ 101 ][ 10 ][ 11 ]]
-  [[ char*->unsigned char ][ !!! *<1* !!! ][ 99 ][ 10 ][ 12 ]]
-  [[ char*->int ][ !!! *6* !!! ][ 112 ][ 23 ][ 24 ]]
-  [[ char*->short ][ !!! *6* !!! ][ 115 ][ 21 ][ 23 ]]
-  [[ char*->long int ][ !!! *8* !!! ][ 111 ][ 21 ][ 24 ]]
-  [[ char*->long long ][ !!! *9* !!! ][ 112 ][ 21 ][ 30 ]]
-  [[ char*->unsigned int ][ !!! *7* !!! ][ 112 ][ 22 ][ 24 ]]
-  [[ char*->unsigned short ][ !!! *6* !!! ][ 119 ][ 19 ][ 23 ]]
-  [[ char*->unsigned long int ][ !!! *7* !!! ][ 115 ][ 22 ][ 23 ]]
-  [[ char*->unsigned long long ][ !!! *7* !!! ][ 115 ][ 20 ][ 23 ]]
-  [[ char*->float ][ !!! *12* !!! ][ 153 ][ 54 ][ 39 ]]
-  [[ char*->double ][ !!! *12* !!! ][ 153 ][ 61 ][ 41 ]]
-  [[ char*->long double ][ 108 ][ 160 ][ 61 ][ !!! *49* !!! ]]
-  [[ char*->array<char, 50> ][ !!! *<1* !!! ][ 107 ][ 20 ][ 14 ]]
-  [[ char*->string ][ !!! *7* !!! ][ 123 ][ 26 ][ --- ]]
-  [[ char*->container::string ][ !!! *2* !!! ][ 121 ][ 24 ][ --- ]]
-  [[ unsigned char*->char ][ !!! *<1* !!! ][ 97 ][ 10 ][ 9 ]]
-  [[ unsigned char*->signed char ][ !!! *<1* !!! ][ 98 ][ 10 ][ 12 ]]
-  [[ unsigned char*->unsigned char ][ !!! *<1* !!! ][ 99 ][ 11 ][ 12 ]]
-  [[ unsigned char*->int ][ !!! *6* !!! ][ 112 ][ 22 ][ 24 ]]
-  [[ unsigned char*->short ][ !!! *10* !!! ][ 111 ][ 24 ][ 24 ]]
-  [[ unsigned char*->long int ][ !!! *8* !!! ][ 110 ][ 23 ][ 24 ]]
-  [[ unsigned char*->long long ][ !!! *9* !!! ][ 115 ][ 21 ][ 25 ]]
-  [[ unsigned char*->unsigned int ][ !!! *6* !!! ][ 111 ][ 24 ][ 23 ]]
-  [[ unsigned char*->unsigned short ][ !!! *6* !!! ][ 118 ][ 19 ][ 23 ]]
-  [[ unsigned char*->unsigned long int ][ !!! *8* !!! ][ 112 ][ 21 ][ 23 ]]
-  [[ unsigned char*->unsigned long long ][ !!! *13* !!! ][ 109 ][ 20 ][ 23 ]]
-  [[ unsigned char*->float ][ !!! *12* !!! ][ 154 ][ 56 ][ 39 ]]
-  [[ unsigned char*->double ][ !!! *17* !!! ][ 150 ][ 58 ][ 41 ]]
-  [[ unsigned char*->long double ][ 108 ][ 149 ][ 68 ][ !!! *43* !!! ]]
-  [[ unsigned char*->array<char, 50> ][ !!! *1* !!! ][ 107 ][ 19 ][ 15 ]]
-  [[ unsigned char*->string ][ !!! *8* !!! ][ 124 ][ 26 ][ --- ]]
-  [[ unsigned char*->container::string ][ !!! *4* !!! ][ 121 ][ 24 ][ --- ]]
-  [[ signed char*->char ][ !!! *<1* !!! ][ 99 ][ 10 ][ 9 ]]
-  [[ signed char*->signed char ][ !!! *<1* !!! ][ 99 ][ 10 ][ 10 ]]
-  [[ signed char*->unsigned char ][ !!! *<1* !!! ][ 99 ][ 10 ][ 12 ]]
-  [[ signed char*->int ][ !!! *6* !!! ][ 113 ][ 28 ][ 24 ]]
-  [[ signed char*->short ][ !!! *6* !!! ][ 110 ][ 21 ][ 25 ]]
-  [[ signed char*->long int ][ !!! *8* !!! ][ 110 ][ 21 ][ 24 ]]
-  [[ signed char*->long long ][ !!! *9* !!! ][ 116 ][ 21 ][ 24 ]]
-  [[ signed char*->unsigned int ][ !!! *7* !!! ][ 114 ][ 21 ][ 23 ]]
-  [[ signed char*->unsigned short ][ !!! *6* !!! ][ 116 ][ 20 ][ 23 ]]
-  [[ signed char*->unsigned long int ][ !!! *8* !!! ][ 113 ][ 27 ][ 23 ]]
-  [[ signed char*->unsigned long long ][ !!! *8* !!! ][ 110 ][ 20 ][ 23 ]]
-  [[ signed char*->float ][ !!! *12* !!! ][ 155 ][ 53 ][ 44 ]]
-  [[ signed char*->double ][ !!! *13* !!! ][ 150 ][ 60 ][ 42 ]]
-  [[ signed char*->long double ][ 108 ][ 151 ][ 62 ][ !!! *44* !!! ]]
-  [[ signed char*->array<char, 50> ][ !!! *1* !!! ][ 107 ][ 19 ][ 15 ]]
-  [[ signed char*->string ][ !!! *8* !!! ][ 124 ][ 26 ][ --- ]]
-  [[ signed char*->container::string ][ !!! *4* !!! ][ 121 ][ 24 ][ --- ]]
-  [[ iterator_range<char*>->char ][ !!! *<1* !!! ][ 103 ][ 14 ][ 10 ]]
-  [[ iterator_range<char*>->signed char ][ !!! *<1* !!! ][ 102 ][ 15 ][ 12 ]]
-  [[ iterator_range<char*>->unsigned char ][ !!! *<1* !!! ][ 102 ][ 14 ][ 12 ]]
-  [[ iterator_range<char*>->int ][ !!! *6* !!! ][ 115 ][ 23 ][ 24 ]]
-  [[ iterator_range<char*>->short ][ !!! *5* !!! ][ 110 ][ 22 ][ 24 ]]
-  [[ iterator_range<char*>->long int ][ !!! *7* !!! ][ 109 ][ 22 ][ 29 ]]
-  [[ iterator_range<char*>->long long ][ !!! *7* !!! ][ 111 ][ 24 ][ 28 ]]
-  [[ iterator_range<char*>->unsigned int ][ !!! *6* !!! ][ 114 ][ 22 ][ 23 ]]
-  [[ iterator_range<char*>->unsigned short ][ !!! *5* !!! ][ 115 ][ 20 ][ 22 ]]
-  [[ iterator_range<char*>->unsigned long int ][ !!! *7* !!! ][ 123 ][ 26 ][ 23 ]]
-  [[ iterator_range<char*>->unsigned long long ][ !!! *7* !!! ][ 110 ][ 23 ][ 24 ]]
-  [[ iterator_range<char*>->float ][ !!! *11* !!! ][ 153 ][ 38 ][ 38 ]]
-  [[ iterator_range<char*>->double ][ !!! *11* !!! ][ 140 ][ 43 ][ 40 ]]
-  [[ iterator_range<char*>->long double ][ 108 ][ 147 ][ !!! *41* !!! ][ 46 ]]
-  [[ iterator_range<char*>->array<char, 50> ][ !!! *<1* !!! ][ 109 ][ 22 ][ 15 ]]
-  [[ iterator_range<char*>->string ][ !!! *8* !!! ][ 122 ][ 29 ][ --- ]]
-  [[ iterator_range<char*>->container::string ][ !!! *3* !!! ][ 117 ][ 23 ][ --- ]]
-  [[ array<char, 50>->char ][ !!! *<1* !!! ][ 98 ][ 10 ][ 9 ]]
-  [[ array<char, 50>->signed char ][ !!! *<1* !!! ][ 99 ][ 9 ][ 12 ]]
-  [[ array<char, 50>->unsigned char ][ !!! *<1* !!! ][ 102 ][ 9 ][ 12 ]]
-  [[ array<char, 50>->int ][ !!! *6* !!! ][ 119 ][ 23 ][ 23 ]]
-  [[ array<char, 50>->short ][ !!! *6* !!! ][ 111 ][ 21 ][ 26 ]]
-  [[ array<char, 50>->long int ][ !!! *7* !!! ][ 115 ][ 20 ][ 28 ]]
-  [[ array<char, 50>->long long ][ !!! *9* !!! ][ 110 ][ 21 ][ 26 ]]
-  [[ array<char, 50>->unsigned int ][ !!! *6* !!! ][ 115 ][ 22 ][ 23 ]]
-  [[ array<char, 50>->unsigned short ][ !!! *6* !!! ][ 115 ][ 19 ][ 23 ]]
-  [[ array<char, 50>->unsigned long int ][ !!! *7* !!! ][ 118 ][ 23 ][ 23 ]]
-  [[ array<char, 50>->unsigned long long ][ !!! *7* !!! ][ 109 ][ 20 ][ 24 ]]
-  [[ array<char, 50>->float ][ !!! *12* !!! ][ 160 ][ 53 ][ 38 ]]
-  [[ array<char, 50>->double ][ !!! *11* !!! ][ 147 ][ 57 ][ 41 ]]
-  [[ array<char, 50>->long double ][ 109 ][ 154 ][ 59 ][ !!! *42* !!! ]]
-  [[ array<char, 50>->array<char, 50> ][ !!! *1* !!! ][ 105 ][ 19 ][ 14 ]]
-  [[ array<char, 50>->string ][ !!! *8* !!! ][ 129 ][ 26 ][ --- ]]
-  [[ array<char, 50>->container::string ][ !!! *4* !!! ][ 116 ][ 25 ][ --- ]]
-  [[ int->int ][ !!! *<1* !!! ][ 118 ][ 24 ][ --- ]]
-  [[ float->double ][ !!! *<1* !!! ][ 242 ][ 132 ][ --- ]]
-  [[ char->signed char ][ !!! *<1* !!! ][ 94 ][ 8 ][ --- ]]
-]
-[endsect]
-
-[section GNU C++ version 4.5.3]
-[table:id Performance Table ( GNU C++ version 4.5.3)
-[[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
-  [[ string->char ][ !!! *<1* !!! ][ 153 ][ 15 ][ 9 ]]
-  [[ string->signed char ][ !!! *<1* !!! ][ 134 ][ 8 ][ 10 ]]
-  [[ string->unsigned char ][ !!! *<1* !!! ][ 97 ][ 8 ][ 14 ]]
-  [[ string->int ][ !!! *7* !!! ][ 115 ][ 22 ][ 22 ]]
-  [[ string->short ][ !!! *5* !!! ][ 112 ][ 19 ][ 21 ]]
-  [[ string->long int ][ !!! *7* !!! ][ 110 ][ 19 ][ 24 ]]
-  [[ string->long long ][ !!! *7* !!! ][ 115 ][ 21 ][ 23 ]]
-  [[ string->unsigned int ][ !!! *6* !!! ][ 113 ][ 20 ][ 23 ]]
-  [[ string->unsigned short ][ !!! *5* !!! ][ 116 ][ 18 ][ 23 ]]
-  [[ string->unsigned long int ][ !!! *7* !!! ][ 111 ][ 20 ][ 23 ]]
-  [[ string->unsigned long long ][ !!! *7* !!! ][ 115 ][ 18 ][ 23 ]]
-  [[ string->float ][ !!! *14* !!! ][ 153 ][ 55 ][ 38 ]]
-  [[ string->double ][ !!! *11* !!! ][ 151 ][ 60 ][ 38 ]]
-  [[ string->long double ][ 107 ][ 151 ][ 59 ][ !!! *44* !!! ]]
-  [[ string->array<char, 50> ][ !!! *<1* !!! ][ 107 ][ 18 ][ 12 ]]
-  [[ string->string ][ !!! *2* !!! ][ 129 ][ 49 ][ --- ]]
-  [[ string->container::string ][ !!! *9* !!! ][ 199 ][ 22 ][ --- ]]
-  [[ string->char ][ !!! *7* !!! ][ 114 ][ 27 ][ 16 ]]
-  [[ string->signed char ][ !!! *7* !!! ][ 116 ][ 32 ][ 23 ]]
-  [[ string->unsigned char ][ !!! *7* !!! ][ 114 ][ 27 ][ 22 ]]
-  [[ int->string ][ !!! *11* !!! ][ 125 ][ 31 ][ 21 ]]
-  [[ short->string ][ !!! *11* !!! ][ 126 ][ 33 ][ 21 ]]
-  [[ long int->string ][ !!! *11* !!! ][ 126 ][ 32 ][ 22 ]]
-  [[ long long->string ][ !!! *11* !!! ][ 118 ][ 30 ][ 23 ]]
-  [[ unsigned int->string ][ !!! *11* !!! ][ 125 ][ 31 ][ 20 ]]
-  [[ unsigned short->string ][ !!! *12* !!! ][ 128 ][ 30 ][ 21 ]]
-  [[ unsigned long int->string ][ !!! *11* !!! ][ 131 ][ 30 ][ 21 ]]
-  [[ unsigned long long->string ][ !!! *11* !!! ][ 127 ][ 32 ][ 23 ]]
-  [[ float->string ][ 49 ][ 197 ][ 92 ][ !!! *39* !!! ]]
-  [[ double->string ][ 56 ][ 195 ][ 80 ][ !!! *43* !!! ]]
-  [[ long double->string ][ 60 ][ 222 ][ 88 ][ !!! *42* !!! ]]
-  [[ char*->char ][ !!! *<1* !!! ][ 100 ][ 10 ][ 9 ]]
-  [[ char*->signed char ][ !!! *<1* !!! ][ 99 ][ 10 ][ 10 ]]
-  [[ char*->unsigned char ][ !!! *<1* !!! ][ 106 ][ 10 ][ 10 ]]
-  [[ char*->int ][ !!! *7* !!! ][ 113 ][ 23 ][ 22 ]]
-  [[ char*->short ][ !!! *6* !!! ][ 113 ][ 21 ][ 23 ]]
-  [[ char*->long int ][ !!! *8* !!! ][ 116 ][ 21 ][ 23 ]]
-  [[ char*->long long ][ !!! *8* !!! ][ 115 ][ 21 ][ 21 ]]
-  [[ char*->unsigned int ][ !!! *6* !!! ][ 114 ][ 25 ][ 22 ]]
-  [[ char*->unsigned short ][ !!! *6* !!! ][ 119 ][ 20 ][ 23 ]]
-  [[ char*->unsigned long int ][ !!! *8* !!! ][ 114 ][ 23 ][ 23 ]]
-  [[ char*->unsigned long long ][ !!! *7* !!! ][ 111 ][ 20 ][ 24 ]]
-  [[ char*->float ][ !!! *16* !!! ][ 154 ][ 54 ][ 38 ]]
-  [[ char*->double ][ !!! *12* !!! ][ 149 ][ 59 ][ 40 ]]
-  [[ char*->long double ][ 107 ][ 166 ][ 62 ][ !!! *44* !!! ]]
-  [[ char*->array<char, 50> ][ !!! *1* !!! ][ 108 ][ 20 ][ 12 ]]
-  [[ char*->string ][ !!! *8* !!! ][ 125 ][ 28 ][ --- ]]
-  [[ char*->container::string ][ !!! *2* !!! ][ 123 ][ 24 ][ --- ]]
-  [[ unsigned char*->char ][ !!! *<1* !!! ][ 104 ][ 11 ][ 9 ]]
-  [[ unsigned char*->signed char ][ !!! *<1* !!! ][ 106 ][ 10 ][ 10 ]]
-  [[ unsigned char*->unsigned char ][ !!! *<1* !!! ][ 101 ][ 10 ][ 10 ]]
-  [[ unsigned char*->int ][ !!! *7* !!! ][ 117 ][ 22 ][ 24 ]]
-  [[ unsigned char*->short ][ !!! *6* !!! ][ 111 ][ 26 ][ 22 ]]
-  [[ unsigned char*->long int ][ !!! *8* !!! ][ 111 ][ 23 ][ 23 ]]
-  [[ unsigned char*->long long ][ !!! *8* !!! ][ 114 ][ 21 ][ 23 ]]
-  [[ unsigned char*->unsigned int ][ !!! *7* !!! ][ 115 ][ 20 ][ 25 ]]
-  [[ unsigned char*->unsigned short ][ !!! *6* !!! ][ 113 ][ 20 ][ 22 ]]
-  [[ unsigned char*->unsigned long int ][ !!! *8* !!! ][ 115 ][ 25 ][ 24 ]]
-  [[ unsigned char*->unsigned long long ][ !!! *7* !!! ][ 113 ][ 25 ][ 25 ]]
-  [[ unsigned char*->float ][ !!! *16* !!! ][ 158 ][ 55 ][ 38 ]]
-  [[ unsigned char*->double ][ !!! *12* !!! ][ 155 ][ 62 ][ 40 ]]
-  [[ unsigned char*->long double ][ 108 ][ 153 ][ 60 ][ !!! *41* !!! ]]
-  [[ unsigned char*->array<char, 50> ][ !!! *1* !!! ][ 111 ][ 19 ][ 12 ]]
-  [[ unsigned char*->string ][ !!! *8* !!! ][ 125 ][ 30 ][ --- ]]
-  [[ unsigned char*->container::string ][ !!! *4* !!! ][ 121 ][ 23 ][ --- ]]
-  [[ signed char*->char ][ !!! *<1* !!! ][ 98 ][ 14 ][ 9 ]]
-  [[ signed char*->signed char ][ !!! *<1* !!! ][ 98 ][ 11 ][ 10 ]]
-  [[ signed char*->unsigned char ][ !!! *<1* !!! ][ 99 ][ 10 ][ 10 ]]
-  [[ signed char*->int ][ !!! *7* !!! ][ 111 ][ 22 ][ 24 ]]
-  [[ signed char*->short ][ !!! *6* !!! ][ 123 ][ 22 ][ 23 ]]
-  [[ signed char*->long int ][ !!! *8* !!! ][ 112 ][ 21 ][ 23 ]]
-  [[ signed char*->long long ][ !!! *8* !!! ][ 114 ][ 24 ][ 24 ]]
-  [[ signed char*->unsigned int ][ !!! *6* !!! ][ 114 ][ 19 ][ 22 ]]
-  [[ signed char*->unsigned short ][ !!! *6* !!! ][ 112 ][ 21 ][ 24 ]]
-  [[ signed char*->unsigned long int ][ !!! *8* !!! ][ 114 ][ 23 ][ 22 ]]
-  [[ signed char*->unsigned long long ][ !!! *8* !!! ][ 116 ][ 22 ][ 24 ]]
-  [[ signed char*->float ][ !!! *16* !!! ][ 156 ][ 55 ][ 38 ]]
-  [[ signed char*->double ][ !!! *12* !!! ][ 151 ][ 59 ][ 39 ]]
-  [[ signed char*->long double ][ 111 ][ 159 ][ 60 ][ !!! *44* !!! ]]
-  [[ signed char*->array<char, 50> ][ !!! *1* !!! ][ 107 ][ 24 ][ 12 ]]
-  [[ signed char*->string ][ !!! *8* !!! ][ 122 ][ 28 ][ --- ]]
-  [[ signed char*->container::string ][ !!! *4* !!! ][ 122 ][ 23 ][ --- ]]
-  [[ iterator_range<char*>->char ][ !!! *<1* !!! ][ 103 ][ 13 ][ 10 ]]
-  [[ iterator_range<char*>->signed char ][ !!! *<1* !!! ][ 103 ][ 13 ][ 10 ]]
-  [[ iterator_range<char*>->unsigned char ][ !!! *<1* !!! ][ 104 ][ 14 ][ 10 ]]
-  [[ iterator_range<char*>->int ][ !!! *6* !!! ][ 115 ][ 23 ][ 24 ]]
-  [[ iterator_range<char*>->short ][ !!! *7* !!! ][ 111 ][ 21 ][ 24 ]]
-  [[ iterator_range<char*>->long int ][ !!! *7* !!! ][ 108 ][ 21 ][ 23 ]]
-  [[ iterator_range<char*>->long long ][ !!! *7* !!! ][ 114 ][ 24 ][ 23 ]]
-  [[ iterator_range<char*>->unsigned int ][ !!! *6* !!! ][ 111 ][ 22 ][ 23 ]]
-  [[ iterator_range<char*>->unsigned short ][ !!! *5* !!! ][ 114 ][ 20 ][ 23 ]]
-  [[ iterator_range<char*>->unsigned long int ][ !!! *7* !!! ][ 119 ][ 25 ][ 24 ]]
-  [[ iterator_range<char*>->unsigned long long ][ !!! *7* !!! ][ 110 ][ 20 ][ 24 ]]
-  [[ iterator_range<char*>->float ][ !!! *15* !!! ][ 148 ][ 38 ][ 40 ]]
-  [[ iterator_range<char*>->double ][ !!! *10* !!! ][ 146 ][ 41 ][ 40 ]]
-  [[ iterator_range<char*>->long double ][ 103 ][ 138 ][ !!! *39* !!! ][ 42 ]]
-  [[ iterator_range<char*>->array<char, 50> ][ !!! *<1* !!! ][ 109 ][ 22 ][ 13 ]]
-  [[ iterator_range<char*>->string ][ !!! *7* !!! ][ 121 ][ 32 ][ --- ]]
-  [[ iterator_range<char*>->container::string ][ !!! *3* !!! ][ 120 ][ 24 ][ --- ]]
-  [[ array<char, 50>->char ][ !!! *<1* !!! ][ 102 ][ 9 ][ 9 ]]
-  [[ array<char, 50>->signed char ][ !!! *<1* !!! ][ 97 ][ 9 ][ 10 ]]
-  [[ array<char, 50>->unsigned char ][ !!! *<1* !!! ][ 99 ][ 9 ][ 10 ]]
-  [[ array<char, 50>->int ][ !!! *7* !!! ][ 114 ][ 22 ][ 23 ]]
-  [[ array<char, 50>->short ][ !!! *6* !!! ][ 116 ][ 21 ][ 23 ]]
-  [[ array<char, 50>->long int ][ !!! *7* !!! ][ 109 ][ 20 ][ 23 ]]
-  [[ array<char, 50>->long long ][ !!! *7* !!! ][ 114 ][ 21 ][ 23 ]]
-  [[ array<char, 50>->unsigned int ][ !!! *7* !!! ][ 119 ][ 20 ][ 25 ]]
-  [[ array<char, 50>->unsigned short ][ !!! *6* !!! ][ 120 ][ 20 ][ 23 ]]
-  [[ array<char, 50>->unsigned long int ][ !!! *7* !!! ][ 113 ][ 20 ][ 21 ]]
-  [[ array<char, 50>->unsigned long long ][ !!! *7* !!! ][ 112 ][ 20 ][ 24 ]]
-  [[ array<char, 50>->float ][ !!! *16* !!! ][ 155 ][ 57 ][ 38 ]]
-  [[ array<char, 50>->double ][ !!! *11* !!! ][ 152 ][ 59 ][ 42 ]]
-  [[ array<char, 50>->long double ][ 107 ][ 152 ][ 60 ][ !!! *41* !!! ]]
-  [[ array<char, 50>->array<char, 50> ][ !!! *1* !!! ][ 111 ][ 20 ][ 12 ]]
-  [[ array<char, 50>->string ][ !!! *8* !!! ][ 123 ][ 36 ][ --- ]]
-  [[ array<char, 50>->container::string ][ !!! *4* !!! ][ 128 ][ 23 ][ --- ]]
-  [[ int->int ][ !!! *<1* !!! ][ 118 ][ 26 ][ --- ]]
-  [[ float->double ][ !!! *<1* !!! ][ 233 ][ 120 ][ --- ]]
-  [[ char->signed char ][ !!! *<1* !!! ][ 97 ][ 8 ][ --- ]]
-]
-[endsect]
-
-[section GNU C++ version 4.4.7]
-[table:id Performance Table ( GNU C++ version 4.4.7)
-[[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
-  [[ string->char ][ !!! *<1* !!! ][ 111 ][ 8 ][ 9 ]]
-  [[ string->signed char ][ !!! *<1* !!! ][ 100 ][ 8 ][ 10 ]]
-  [[ string->unsigned char ][ !!! *<1* !!! ][ 102 ][ 8 ][ 11 ]]
-  [[ string->int ][ !!! *6* !!! ][ 114 ][ 21 ][ 23 ]]
-  [[ string->short ][ !!! *5* !!! ][ 120 ][ 21 ][ 29 ]]
-  [[ string->long int ][ !!! *7* !!! ][ 114 ][ 22 ][ 26 ]]
-  [[ string->long long ][ !!! *7* !!! ][ 118 ][ 21 ][ 23 ]]
-  [[ string->unsigned int ][ !!! *7* !!! ][ 115 ][ 21 ][ 23 ]]
-  [[ string->unsigned short ][ !!! *5* !!! ][ 119 ][ 18 ][ 22 ]]
-  [[ string->unsigned long int ][ !!! *7* !!! ][ 115 ][ 20 ][ 23 ]]
-  [[ string->unsigned long long ][ !!! *9* !!! ][ 116 ][ 26 ][ 24 ]]
-  [[ string->float ][ !!! *12* !!! ][ 165 ][ 53 ][ 40 ]]
-  [[ string->double ][ !!! *12* !!! ][ 154 ][ 54 ][ 40 ]]
-  [[ string->long double ][ 112 ][ 148 ][ 61 ][ !!! *45* !!! ]]
-  [[ string->array<char, 50> ][ !!! *<1* !!! ][ 120 ][ 19 ][ 14 ]]
-  [[ string->string ][ !!! *2* !!! ][ 141 ][ 55 ][ --- ]]
-  [[ string->container::string ][ !!! *2* !!! ][ 164 ][ 36 ][ --- ]]
-  [[ string->char ][ !!! *7* !!! ][ 161 ][ 24 ][ 18 ]]
-  [[ string->signed char ][ !!! *6* !!! ][ 109 ][ 25 ][ 24 ]]
-  [[ string->unsigned char ][ !!! *6* !!! ][ 109 ][ 25 ][ 25 ]]
-  [[ int->string ][ !!! *11* !!! ][ 128 ][ 32 ][ 23 ]]
-  [[ short->string ][ !!! *12* !!! ][ 136 ][ 54 ][ 34 ]]
-  [[ long int->string ][ !!! *15* !!! ][ 187 ][ 41 ][ 23 ]]
-  [[ long long->string ][ !!! *11* !!! ][ 128 ][ 30 ][ 29 ]]
-  [[ unsigned int->string ][ !!! *13* !!! ][ 124 ][ 29 ][ 23 ]]
-  [[ unsigned short->string ][ !!! *11* !!! ][ 128 ][ 30 ][ 22 ]]
-  [[ unsigned long int->string ][ !!! *11* !!! ][ 131 ][ 30 ][ 22 ]]
-  [[ unsigned long long->string ][ !!! *11* !!! ][ 133 ][ 33 ][ 29 ]]
-  [[ float->string ][ 52 ][ 187 ][ 90 ][ !!! *39* !!! ]]
-  [[ double->string ][ 58 ][ 190 ][ 86 ][ !!! *45* !!! ]]
-  [[ long double->string ][ 70 ][ 218 ][ 88 ][ !!! *47* !!! ]]
-  [[ char*->char ][ !!! *<1* !!! ][ 99 ][ 11 ][ 9 ]]
-  [[ char*->signed char ][ !!! *<1* !!! ][ 99 ][ 11 ][ 10 ]]
-  [[ char*->unsigned char ][ !!! *<1* !!! ][ 100 ][ 12 ][ 10 ]]
-  [[ char*->int ][ !!! *6* !!! ][ 117 ][ 23 ][ 21 ]]
-  [[ char*->short ][ !!! *6* !!! ][ 115 ][ 28 ][ 23 ]]
-  [[ char*->long int ][ !!! *7* !!! ][ 119 ][ 22 ][ 24 ]]
-  [[ char*->long long ][ !!! *7* !!! ][ 114 ][ 23 ][ 22 ]]
-  [[ char*->unsigned int ][ !!! *6* !!! ][ 113 ][ 21 ][ 21 ]]
-  [[ char*->unsigned short ][ !!! *6* !!! ][ 120 ][ 21 ][ 21 ]]
-  [[ char*->unsigned long int ][ !!! *7* !!! ][ 117 ][ 25 ][ 23 ]]
-  [[ char*->unsigned long long ][ !!! *7* !!! ][ 119 ][ 23 ][ 21 ]]
-  [[ char*->float ][ !!! *13* !!! ][ 160 ][ 61 ][ 36 ]]
-  [[ char*->double ][ !!! *13* !!! ][ 152 ][ 54 ][ 40 ]]
-  [[ char*->long double ][ 116 ][ 173 ][ 58 ][ !!! *43* !!! ]]
-  [[ char*->array<char, 50> ][ !!! *1* !!! ][ 121 ][ 20 ][ 12 ]]
-  [[ char*->string ][ !!! *7* !!! ][ 126 ][ 29 ][ --- ]]
-  [[ char*->container::string ][ !!! *2* !!! ][ 119 ][ 27 ][ --- ]]
-  [[ unsigned char*->char ][ !!! *<1* !!! ][ 96 ][ 12 ][ 9 ]]
-  [[ unsigned char*->signed char ][ !!! *<1* !!! ][ 95 ][ 11 ][ 12 ]]
-  [[ unsigned char*->unsigned char ][ !!! *<1* !!! ][ 95 ][ 12 ][ 12 ]]
-  [[ unsigned char*->int ][ !!! *6* !!! ][ 113 ][ 27 ][ 24 ]]
-  [[ unsigned char*->short ][ !!! *6* !!! ][ 120 ][ 23 ][ 21 ]]
-  [[ unsigned char*->long int ][ !!! *7* !!! ][ 114 ][ 22 ][ 23 ]]
-  [[ unsigned char*->long long ][ !!! *7* !!! ][ 114 ][ 23 ][ 23 ]]
-  [[ unsigned char*->unsigned int ][ !!! *6* !!! ][ 115 ][ 23 ][ 23 ]]
-  [[ unsigned char*->unsigned short ][ !!! *6* !!! ][ 120 ][ 21 ][ 23 ]]
-  [[ unsigned char*->unsigned long int ][ !!! *7* !!! ][ 117 ][ 23 ][ 21 ]]
-  [[ unsigned char*->unsigned long long ][ !!! *7* !!! ][ 121 ][ 23 ][ 21 ]]
-  [[ unsigned char*->float ][ !!! *12* !!! ][ 161 ][ 58 ][ 39 ]]
-  [[ unsigned char*->double ][ !!! *13* !!! ][ 153 ][ 54 ][ 38 ]]
-  [[ unsigned char*->long double ][ 110 ][ 150 ][ 62 ][ !!! *43* !!! ]]
-  [[ unsigned char*->array<char, 50> ][ !!! *1* !!! ][ 113 ][ 20 ][ 12 ]]
-  [[ unsigned char*->string ][ !!! *8* !!! ][ 124 ][ 30 ][ --- ]]
-  [[ unsigned char*->container::string ][ !!! *3* !!! ][ 118 ][ 27 ][ --- ]]
-  [[ signed char*->char ][ !!! *<1* !!! ][ 99 ][ 11 ][ 9 ]]
-  [[ signed char*->signed char ][ !!! *<1* !!! ][ 102 ][ 12 ][ 10 ]]
-  [[ signed char*->unsigned char ][ !!! *<1* !!! ][ 99 ][ 12 ][ 10 ]]
-  [[ signed char*->int ][ !!! *6* !!! ][ 114 ][ 30 ][ 23 ]]
-  [[ signed char*->short ][ !!! *6* !!! ][ 118 ][ 23 ][ 23 ]]
-  [[ signed char*->long int ][ !!! *7* !!! ][ 119 ][ 22 ][ 21 ]]
-  [[ signed char*->long long ][ !!! *7* !!! ][ 114 ][ 23 ][ 26 ]]
-  [[ signed char*->unsigned int ][ !!! *6* !!! ][ 114 ][ 26 ][ 23 ]]
-  [[ signed char*->unsigned short ][ !!! *6* !!! ][ 121 ][ 22 ][ 23 ]]
-  [[ signed char*->unsigned long int ][ !!! *7* !!! ][ 126 ][ 23 ][ 21 ]]
-  [[ signed char*->unsigned long long ][ !!! *7* !!! ][ 114 ][ 22 ][ 21 ]]
-  [[ signed char*->float ][ !!! *12* !!! ][ 163 ][ 57 ][ 39 ]]
-  [[ signed char*->double ][ !!! *13* !!! ][ 156 ][ 53 ][ 40 ]]
-  [[ signed char*->long double ][ 112 ][ 156 ][ 56 ][ !!! *42* !!! ]]
-  [[ signed char*->array<char, 50> ][ !!! *1* !!! ][ 117 ][ 20 ][ 12 ]]
-  [[ signed char*->string ][ !!! *8* !!! ][ 127 ][ 28 ][ --- ]]
-  [[ signed char*->container::string ][ !!! *4* !!! ][ 112 ][ 27 ][ --- ]]
-  [[ iterator_range<char*>->char ][ !!! *<1* !!! ][ 103 ][ 14 ][ 9 ]]
-  [[ iterator_range<char*>->signed char ][ !!! *<1* !!! ][ 104 ][ 16 ][ 10 ]]
-  [[ iterator_range<char*>->unsigned char ][ !!! *<1* !!! ][ 103 ][ 16 ][ 10 ]]
-  [[ iterator_range<char*>->int ][ !!! *6* !!! ][ 121 ][ 22 ][ 21 ]]
-  [[ iterator_range<char*>->short ][ !!! *7* !!! ][ 112 ][ 23 ][ 23 ]]
-  [[ iterator_range<char*>->long int ][ !!! *7* !!! ][ 115 ][ 24 ][ 23 ]]
-  [[ iterator_range<char*>->long long ][ !!! *7* !!! ][ 113 ][ 24 ][ 23 ]]
-  [[ iterator_range<char*>->unsigned int ][ !!! *6* !!! ][ 117 ][ 26 ][ 23 ]]
-  [[ iterator_range<char*>->unsigned short ][ !!! *5* !!! ][ 120 ][ 20 ][ 23 ]]
-  [[ iterator_range<char*>->unsigned long int ][ !!! *7* !!! ][ 124 ][ 28 ][ 21 ]]
-  [[ iterator_range<char*>->unsigned long long ][ !!! *7* !!! ][ 113 ][ 22 ][ 21 ]]
-  [[ iterator_range<char*>->float ][ !!! *11* !!! ][ 190 ][ 58 ][ 63 ]]
-  [[ iterator_range<char*>->double ][ !!! *20* !!! ][ 194 ][ 44 ][ 39 ]]
-  [[ iterator_range<char*>->long double ][ 116 ][ 145 ][ 46 ][ !!! *44* !!! ]]
-  [[ iterator_range<char*>->array<char, 50> ][ !!! *<1* !!! ][ 116 ][ 23 ][ 15 ]]
-  [[ iterator_range<char*>->string ][ !!! *7* !!! ][ 127 ][ 33 ][ --- ]]
-  [[ iterator_range<char*>->container::string ][ !!! *3* !!! ][ 112 ][ 24 ][ --- ]]
-  [[ array<char, 50>->char ][ !!! *<1* !!! ][ 98 ][ 11 ][ 10 ]]
-  [[ array<char, 50>->signed char ][ !!! *<1* !!! ][ 99 ][ 12 ][ 15 ]]
-  [[ array<char, 50>->unsigned char ][ !!! *<1* !!! ][ 100 ][ 11 ][ 10 ]]
-  [[ array<char, 50>->int ][ !!! *6* !!! ][ 114 ][ 27 ][ 22 ]]
-  [[ array<char, 50>->short ][ !!! *5* !!! ][ 113 ][ 23 ][ 23 ]]
-  [[ array<char, 50>->long int ][ !!! *7* !!! ][ 118 ][ 22 ][ 23 ]]
-  [[ array<char, 50>->long long ][ !!! *7* !!! ][ 114 ][ 26 ][ 23 ]]
-  [[ array<char, 50>->unsigned int ][ !!! *6* !!! ][ 113 ][ 27 ][ 23 ]]
-  [[ array<char, 50>->unsigned short ][ !!! *5* !!! ][ 124 ][ 21 ][ 23 ]]
-  [[ array<char, 50>->unsigned long int ][ !!! *7* !!! ][ 116 ][ 23 ][ 21 ]]
-  [[ array<char, 50>->unsigned long long ][ !!! *7* !!! ][ 115 ][ 22 ][ 21 ]]
-  [[ array<char, 50>->float ][ !!! *11* !!! ][ 162 ][ 58 ][ 36 ]]
-  [[ array<char, 50>->double ][ !!! *13* !!! ][ 155 ][ 54 ][ 44 ]]
-  [[ array<char, 50>->long double ][ 111 ][ 149 ][ 55 ][ !!! *42* !!! ]]
-  [[ array<char, 50>->array<char, 50> ][ !!! *1* !!! ][ 114 ][ 18 ][ 14 ]]
-  [[ array<char, 50>->string ][ !!! *7* !!! ][ 129 ][ 29 ][ --- ]]
-  [[ array<char, 50>->container::string ][ !!! *3* !!! ][ 113 ][ 26 ][ --- ]]
-  [[ int->int ][ !!! *<1* !!! ][ 114 ][ 25 ][ --- ]]
-  [[ float->double ][ !!! *<1* !!! ][ 236 ][ 121 ][ --- ]]
-  [[ char->signed char ][ !!! *<1* !!! ][ 97 ][ 8 ][ --- ]]
-]
-[endsect]
-
-[section Microsoft Visual C++ version 11.0]
-[table:id Performance Table ( Microsoft Visual C++ version 11.0)
-[[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
-  [[ string->char ][ !!! *<1* !!! ][ 43 ][ 17 ][ 7 ]]
-  [[ string->signed char ][ !!! *<1* !!! ][ 43 ][ 17 ][ 8 ]]
-  [[ string->unsigned char ][ !!! *<1* !!! ][ 42 ][ 17 ][ 8 ]]
-  [[ string->int ][ !!! *8* !!! ][ 71 ][ 49 ][ 10 ]]
-  [[ string->short ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
-  [[ string->long int ][ !!! *8* !!! ][ 71 ][ 47 ][ 10 ]]
-  [[ string->long long ][ !!! *8* !!! ][ 71 ][ 47 ][ 10 ]]
-  [[ string->unsigned int ][ !!! *8* !!! ][ 72 ][ 46 ][ 10 ]]
-  [[ string->unsigned short ][ !!! *8* !!! ][ 71 ][ 47 ][ 10 ]]
-  [[ string->unsigned long int ][ !!! *8* !!! ][ 70 ][ 45 ][ 10 ]]
-  [[ string->unsigned long long ][ !!! *8* !!! ][ 70 ][ 46 ][ 10 ]]
-  [[ string->float ][ !!! *14* !!! ][ 586 ][ 559 ][ 37 ]]
-  [[ string->double ][ 601 ][ 618 ][ 592 ][ !!! *37* !!! ]]
-  [[ string->long double ][ 629 ][ 645 ][ 618 ][ !!! *37* !!! ]]
-  [[ string->array<char, 50> ][ !!! *<1* !!! ][ 52 ][ 28 ][ 11 ]]
-  [[ string->string ][ !!! *1* !!! ][ 59 ][ 34 ][ --- ]]
-  [[ string->container::string ][ !!! *2* !!! ][ 54 ][ 31 ][ --- ]]
-  [[ string->char ][ !!! *2* !!! ][ 50 ][ 24 ][ 9 ]]
-  [[ string->signed char ][ !!! *2* !!! ][ 50 ][ 24 ][ 13 ]]
-  [[ string->unsigned char ][ !!! *2* !!! ][ 50 ][ 24 ][ 13 ]]
-  [[ int->string ][ !!! *9* !!! ][ 86 ][ 59 ][ 13 ]]
-  [[ short->string ][ !!! *9* !!! ][ 86 ][ 59 ][ 13 ]]
-  [[ long int->string ][ !!! *9* !!! ][ 87 ][ 59 ][ 13 ]]
-  [[ long long->string ][ !!! *9* !!! ][ 88 ][ 62 ][ 13 ]]
-  [[ unsigned int->string ][ !!! *9* !!! ][ 87 ][ 60 ][ 13 ]]
-  [[ unsigned short->string ][ !!! *9* !!! ][ 91 ][ 63 ][ 13 ]]
-  [[ unsigned long int->string ][ !!! *9* !!! ][ 91 ][ 62 ][ 13 ]]
-  [[ unsigned long long->string ][ !!! *9* !!! ][ 88 ][ 60 ][ 13 ]]
-  [[ float->string ][ 73 ][ 167 ][ 137 ][ !!! *56* !!! ]]
-  [[ double->string ][ 77 ][ 176 ][ 144 ][ !!! *64* !!! ]]
-  [[ long double->string ][ 79 ][ 175 ][ 143 ][ !!! *63* !!! ]]
-  [[ char*->char ][ !!! *<1* !!! ][ 43 ][ 17 ][ 7 ]]
-  [[ char*->signed char ][ !!! *<1* !!! ][ 43 ][ 17 ][ 8 ]]
-  [[ char*->unsigned char ][ !!! *<1* !!! ][ 44 ][ 17 ][ 8 ]]
-  [[ char*->int ][ !!! *8* !!! ][ 70 ][ 47 ][ 10 ]]
-  [[ char*->short ][ !!! *8* !!! ][ 72 ][ 48 ][ 10 ]]
-  [[ char*->long int ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
-  [[ char*->long long ][ !!! *8* !!! ][ 71 ][ 47 ][ 10 ]]
-  [[ char*->unsigned int ][ !!! *8* !!! ][ 72 ][ 46 ][ 10 ]]
-  [[ char*->unsigned short ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
-  [[ char*->unsigned long int ][ !!! *8* !!! ][ 70 ][ 46 ][ 10 ]]
-  [[ char*->unsigned long long ][ !!! *8* !!! ][ 70 ][ 45 ][ 10 ]]
-  [[ char*->float ][ !!! *14* !!! ][ 586 ][ 560 ][ 37 ]]
-  [[ char*->double ][ 598 ][ 617 ][ 597 ][ !!! *40* !!! ]]
-  [[ char*->long double ][ 635 ][ 653 ][ 622 ][ !!! *37* !!! ]]
-  [[ char*->array<char, 50> ][ !!! *1* !!! ][ 53 ][ 28 ][ 11 ]]
-  [[ char*->string ][ !!! *1* !!! ][ 59 ][ 35 ][ --- ]]
-  [[ char*->container::string ][ !!! *3* !!! ][ 54 ][ 30 ][ --- ]]
-  [[ unsigned char*->char ][ !!! *<1* !!! ][ 41 ][ 17 ][ 7 ]]
-  [[ unsigned char*->signed char ][ !!! *<1* !!! ][ 42 ][ 17 ][ 8 ]]
-  [[ unsigned char*->unsigned char ][ !!! *<1* !!! ][ 41 ][ 17 ][ 8 ]]
-  [[ unsigned char*->int ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
-  [[ unsigned char*->short ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
-  [[ unsigned char*->long int ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
-  [[ unsigned char*->long long ][ !!! *8* !!! ][ 72 ][ 47 ][ 11 ]]
-  [[ unsigned char*->unsigned int ][ !!! *8* !!! ][ 70 ][ 46 ][ 10 ]]
-  [[ unsigned char*->unsigned short ][ !!! *8* !!! ][ 72 ][ 48 ][ 10 ]]
-  [[ unsigned char*->unsigned long int ][ !!! *8* !!! ][ 71 ][ 46 ][ 10 ]]
-  [[ unsigned char*->unsigned long long ][ !!! *8* !!! ][ 70 ][ 45 ][ 11 ]]
-  [[ unsigned char*->float ][ !!! *14* !!! ][ 589 ][ 564 ][ 38 ]]
-  [[ unsigned char*->double ][ 601 ][ 615 ][ 588 ][ !!! *37* !!! ]]
-  [[ unsigned char*->long double ][ 628 ][ 644 ][ 620 ][ !!! *38* !!! ]]
-  [[ unsigned char*->array<char, 50> ][ !!! *1* !!! ][ 54 ][ 28 ][ 11 ]]
-  [[ unsigned char*->string ][ !!! *2* !!! ][ 59 ][ 36 ][ --- ]]
-  [[ unsigned char*->container::string ][ !!! *3* !!! ][ 54 ][ 30 ][ --- ]]
-  [[ signed char*->char ][ !!! *<1* !!! ][ 41 ][ 17 ][ 7 ]]
-  [[ signed char*->signed char ][ !!! *<1* !!! ][ 43 ][ 17 ][ 8 ]]
-  [[ signed char*->unsigned char ][ !!! *<1* !!! ][ 42 ][ 17 ][ 8 ]]
-  [[ signed char*->int ][ !!! *8* !!! ][ 71 ][ 47 ][ 10 ]]
-  [[ signed char*->short ][ !!! *8* !!! ][ 72 ][ 48 ][ 10 ]]
-  [[ signed char*->long int ][ !!! *8* !!! ][ 71 ][ 47 ][ 10 ]]
-  [[ signed char*->long long ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
-  [[ signed char*->unsigned int ][ !!! *8* !!! ][ 70 ][ 46 ][ 10 ]]
-  [[ signed char*->unsigned short ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
-  [[ signed char*->unsigned long int ][ !!! *8* !!! ][ 70 ][ 46 ][ 10 ]]
-  [[ signed char*->unsigned long long ][ !!! *8* !!! ][ 70 ][ 46 ][ 11 ]]
-  [[ signed char*->float ][ !!! *14* !!! ][ 586 ][ 562 ][ 37 ]]
-  [[ signed char*->double ][ 603 ][ 615 ][ 589 ][ !!! *37* !!! ]]
-  [[ signed char*->long double ][ 630 ][ 644 ][ 623 ][ !!! *40* !!! ]]
-  [[ signed char*->array<char, 50> ][ !!! *1* !!! ][ 54 ][ 28 ][ 11 ]]
-  [[ signed char*->string ][ !!! *2* !!! ][ 59 ][ 36 ][ --- ]]
-  [[ signed char*->container::string ][ !!! *3* !!! ][ 54 ][ 30 ][ --- ]]
-  [[ iterator_range<char*>->char ][ !!! *<1* !!! ][ 74 ][ 46 ][ 7 ]]
-  [[ iterator_range<char*>->signed char ][ !!! *<1* !!! ][ 75 ][ 46 ][ 8 ]]
-  [[ iterator_range<char*>->unsigned char ][ !!! *<1* !!! ][ 74 ][ 46 ][ 8 ]]
-  [[ iterator_range<char*>->int ][ !!! *8* !!! ][ 98 ][ 70 ][ 10 ]]
-  [[ iterator_range<char*>->short ][ !!! *8* !!! ][ 103 ][ 72 ][ 10 ]]
-  [[ iterator_range<char*>->long int ][ !!! *8* !!! ][ 111 ][ 71 ][ 10 ]]
-  [[ iterator_range<char*>->long long ][ !!! *8* !!! ][ 98 ][ 70 ][ 10 ]]
-  [[ iterator_range<char*>->unsigned int ][ !!! *7* !!! ][ 103 ][ 76 ][ 10 ]]
-  [[ iterator_range<char*>->unsigned short ][ !!! *8* !!! ][ 104 ][ 75 ][ 10 ]]
-  [[ iterator_range<char*>->unsigned long int ][ !!! *7* !!! ][ 104 ][ 71 ][ 10 ]]
-  [[ iterator_range<char*>->unsigned long long ][ !!! *8* !!! ][ 99 ][ 71 ][ 11 ]]
-  [[ iterator_range<char*>->float ][ !!! *13* !!! ][ 123 ][ 93 ][ 37 ]]
-  [[ iterator_range<char*>->double ][ 603 ][ 111 ][ 82 ][ !!! *38* !!! ]]
-  [[ iterator_range<char*>->long double ][ 629 ][ 116 ][ 83 ][ !!! *38* !!! ]]
-  [[ iterator_range<char*>->array<char, 50> ][ !!! *<1* !!! ][ 82 ][ 52 ][ 11 ]]
-  [[ iterator_range<char*>->string ][ !!! *2* !!! ][ 83 ][ 56 ][ --- ]]
-  [[ iterator_range<char*>->container::string ][ !!! *2* !!! ][ 81 ][ 53 ][ --- ]]
-  [[ array<char, 50>->char ][ !!! *<1* !!! ][ 41 ][ 17 ][ 7 ]]
-  [[ array<char, 50>->signed char ][ !!! *<1* !!! ][ 41 ][ 17 ][ 8 ]]
-  [[ array<char, 50>->unsigned char ][ !!! *<1* !!! ][ 41 ][ 17 ][ 8 ]]
-  [[ array<char, 50>->int ][ !!! *8* !!! ][ 73 ][ 46 ][ 10 ]]
-  [[ array<char, 50>->short ][ !!! *8* !!! ][ 73 ][ 47 ][ 10 ]]
-  [[ array<char, 50>->long int ][ !!! *8* !!! ][ 75 ][ 48 ][ 10 ]]
-  [[ array<char, 50>->long long ][ !!! *8* !!! ][ 73 ][ 48 ][ 11 ]]
-  [[ array<char, 50>->unsigned int ][ !!! *8* !!! ][ 73 ][ 47 ][ 10 ]]
-  [[ array<char, 50>->unsigned short ][ !!! *8* !!! ][ 74 ][ 50 ][ 10 ]]
-  [[ array<char, 50>->unsigned long int ][ !!! *8* !!! ][ 71 ][ 46 ][ 10 ]]
-  [[ array<char, 50>->unsigned long long ][ !!! *8* !!! ][ 70 ][ 47 ][ 11 ]]
-  [[ array<char, 50>->float ][ !!! *14* !!! ][ 586 ][ 567 ][ 37 ]]
-  [[ array<char, 50>->double ][ 599 ][ 624 ][ 590 ][ !!! *37* !!! ]]
-  [[ array<char, 50>->long double ][ 632 ][ 643 ][ 618 ][ !!! *37* !!! ]]
-  [[ array<char, 50>->array<char, 50> ][ !!! *1* !!! ][ 52 ][ 28 ][ 11 ]]
-  [[ array<char, 50>->string ][ !!! *2* !!! ][ 59 ][ 34 ][ --- ]]
-  [[ array<char, 50>->container::string ][ !!! *3* !!! ][ 55 ][ 30 ][ --- ]]
-  [[ int->int ][ !!! *<1* !!! ][ 105 ][ 79 ][ --- ]]
-  [[ float->double ][ !!! *<1* !!! ][ 226 ][ 188 ][ --- ]]
-  [[ char->signed char ][ !!! *<1* !!! ][ 40 ][ 16 ][ --- ]]
-]
-[endsect]
-
-
-
-[/ END of section, generated by performance measuring program ]
-[endsect]
-
diff --git a/example/args_to_numbers.cpp b/example/args_to_numbers.cpp
deleted file mode 100644
index edcc779..0000000
--- a/example/args_to_numbers.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright 2013 Antony Polukhin
-
-// Distributed under the Boost Software License, Version 1.0.
-// (See the accompanying file LICENSE_1_0.txt
-// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
-
-//[lexical_cast_args_example
-//`The following example treats command line arguments as a sequence of numeric data
-
-#include <boost/lexical_cast.hpp>
-#include <vector>
-
-int main(int /*argc*/, char * argv[])
-{
-    using boost::lexical_cast;
-    using boost::bad_lexical_cast;
-
-    std::vector<short> args;
-
-    while (*++argv)
-    {
-        try
-        {
-            args.push_back(lexical_cast<short>(*argv));
-        }
-        catch(const bad_lexical_cast &)
-        {
-            args.push_back(0);
-        }
-    }
-
-    // ...
-}
-
-//] [/lexical_cast_args_example]
diff --git a/example/generic_stringize.cpp b/example/generic_stringize.cpp
deleted file mode 100644
index d480ba5..0000000
--- a/example/generic_stringize.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2013 Antony Polukhin
-
-// Distributed under the Boost Software License, Version 1.0.
-// (See the accompanying file LICENSE_1_0.txt
-// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
-
-
-//[lexical_cast_stringize
-/*`
-    In this example we'll make a `stringize` method that accepts a sequence, converts
-    each element of the sequence into string and appends that string to the result.
-
-    Example is based on the example from the [@http://www.packtpub.com/boost-cplusplus-application-development-cookbook/book Boost C++ Application Development Cookbook]
-    by Antony Polukhin, ISBN 9781849514880.
-
-    Step 1: Making a functor that converts any type to a string and remembers result:
-*/
-
-#include <boost/lexical_cast.hpp>
-
-struct stringize_functor {
-private:
-    std::string& result;
-
-public:
-    explicit stringize_functor(std::string& res)
-        : result(res)
-    {}
-
-    template <class T>
-    void operator()(const T& v) const {
-        result += boost::lexical_cast<std::string>(v);
-    }
-};
-
-//` Step 2: Applying `stringize_functor` to each element in sequence:
-#include <boost/fusion/include/for_each.hpp>
-template <class Sequence>
-std::string stringize(const Sequence& seq) {
-    std::string result;
-    boost::fusion::for_each(seq, stringize_functor(result));
-    return result;
-}
-
-//` Step 3: Using the `stringize` with different types:
-#include <cassert>
-#include <boost/fusion/adapted/boost_tuple.hpp>
-#include <boost/fusion/adapted/std_pair.hpp>
-
-int main() {
-    boost::tuple<char, int, char, int> decim('-', 10, 'e', 5);
-    assert(stringize(decim) == "-10e5");
-
-    std::pair<short, std::string> value_and_type(270, "Kelvin");
-    assert(stringize(value_and_type) == "270Kelvin");
-}
-
-//] [/lexical_cast_stringize]
-
-
-
diff --git a/example/small_examples.cpp b/example/small_examples.cpp
deleted file mode 100644
index 31f3981..0000000
--- a/example/small_examples.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2013 Antony Polukhin
-
-// Distributed under the Boost Software License, Version 1.0.
-// (See the accompanying file LICENSE_1_0.txt
-// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
-
-#include <boost/lexical_cast.hpp>
-#include <string>
-#include <cstdio>
-
-//[lexical_cast_log_errno
-//`The following example uses numeric data in a string expression: 
-
-void log_message(const std::string &);
-
-void log_errno(int yoko)
-{
-    log_message("Error " + boost::lexical_cast<std::string>(yoko) + ": " + strerror(yoko));
-}
-
-//] [/lexical_cast_log_errno]
-
-
-//[lexical_cast_fixed_buffer
-//`The following example converts some number and puts it to file:
-
-void number_to_file(int number, FILE* file)
-{
-    typedef boost::array<char, 50> buf_t; // You can use std::array if your compiler supports it
-    buf_t buffer = boost::lexical_cast<buf_t>(number); // No dynamic memory allocation
-    fputs(buffer.begin(), file);
-}
-
-//] [/lexical_cast_fixed_buffer]
-
-//[lexical_cast_substring_conversion
-//`The following example takes part of the string and converts it to `int`:
-
-int convert_strings_part(const std::string& s, std::size_t pos, std::size_t n)
-{
-    return boost::lexical_cast<int>(s.data() + pos, n);
-}
-
-//] [/lexical_cast_substring_conversion]
-
-void log_message(const std::string &) {}
-
-int main()
-{
-    return 0;
-}
-
diff --git a/example/variant_to_long_double.cpp b/example/variant_to_long_double.cpp
deleted file mode 100644
index 2ed95a8..0000000
--- a/example/variant_to_long_double.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright 2013 Antony Polukhin
-
-// Distributed under the Boost Software License, Version 1.0.
-// (See the accompanying file LICENSE_1_0.txt
-// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
-
-
-//[lexical_cast_variant_to_long_double
-/*`
-    In this example we'll make a `to_long_double` method that converts value of the Boost.Variant to `long double`.
-*/
-
-#include <boost/lexical_cast.hpp>
-#include <boost/variant.hpp>
-#include <cassert>
-
-struct to_long_double_functor: boost::static_visitor<long double> {
-    template <class T>
-    long double operator()(const T& v) const {
-        // Lexical cast has many optimizations including optimizations for situations that usually 
-        // occur in generic programming, like std::string to std::string or arithmetic type to arithmetic type conversion. 
-        return boost::lexical_cast<long double>(v);
-    }
-};
-
-// Throws `boost::bad_lexical_cast` if value of the variant is not convertible to `long double`
-template <class Variant>
-long double to_long_double(const Variant& v) {
-    return boost::apply_visitor(to_long_double_functor(), v);
-}
-
-int main() {
-    boost::variant<char, int, std::string> v1('0'), v2("10.0001"), v3(1);
-
-    long double sum = to_long_double(v1) + to_long_double(v2) + to_long_double(v3);
-    assert(sum > 11 && sum < 11.1);
-}
-
-//] [/lexical_cast_variant_to_long_double]
diff --git a/include/boost/cast.hpp b/include/boost/cast.hpp
index 0018924..ab452bd 100644
--- a/include/boost/cast.hpp
+++ b/include/boost/cast.hpp
@@ -1,94 +1,20 @@
-//  boost cast.hpp header file  ----------------------------------------------//
-
-//  (C) Copyright Kevlin Henney and Dave Abrahams 1999.
+//  boost cast.hpp header file
+//
+//  (C) Copyright Antony Polukhin 2014.
+//
 //  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/conversion for Documentation.
 
-//  Revision History
-//  23 JUn 05  numeric_cast removed and redirected to the new verion (Fernando Cacciola)
-//  02 Apr 01  Removed BOOST_NO_LIMITS workarounds and included
-//             <boost/limits.hpp> instead (the workaround did not
-//             actually compile when BOOST_NO_LIMITS was defined in
-//             any case, so we loose nothing). (John Maddock)
-//  21 Jan 01  Undid a bug I introduced yesterday. numeric_cast<> never
-//             worked with stock GCC; trying to get it to do that broke
-//             vc-stlport.
-//  20 Jan 01  Moved BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS to config.hpp.
-//             Removed unused BOOST_EXPLICIT_TARGET macro. Moved
-//             boost::detail::type to boost/type.hpp. Made it compile with
-//             stock gcc again (Dave Abrahams)
-//  29 Nov 00  Remove nested namespace cast, cleanup spacing before Formal
-//             Review (Beman Dawes)
-//  19 Oct 00  Fix numeric_cast for floating-point types (Dave Abrahams)
-//  15 Jul 00  Suppress numeric_cast warnings for GCC, Borland and MSVC
-//             (Dave Abrahams)
-//  30 Jun 00  More MSVC6 wordarounds.  See comments below.  (Dave Abrahams)
-//  28 Jun 00  Removed implicit_cast<>.  See comment below. (Beman Dawes)
-//  27 Jun 00  More MSVC6 workarounds
-//  15 Jun 00  Add workarounds for MSVC6
-//   2 Feb 00  Remove bad_numeric_cast ";" syntax error (Doncho Angelov)
-//  26 Jan 00  Add missing throw() to bad_numeric_cast::what(0 (Adam Levar)
-//  29 Dec 99  Change using declarations so usages in other namespaces work
-//             correctly (Dave Abrahams)
-//  23 Sep 99  Change polymorphic_downcast assert to also detect M.I. errors
-//             as suggested Darin Adler and improved by Valentin Bonnard.
-//   2 Sep 99  Remove controversial asserts, simplify, rename.
-//  30 Aug 99  Move to cast.hpp, replace value_cast with numeric_cast,
-//             place in nested namespace.
-//   3 Aug 99  Initial version
+// This is a DEPRECATED header file!
+// Use <boost/polymorphic_cast.hpp> or <boost/numeric/conversion/cast.hpp> instead
 
 #ifndef BOOST_CAST_HPP
 #define BOOST_CAST_HPP
 
-# include <boost/config.hpp>
-# include <boost/assert.hpp>
-# include <typeinfo>
-# include <boost/type.hpp>
-# include <boost/limits.hpp>
-# include <boost/detail/select_type.hpp>
-
-namespace boost
-{
-//  See the documentation for descriptions of how to choose between
-//  static_cast<>, dynamic_cast<>, polymorphic_cast<> and polymorphic_downcast<>
-
-//  polymorphic_cast  --------------------------------------------------------//
-
-    //  Runtime checked polymorphic downcasts and crosscasts.
-    //  Suggested in The C++ Programming Language, 3rd Ed, Bjarne Stroustrup,
-    //  section 15.8 exercise 1, page 425.
-
-    template <class Target, class Source>
-    inline Target polymorphic_cast(Source* x)
-    {
-        Target tmp = dynamic_cast<Target>(x);
-        if ( tmp == 0 ) throw std::bad_cast();
-        return tmp;
-    }
-
-//  polymorphic_downcast  ----------------------------------------------------//
-
-    //  BOOST_ASSERT() checked polymorphic downcast.  Crosscasts prohibited.
-
-    //  WARNING: Because this cast uses BOOST_ASSERT(), it violates
-    //  the One Definition Rule if used in multiple translation units
-    //  where BOOST_DISABLE_ASSERTS, BOOST_ENABLE_ASSERT_HANDLER
-    //  NDEBUG are defined inconsistently.
-
-    //  Contributed by Dave Abrahams
-
-    template <class Target, class Source>
-    inline Target polymorphic_downcast(Source* x)
-    {
-        BOOST_ASSERT( dynamic_cast<Target>(x) == x );  // detect logic error
-        return static_cast<Target>(x);
-    }
-
-} // namespace boost
-
+# include <boost/polymorphic_cast.hpp>
 # include <boost/numeric/conversion/cast.hpp>
 
 #endif  // BOOST_CAST_HPP
diff --git a/include/boost/detail/basic_pointerbuf.hpp b/include/boost/detail/basic_pointerbuf.hpp
deleted file mode 100644
index 1d8cf37..0000000
--- a/include/boost/detail/basic_pointerbuf.hpp
+++ /dev/null
@@ -1,139 +0,0 @@
-//-----------------------------------------------------------------------------
-// boost detail/templated_streams.hpp header file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2013 John Maddock, Antony Polukhin
-// 
-//
-// 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_DETAIL_BASIC_POINTERBUF_HPP
-#define BOOST_DETAIL_BASIC_POINTERBUF_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-#include "boost/config.hpp"
-#include <streambuf>
-
-namespace boost { namespace detail {
-
-//
-// class basic_pointerbuf:
-// acts as a stream buffer which wraps around a pair of pointers:
-//
-template <class charT, class BufferT >
-class basic_pointerbuf : public BufferT {
-protected:
-   typedef BufferT base_type;
-   typedef basic_pointerbuf<charT, BufferT> this_type;
-   typedef typename base_type::int_type int_type;
-   typedef typename base_type::char_type char_type;
-   typedef typename base_type::pos_type pos_type;
-   typedef ::std::streamsize streamsize;
-   typedef typename base_type::off_type off_type;
-
-public:
-   basic_pointerbuf() : base_type() { setbuf(0, 0); }
-   const charT* getnext() { return this->gptr(); }
-
-#ifndef BOOST_NO_USING_TEMPLATE
-    using base_type::pptr;
-    using base_type::pbase;
-#else
-    charT* pptr() const { return base_type::pptr(); }
-    charT* pbase() const { return base_type::pbase(); }
-#endif
-
-protected:
-   // VC mistakenly assumes that `setbuf` and other functions are not referenced.
-   // Marking those functions with `inline` suppresses the warnings.
-   // There must be no harm from marking virtual functions as inline: inline virtual
-   // call can be inlined ONLY when the compiler knows the "exact class".
-   inline base_type* setbuf(char_type* s, streamsize n);
-   inline typename this_type::pos_type seekpos(pos_type sp, ::std::ios_base::openmode which);
-   inline typename this_type::pos_type seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which);
-
-private:
-   basic_pointerbuf& operator=(const basic_pointerbuf&);
-   basic_pointerbuf(const basic_pointerbuf&);
-};
-
-template<class charT, class BufferT>
-BufferT*
-basic_pointerbuf<charT, BufferT>::setbuf(char_type* s, streamsize n)
-{
-   this->setg(s, s, s + n);
-   return this;
-}
-
-template<class charT, class BufferT>
-typename basic_pointerbuf<charT, BufferT>::pos_type
-basic_pointerbuf<charT, BufferT>::seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which)
-{
-   typedef typename boost::int_t<sizeof(way) * CHAR_BIT>::least cast_type;
-
-   if(which & ::std::ios_base::out)
-      return pos_type(off_type(-1));
-   std::ptrdiff_t size = this->egptr() - this->eback();
-   std::ptrdiff_t pos = this->gptr() - this->eback();
-   charT* g = this->eback();
-   switch(static_cast<cast_type>(way))
-   {
-   case ::std::ios_base::beg:
-      if((off < 0) || (off > size))
-         return pos_type(off_type(-1));
-      else
-         this->setg(g, g + off, g + size);
-      break;
-   case ::std::ios_base::end:
-      if((off < 0) || (off > size))
-         return pos_type(off_type(-1));
-      else
-         this->setg(g, g + size - off, g + size);
-      break;
-   case ::std::ios_base::cur:
-   {
-      std::ptrdiff_t newpos = static_cast<std::ptrdiff_t>(pos + off);
-      if((newpos < 0) || (newpos > size))
-         return pos_type(off_type(-1));
-      else
-         this->setg(g, g + newpos, g + size);
-      break;
-   }
-   default: ;
-   }
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4244)
-#endif
-   return static_cast<pos_type>(this->gptr() - this->eback());
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-}
-
-template<class charT, class BufferT>
-typename basic_pointerbuf<charT, BufferT>::pos_type
-basic_pointerbuf<charT, BufferT>::seekpos(pos_type sp, ::std::ios_base::openmode which)
-{
-   if(which & ::std::ios_base::out)
-      return pos_type(off_type(-1));
-   off_type size = static_cast<off_type>(this->egptr() - this->eback());
-   charT* g = this->eback();
-   if(off_type(sp) <= size)
-   {
-      this->setg(g, g + off_type(sp), g + size);
-   }
-   return pos_type(off_type(-1));
-}
-
-}} // namespace boost::detail
-
-#endif // BOOST_DETAIL_BASIC_POINTERBUF_HPP
-
diff --git a/include/boost/detail/lcast_precision.hpp b/include/boost/detail/lcast_precision.hpp
deleted file mode 100644
index 93abce1..0000000
--- a/include/boost/detail/lcast_precision.hpp
+++ /dev/null
@@ -1,184 +0,0 @@
-// Copyright Alexander Nasonov & Paul A. Bristow 2006.
-
-// 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)
-
-#ifndef BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
-#define BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
-
-#include <climits>
-#include <ios>
-#include <limits>
-
-#include <boost/config.hpp>
-#include <boost/integer_traits.hpp>
-
-#ifndef BOOST_NO_IS_ABSTRACT
-// Fix for SF:1358600 - lexical_cast & pure virtual functions & VC 8 STL
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits/is_abstract.hpp>
-#endif
-
-#if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || \
-  (defined(BOOST_MSVC) && (BOOST_MSVC<1310))
-
-#define BOOST_LCAST_NO_COMPILE_TIME_PRECISION
-#endif
-
-#ifdef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
-#include <boost/assert.hpp>
-#else
-#include <boost/static_assert.hpp>
-#endif
-
-namespace boost { namespace detail {
-
-class lcast_abstract_stub {};
-
-#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
-// Calculate an argument to pass to std::ios_base::precision from
-// lexical_cast. See alternative implementation for broken standard
-// libraries in lcast_get_precision below. Keep them in sync, please.
-template<class T>
-struct lcast_precision
-{
-#ifdef BOOST_NO_IS_ABSTRACT
-    typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
-#else
-    typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
-        boost::is_abstract<T>
-      , std::numeric_limits<lcast_abstract_stub>
-      , std::numeric_limits<T>
-      >::type limits;
-#endif
-
-    BOOST_STATIC_CONSTANT(bool, use_default_precision =
-            !limits::is_specialized || limits::is_exact
-        );
-
-    BOOST_STATIC_CONSTANT(bool, is_specialized_bin =
-            !use_default_precision &&
-            limits::radix == 2 && limits::digits > 0
-        );
-
-    BOOST_STATIC_CONSTANT(bool, is_specialized_dec =
-            !use_default_precision &&
-            limits::radix == 10 && limits::digits10 > 0
-        );
-
-    BOOST_STATIC_CONSTANT(std::streamsize, streamsize_max =
-            boost::integer_traits<std::streamsize>::const_max
-        );
-
-    BOOST_STATIC_CONSTANT(unsigned int, precision_dec = limits::digits10 + 1U);
-
-    BOOST_STATIC_ASSERT(!is_specialized_dec ||
-            precision_dec <= streamsize_max + 0UL
-        );
-
-    BOOST_STATIC_CONSTANT(unsigned long, precision_bin =
-            2UL + limits::digits * 30103UL / 100000UL
-        );
-
-    BOOST_STATIC_ASSERT(!is_specialized_bin ||
-            (limits::digits + 0UL < ULONG_MAX / 30103UL &&
-            precision_bin > limits::digits10 + 0UL &&
-            precision_bin <= streamsize_max + 0UL)
-        );
-
-    BOOST_STATIC_CONSTANT(std::streamsize, value =
-            is_specialized_bin ? precision_bin
-                               : is_specialized_dec ? precision_dec : 6
-        );
-};
-#endif
-
-template<class T>
-inline std::streamsize lcast_get_precision(T* = 0)
-{
-#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
-    return lcast_precision<T>::value;
-#else // Follow lcast_precision algorithm at run-time:
-
-#ifdef BOOST_NO_IS_ABSTRACT
-    typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
-#else
-    typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
-        boost::is_abstract<T>
-      , std::numeric_limits<lcast_abstract_stub>
-      , std::numeric_limits<T>
-      >::type limits;
-#endif
-
-    bool const use_default_precision =
-        !limits::is_specialized || limits::is_exact;
-
-    if(!use_default_precision)
-    { // Includes all built-in floating-point types, float, double ...
-      // and UDT types for which digits (significand bits) is defined (not zero)
-
-        bool const is_specialized_bin =
-            limits::radix == 2 && limits::digits > 0;
-        bool const is_specialized_dec =
-            limits::radix == 10 && limits::digits10 > 0;
-        std::streamsize const streamsize_max =
-            (boost::integer_traits<std::streamsize>::max)();
-
-        if(is_specialized_bin)
-        { // Floating-point types with
-          // limits::digits defined by the specialization.
-
-            unsigned long const digits = limits::digits;
-            unsigned long const precision = 2UL + digits * 30103UL / 100000UL;
-            // unsigned long is selected because it is at least 32-bits
-            // and thus ULONG_MAX / 30103UL is big enough for all types.
-            BOOST_ASSERT(
-                    digits < ULONG_MAX / 30103UL &&
-                    precision > limits::digits10 + 0UL &&
-                    precision <= streamsize_max + 0UL
-                );
-            return precision;
-        }
-        else if(is_specialized_dec)
-        {   // Decimal Floating-point type, most likely a User Defined Type
-            // rather than a real floating-point hardware type.
-            unsigned int const precision = limits::digits10 + 1U;
-            BOOST_ASSERT(precision <= streamsize_max + 0UL);
-            return precision;
-        }
-    }
-
-    // Integral type (for which precision has no effect)
-    // or type T for which limits is NOT specialized,
-    // so assume stream precision remains the default 6 decimal digits.
-    // Warning: if your User-defined Floating-point type T is NOT specialized,
-    // then you may lose accuracy by only using 6 decimal digits.
-    // To avoid this, you need to specialize T with either
-    // radix == 2 and digits == the number of significand bits,
-    // OR
-    // radix = 10 and digits10 == the number of decimal digits.
-
-    return 6;
-#endif
-}
-
-template<class T>
-inline void lcast_set_precision(std::ios_base& stream, T*)
-{
-    stream.precision(lcast_get_precision<T>());
-}
-
-template<class Source, class Target>
-inline void lcast_set_precision(std::ios_base& stream, Source*, Target*)
-{
-    std::streamsize const s = lcast_get_precision(static_cast<Source*>(0));
-    std::streamsize const t = lcast_get_precision(static_cast<Target*>(0));
-    stream.precision(s > t ? s : t);
-}
-
-}}
-
-#endif //  BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
-
diff --git a/include/boost/lexical_cast.hpp b/include/boost/lexical_cast.hpp
deleted file mode 100644
index 814b69e..0000000
--- a/include/boost/lexical_cast.hpp
+++ /dev/null
@@ -1,2514 +0,0 @@
-#ifndef BOOST_LEXICAL_CAST_INCLUDED
-#define BOOST_LEXICAL_CAST_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-// Boost lexical_cast.hpp header  -------------------------------------------//
-//
-// See http://www.boost.org/libs/conversion for documentation.
-// See end of this header for rights and permissions.
-//
-// what:  lexical_cast custom keyword cast
-// who:   contributed by Kevlin Henney,
-//        enhanced with contributions from Terje Slettebo,
-//        with additional fixes and suggestions from Gennaro Prota,
-//        Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
-//        Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
-//        Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
-// when:  November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
-#define BOOST_LCAST_NO_WCHAR_T
-#endif
-
-#include <climits>
-#include <cstddef>
-#include <string>
-#include <cstring>
-#include <cstdio>
-#include <typeinfo>
-#include <exception>
-#include <boost/limits.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/type_traits/ice.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/detail/lcast_precision.hpp>
-#include <boost/detail/workaround.hpp>
-
-
-#ifndef BOOST_NO_STD_LOCALE
-#   include <locale>
-#else
-#   ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
-        // Getting error at this point means, that your STL library is old/lame/misconfigured.
-        // If nothing can be done with STL library, define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE,
-        // but beware: lexical_cast will understand only 'C' locale delimeters and thousands
-        // separators.
-#       error "Unable to use <locale> header. Define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE to force "
-#       error "boost::lexical_cast to use only 'C' locale during conversions."
-#   endif
-#endif
-
-#ifdef BOOST_NO_STRINGSTREAM
-#include <strstream>
-#else
-#include <sstream>
-#endif
-
-#ifdef BOOST_NO_TYPEID
-#define BOOST_LCAST_THROW_BAD_CAST(S, T) throw_exception(bad_lexical_cast())
-#else
-#define BOOST_LCAST_THROW_BAD_CAST(Source, Target) \
-    throw_exception(bad_lexical_cast(typeid(Source), typeid(Target)))
-#endif
-
-namespace boost
-{
-    // exception used to indicate runtime lexical_cast failure
-    class BOOST_SYMBOL_VISIBLE bad_lexical_cast :
-    // workaround MSVC bug with std::bad_cast when _HAS_EXCEPTIONS == 0 
-#if defined(BOOST_MSVC) && defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS 
-        public std::exception 
-#else 
-        public std::bad_cast 
-#endif 
-
-#if defined(__BORLANDC__) && BOOST_WORKAROUND( __BORLANDC__, < 0x560 )
-        // under bcc32 5.5.1 bad_cast doesn't derive from exception
-        , public std::exception
-#endif
-
-    {
-    public:
-        bad_lexical_cast() BOOST_NOEXCEPT
-#ifndef BOOST_NO_TYPEID
-           : source(&typeid(void)), target(&typeid(void))
-#endif
-        {}
-
-        virtual const char *what() const BOOST_NOEXCEPT_OR_NOTHROW {
-            return "bad lexical cast: "
-                   "source type value could not be interpreted as target";
-        }
-
-        virtual ~bad_lexical_cast() BOOST_NOEXCEPT_OR_NOTHROW
-        {}
-
-#ifndef BOOST_NO_TYPEID
-        bad_lexical_cast(
-                const std::type_info &source_type_arg,
-                const std::type_info &target_type_arg) BOOST_NOEXCEPT
-            : source(&source_type_arg), target(&target_type_arg)
-        {}
-
-        const std::type_info &source_type() const BOOST_NOEXCEPT {
-            return *source;
-        }
-
-        const std::type_info &target_type() const BOOST_NOEXCEPT {
-            return *target;
-        }
-
-    private:
-        const std::type_info *source;
-        const std::type_info *target;
-#endif
-    };
-
-    namespace detail // widest_char
-    {
-        template <typename TargetChar, typename SourceChar>
-        struct widest_char
-        {
-            typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
-                (sizeof(TargetChar) > sizeof(SourceChar))
-                , TargetChar
-                , SourceChar >::type type;
-        };
-    }
-} // namespace boost
-
-#if !defined(__SUNPRO_CC) && !defined(__PGIC__)
-
-#include <cmath>
-#include <istream>
-
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
-#include <array>
-#endif
-
-#include <boost/array.hpp>
-#include <boost/numeric/conversion/cast.hpp>
-#include <boost/type_traits/make_unsigned.hpp>
-#include <boost/type_traits/is_signed.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/type_traits/has_left_shift.hpp>
-#include <boost/type_traits/has_right_shift.hpp>
-#include <boost/math/special_functions/sign.hpp>
-#include <boost/math/special_functions/fpclassify.hpp>
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/container/container_fwd.hpp>
-#include <boost/integer.hpp>
-#include <boost/detail/basic_pointerbuf.hpp>
-#include <boost/noncopyable.hpp>
-#ifndef BOOST_NO_CWCHAR
-#   include <cwchar>
-#endif
-
-namespace boost {
-
-    namespace detail // is_character<...>
-    {
-        // returns true, if T is one of the character types
-        template < typename T >
-        struct is_character
-        {
-            typedef boost::type_traits::ice_or<
-                    boost::is_same< T, char >::value,
-                    #ifndef BOOST_LCAST_NO_WCHAR_T
-                        boost::is_same< T, wchar_t >::value,
-                    #endif
-                    #ifndef BOOST_NO_CXX11_CHAR16_T
-                        boost::is_same< T, char16_t >::value,
-                    #endif
-                    #ifndef BOOST_NO_CXX11_CHAR32_T
-                        boost::is_same< T, char32_t >::value,
-                    #endif
-                    boost::is_same< T, unsigned char >::value,
-                    boost::is_same< T, signed char >::value
-            > result_type;
-
-            BOOST_STATIC_CONSTANT(bool, value = (result_type::value) );
-        };
-    }
-
-    namespace detail // normalize_single_byte_char<Char>
-    {
-        // Converts signed/unsigned char to char
-        template < class Char >
-        struct normalize_single_byte_char 
-        {
-            typedef Char type;
-        };
-
-        template <>
-        struct normalize_single_byte_char< signed char >
-        {
-            typedef char type;
-        };
-
-        template <>
-        struct normalize_single_byte_char< unsigned char >
-        {
-            typedef char type;
-        };
-    }
-
-    namespace detail // deduce_character_type_later<T>
-    {
-        // Helper type, meaning that stram character for T must be deduced 
-        // at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>)
-        template < class T > struct deduce_character_type_later {};
-    }
-
-    namespace detail // stream_char_common<T>
-    {
-        // Selectors to choose stream character type (common for Source and Target)
-        // Returns one of char, wchar_t, char16_t, char32_t or deduce_character_type_later<T> types
-        // Executed on Stage 1 (See deduce_source_char<T> and deduce_target_char<T>)
-        template < typename Type >
-        struct stream_char_common: public boost::mpl::if_c<
-            boost::detail::is_character< Type >::value,
-            Type,
-            boost::detail::deduce_character_type_later< Type >
-        > {};
-
-        template < typename Char >
-        struct stream_char_common< Char* >: public boost::mpl::if_c<
-            boost::detail::is_character< Char >::value,
-            Char,
-            boost::detail::deduce_character_type_later< Char* >
-        > {};
-
-        template < typename Char >
-        struct stream_char_common< const Char* >: public boost::mpl::if_c<
-            boost::detail::is_character< Char >::value,
-            Char,
-            boost::detail::deduce_character_type_later< const Char* >
-        > {};
-
-        template < typename Char >
-        struct stream_char_common< boost::iterator_range< Char* > >: public boost::mpl::if_c<
-            boost::detail::is_character< Char >::value,
-            Char,
-            boost::detail::deduce_character_type_later< boost::iterator_range< Char* > >
-        > {};
-    
-        template < typename Char >
-        struct stream_char_common< boost::iterator_range< const Char* > >: public boost::mpl::if_c<
-            boost::detail::is_character< Char >::value,
-            Char,
-            boost::detail::deduce_character_type_later< boost::iterator_range< const Char* > >
-        > {};
-
-        template < class Char, class Traits, class Alloc >
-        struct stream_char_common< std::basic_string< Char, Traits, Alloc > >
-        {
-            typedef Char type;
-        };
-
-        template < class Char, class Traits, class Alloc >
-        struct stream_char_common< boost::container::basic_string< Char, Traits, Alloc > >
-        {
-            typedef Char type;
-        };
-
-        template < typename Char, std::size_t N >
-        struct stream_char_common< boost::array< Char, N > >: public boost::mpl::if_c<
-            boost::detail::is_character< Char >::value,
-            Char,
-            boost::detail::deduce_character_type_later< boost::array< Char, N > >
-        > {};
-
-        template < typename Char, std::size_t N >
-        struct stream_char_common< boost::array< const Char, N > >: public boost::mpl::if_c<
-            boost::detail::is_character< Char >::value,
-            Char,
-            boost::detail::deduce_character_type_later< boost::array< const Char, N > >
-        > {};
-
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
-        template < typename Char, std::size_t N >
-        struct stream_char_common< std::array<Char, N > >: public boost::mpl::if_c<
-            boost::detail::is_character< Char >::value,
-            Char,
-            boost::detail::deduce_character_type_later< std::array< Char, N > >
-        > {};
-
-        template < typename Char, std::size_t N >
-        struct stream_char_common< std::array< const Char, N > >: public boost::mpl::if_c<
-            boost::detail::is_character< Char >::value,
-            Char,
-            boost::detail::deduce_character_type_later< std::array< const Char, N > >
-        > {};
-#endif
-
-#ifdef BOOST_HAS_INT128
-        template <> struct stream_char_common< boost::int128_type >: public boost::mpl::identity< char > {};
-        template <> struct stream_char_common< boost::uint128_type >: public boost::mpl::identity< char > {};
-#endif
-
-#if !defined(BOOST_LCAST_NO_WCHAR_T) && defined(BOOST_NO_INTRINSIC_WCHAR_T)
-        template <>
-        struct stream_char_common< wchar_t >
-        {
-            typedef char type;
-        };
-#endif
-    }
-
-    namespace detail // deduce_source_char_impl<T>
-    {
-        // If type T is `deduce_character_type_later` type, then tries to deduce
-        // character type using boost::has_left_shift<T> metafunction.
-        // Otherwise supplied type T is a character type, that must be normalized
-        // using normalize_single_byte_char<Char>.
-        // Executed at Stage 2  (See deduce_source_char<T> and deduce_target_char<T>)
-        template < class Char > 
-        struct deduce_source_char_impl
-        { 
-            typedef BOOST_DEDUCED_TYPENAME boost::detail::normalize_single_byte_char< Char >::type type; 
-        };
-        
-        template < class T > 
-        struct deduce_source_char_impl< deduce_character_type_later< T > > 
-        {
-            typedef boost::has_left_shift< std::basic_ostream< char >, T > result_t;
-
-#if defined(BOOST_LCAST_NO_WCHAR_T)
-            BOOST_STATIC_ASSERT_MSG((result_t::value), 
-                "Source type is not std::ostream`able and std::wostream`s are not supported by your STL implementation");
-            typedef char type;
-#else
-            typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
-                result_t::value, char, wchar_t
-            >::type type;
-
-            BOOST_STATIC_ASSERT_MSG((result_t::value || boost::has_left_shift< std::basic_ostream< type >, T >::value), 
-                "Source type is neither std::ostream`able nor std::wostream`able");
-#endif
-        };
-    }
-
-    namespace detail  // deduce_target_char_impl<T>
-    {
-        // If type T is `deduce_character_type_later` type, then tries to deduce
-        // character type using boost::has_right_shift<T> metafunction.
-        // Otherwise supplied type T is a character type, that must be normalized
-        // using normalize_single_byte_char<Char>.
-        // Executed at Stage 2  (See deduce_source_char<T> and deduce_target_char<T>)
-        template < class Char > 
-        struct deduce_target_char_impl 
-        { 
-            typedef BOOST_DEDUCED_TYPENAME normalize_single_byte_char< Char >::type type; 
-        };
-        
-        template < class T > 
-        struct deduce_target_char_impl< deduce_character_type_later<T> > 
-        { 
-            typedef boost::has_right_shift<std::basic_istream<char>, T > result_t;
-
-#if defined(BOOST_LCAST_NO_WCHAR_T)
-            BOOST_STATIC_ASSERT_MSG((result_t::value), 
-                "Target type is not std::istream`able and std::wistream`s are not supported by your STL implementation");
-            typedef char type;
-#else
-            typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
-                result_t::value, char, wchar_t
-            >::type type;
-            
-            BOOST_STATIC_ASSERT_MSG((result_t::value || boost::has_right_shift<std::basic_istream<wchar_t>, T >::value), 
-                "Target type is neither std::istream`able nor std::wistream`able");
-#endif
-        };
-    } 
-
-    namespace detail  // deduce_target_char<T> and deduce_source_char<T>
-    {
-        // We deduce stream character types in two stages.
-        //
-        // Stage 1 is common for Target and Source. At Stage 1 we get 
-        // non normalized character type (may contain unsigned/signed char)
-        // or deduce_character_type_later<T> where T is the original type.
-        // Stage 1 is executed by stream_char_common<T>
-        //
-        // At Stage 2 we normalize character types or try to deduce character 
-        // type using metafunctions. 
-        // Stage 2 is executed by deduce_target_char_impl<T> and 
-        // deduce_source_char_impl<T>
-        //
-        // deduce_target_char<T> and deduce_source_char<T> functions combine 
-        // both stages
-
-        template < class T >
-        struct deduce_target_char
-        {
-            typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type;
-            typedef BOOST_DEDUCED_TYPENAME deduce_target_char_impl< stage1_type >::type stage2_type;
-
-            typedef stage2_type type;
-        };
-
-        template < class T >
-        struct deduce_source_char
-        {
-            typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type;
-            typedef BOOST_DEDUCED_TYPENAME deduce_source_char_impl< stage1_type >::type stage2_type;
-
-            typedef stage2_type type;
-        };
-    }
-
-    namespace detail // extract_char_traits template
-    {
-        // We are attempting to get char_traits<> from T
-        // template parameter. Otherwise we'll be using std::char_traits<Char>
-        template < class Char, class T >
-        struct extract_char_traits
-                : boost::false_type
-        {
-            typedef std::char_traits< Char > trait_t;
-        };
-
-        template < class Char, class Traits, class Alloc >
-        struct extract_char_traits< Char, std::basic_string< Char, Traits, Alloc > >
-            : boost::true_type
-        {
-            typedef Traits trait_t;
-        };
-
-        template < class Char, class Traits, class Alloc>
-        struct extract_char_traits< Char, boost::container::basic_string< Char, Traits, Alloc > >
-            : boost::true_type
-        {
-            typedef Traits trait_t;
-        };
-    }
-
-    namespace detail // array_to_pointer_decay<T>
-    {
-        template<class T>
-        struct array_to_pointer_decay
-        {
-            typedef T type;
-        };
-
-        template<class T, std::size_t N>
-        struct array_to_pointer_decay<T[N]>
-        {
-            typedef const T * type;
-        };
-    }
-
-    namespace detail // is_this_float_conversion_optimized<Float, Char>
-    {
-        // this metafunction evaluates to true, if we have optimized comnversion 
-        // from Float type to Char array. 
-        // Must be in sync with lexical_stream_limited_src<Char, ...>::shl_real_type(...)
-        template <typename Float, typename Char>
-        struct is_this_float_conversion_optimized 
-        {
-            typedef boost::type_traits::ice_and<
-                boost::is_float<Float>::value,
-#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__)
-                boost::type_traits::ice_or<
-                    boost::type_traits::ice_eq<sizeof(Char), sizeof(char) >::value,
-                    boost::is_same<Char, wchar_t>::value
-                >::value
-#else
-                boost::type_traits::ice_eq<sizeof(Char), sizeof(char) >::value
-#endif
-            > result_type;
-
-            BOOST_STATIC_CONSTANT(bool, value = (result_type::value) );
-        };
-    }
-    
-    namespace detail // lcast_src_length
-    {
-        // Return max. length of string representation of Source;
-        template< class Source,         // Source type of lexical_cast.
-                  class Enable = void   // helper type
-                >
-        struct lcast_src_length
-        {
-            BOOST_STATIC_CONSTANT(std::size_t, value = 1);
-        };
-
-        // Helper for integral types.
-        // Notes on length calculation:
-        // Max length for 32bit int with grouping "\1" and thousands_sep ',':
-        // "-2,1,4,7,4,8,3,6,4,7"
-        //  ^                    - is_signed
-        //   ^                   - 1 digit not counted by digits10
-        //    ^^^^^^^^^^^^^^^^^^ - digits10 * 2
-        //
-        // Constant is_specialized is used instead of constant 1
-        // to prevent buffer overflow in a rare case when
-        // <boost/limits.hpp> doesn't add missing specialization for
-        // numeric_limits<T> for some integral type T.
-        // When is_specialized is false, the whole expression is 0.
-        template <class Source>
-        struct lcast_src_length<
-                    Source, BOOST_DEDUCED_TYPENAME boost::enable_if<boost::is_integral<Source> >::type
-                >
-        {
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-            BOOST_STATIC_CONSTANT(std::size_t, value =
-                  std::numeric_limits<Source>::is_signed +
-                  std::numeric_limits<Source>::is_specialized + /* == 1 */
-                  std::numeric_limits<Source>::digits10 * 2
-              );
-#else
-            BOOST_STATIC_CONSTANT(std::size_t, value = 156);
-            BOOST_STATIC_ASSERT(sizeof(Source) * CHAR_BIT <= 256);
-#endif
-        };
-
-#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
-        // Helper for floating point types.
-        // -1.23456789e-123456
-        // ^                   sign
-        //  ^                  leading digit
-        //   ^                 decimal point 
-        //    ^^^^^^^^         lcast_precision<Source>::value
-        //            ^        "e"
-        //             ^       exponent sign
-        //              ^^^^^^ exponent (assumed 6 or less digits)
-        // sign + leading digit + decimal point + "e" + exponent sign == 5
-        template<class Source>
-        struct lcast_src_length<
-                Source, BOOST_DEDUCED_TYPENAME boost::enable_if<boost::is_float<Source> >::type
-            >
-        {
-            BOOST_STATIC_ASSERT(
-                    std::numeric_limits<Source>::max_exponent10 <=  999999L &&
-                    std::numeric_limits<Source>::min_exponent10 >= -999999L
-                );
-
-            BOOST_STATIC_CONSTANT(std::size_t, value =
-                    5 + lcast_precision<Source>::value + 6
-                );
-        };
-#endif // #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
-    }
-
-    namespace detail // lexical_cast_stream_traits<Source, Target>
-    {
-        template <class Source, class Target>
-        struct lexical_cast_stream_traits {
-            typedef BOOST_DEDUCED_TYPENAME boost::detail::array_to_pointer_decay<Source>::type src;
-            typedef BOOST_DEDUCED_TYPENAME boost::remove_cv<src>::type            no_cv_src;
-                
-            typedef boost::detail::deduce_source_char<no_cv_src>                           deduce_src_char_metafunc;
-            typedef BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::type           src_char_t;
-            typedef BOOST_DEDUCED_TYPENAME boost::detail::deduce_target_char<Target>::type target_char_t;
-                
-            typedef BOOST_DEDUCED_TYPENAME boost::detail::widest_char<
-                target_char_t, src_char_t
-            >::type char_type;
-
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-            BOOST_STATIC_ASSERT_MSG(( !boost::is_same<char16_t, src_char_t>::value
-                                        && !boost::is_same<char16_t, target_char_t>::value),
-                "Your compiler does not have full support for char16_t" );
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-            BOOST_STATIC_ASSERT_MSG(( !boost::is_same<char32_t, src_char_t>::value
-                                        && !boost::is_same<char32_t, target_char_t>::value),
-                "Your compiler does not have full support for char32_t" );
-#endif
-
-            typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
-                boost::detail::extract_char_traits<char_type, Target>::value,
-                BOOST_DEDUCED_TYPENAME boost::detail::extract_char_traits<char_type, Target>,
-                BOOST_DEDUCED_TYPENAME boost::detail::extract_char_traits<char_type, no_cv_src>
-            >::type::trait_t traits;
-
-            typedef boost::type_traits::ice_and<
-                boost::is_same<char, src_char_t>::value,                                  // source is not a wide character based type
-                boost::type_traits::ice_ne<sizeof(char), sizeof(target_char_t) >::value,  // target type is based on wide character
-                boost::type_traits::ice_not<
-                    boost::detail::is_character<no_cv_src>::value                     // single character widening is optimized
-                >::value                                                                  // and does not requires stringbuffer
-            >   is_string_widening_required_t;
-
-            typedef boost::type_traits::ice_not< boost::type_traits::ice_or<
-                boost::is_integral<no_cv_src>::value,
-                boost::detail::is_this_float_conversion_optimized<no_cv_src, char_type >::value,
-                boost::detail::is_character<
-                    BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::stage1_type          // if we did not get character type at stage1
-                >::value                                                                  // then we have no optimization for that type
-            >::value >   is_source_input_not_optimized_t;
-
-            // If we have an optimized conversion for
-            // Source, we do not need to construct stringbuf.
-            BOOST_STATIC_CONSTANT(bool, requires_stringbuf = 
-                (boost::type_traits::ice_or<
-                    is_string_widening_required_t::value, is_source_input_not_optimized_t::value
-                >::value)
-            );
-            
-            typedef boost::detail::lcast_src_length<no_cv_src> len_t;
-        };
-    }
-
-    namespace detail // '0', '-', '+', 'e', 'E' and '.' constants
-    {
-        template < typename Char >
-        struct lcast_char_constants {
-            // We check in tests assumption that static casted character is
-            // equal to correctly written C++ literal: U'0' == static_cast<char32_t>('0')
-            BOOST_STATIC_CONSTANT(Char, zero  = static_cast<Char>('0'));
-            BOOST_STATIC_CONSTANT(Char, minus = static_cast<Char>('-'));
-            BOOST_STATIC_CONSTANT(Char, plus = static_cast<Char>('+'));
-            BOOST_STATIC_CONSTANT(Char, lowercase_e = static_cast<Char>('e'));
-            BOOST_STATIC_CONSTANT(Char, capital_e = static_cast<Char>('E'));
-            BOOST_STATIC_CONSTANT(Char, c_decimal_separator = static_cast<Char>('.'));
-        };
-    }
-
-    namespace detail // lcast_to_unsigned
-    {
-        template<class T>
-        inline
-        BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type lcast_to_unsigned(const T value) BOOST_NOEXCEPT {
-            typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type result_type;
-            return value < 0 
-                ? static_cast<result_type>(0u - static_cast<result_type>(value)) 
-                : static_cast<result_type>(value);
-        }
-    }
-
-    namespace detail // lcast_put_unsigned
-    {
-        template <class Traits, class T, class CharT>
-        class lcast_put_unsigned: boost::noncopyable {
-            typedef BOOST_DEDUCED_TYPENAME Traits::int_type int_type;
-            BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
-                    (sizeof(int_type) > sizeof(T))
-                    , int_type
-                    , T
-            >::type         m_value;
-            CharT*          m_finish;
-            CharT    const  m_czero;
-            int_type const  m_zero;
-
-        public:
-            lcast_put_unsigned(const T n_param, CharT* finish) BOOST_NOEXCEPT 
-                : m_value(n_param), m_finish(finish)
-                , m_czero(lcast_char_constants<CharT>::zero), m_zero(Traits::to_int_type(m_czero))
-            {
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-                BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
-#endif
-            }
-
-            CharT* convert() {
-#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
-                std::locale loc;
-                if (loc == std::locale::classic()) {
-                    return main_convert_loop();
-                }
-
-                typedef std::numpunct<CharT> numpunct;
-                numpunct const& np = BOOST_USE_FACET(numpunct, loc);
-                std::string const grouping = np.grouping();
-                std::string::size_type const grouping_size = grouping.size();
-
-                if (!grouping_size || grouping[0] <= 0) {
-                    return main_convert_loop();
-                }
-
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-                // Check that ulimited group is unreachable:
-                BOOST_STATIC_ASSERT(std::numeric_limits<T>::digits10 < CHAR_MAX);
-#endif
-                CharT const thousands_sep = np.thousands_sep();
-                std::string::size_type group = 0; // current group number
-                char last_grp_size = grouping[0];
-                char left = last_grp_size;
-
-                do {
-                    if (left == 0) {
-                        ++group;
-                        if (group < grouping_size) {
-                            char const grp_size = grouping[group];
-                            last_grp_size = (grp_size <= 0 ? static_cast<char>(CHAR_MAX) : grp_size);
-                        }
-
-                        left = last_grp_size;
-                        --m_finish;
-                        Traits::assign(*m_finish, thousands_sep);
-                    }
-
-                    --left;
-                } while (main_convert_itaration());
-
-                return m_finish;
-#else
-                return main_convert_loop();
-#endif
-            }
-
-        private:
-            inline bool main_convert_itaration() BOOST_NOEXCEPT {
-                --m_finish;
-                int_type const digit = static_cast<int_type>(m_value % 10U);
-                Traits::assign(*m_finish, Traits::to_char_type(m_zero + digit));
-                m_value /= 10;
-                return !!m_value; // supressing warnings
-            }
-
-            inline CharT* main_convert_loop() BOOST_NOEXCEPT {
-                while (main_convert_itaration());
-                return m_finish;
-            }
-        };
-    }
-
-    namespace detail // lcast_ret_unsigned
-    {
-        template <class Traits, class T, class CharT>
-        class lcast_ret_unsigned: boost::noncopyable {
-            bool m_multiplier_overflowed;
-            T m_multiplier;
-            T& m_value;
-            const CharT* const m_begin;
-            const CharT* m_end;
-    
-        public:
-            lcast_ret_unsigned(T& value, const CharT* const begin, const CharT* end) BOOST_NOEXCEPT
-                : m_multiplier_overflowed(false), m_multiplier(1), m_value(value), m_begin(begin), m_end(end)
-            {
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-                BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
-
-                // GCC when used with flag -std=c++0x may not have std::numeric_limits
-                // specializations for __int128 and unsigned __int128 types.
-                // Try compilation with -std=gnu++0x or -std=gnu++11.
-                //
-                // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=40856
-                BOOST_STATIC_ASSERT_MSG(std::numeric_limits<T>::is_specialized,
-                    "std::numeric_limits are not specialized for integral type passed to boost::lexical_cast"
-                );
-#endif
-            }
-
-            inline bool convert() {
-                CharT const czero = lcast_char_constants<CharT>::zero;
-                --m_end;
-                m_value = static_cast<T>(0);
-
-                if (m_begin > m_end || *m_end < czero || *m_end >= czero + 10)
-                    return false;
-                m_value = static_cast<T>(*m_end - czero);
-                --m_end;
-
-#ifdef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
-                return main_convert_loop();
-#else
-                std::locale loc;
-                if (loc == std::locale::classic()) {
-                    return main_convert_loop();
-                }
-
-                typedef std::numpunct<CharT> numpunct;
-                numpunct const& np = BOOST_USE_FACET(numpunct, loc);
-                std::string const& grouping = np.grouping();
-                std::string::size_type const grouping_size = grouping.size();
-
-                /* According to Programming languages - C++
-                 * we MUST check for correct grouping
-                 */
-                if (!grouping_size || grouping[0] <= 0) {
-                    return main_convert_loop();
-                }
-
-                unsigned char current_grouping = 0;
-                CharT const thousands_sep = np.thousands_sep();
-                char remained = static_cast<char>(grouping[current_grouping] - 1);
-
-                for (;m_end >= m_begin; --m_end)
-                {
-                    if (remained) {
-                        if (!main_convert_itaration()) {
-                            return false;
-                        }
-                        --remained;
-                    } else {
-                        if ( !Traits::eq(*m_end, thousands_sep) ) //|| begin == end ) return false;
-                        {
-                            /*
-                             * According to Programming languages - C++
-                             * Digit grouping is checked. That is, the positions of discarded
-                             * separators is examined for consistency with
-                             * use_facet<numpunct<charT> >(loc ).grouping()
-                             *
-                             * BUT what if there is no separators at all and grouping()
-                             * is not empty? Well, we have no extraced separators, so we
-                             * won`t check them for consistency. This will allow us to
-                             * work with "C" locale from other locales
-                             */
-                            return main_convert_loop();
-                        } else {
-                            if (m_begin == m_end) return false;
-                            if (current_grouping < grouping_size - 1) ++current_grouping;
-                            remained = grouping[current_grouping];
-                        }
-                    }
-                } /*for*/
-
-                return true;
-#endif
-            }
-
-        private:
-            // Iteration that does not care about grouping/separators and assumes that all 
-            // input characters are digits
-            inline bool main_convert_itaration() BOOST_NOEXCEPT {
-                CharT const czero = lcast_char_constants<CharT>::zero;
-                T const maxv = (std::numeric_limits<T>::max)();
-
-                m_multiplier_overflowed = m_multiplier_overflowed || (maxv/10 < m_multiplier);
-                m_multiplier = static_cast<T>(m_multiplier * 10);
-
-                T const dig_value = static_cast<T>(*m_end - czero);
-                T const new_sub_value = static_cast<T>(m_multiplier * dig_value);
-
-                // We must correctly handle situations like `000000000000000000000000000001`.
-                // So we take care of overflow only if `dig_value` is not '0'.
-                if (*m_end < czero || *m_end >= czero + 10  // checking for correct digit
-                    || (dig_value && (                      // checking for overflow of ... 
-                        m_multiplier_overflowed                             // ... multiplier
-                        || static_cast<T>(maxv / dig_value) < m_multiplier  // ... subvalue
-                        || static_cast<T>(maxv - new_sub_value) < m_value   // ... whole expression
-                    ))
-                ) return false;
-
-                m_value = static_cast<T>(m_value + new_sub_value);
-                
-                return true;
-            }
-
-            bool main_convert_loop() BOOST_NOEXCEPT {
-                for ( ; m_end >= m_begin; --m_end) {
-                    if (!main_convert_itaration()) {
-                        return false;
-                    }
-                }
-            
-                return true;
-            }
-        };
-    }
-
-    namespace detail
-    {
-        template <class CharT>
-        bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) BOOST_NOEXCEPT {
-            for( unsigned int i=0; i < len; ++i ) {
-                if ( val[i] != lcase[i] && val[i] != ucase[i] ) return false;
-            }
-
-            return true;
-        }
-
-        /* Returns true and sets the correct value if found NaN or Inf. */
-        template <class CharT, class T>
-        inline bool parse_inf_nan_impl(const CharT* begin, const CharT* end, T& value
-            , const CharT* lc_NAN, const CharT* lc_nan
-            , const CharT* lc_INFINITY, const CharT* lc_infinity
-            , const CharT opening_brace, const CharT closing_brace) BOOST_NOEXCEPT
-        {
-            using namespace std;
-            if (begin == end) return false;
-            const CharT minus = lcast_char_constants<CharT>::minus;
-            const CharT plus = lcast_char_constants<CharT>::plus;
-            const int inifinity_size = 8; // == sizeof("infinity") - 1
-
-            /* Parsing +/- */
-            bool const has_minus = (*begin == minus);
-            if (has_minus || *begin == plus) {
-                ++ begin;
-            }
-
-            if (end - begin < 3) return false;
-            if (lc_iequal(begin, lc_nan, lc_NAN, 3)) {
-                begin += 3;
-                if (end != begin) {
-                    /* It is 'nan(...)' or some bad input*/
-                    
-                    if (end - begin < 2) return false; // bad input
-                    -- end;
-                    if (*begin != opening_brace || *end != closing_brace) return false; // bad input
-                }
-
-                if( !has_minus ) value = std::numeric_limits<T>::quiet_NaN();
-                else value = (boost::math::changesign) (std::numeric_limits<T>::quiet_NaN());
-                return true;
-            } else if (
-                ( /* 'INF' or 'inf' */
-                  end - begin == 3      // 3 == sizeof('inf') - 1
-                  && lc_iequal(begin, lc_infinity, lc_INFINITY, 3)
-                )
-                ||
-                ( /* 'INFINITY' or 'infinity' */
-                  end - begin == inifinity_size
-                  && lc_iequal(begin, lc_infinity, lc_INFINITY, inifinity_size)
-                )
-             )
-            {
-                if( !has_minus ) value = std::numeric_limits<T>::infinity();
-                else value = (boost::math::changesign) (std::numeric_limits<T>::infinity());
-                return true;
-            }
-
-            return false;
-        }
-
-        template <class CharT, class T>
-        bool put_inf_nan_impl(CharT* begin, CharT*& end, const T& value
-                         , const CharT* lc_nan
-                         , const CharT* lc_infinity) BOOST_NOEXCEPT
-        {
-            using namespace std;
-            const CharT minus = lcast_char_constants<CharT>::minus;
-            if ((boost::math::isnan)(value)) {
-                if ((boost::math::signbit)(value)) {
-                    *begin = minus;
-                    ++ begin;
-                }
-
-                memcpy(begin, lc_nan, 3 * sizeof(CharT));
-                end = begin + 3;
-                return true;
-            } else if ((boost::math::isinf)(value)) {
-                if ((boost::math::signbit)(value)) {
-                    *begin = minus;
-                    ++ begin;
-                }
-
-                memcpy(begin, lc_infinity, 3 * sizeof(CharT));
-                end = begin + 3;
-                return true;
-            }
-
-            return false;
-        }
-
-
-#ifndef BOOST_LCAST_NO_WCHAR_T
-        template <class T>
-        bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value) BOOST_NOEXCEPT {
-            return parse_inf_nan_impl(begin, end, value
-                               , L"NAN", L"nan"
-                               , L"INFINITY", L"infinity"
-                               , L'(', L')');
-        }
-
-        template <class T>
-        bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value) BOOST_NOEXCEPT {
-            return put_inf_nan_impl(begin, end, value, L"nan", L"infinity");
-        }
-
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-        template <class T>
-        bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value) BOOST_NOEXCEPT {
-            return parse_inf_nan_impl(begin, end, value
-                               , u"NAN", u"nan"
-                               , u"INFINITY", u"infinity"
-                               , u'(', u')');
-        }
-
-        template <class T>
-        bool put_inf_nan(char16_t* begin, char16_t*& end, const T& value) BOOST_NOEXCEPT {
-            return put_inf_nan_impl(begin, end, value, u"nan", u"infinity");
-        }
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-        template <class T>
-        bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value) BOOST_NOEXCEPT {
-            return parse_inf_nan_impl(begin, end, value
-                               , U"NAN", U"nan"
-                               , U"INFINITY", U"infinity"
-                               , U'(', U')');
-        }
-
-        template <class T>
-        bool put_inf_nan(char32_t* begin, char32_t*& end, const T& value) BOOST_NOEXCEPT {
-            return put_inf_nan_impl(begin, end, value, U"nan", U"infinity");
-        }
-#endif
-
-        template <class CharT, class T>
-        bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) BOOST_NOEXCEPT {
-            return parse_inf_nan_impl(begin, end, value
-                               , "NAN", "nan"
-                               , "INFINITY", "infinity"
-                               , '(', ')');
-        }
-
-        template <class CharT, class T>
-        bool put_inf_nan(CharT* begin, CharT*& end, const T& value) BOOST_NOEXCEPT {
-            return put_inf_nan_impl(begin, end, value, "nan", "infinity");
-        }
-    }
-
-
-    namespace detail // lcast_ret_float
-    {
-
-// Silence buggy MS warnings like C4244: '+=' : conversion from 'int' to 'unsigned short', possible loss of data 
-#if defined(_MSC_VER) && (_MSC_VER == 1400) 
-#  pragma warning(push) 
-#  pragma warning(disable:4244) 
-#endif 
-        template <class T>
-        struct mantissa_holder_type
-        {
-            /* Can not be used with this type */
-        };
-
-        template <>
-        struct mantissa_holder_type<float>
-        {
-            typedef unsigned int type;
-            typedef double       wide_result_t;
-        };
-
-        template <>
-        struct mantissa_holder_type<double>
-        {
-#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
-            typedef long double  wide_result_t;
-#if defined(BOOST_HAS_LONG_LONG)
-            typedef boost::ulong_long_type type;
-#elif defined(BOOST_HAS_MS_INT64)
-            typedef unsigned __int64 type;
-#endif
-#endif
-        };
-
-        template<class Traits, class T, class CharT>
-        inline bool lcast_ret_float(T& value, const CharT* begin, const CharT* const end)
-        {
-            value = static_cast<T>(0);
-            if (begin == end) return false;
-            if (parse_inf_nan(begin, end, value)) return true;
-
-            CharT const czero = lcast_char_constants<CharT>::zero;
-            CharT const minus = lcast_char_constants<CharT>::minus;
-            CharT const plus = lcast_char_constants<CharT>::plus;
-            CharT const capital_e = lcast_char_constants<CharT>::capital_e;
-            CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e;
-            
-            /* Getting the plus/minus sign */
-            bool const has_minus = Traits::eq(*begin, minus);
-            if (has_minus || Traits::eq(*begin, plus)) {
-                ++ begin;
-                if (begin == end) return false;
-            }
-
-#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
-            std::locale loc;
-            typedef std::numpunct<CharT> numpunct;
-            numpunct const& np = BOOST_USE_FACET(numpunct, loc);
-            std::string const grouping(
-                    (loc == std::locale::classic())
-                    ? std::string()
-                    : np.grouping()
-            );
-            std::string::size_type const grouping_size = grouping.size();
-            CharT const thousands_sep = static_cast<CharT>(grouping_size ? np.thousands_sep() : 0);
-            CharT const decimal_point = np.decimal_point();
-            bool found_grouping = false;
-            std::string::size_type last_grouping_pos = grouping_size - 1;
-#else
-            CharT const decimal_point = lcast_char_constants<CharT>::c_decimal_separator;
-#endif
-
-            bool found_decimal = false;
-            bool found_number_before_exp = false;
-            typedef int pow_of_10_t;
-            pow_of_10_t pow_of_10 = 0;
-
-            typedef BOOST_DEDUCED_TYPENAME mantissa_holder_type<T>::type mantissa_type;
-            mantissa_type mantissa=0;
-            bool is_mantissa_full = false;
-            char length_since_last_delim = 0;
-
-            while (begin != end) {
-                if (found_decimal) {
-                    /* We allow no thousand_separators after decimal point */
-
-                    const mantissa_type tmp_sub_value = static_cast<mantissa_type>(*begin - czero);
-                    if (Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) break;
-                    if ( *begin < czero || *begin >= czero + 10 ) return false;
-                    if (    is_mantissa_full
-                            || ((std::numeric_limits<mantissa_type>::max)() - tmp_sub_value) / 10u  < mantissa
-                            ) {
-                        is_mantissa_full = true;
-                        ++ begin;
-                        continue;
-                    }
-
-                    -- pow_of_10;
-                    mantissa = static_cast<mantissa_type>(mantissa * 10 + tmp_sub_value);
-
-                    found_number_before_exp = true;
-                } else {
-
-                    if (*begin >= czero && *begin < czero + 10) {
-
-                        /* Checking for mantissa overflow. If overflow will
-                         * occur, them we only increase multiplyer
-                         */
-                        const mantissa_type tmp_sub_value = static_cast<mantissa_type>(*begin - czero);
-                        if(     is_mantissa_full
-                                || ((std::numeric_limits<mantissa_type>::max)() - tmp_sub_value) / 10u  < mantissa
-                            )
-                        {
-                            is_mantissa_full = true;
-                            ++ pow_of_10;
-                        } else {
-                            mantissa = static_cast<mantissa_type>(mantissa * 10 + tmp_sub_value);
-                        }
-
-                        found_number_before_exp = true;
-                        ++ length_since_last_delim;
-                    } else if (Traits::eq(*begin, decimal_point) || Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) {
-#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
-                        /* If ( we need to check grouping
-                         *      and (   grouping missmatches
-                         *              or grouping position is incorrect
-                         *              or we are using the grouping position 0 twice
-                         *           )
-                         *    ) then return error
-                         */
-                        if( grouping_size && found_grouping
-                            && (
-                                   length_since_last_delim != grouping[0]
-                                   || last_grouping_pos>1
-                                   || (last_grouping_pos==0 && grouping_size>1)
-                                )
-                           ) return false;
-#endif
-
-                        if (Traits::eq(*begin, decimal_point)) {
-                            ++ begin;
-                            found_decimal = true;
-                            if (!found_number_before_exp && begin==end) return false;
-                            continue;
-                        } else {
-                            if (!found_number_before_exp) return false;
-                            break;
-                        }
-                    }
-#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
-                    else if (grouping_size && Traits::eq(*begin, thousands_sep)){
-                        if(found_grouping)
-                        {
-                            /* It is not he first time, when we find thousands separator,
-                             * so we need to chek, is the distance between two groupings
-                             * equal to grouping[last_grouping_pos] */
-
-                            if (length_since_last_delim != grouping[last_grouping_pos] )
-                            {
-                                if (!last_grouping_pos) return false;
-                                else
-                                {
-                                    -- last_grouping_pos;
-                                    if (length_since_last_delim != grouping[last_grouping_pos]) return false;
-                                }
-                            } else
-                                /* We are calling the grouping[0] twice, when grouping size is more than 1 */
-                                if (grouping_size>1u && last_grouping_pos+1<grouping_size) return false;
-
-                        } else {
-                            /* Delimiter at the begining ',000' */
-                            if (!length_since_last_delim) return false;
-
-                            found_grouping = true;
-                            if (length_since_last_delim > grouping[last_grouping_pos] ) return false;
-                        }
-
-                        length_since_last_delim = 0;
-                        ++ begin;
-
-                        /* Delimiter at the end '100,' */
-                        if (begin == end) return false;
-                        continue;
-                    }
-#endif
-                    else return false;
-                }
-
-                ++begin;
-            }
-
-            // Exponent found
-            if (begin != end && (Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e))) {
-                ++ begin;
-                if (begin == end) return false;
-
-                bool const exp_has_minus = Traits::eq(*begin, minus);
-                if (exp_has_minus || Traits::eq(*begin, plus)) {
-                    ++ begin;
-                    if (begin == end) return false;
-                }
-
-                pow_of_10_t exp_pow_of_10 = 0;
-                while (begin != end) {
-                    pow_of_10_t const sub_value = *begin - czero;
-
-                    if ( *begin < czero || *begin >= czero + 10
-                         || ((std::numeric_limits<pow_of_10_t>::max)() - sub_value) / 10 < exp_pow_of_10)
-                        return false;
-
-                    exp_pow_of_10 *= 10;
-                    exp_pow_of_10 += sub_value;
-                    ++ begin;
-                };
-
-                if (exp_has_minus) {
-                    if ((std::numeric_limits<pow_of_10_t>::min)() + exp_pow_of_10 > pow_of_10)
-                        return false;   // failed overflow check
-                    pow_of_10 -= exp_pow_of_10;
-                } else {
-                    if ((std::numeric_limits<pow_of_10_t>::max)() - exp_pow_of_10 < pow_of_10)
-                        return false;   // failed overflow check
-                    pow_of_10 += exp_pow_of_10;
-                }
-            }
-
-            /* We need a more accurate algorithm... We can not use current algorithm
-             * with long doubles (and with doubles if sizeof(double)==sizeof(long double)).
-             */
-            typedef BOOST_DEDUCED_TYPENAME mantissa_holder_type<T>::wide_result_t wide_result_t;
-            const wide_result_t result = std::pow(static_cast<wide_result_t>(10.0), pow_of_10) * mantissa;
-            value = static_cast<T>( has_minus ? (boost::math::changesign)(result) : result);
-
-            return !((boost::math::isinf)(value) || (boost::math::isnan)(value));
-        }
-// Unsilence buggy MS warnings like C4244: '+=' : conversion from 'int' to 'unsigned short', possible loss of data 
-#if defined(_MSC_VER) && (_MSC_VER == 1400) 
-#  pragma warning(pop) 
-#endif 
-    }
-
-    namespace detail // basic_unlockedbuf
-    {
-        // acts as a stream buffer which wraps around a pair of pointers
-        // and gives acces to internals
-        template <class BufferType, class CharT>
-        class basic_unlockedbuf : public basic_pointerbuf<CharT, BufferType> {
-        public:
-           typedef basic_pointerbuf<CharT, BufferType> base_type;
-           typedef BOOST_DEDUCED_TYPENAME base_type::streamsize streamsize;
-
-#ifndef BOOST_NO_USING_TEMPLATE
-            using base_type::pptr;
-            using base_type::pbase;
-            using base_type::setbuf;
-#else
-            charT* pptr() const { return base_type::pptr(); }
-            charT* pbase() const { return base_type::pbase(); }
-            BufferType* setbuf(char_type* s, streamsize n) { return base_type::setbuf(s, n); }
-#endif
-        };
-    }
-
-    namespace detail
-    {
-        struct do_not_construct_out_stream_t{};
-        
-        template <class CharT, class Traits>
-        struct out_stream_helper_trait {
-#if defined(BOOST_NO_STRINGSTREAM)
-            typedef std::ostrstream                                 out_stream_t;
-            typedef void                                            buffer_t;
-#elif defined(BOOST_NO_STD_LOCALE)
-            typedef std::ostringstream                              out_stream_t;
-            typedef basic_unlockedbuf<std::streambuf, char>         buffer_t;
-#else
-            typedef std::basic_ostringstream<CharT, Traits> 
-                out_stream_t;
-            typedef basic_unlockedbuf<std::basic_streambuf<CharT, Traits>, CharT>  
-                buffer_t;
-#endif
-        };   
-    }
-
-    namespace detail // optimized stream wrappers
-    {
-        template< class CharT // a result of widest_char transformation
-                , class Traits
-                , bool RequiresStringbuffer
-                , std::size_t CharacterBufferSize
-                >
-        class lexical_istream_limited_src: boost::noncopyable {
-            typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::buffer_t
-                buffer_t;
-
-            typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::out_stream_t
-                out_stream_t;
-    
-            typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
-                RequiresStringbuffer,
-                out_stream_t,
-                do_not_construct_out_stream_t
-            >::type deduced_out_stream_t;
-
-            // A string representation of Source is written to `buffer`.
-            deduced_out_stream_t out_stream;
-            CharT   buffer[CharacterBufferSize];
-
-            // After the `operator <<`  finishes, `[start, finish)` is
-            // the range to output by `operator >>` 
-            const CharT*  start;
-            const CharT*  finish;
-
-        public:
-            lexical_istream_limited_src() BOOST_NOEXCEPT
-              : start(buffer)
-              , finish(buffer + CharacterBufferSize)
-            {}
-    
-            const CharT* cbegin() const BOOST_NOEXCEPT {
-                return start;
-            }
-
-            const CharT* cend() const BOOST_NOEXCEPT {
-                return finish;
-            }
-
-        private:
-            // Undefined:
-            lexical_istream_limited_src(lexical_istream_limited_src const&);
-            void operator=(lexical_istream_limited_src const&);
-
-/************************************ HELPER FUNCTIONS FOR OPERATORS << ( ... ) ********************************/
-            bool shl_char(CharT ch) BOOST_NOEXCEPT {
-                Traits::assign(buffer[0], ch);
-                finish = start + 1;
-                return true;
-            }
-
-#ifndef BOOST_LCAST_NO_WCHAR_T
-            template <class T>
-            bool shl_char(T ch) {
-                BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)) ,
-                    "boost::lexical_cast does not support narrowing of char types."
-                    "Use boost::locale instead" );
-#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
-                std::locale loc;
-                CharT const w = BOOST_USE_FACET(std::ctype<CharT>, loc).widen(ch);
-#else
-                CharT const w = static_cast<CharT>(ch);
-#endif
-                Traits::assign(buffer[0], w);
-                finish = start + 1;
-                return true;
-            }
-#endif
-
-            bool shl_char_array(CharT const* str) BOOST_NOEXCEPT {
-                start = str;
-                finish = start + Traits::length(str);
-                return true;
-            }
-
-            template <class T>
-            bool shl_char_array(T const* str) {
-                BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)),
-                    "boost::lexical_cast does not support narrowing of char types."
-                    "Use boost::locale instead" );
-                return shl_input_streamable(str);
-            }
-            
-            bool shl_char_array_limited(CharT const* str, std::size_t max_size) BOOST_NOEXCEPT {
-                start = str;
-                finish = std::find(start, start + max_size, Traits::to_char_type(0));
-                return true;
-            }
-
-            template<typename InputStreamable>
-            bool shl_input_streamable(InputStreamable& input) {
-#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
-                // If you have compilation error at this point, than your STL library
-                // does not support such conversions. Try updating it.
-                BOOST_STATIC_ASSERT((boost::is_same<char, CharT>::value));
-#endif
-
-#ifndef BOOST_NO_EXCEPTIONS
-                out_stream.exceptions(std::ios::badbit);
-                try {
-#endif
-                bool const result = !(out_stream << input).fail();
-                const buffer_t* const p = static_cast<buffer_t*>(
-                    static_cast<std::basic_streambuf<CharT, Traits>*>(out_stream.rdbuf())
-                );
-                start = p->pbase();
-                finish = p->pptr();
-                return result;
-#ifndef BOOST_NO_EXCEPTIONS
-                } catch (const ::std::ios_base::failure& /*f*/) {
-                    return false;
-                }
-#endif
-            }
-
-            template <class T>
-            inline bool shl_unsigned(const T n) {
-                CharT* tmp_finish = buffer + CharacterBufferSize;
-                start = lcast_put_unsigned<Traits, T, CharT>(n, tmp_finish).convert();
-                finish = tmp_finish;
-                return true;
-            }
-
-            template <class T>
-            inline bool shl_signed(const T n) {
-                CharT* tmp_finish = buffer + CharacterBufferSize;
-                typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type utype;
-                CharT* tmp_start = lcast_put_unsigned<Traits, utype, CharT>(lcast_to_unsigned(n), tmp_finish).convert();
-                if (n < 0) {
-                    --tmp_start;
-                    CharT const minus = lcast_char_constants<CharT>::minus;
-                    Traits::assign(*tmp_start, minus);
-                }
-                start = tmp_start;
-                finish = tmp_finish;
-                return true;
-            }
-
-            template <class T, class SomeCharT>
-            bool shl_real_type(const T& val, SomeCharT* /*begin*/) {
-                lcast_set_precision(out_stream, &val);
-                return shl_input_streamable(val);
-            }
-
-            bool shl_real_type(float val, char* begin) {
-                using namespace std;
-                const double val_as_double = val;
-                finish = start +
-#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
-                    sprintf_s(begin, CharacterBufferSize,
-#else
-                    sprintf(begin, 
-#endif
-                    "%.*g", static_cast<int>(boost::detail::lcast_get_precision<float>()), val_as_double);
-                return finish > start;
-            }
-
-            bool shl_real_type(double val, char* begin) {
-                using namespace std;
-                finish = start +
-#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
-                    sprintf_s(begin, CharacterBufferSize,
-#else
-                    sprintf(begin, 
-#endif
-                    "%.*g", static_cast<int>(boost::detail::lcast_get_precision<double>()), val);
-                return finish > start;
-            }
-
-#ifndef __MINGW32__
-            bool shl_real_type(long double val, char* begin) {
-                using namespace std;
-                finish = start +
-#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
-                    sprintf_s(begin, CharacterBufferSize,
-#else
-                    sprintf(begin, 
-#endif
-                    "%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double>()), val );
-                return finish > start;
-            }
-#endif
-
-
-#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__)
-            bool shl_real_type(float val, wchar_t* begin) {
-                using namespace std;
-                const double val_as_double = val;
-                finish = start + swprintf(begin, CharacterBufferSize,
-                                       L"%.*g",
-                                       static_cast<int>(boost::detail::lcast_get_precision<float >()),
-                                       val_as_double );
-                return finish > start;
-            }
-
-            bool shl_real_type(double val, wchar_t* begin) {
-                using namespace std;
-                finish = start + swprintf(begin, CharacterBufferSize,
-                                          L"%.*g", static_cast<int>(boost::detail::lcast_get_precision<double >()), val );
-                return finish > start;
-            }
-
-            bool shl_real_type(long double val, wchar_t* begin) {
-                using namespace std;
-                finish = start + swprintf(begin, CharacterBufferSize,
-                                          L"%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double >()), val );
-                return finish > start;
-            }
-#endif
-            template <class T>
-            bool shl_real(T val) {
-                CharT* tmp_finish = buffer + CharacterBufferSize;
-                if (put_inf_nan(buffer, tmp_finish, val)) {
-                    finish = tmp_finish;
-                    return true;
-                }
-
-                return shl_real_type(val, static_cast<CharT*>(buffer));
-            }
-
-/************************************ OPERATORS << ( ... ) ********************************/
-        public:
-            template<class Alloc>
-            bool operator<<(std::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT {
-                start = str.data();
-                finish = start + str.length();
-                return true;
-            }
-
-            template<class Alloc>
-            bool operator<<(boost::container::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT {
-                start = str.data();
-                finish = start + str.length();
-                return true;
-            }
-
-            bool operator<<(bool value) BOOST_NOEXCEPT {
-                CharT const czero = lcast_char_constants<CharT>::zero;
-                Traits::assign(buffer[0], Traits::to_char_type(czero + value));
-                finish = start + 1;
-                return true;
-            }
-
-            template <class C>
-            BOOST_DEDUCED_TYPENAME boost::disable_if<boost::is_const<C>, bool>::type 
-            operator<<(const iterator_range<C*>& rng) BOOST_NOEXCEPT {
-                return (*this) << iterator_range<const C*>(rng.begin(), rng.end());
-            }
-            
-            bool operator<<(const iterator_range<const CharT*>& rng) BOOST_NOEXCEPT {
-                start = rng.begin();
-                finish = rng.end();
-                return true; 
-            }
-
-            bool operator<<(const iterator_range<const signed char*>& rng) BOOST_NOEXCEPT {
-                return (*this) << iterator_range<const char*>(
-                    reinterpret_cast<const char*>(rng.begin()),
-                    reinterpret_cast<const char*>(rng.end())
-                );
-            }
-
-            bool operator<<(const iterator_range<const unsigned char*>& rng) BOOST_NOEXCEPT {
-                return (*this) << iterator_range<const char*>(
-                    reinterpret_cast<const char*>(rng.begin()),
-                    reinterpret_cast<const char*>(rng.end())
-                );
-            }
-
-            bool operator<<(char ch)                    { return shl_char(ch); }
-            bool operator<<(unsigned char ch)           { return ((*this) << static_cast<char>(ch)); }
-            bool operator<<(signed char ch)             { return ((*this) << static_cast<char>(ch)); }
-#if !defined(BOOST_LCAST_NO_WCHAR_T)
-            bool operator<<(wchar_t const* str)         { return shl_char_array(str); }
-            bool operator<<(wchar_t * str)              { return shl_char_array(str); }
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-            bool operator<<(wchar_t ch)                 { return shl_char(ch); }
-#endif
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-            bool operator<<(char16_t ch)                { return shl_char(ch); }
-            bool operator<<(char16_t * str)             { return shl_char_array(str); }
-            bool operator<<(char16_t const * str)       { return shl_char_array(str); }
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-            bool operator<<(char32_t ch)                { return shl_char(ch); }
-            bool operator<<(char32_t * str)             { return shl_char_array(str); }
-            bool operator<<(char32_t const * str)       { return shl_char_array(str); }
-#endif
-            bool operator<<(unsigned char const* ch)    { return ((*this) << reinterpret_cast<char const*>(ch)); }
-            bool operator<<(unsigned char * ch)         { return ((*this) << reinterpret_cast<char *>(ch)); }
-            bool operator<<(signed char const* ch)      { return ((*this) << reinterpret_cast<char const*>(ch)); }
-            bool operator<<(signed char * ch)           { return ((*this) << reinterpret_cast<char *>(ch)); }
-            bool operator<<(char const* str)            { return shl_char_array(str); }
-            bool operator<<(char* str)                  { return shl_char_array(str); }
-            bool operator<<(short n)                    { return shl_signed(n); }
-            bool operator<<(int n)                      { return shl_signed(n); }
-            bool operator<<(long n)                     { return shl_signed(n); }
-            bool operator<<(unsigned short n)           { return shl_unsigned(n); }
-            bool operator<<(unsigned int n)             { return shl_unsigned(n); }
-            bool operator<<(unsigned long n)            { return shl_unsigned(n); }
-
-#if defined(BOOST_HAS_LONG_LONG)
-            bool operator<<(boost::ulong_long_type n)   { return shl_unsigned(n); }
-            bool operator<<(boost::long_long_type n)    { return shl_signed(n); }
-#elif defined(BOOST_HAS_MS_INT64)
-            bool operator<<(unsigned __int64 n)         { return shl_unsigned(n); }
-            bool operator<<(         __int64 n)         { return shl_signed(n); }
-#endif
-
-#ifdef BOOST_HAS_INT128
-            bool operator<<(const boost::uint128_type& n)   { return shl_unsigned(n); }
-            bool operator<<(const boost::int128_type& n)    { return shl_signed(n); }
-#endif
-            bool operator<<(float val)                  { return shl_real(val); }
-            bool operator<<(double val)                 { return shl_real(val); }
-            bool operator<<(long double val)            {
-#ifndef __MINGW32__
-                return shl_real(val);
-#else
-                return shl_real(static_cast<double>(val));
-#endif
-            }
-            
-            // Adding constness to characters. Constness does not change layout
-            template <class C, std::size_t N>
-            BOOST_DEDUCED_TYPENAME boost::disable_if<boost::is_const<C>, bool>::type
-            operator<<(boost::array<C, N> const& input) BOOST_NOEXCEPT { 
-                BOOST_STATIC_ASSERT_MSG(
-                    (sizeof(boost::array<const C, N>) == sizeof(boost::array<C, N>)),
-                    "boost::array<C, N> and boost::array<const C, N> must have exactly the same layout."
-                );
-                return ((*this) << reinterpret_cast<boost::array<const C, N> const& >(input)); 
-            }
-
-            template <std::size_t N>
-            bool operator<<(boost::array<const CharT, N> const& input) BOOST_NOEXCEPT { 
-                return shl_char_array_limited(input.begin(), N); 
-            }
-
-            template <std::size_t N>
-            bool operator<<(boost::array<const unsigned char, N> const& input) BOOST_NOEXCEPT { 
-                return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input)); 
-            }
-
-            template <std::size_t N>
-            bool operator<<(boost::array<const signed char, N> const& input) BOOST_NOEXCEPT { 
-                return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input)); 
-            }
- 
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
-            // Making a Boost.Array from std::array
-            template <class C, std::size_t N>
-            bool operator<<(std::array<C, N> const& input) BOOST_NOEXCEPT { 
-                BOOST_STATIC_ASSERT_MSG(
-                    (sizeof(std::array<C, N>) == sizeof(boost::array<C, N>)),
-                    "std::array and boost::array must have exactly the same layout. "
-                    "Bug in implementation of std::array or boost::array."
-                );
-                return ((*this) << reinterpret_cast<boost::array<C, N> const& >(input)); 
-            }
-#endif
-            template <class InStreamable>
-            bool operator<<(const InStreamable& input)  { return shl_input_streamable(input); }
-        };
-
-
-        template <class CharT, class Traits>
-        class lexical_ostream_limited_src: boost::noncopyable {
-            //`[start, finish)` is the range to output by `operator >>` 
-            const CharT*        start;
-            const CharT* const  finish;
-
-        public:
-            lexical_ostream_limited_src(const CharT* begin, const CharT* end) BOOST_NOEXCEPT
-              : start(begin)
-              , finish(end)
-            {}
-
-/************************************ HELPER FUNCTIONS FOR OPERATORS >> ( ... ) ********************************/
-        private:
-            template <typename Type>
-            bool shr_unsigned(Type& output) {
-                if (start == finish) return false;
-                CharT const minus = lcast_char_constants<CharT>::minus;
-                CharT const plus = lcast_char_constants<CharT>::plus;
-                bool const has_minus = Traits::eq(minus, *start);
-
-                /* We won`t use `start' any more, so no need in decrementing it after */
-                if (has_minus || Traits::eq(plus, *start)) {
-                    ++start;
-                }
-
-                bool const succeed = lcast_ret_unsigned<Traits, Type, CharT>(output, start, finish).convert();
-
-                if (has_minus) {
-                    output = static_cast<Type>(0u - output);
-                }
-
-                return succeed;
-            }
-
-            template <typename Type>
-            bool shr_signed(Type& output) {
-                if (start == finish) return false;
-                CharT const minus = lcast_char_constants<CharT>::minus;
-                CharT const plus = lcast_char_constants<CharT>::plus;
-                typedef BOOST_DEDUCED_TYPENAME make_unsigned<Type>::type utype;
-                utype out_tmp = 0;
-                bool const has_minus = Traits::eq(minus, *start);
-
-                /* We won`t use `start' any more, so no need in decrementing it after */
-                if (has_minus || Traits::eq(plus, *start)) {
-                    ++start;
-                }
-
-                bool succeed = lcast_ret_unsigned<Traits, utype, CharT>(out_tmp, start, finish).convert();
-                if (has_minus) {
-                    utype const comp_val = (static_cast<utype>(1) << std::numeric_limits<Type>::digits);
-                    succeed = succeed && out_tmp<=comp_val;
-                    output = static_cast<Type>(0u - out_tmp);
-                } else {
-                    utype const comp_val = static_cast<utype>((std::numeric_limits<Type>::max)());
-                    succeed = succeed && out_tmp<=comp_val;
-                    output = static_cast<Type>(out_tmp);
-                }
-                return succeed;
-            }
-
-            template<typename InputStreamable>
-            bool shr_using_base_class(InputStreamable& output)
-            {
-                BOOST_STATIC_ASSERT_MSG(
-                    (!boost::is_pointer<InputStreamable>::value),
-                    "boost::lexical_cast can not convert to pointers"
-                );
-
-#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
-                BOOST_STATIC_ASSERT_MSG((boost::is_same<char, CharT>::value),
-                    "boost::lexical_cast can not convert, because your STL library does not "
-                    "support such conversions. Try updating it."
-                );
-#endif
-                typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::buffer_t
-                    buffer_t;
-
-#if defined(BOOST_NO_STRINGSTREAM)
-                std::istrstream stream(start, finish - start);
-#else
-
-                buffer_t buf;
-                // Usually `istream` and `basic_istream` do not modify 
-                // content of buffer; `buffer_t` assures that this is true
-                buf.setbuf(const_cast<CharT*>(start), finish - start);
-#if defined(BOOST_NO_STD_LOCALE)
-                std::istream stream(&buf);
-#else
-                std::basic_istream<CharT, Traits> stream(&buf);
-#endif // BOOST_NO_STD_LOCALE
-#endif // BOOST_NO_STRINGSTREAM
-
-#ifndef BOOST_NO_EXCEPTIONS
-                stream.exceptions(std::ios::badbit);
-                try {
-#endif
-                stream.unsetf(std::ios::skipws);
-                lcast_set_precision(stream, static_cast<InputStreamable*>(0));
-
-                return (stream >> output) 
-                    && (stream.get() == Traits::eof());
-
-#ifndef BOOST_NO_EXCEPTIONS
-                } catch (const ::std::ios_base::failure& /*f*/) {
-                    return false;
-                }
-#endif
-            }
-
-            template<class T>
-            inline bool shr_xchar(T& output) BOOST_NOEXCEPT {
-                BOOST_STATIC_ASSERT_MSG(( sizeof(CharT) == sizeof(T) ),
-                    "boost::lexical_cast does not support narrowing of character types."
-                    "Use boost::locale instead" );
-                bool const ok = (finish - start == 1);
-                if (ok) {
-                    CharT out;
-                    Traits::assign(out, *start);
-                    output = static_cast<T>(out);
-                }
-                return ok;
-            }
-
-            template <std::size_t N, class ArrayT>
-            bool shr_std_array(ArrayT& output) BOOST_NOEXCEPT {
-                using namespace std;
-                const std::size_t size = static_cast<std::size_t>(finish - start);
-                if (size > N - 1) { // `-1` because we need to store \0 at the end 
-                    return false;
-                }
-
-                memcpy(&output[0], start, size * sizeof(CharT));
-                output[size] = Traits::to_char_type(0);
-                return true;
-            }
-
-/************************************ OPERATORS >> ( ... ) ********************************/
-        public:
-            bool operator>>(unsigned short& output)             { return shr_unsigned(output); }
-            bool operator>>(unsigned int& output)               { return shr_unsigned(output); }
-            bool operator>>(unsigned long int& output)          { return shr_unsigned(output); }
-            bool operator>>(short& output)                      { return shr_signed(output); }
-            bool operator>>(int& output)                        { return shr_signed(output); }
-            bool operator>>(long int& output)                   { return shr_signed(output); }
-#if defined(BOOST_HAS_LONG_LONG)
-            bool operator>>(boost::ulong_long_type& output)     { return shr_unsigned(output); }
-            bool operator>>(boost::long_long_type& output)      { return shr_signed(output); }
-#elif defined(BOOST_HAS_MS_INT64)
-            bool operator>>(unsigned __int64& output)           { return shr_unsigned(output); }
-            bool operator>>(__int64& output)                    { return shr_signed(output); }
-#endif
-
-#ifdef BOOST_HAS_INT128
-            bool operator>>(boost::uint128_type& output)        { return shr_unsigned(output); }
-            bool operator>>(boost::int128_type& output)         { return shr_signed(output); }
-#endif
-
-            bool operator>>(char& output)                       { return shr_xchar(output); }
-            bool operator>>(unsigned char& output)              { return shr_xchar(output); }
-            bool operator>>(signed char& output)                { return shr_xchar(output); }
-#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-            bool operator>>(wchar_t& output)                    { return shr_xchar(output); }
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-            bool operator>>(char16_t& output)                   { return shr_xchar(output); }
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-            bool operator>>(char32_t& output)                   { return shr_xchar(output); }
-#endif
-            template<class Alloc>
-            bool operator>>(std::basic_string<CharT,Traits,Alloc>& str) { 
-                str.assign(start, finish); return true; 
-            }
-
-            template<class Alloc>
-            bool operator>>(boost::container::basic_string<CharT,Traits,Alloc>& str) { 
-                str.assign(start, finish); return true; 
-            }
-
-            template <std::size_t N>
-            bool operator>>(boost::array<CharT, N>& output) BOOST_NOEXCEPT { 
-                return shr_std_array<N>(output); 
-            }
-
-            template <std::size_t N>
-            bool operator>>(boost::array<unsigned char, N>& output) BOOST_NOEXCEPT { 
-                return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output)); 
-            }
-
-            template <std::size_t N>
-            bool operator>>(boost::array<signed char, N>& output) BOOST_NOEXCEPT { 
-                return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output)); 
-            }
- 
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
-            template <class C, std::size_t N>
-            bool operator>>(std::array<C, N>& output) BOOST_NOEXCEPT { 
-                BOOST_STATIC_ASSERT_MSG(
-                    (sizeof(boost::array<C, N>) == sizeof(boost::array<C, N>)),
-                    "std::array<C, N> and boost::array<C, N> must have exactly the same layout."
-                );
-                return ((*this) >> reinterpret_cast<boost::array<C, N>& >(output));
-            }
-#endif
-
-            bool operator>>(bool& output) BOOST_NOEXCEPT {
-                output = false; // Suppress warning about uninitalized variable
-
-                if (start == finish) return false;
-                CharT const zero = lcast_char_constants<CharT>::zero;
-                CharT const plus = lcast_char_constants<CharT>::plus;
-                CharT const minus = lcast_char_constants<CharT>::minus;
-
-                const CharT* const dec_finish = finish - 1;
-                output = Traits::eq(*dec_finish, zero + 1);
-                if (!output && !Traits::eq(*dec_finish, zero)) {
-                    return false; // Does not ends on '0' or '1'
-                }
-
-                if (start == dec_finish) return true;
-
-                // We may have sign at the beginning
-                if (Traits::eq(plus, *start) || (Traits::eq(minus, *start) && !output)) {
-                    ++ start;
-                }
-
-                // Skipping zeros
-                while (start != dec_finish) {
-                    if (!Traits::eq(zero, *start)) {
-                        return false; // Not a zero => error
-                    }
-
-                    ++ start;
-                }
-
-                return true;
-            }
-
-            bool operator>>(float& output) { return lcast_ret_float<Traits>(output,start,finish); }
-
-        private:
-            // Not optimised converter
-            template <class T>
-            bool float_types_converter_internal(T& output, int /*tag*/) {
-                if (parse_inf_nan(start, finish, output)) return true;
-                bool const return_value = shr_using_base_class(output);
-
-                /* Some compilers and libraries successfully
-                 * parse 'inf', 'INFINITY', '1.0E', '1.0E-'...
-                 * We are trying to provide a unified behaviour,
-                 * so we just forbid such conversions (as some
-                 * of the most popular compilers/libraries do)
-                 * */
-                CharT const minus = lcast_char_constants<CharT>::minus;
-                CharT const plus = lcast_char_constants<CharT>::plus;
-                CharT const capital_e = lcast_char_constants<CharT>::capital_e;
-                CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e;
-                if ( return_value &&
-                     (
-                        Traits::eq(*(finish-1), lowercase_e)                   // 1.0e
-                        || Traits::eq(*(finish-1), capital_e)                  // 1.0E
-                        || Traits::eq(*(finish-1), minus)                      // 1.0e- or 1.0E-
-                        || Traits::eq(*(finish-1), plus)                       // 1.0e+ or 1.0E+
-                     )
-                ) return false;
-
-                return return_value;
-            }
-
-            // Optimised converter
-            bool float_types_converter_internal(double& output, char /*tag*/) {
-                return lcast_ret_float<Traits>(output, start, finish);
-            }
-        public:
-
-            bool operator>>(double& output) {
-                /*
-                 * Some compilers implement long double as double. In that case these types have
-                 * same size, same precision, same max and min values... And it means,
-                 * that current implementation of lcast_ret_float cannot be used for type
-                 * double, because it will give a big precision loss.
-                 * */
-                boost::mpl::if_c<
-#if (defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)) && !defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS)
-                    boost::type_traits::ice_eq< sizeof(double), sizeof(long double) >::value,
-#else
-                     1,
-#endif
-                    int,
-                    char
-                >::type tag = 0;
-
-                return float_types_converter_internal(output, tag);
-            }
-
-            bool operator>>(long double& output) {
-                int tag = 0;
-                return float_types_converter_internal(output, tag);
-            }
-
-            // Generic istream-based algorithm.
-            // lcast_streambuf_for_target<InputStreamable>::value is true.
-            template <typename InputStreamable>
-            bool operator>>(InputStreamable& output) { 
-                return shr_using_base_class(output); 
-            }
-        };
-    }
-
-    namespace detail
-    {
-        template<typename T>
-        struct is_stdstring
-            : boost::false_type
-        {};
-
-        template<typename CharT, typename Traits, typename Alloc>
-        struct is_stdstring< std::basic_string<CharT, Traits, Alloc> >
-            : boost::true_type
-        {};
-
-        template<typename CharT, typename Traits, typename Alloc>
-        struct is_stdstring< boost::container::basic_string<CharT, Traits, Alloc> >
-            : boost::true_type
-        {};
-
-        template<typename Target, typename Source>
-        struct is_arithmetic_and_not_xchars
-        {
-            BOOST_STATIC_CONSTANT(bool, value = (
-                boost::type_traits::ice_and<
-                    boost::type_traits::ice_not<
-                        boost::detail::is_character<Target>::value
-                    >::value,
-                    boost::type_traits::ice_not<
-                        boost::detail::is_character<Source>::value
-                    >::value,
-                    boost::is_arithmetic<Source>::value,
-                    boost::is_arithmetic<Target>::value       
-                >::value
-            ));
-        };
-
-        /*
-         * is_xchar_to_xchar<Target, Source>::value is true, 
-         * Target and Souce are char types of the same size 1 (char, signed char, unsigned char).
-         */
-        template<typename Target, typename Source>
-        struct is_xchar_to_xchar 
-        {
-            BOOST_STATIC_CONSTANT(bool, value = (
-                boost::type_traits::ice_and<
-                     boost::type_traits::ice_eq<sizeof(Source), sizeof(Target)>::value,
-                     boost::type_traits::ice_eq<sizeof(Source), sizeof(char)>::value,
-                     boost::detail::is_character<Target>::value,
-                     boost::detail::is_character<Source>::value
-                >::value
-            ));
-        };
-
-        template<typename Target, typename Source>
-        struct is_char_array_to_stdstring
-            : boost::false_type
-        {};
-
-        template<typename CharT, typename Traits, typename Alloc>
-        struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, CharT* >
-            : boost::true_type
-        {};
-
-        template<typename CharT, typename Traits, typename Alloc>
-        struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, const CharT* >
-            : boost::true_type
-        {};
-
-        template<typename CharT, typename Traits, typename Alloc>
-        struct is_char_array_to_stdstring< boost::container::basic_string<CharT, Traits, Alloc>, CharT* >
-            : boost::true_type
-        {};
-
-        template<typename CharT, typename Traits, typename Alloc>
-        struct is_char_array_to_stdstring< boost::container::basic_string<CharT, Traits, Alloc>, const CharT* >
-            : boost::true_type
-        {};
-
-        template<typename Target, typename Source>
-        struct lexical_converter_impl
-        {
-            typedef lexical_cast_stream_traits<Source, Target>  stream_trait;
-
-            typedef detail::lexical_istream_limited_src<
-                BOOST_DEDUCED_TYPENAME stream_trait::char_type,
-                BOOST_DEDUCED_TYPENAME stream_trait::traits,
-                stream_trait::requires_stringbuf,
-                stream_trait::len_t::value + 1
-            > i_interpreter_type;
-
-            typedef detail::lexical_ostream_limited_src<
-                BOOST_DEDUCED_TYPENAME stream_trait::char_type,
-                BOOST_DEDUCED_TYPENAME stream_trait::traits
-            > o_interpreter_type;
-
-            static inline bool try_convert(const Source& arg, Target& result) {
-                i_interpreter_type i_interpreter;
-
-                // Disabling ADL, by directly specifying operators.
-                if (!(i_interpreter.operator <<(arg)))
-                    return false;
-
-                o_interpreter_type out(i_interpreter.cbegin(), i_interpreter.cend());
-
-                // Disabling ADL, by directly specifying operators.
-                if(!(out.operator >>(result)))
-                    return false;
-
-                return true;
-            }
-        };
-
-        template <typename Target, typename Source>
-        struct copy_converter_impl
-        {
-// MSVC fail to forward an array (DevDiv#555157 "SILENT BAD CODEGEN triggered by perfect forwarding",
-// fixed in 2013 RTM).
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && (!defined(BOOST_MSVC) || BOOST_MSVC >= 1800)
-            template <class T>
-            static inline bool try_convert(T&& arg, Target& result) {
-                result = static_cast<T&&>(arg); // eqaul to `result = std::forward<T>(arg);`
-                return true;
-            }
-#else
-            static inline bool try_convert(const Source& arg, Target& result) {
-                result = arg;
-                return true;
-            }
-#endif
-        };
-
-        template <class Source >
-        struct detect_precision_loss
-        {
-            typedef Source source_type;
-            typedef boost::numeric::Trunc<Source> Rounder;
-            typedef BOOST_DEDUCED_TYPENAME mpl::if_<
-                boost::is_arithmetic<Source>, Source, Source const&
-            >::type argument_type ;
-
-            static inline source_type nearbyint(argument_type s, bool& is_ok) BOOST_NOEXCEPT {
-                const source_type near_int = Rounder::nearbyint(s);
-                if (near_int && is_ok) {
-                    const source_type orig_div_round = s / near_int;
-                    const source_type eps = std::numeric_limits<source_type>::epsilon();
-
-                    is_ok = !((orig_div_round > 1 ? orig_div_round - 1 : 1 - orig_div_round) > eps);
-                }
-
-                return s;
-            }
-
-            typedef typename Rounder::round_style round_style;
-        };
-
-        template <typename Base, class Source>
-        struct fake_precision_loss: public Base
-        {
-            typedef Source source_type ;
-            typedef BOOST_DEDUCED_TYPENAME mpl::if_<
-                boost::is_arithmetic<Source>, Source, Source const&
-            >::type argument_type ;
-
-            static inline source_type nearbyint(argument_type s, bool& /*is_ok*/) BOOST_NOEXCEPT {
-                return s;
-            }
-        };
-
-        struct nothrow_overflow_handler
-        {
-            inline bool operator() ( boost::numeric::range_check_result r ) const BOOST_NOEXCEPT {
-                return (r == boost::numeric::cInRange);
-            }
-        };
-
-        template <typename Target, typename Source>
-        inline bool noexcept_numeric_convert(const Source& arg, Target& result) BOOST_NOEXCEPT {
-            typedef boost::numeric::converter<
-                    Target,
-                    Source,
-                    boost::numeric::conversion_traits<Target, Source >,
-                    nothrow_overflow_handler,
-                    detect_precision_loss<Source >
-            > converter_orig_t;
-
-            typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
-                boost::is_base_of< detect_precision_loss<Source >, converter_orig_t >::value,
-                converter_orig_t,
-                fake_precision_loss<converter_orig_t, Source>
-            >::type converter_t;
-
-            bool res = nothrow_overflow_handler()(converter_t::out_of_range(arg));
-            result = converter_t::low_level_convert(converter_t::nearbyint(arg, res));
-            return res;
-        }
-
-        template <typename Target, typename Source>
-        struct lexical_cast_dynamic_num_not_ignoring_minus
-        {
-            static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT {
-                return noexcept_numeric_convert<Target, Source >(arg, result);
-            }
-        };
-
-        template <typename Target, typename Source>
-        struct lexical_cast_dynamic_num_ignoring_minus
-        {
-            static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT {
-                typedef BOOST_DEDUCED_TYPENAME boost::mpl::eval_if_c<
-                        boost::is_float<Source>::value,
-                        boost::mpl::identity<Source>,
-                        boost::make_unsigned<Source>
-                >::type usource_t;
-        
-                if (arg < 0) {
-                    const bool res = noexcept_numeric_convert<Target, usource_t>(0u - arg, result);
-                    result = static_cast<Target>(0u - result);
-                    return res;
-                } else {
-                    return noexcept_numeric_convert<Target, usource_t>(arg, result);
-                }
-            }
-        };
-
-        /*
-         * lexical_cast_dynamic_num follows the rules:
-         * 1) If Source can be converted to Target without precision loss and
-         * without overflows, then assign Source to Target and return
-         *
-         * 2) If Source is less than 0 and Target is an unsigned integer,
-         * then negate Source, check the requirements of rule 1) and if
-         * successful, assign static_casted Source to Target and return
-         *
-         * 3) Otherwise throw a bad_lexical_cast exception
-         *
-         *
-         * Rule 2) required because boost::lexical_cast has the behavior of
-         * stringstream, which uses the rules of scanf for conversions. And
-         * in the C99 standard for unsigned input value minus sign is
-         * optional, so if a negative number is read, no errors will arise
-         * and the result will be the two's complement.
-         */
-        template <typename Target, typename Source>
-        struct dynamic_num_converter_impl
-        {
-            static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT {
-                typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
-                    boost::type_traits::ice_and<
-                        boost::is_unsigned<Target>::value,
-                        boost::type_traits::ice_or<
-                            boost::is_signed<Source>::value,
-                            boost::is_float<Source>::value
-                        >::value,
-                        boost::type_traits::ice_not<
-                            boost::is_same<Source, bool>::value
-                        >::value,
-                        boost::type_traits::ice_not<
-                            boost::is_same<Target, bool>::value
-                        >::value
-                    >::value,
-                    lexical_cast_dynamic_num_ignoring_minus<Target, Source>,
-                    lexical_cast_dynamic_num_not_ignoring_minus<Target, Source>
-                >::type caster_type;
-
-                return caster_type::try_convert(arg, result);
-            }
-        };
-    }
-
-    namespace conversion { namespace detail {
-
-        template <typename Target, typename Source>
-        inline bool try_lexical_convert(const Source& arg, Target& result)
-        {
-            typedef BOOST_DEDUCED_TYPENAME boost::detail::array_to_pointer_decay<Source>::type src;
-
-            typedef BOOST_DEDUCED_TYPENAME boost::type_traits::ice_or<
-                boost::detail::is_xchar_to_xchar<Target, src >::value,
-                boost::detail::is_char_array_to_stdstring<Target, src >::value,
-                boost::type_traits::ice_and<
-                     boost::is_same<Target, src >::value,
-                     boost::detail::is_stdstring<Target >::value
-                >::value,
-                boost::type_traits::ice_and<
-                     boost::is_same<Target, src >::value,
-                     boost::detail::is_character<Target >::value
-                >::value
-            > shall_we_copy_t;
-
-            typedef boost::detail::is_arithmetic_and_not_xchars<Target, src >
-                shall_we_copy_with_dynamic_check_t;
-
-            // We do evaluate second `if_` lazily to avoid unnecessary instantiations
-            // of `shall_we_copy_with_dynamic_check_t` and improve compilation times.
-            typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
-                shall_we_copy_t::value,
-                boost::mpl::identity<boost::detail::copy_converter_impl<Target, src > >,
-                boost::mpl::if_<
-                     shall_we_copy_with_dynamic_check_t,
-                     boost::detail::dynamic_num_converter_impl<Target, src >,
-                     boost::detail::lexical_converter_impl<Target, src >
-                >
-            >::type caster_type_lazy;
-
-            typedef BOOST_DEDUCED_TYPENAME caster_type_lazy::type caster_type;
-
-            return caster_type::try_convert(arg, result);
-        }
-
-        template <typename Target, typename CharacterT>
-        inline bool try_lexical_convert(const CharacterT* chars, std::size_t count, Target& result)
-        {
-            BOOST_STATIC_ASSERT_MSG(
-                boost::detail::is_character<CharacterT>::value,
-                "This overload of try_lexical_convert is meant to be used only with arrays of characters."
-            );
-            return ::boost::conversion::detail::try_lexical_convert(
-                ::boost::iterator_range<const CharacterT*>(chars, chars + count), result
-            );
-        }
-
-    }} // namespace conversion::detail
-
-    namespace conversion {
-        // ADL barrier
-        using ::boost::conversion::detail::try_lexical_convert;
-    }
-
-    template <typename Target, typename Source>
-    inline Target lexical_cast(const Source &arg)
-    {
-        Target result;
-
-        if (!boost::conversion::detail::try_lexical_convert(arg, result))
-            BOOST_LCAST_THROW_BAD_CAST(Source, Target);
-
-        return result;
-    }
-
-    template <typename Target>
-    inline Target lexical_cast(const char* chars, std::size_t count)
-    {
-        return ::boost::lexical_cast<Target>(
-            ::boost::iterator_range<const char*>(chars, chars + count)
-        );
-    }
-
-    template <typename Target>
-    inline Target lexical_cast(const unsigned char* chars, std::size_t count)
-    {
-        return ::boost::lexical_cast<Target>(
-            ::boost::iterator_range<const unsigned char*>(chars, chars + count)
-        );
-    }
-
-    template <typename Target>
-    inline Target lexical_cast(const signed char* chars, std::size_t count)
-    {
-        return ::boost::lexical_cast<Target>(
-            ::boost::iterator_range<const signed char*>(chars, chars + count)
-        );
-    }
-
-#ifndef BOOST_LCAST_NO_WCHAR_T
-    template <typename Target>
-    inline Target lexical_cast(const wchar_t* chars, std::size_t count)
-    {
-        return ::boost::lexical_cast<Target>(
-            ::boost::iterator_range<const wchar_t*>(chars, chars + count)
-        );
-    }
-#endif
-#ifndef BOOST_NO_CXX11_CHAR16_T
-    template <typename Target>
-    inline Target lexical_cast(const char16_t* chars, std::size_t count)
-    {
-        return ::boost::lexical_cast<Target>(
-            ::boost::iterator_range<const char16_t*>(chars, chars + count)
-        );
-    }
-#endif
-#ifndef BOOST_NO_CXX11_CHAR32_T
-    template <typename Target>
-    inline Target lexical_cast(const char32_t* chars, std::size_t count)
-    {
-        return ::boost::lexical_cast<Target>(
-            ::boost::iterator_range<const char32_t*>(chars, chars + count)
-        );
-    }
-#endif
-
-} // namespace boost
-
-#else
-
-namespace boost {
-    namespace detail
-    {
-
-        // selectors for choosing stream character type
-        template<typename Type>
-        struct stream_char
-        {
-            typedef char type;
-        };
-
-#ifndef BOOST_LCAST_NO_WCHAR_T
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-        template<>
-        struct stream_char<wchar_t>
-        {
-            typedef wchar_t type;
-        };
-#endif
-
-        template<>
-        struct stream_char<wchar_t *>
-        {
-            typedef wchar_t type;
-        };
-
-        template<>
-        struct stream_char<const wchar_t *>
-        {
-            typedef wchar_t type;
-        };
-
-        template<>
-        struct stream_char<std::wstring>
-        {
-            typedef wchar_t type;
-        };
-#endif
-
-        // stream wrapper for handling lexical conversions
-        template<typename Target, typename Source, typename Traits>
-        class lexical_stream
-        {
-        private:
-            typedef typename widest_char<
-                typename stream_char<Target>::type,
-                typename stream_char<Source>::type>::type char_type;
-
-            typedef Traits traits_type;
-
-        public:
-            lexical_stream(char_type* = 0, char_type* = 0)
-            {
-                stream.unsetf(std::ios::skipws);
-                lcast_set_precision(stream, static_cast<Source*>(0), static_cast<Target*>(0) );
-            }
-            ~lexical_stream()
-            {
-                #if defined(BOOST_NO_STRINGSTREAM)
-                stream.freeze(false);
-                #endif
-            }
-            bool operator<<(const Source &input)
-            {
-                return !(stream << input).fail();
-            }
-            template<typename InputStreamable>
-            bool operator>>(InputStreamable &output)
-            {
-                return !is_pointer<InputStreamable>::value &&
-                       stream >> output &&
-                       stream.get() == traits_type::eof();
-            }
-
-            bool operator>>(std::string &output)
-            {
-                #if defined(BOOST_NO_STRINGSTREAM)
-                stream << '\0';
-                #endif
-                stream.str().swap(output);
-                return true;
-            }
-            #ifndef BOOST_LCAST_NO_WCHAR_T
-            bool operator>>(std::wstring &output)
-            {
-                stream.str().swap(output);
-                return true;
-            }
-            #endif
-
-        private:
-            #if defined(BOOST_NO_STRINGSTREAM)
-            std::strstream stream;
-            #elif defined(BOOST_NO_STD_LOCALE)
-            std::stringstream stream;
-            #else
-            std::basic_stringstream<char_type,traits_type> stream;
-            #endif
-        };
-    }
-
-    // call-by-value fallback version (deprecated)
-
-    template<typename Target, typename Source>
-    Target lexical_cast(Source arg)
-    {
-        typedef typename detail::widest_char< 
-            BOOST_DEDUCED_TYPENAME detail::stream_char<Target>::type 
-          , BOOST_DEDUCED_TYPENAME detail::stream_char<Source>::type 
-        >::type char_type; 
-
-        typedef std::char_traits<char_type> traits;
-        detail::lexical_stream<Target, Source, traits> interpreter;
-        Target result;
-
-        if(!(interpreter << arg && interpreter >> result))
-          BOOST_LCAST_THROW_BAD_CAST(Source, Target);
-        return result;
-    }
-
-} // namespace boost
-
-#endif
-
-// Copyright Kevlin Henney, 2000-2005.
-// Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2014.
-//
-// 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)
-
-#undef BOOST_LCAST_THROW_BAD_CAST
-#undef BOOST_LCAST_NO_WCHAR_T
-
-#endif // BOOST_LEXICAL_CAST_INCLUDED
-
diff --git a/include/boost/polymorphic_cast.hpp b/include/boost/polymorphic_cast.hpp
new file mode 100644
index 0000000..f02d7ea
--- /dev/null
+++ b/include/boost/polymorphic_cast.hpp
@@ -0,0 +1,94 @@
+//  boost polymorphic_cast.hpp header file  ----------------------------------------------//
+
+//  (C) Copyright Kevlin Henney and Dave Abrahams 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/conversion for Documentation.
+
+//  Revision History
+//  09 Jun 14  "cast.hpp" was renamed to "polymorphic_cast.hpp" and
+//             inclusion of numeric_cast was removed (Antony Polukhin)
+//  23 Jun 05  numeric_cast removed and redirected to the new verion (Fernando Cacciola)
+//  02 Apr 01  Removed BOOST_NO_LIMITS workarounds and included
+//             <boost/limits.hpp> instead (the workaround did not
+//             actually compile when BOOST_NO_LIMITS was defined in
+//             any case, so we loose nothing). (John Maddock)
+//  21 Jan 01  Undid a bug I introduced yesterday. numeric_cast<> never
+//             worked with stock GCC; trying to get it to do that broke
+//             vc-stlport.
+//  20 Jan 01  Moved BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS to config.hpp.
+//             Removed unused BOOST_EXPLICIT_TARGET macro. Moved
+//             boost::detail::type to boost/type.hpp. Made it compile with
+//             stock gcc again (Dave Abrahams)
+//  29 Nov 00  Remove nested namespace cast, cleanup spacing before Formal
+//             Review (Beman Dawes)
+//  19 Oct 00  Fix numeric_cast for floating-point types (Dave Abrahams)
+//  15 Jul 00  Suppress numeric_cast warnings for GCC, Borland and MSVC
+//             (Dave Abrahams)
+//  30 Jun 00  More MSVC6 wordarounds.  See comments below.  (Dave Abrahams)
+//  28 Jun 00  Removed implicit_cast<>.  See comment below. (Beman Dawes)
+//  27 Jun 00  More MSVC6 workarounds
+//  15 Jun 00  Add workarounds for MSVC6
+//   2 Feb 00  Remove bad_numeric_cast ";" syntax error (Doncho Angelov)
+//  26 Jan 00  Add missing throw() to bad_numeric_cast::what(0 (Adam Levar)
+//  29 Dec 99  Change using declarations so usages in other namespaces work
+//             correctly (Dave Abrahams)
+//  23 Sep 99  Change polymorphic_downcast assert to also detect M.I. errors
+//             as suggested Darin Adler and improved by Valentin Bonnard.
+//   2 Sep 99  Remove controversial asserts, simplify, rename.
+//  30 Aug 99  Move to cast.hpp, replace value_cast with numeric_cast,
+//             place in nested namespace.
+//   3 Aug 99  Initial version
+
+#ifndef BOOST_POLYMORPHIC_CAST_HPP
+#define BOOST_POLYMORPHIC_CAST_HPP
+
+# include <boost/config.hpp>
+# include <boost/assert.hpp>
+# include <typeinfo>
+# include <boost/type.hpp>
+# include <boost/limits.hpp>
+# include <boost/detail/select_type.hpp>
+
+namespace boost
+{
+//  See the documentation for descriptions of how to choose between
+//  static_cast<>, dynamic_cast<>, polymorphic_cast<> and polymorphic_downcast<>
+
+//  polymorphic_cast  --------------------------------------------------------//
+
+    //  Runtime checked polymorphic downcasts and crosscasts.
+    //  Suggested in The C++ Programming Language, 3rd Ed, Bjarne Stroustrup,
+    //  section 15.8 exercise 1, page 425.
+
+    template <class Target, class Source>
+    inline Target polymorphic_cast(Source* x)
+    {
+        Target tmp = dynamic_cast<Target>(x);
+        if ( tmp == 0 ) throw std::bad_cast();
+        return tmp;
+    }
+
+//  polymorphic_downcast  ----------------------------------------------------//
+
+    //  BOOST_ASSERT() checked polymorphic downcast.  Crosscasts prohibited.
+
+    //  WARNING: Because this cast uses BOOST_ASSERT(), it violates
+    //  the One Definition Rule if used in multiple translation units
+    //  where BOOST_DISABLE_ASSERTS, BOOST_ENABLE_ASSERT_HANDLER
+    //  NDEBUG are defined inconsistently.
+
+    //  Contributed by Dave Abrahams
+
+    template <class Target, class Source>
+    inline Target polymorphic_downcast(Source* x)
+    {
+        BOOST_ASSERT( dynamic_cast<Target>(x) == x );  // detect logic error
+        return static_cast<Target>(x);
+    }
+
+} // namespace boost
+
+#endif  // BOOST_POLYMORPHIC_CAST_HPP
diff --git a/lexical_cast.htm b/lexical_cast.htm
deleted file mode 100644
index 73b6ba5..0000000
--- a/lexical_cast.htm
+++ /dev/null
@@ -1,16 +0,0 @@
-
-<!--
-Copyright 2005-2007 Daniel James.
-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)
--->
-
-<html>
-<head>
-    <meta http-equiv="refresh" content="0; URL=../../doc/html/boost_lexical_cast.html">
-</head>
-<body>
-Automatic redirection failed, please go to
-<a href="../../doc/html/boost_lexical_cast.html">../../doc/html/boost_lexical_cast.html</a>
-</body>
-</html>
diff --git a/meta/libraries.json b/meta/libraries.json
index e1d1860..3c7c726 100644
--- a/meta/libraries.json
+++ b/meta/libraries.json
@@ -7,8 +7,7 @@
     ],
     "description": "Polymorphic casts.",
     "category": [
-        "Miscellaneous",
-        "String"
+        "Miscellaneous"
     ],
     "maintainers": [
         "Antony Polukhin <antoshkka -at- gmail.com>"
diff --git a/perf/Jamfile.v2 b/perf/Jamfile.v2
deleted file mode 100644
index 6f03fe1..0000000
--- a/perf/Jamfile.v2
+++ /dev/null
@@ -1,29 +0,0 @@
-#==============================================================================
-#   Copyright (c) 2012 Antony Polukhin
-#
-#   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)
-#==============================================================================
-
-# performance tests
-import testing ;
-import path ;
-
-path-constant TEST_DIR : . ;
-
-project performance/test
-    : source-location ./
-    : requirements
-#      <library>/boost/chrono//boost_chrono
-#      <library>/boost/system//boost_system
-      <link>static
-      <target-os>freebsd:<linkflags>"-lrt"
-      <target-os>linux:<linkflags>"-lrt"
-      <toolset>gcc:<cxxflags>-fvisibility=hidden
-      <toolset>intel-linux:<cxxflags>-fvisibility=hidden
-      <toolset>sun:<cxxflags>-xldscope=hidden
-    : default-build release
- ;
-
-run performance_test.cpp : $(TEST_DIR) ;
-
diff --git a/perf/performance_test.cpp b/perf/performance_test.cpp
deleted file mode 100644
index 7fbac4f..0000000
--- a/perf/performance_test.cpp
+++ /dev/null
@@ -1,369 +0,0 @@
-//  (C) Copyright Antony Polukhin 2012.
-//  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)
-
-//  See http://www.boost.org/libs/config for most recent version.
-
-//
-// Testing lexical_cast<> performance
-//
-
-#define BOOST_ERROR_CODE_HEADER_ONLY
-#define BOOST_CHRONO_HEADER_ONLY
-
-#include <boost/lexical_cast.hpp>
-
-#include <boost/chrono.hpp>
-#include <fstream>
-#include <cstring>
-#include <boost/container/string.hpp>
-
-// File to output data
-std::fstream fout;
-
-namespace boost {
-inline std::istream& operator>> (std::istream& in, boost::array<char,50>& res) {
-    in >> res.begin();
-    return in;
-}
-}
-
-template <class OutT, class InT>
-static inline void test_lexical(const InT& in_val) {
-    OutT out_val = boost::lexical_cast<OutT>(in_val);
-    (void)out_val;
-}
-
-template <class OutT, class InT>
-static inline void test_ss_constr(const InT& in_val) {
-    OutT out_val;
-    std::stringstream ss;
-    ss << in_val;
-    if (ss.fail()) throw std::logic_error("descr");
-    ss >> out_val;
-    if (ss.fail()) throw std::logic_error("descr");
-}
-
-template <class OutT, class CharT, std::size_t N>
-static inline void test_ss_constr(const boost::array<CharT, N>& in_val) {
-    OutT out_val;
-    std::stringstream ss;
-    ss << in_val.begin();
-    if (ss.fail()) throw std::logic_error("descr");
-    ss >> out_val;
-    if (ss.fail()) throw std::logic_error("descr");
-}
-
-template <class OutT, class StringStreamT, class CharT, std::size_t N>
-static inline void test_ss_noconstr(StringStreamT& ss, const boost::array<CharT, N>& in_val) {
-    OutT out_val;
-    ss << in_val.begin(); // ss is an instance of std::stringstream
-    if (ss.fail()) throw std::logic_error("descr");
-    ss >> out_val;
-    if (ss.fail()) throw std::logic_error("descr");
-    /* reseting std::stringstream to use it again */
-    ss.str(std::string());
-    ss.clear();
-}
-
-template <class OutT, class StringStreamT, class InT>
-static inline void test_ss_noconstr(StringStreamT& ss, const InT& in_val) {
-    OutT out_val;
-    ss << in_val; // ss is an instance of std::stringstream
-    if (ss.fail()) throw std::logic_error("descr");
-    ss >> out_val;
-    if (ss.fail()) throw std::logic_error("descr");
-    /* reseting std::stringstream to use it again */
-    ss.str(std::string());
-    ss.clear();
-}
-
-struct structure_sprintf {
-    template <class OutT, class BufferT, class InT>
-    static inline void test(BufferT* buffer, const InT& in_val, const char* const conv) {
-        sprintf(buffer, conv, in_val);
-        OutT out_val(buffer);
-    }
-
-    template <class OutT, class BufferT>
-    static inline void test(BufferT* buffer, const std::string& in_val, const char* const conv) {
-        sprintf(buffer, conv, in_val.c_str());
-        OutT out_val(buffer);
-    }
-};
-
-struct structure_sscanf {
-    template <class OutT, class BufferT, class CharT, std::size_t N>
-    static inline void test(BufferT* /*buffer*/, const boost::array<CharT, N>& in_val, const char* const conv) {
-        OutT out_val;
-        sscanf(in_val.cbegin(), conv, &out_val);
-    }
-
-    template <class OutT, class BufferT, class InT>
-    static inline void test(BufferT* /*buffer*/, const InT& in_val, const char* const conv) {
-        OutT out_val;
-        sscanf(reinterpret_cast<const char*>(in_val), conv, &out_val);
-    }
-
-    template <class OutT, class BufferT>
-    static inline void test(BufferT* /*buffer*/, const std::string& in_val, const char* const conv) {
-        OutT out_val;
-        sscanf(in_val.c_str(), conv, &out_val);
-    }
-
-    template <class OutT, class BufferT>
-    static inline void test(BufferT* /*buffer*/, const boost::iterator_range<const char*>& in_val, const char* const conv) {
-        OutT out_val;
-        sscanf(in_val.begin(), conv, &out_val);
-    }
-};
-
-struct structure_fake {
-    template <class OutT, class BufferT, class InT>
-    static inline void test(BufferT* /*buffer*/, const InT& /*in_val*/, const char* const /*conv*/) {}
-};
-
-static const int fake_test_value = 9999;
-
-template <class T>
-static inline void min_fancy_output(T v1, T v2, T v3, T v4) {
-    const char beg_mark[] = "!!! *";
-    const char end_mark[] = "* !!!";
-    const char no_mark[] = "";
-
-    unsigned int res = 4;
-    if (v1 < v2 && v1 < v3 && v1 < v4) res = 1;
-    if (v2 < v1 && v2 < v3 && v2 < v4) res = 2;
-    if (v3 < v1 && v3 < v2 && v3 < v4) res = 3;
-
-    fout << "[ "
-         << (res == 1 ? beg_mark : no_mark)
-         ;
-
-    if (v1) fout << v1;
-    else fout << "<1";
-
-    fout << (res == 1 ? end_mark : no_mark)
-         << " ][ "
-         << (res == 2 ? beg_mark : no_mark)
-         ;
-
-       if (v2) fout << v2;
-       else fout << "<1";
-
-       fout << (res == 2 ? end_mark : no_mark)
-         << " ][ "
-         << (res == 3 ? beg_mark : no_mark)
-         ;
-
-       if (v3) fout << v3;
-       else fout << "<1";
-
-       fout << (res == 3 ? end_mark : no_mark)
-         << " ][ "
-         << (res == 4 ? beg_mark : no_mark)
-         ;
-
-       if (!v4) fout << "<1";
-       else if (v4 == fake_test_value) fout << "---";
-       else fout << v4;
-
-       fout
-         << (res == 4 ? end_mark : no_mark)
-         << " ]";
-}
-
-template <unsigned int IetartionsCountV, class ToT, class SprintfT, class FromT>
-static inline void perf_test_impl(const FromT& in_val, const char* const conv) {
-
-    typedef boost::chrono::steady_clock test_clock;
-    test_clock::time_point start;
-    typedef boost::chrono::milliseconds duration_t;
-    duration_t lexical_cast_time, ss_constr_time, ss_noconstr_time, printf_time;
-
-    start = test_clock::now();
-    for (unsigned int i = 0; i < IetartionsCountV; ++i) {
-        test_lexical<ToT>(in_val);
-        test_lexical<ToT>(in_val);
-        test_lexical<ToT>(in_val);
-        test_lexical<ToT>(in_val);
-    }
-    lexical_cast_time = boost::chrono::duration_cast<duration_t>(test_clock::now() - start);
-
-
-    start = test_clock::now();
-    for (unsigned int i = 0; i < IetartionsCountV; ++i) {
-        test_ss_constr<ToT>(in_val);
-        test_ss_constr<ToT>(in_val);
-        test_ss_constr<ToT>(in_val);
-        test_ss_constr<ToT>(in_val);
-    }
-    ss_constr_time = boost::chrono::duration_cast<duration_t>(test_clock::now() - start);
-
-    std::stringstream ss;
-    start = test_clock::now();
-    for (unsigned int i = 0; i < IetartionsCountV; ++i) {
-        test_ss_noconstr<ToT>(ss, in_val);
-        test_ss_noconstr<ToT>(ss, in_val);
-        test_ss_noconstr<ToT>(ss, in_val);
-        test_ss_noconstr<ToT>(ss, in_val);
-    }
-    ss_noconstr_time = boost::chrono::duration_cast<duration_t>(test_clock::now() - start);
-
-
-    char buffer[128];
-    start = test_clock::now();
-    for (unsigned int i = 0; i < IetartionsCountV; ++i) {
-        SprintfT::template test<ToT>(buffer, in_val, conv);
-        SprintfT::template test<ToT>(buffer, in_val, conv);
-        SprintfT::template test<ToT>(buffer, in_val, conv);
-        SprintfT::template test<ToT>(buffer, in_val, conv);
-    }
-    printf_time = boost::chrono::duration_cast<duration_t>(test_clock::now() - start);
-
-    min_fancy_output(
-                lexical_cast_time.count(),
-                ss_constr_time.count(),
-                ss_noconstr_time.count(),
-                boost::is_same<SprintfT, structure_fake>::value ? fake_test_value : printf_time.count()
-    );
-}
-
-template <class ToT, class SprintfT, class FromT>
-static inline void perf_test(const std::string& test_name, const FromT& in_val, const char* const conv) {
-    const unsigned int ITERATIONSCOUNT = 100000;
-    fout << "  [[ " << test_name << " ]";
-
-    perf_test_impl<ITERATIONSCOUNT/4, ToT, SprintfT>(in_val, conv);
-
-    fout << "]\n";
-}
-
-
-template <class ConverterT>
-void string_like_test_set(const std::string& from) {
-    typedef structure_sscanf ssc_t;
-    ConverterT conv;
-
-    perf_test<char, ssc_t>(from + "->char",               conv("c"), "%c");
-    perf_test<signed char, ssc_t>(from + "->signed char", conv("c"), "%hhd");
-    perf_test<unsigned char, ssc_t>(from + "->unsigned char", conv("c"), "%hhu");
-
-    perf_test<int, ssc_t>(from + "->int",             conv("100"), "%d");
-    perf_test<short, ssc_t>(from + "->short",         conv("100"), "%hd");
-    perf_test<long int, ssc_t>(from + "->long int",   conv("100"), "%ld");
-    perf_test<boost::long_long_type, ssc_t>(from + "->long long", conv("100"), "%lld");
-
-    perf_test<unsigned int, ssc_t>(from + "->unsigned int",             conv("100"), "%u");
-    perf_test<unsigned short, ssc_t>(from + "->unsigned short",         conv("100"), "%hu");
-    perf_test<unsigned long int, ssc_t>(from + "->unsigned long int",   conv("100"), "%lu");
-    perf_test<boost::ulong_long_type, ssc_t>(from + "->unsigned long long", conv("100"), "%llu");
-
-    // perf_test<bool, ssc_t>(from + "->bool", conv("1"), "%");
-
-    perf_test<float, ssc_t>(from + "->float",             conv("1.123"), "%f");
-    perf_test<double, ssc_t>(from + "->double",           conv("1.123"), "%lf");
-    perf_test<long double, ssc_t>(from + "->long double", conv("1.123"), "%Lf");
-    perf_test<boost::array<char, 50>, ssc_t>(from + "->array<char, 50>", conv("1.123"), "%s");
-
-    perf_test<std::string, structure_fake>(from + "->string", conv("string"), "%Lf");
-    perf_test<boost::container::string, structure_fake>(from + "->container::string"
-                                                        , conv("string"), "%Lf");
-
-}
-
-struct to_string_conv {
-    std::string operator()(const char* const c) const {
-        return c;
-    }
-};
-
-struct to_char_conv {
-    const char*  operator()(const char* const c) const {
-        return c;
-    }
-};
-
-struct to_uchar_conv {
-    const unsigned char*  operator()(const char* const c) const {
-        return reinterpret_cast<const unsigned char*>(c);
-    }
-};
-
-
-struct to_schar_conv {
-    const signed char*  operator()(const char* const c) const {
-        return reinterpret_cast<const signed char*>(c);
-    }
-};
-
-struct to_iterator_range {
-    boost::iterator_range<const char*>  operator()(const char* const c) const {
-        return boost::make_iterator_range(c, c + std::strlen(c));
-    }
-};
-
-struct to_array_50 {
-    boost::array<char, 50> operator()(const char* const c) const {
-        boost::array<char, 50> ret;
-        std::strcpy(ret.begin(), c);
-        return ret;
-    }
-};
-
-int main(int argc, char** argv) {
-    BOOST_ASSERT(argc >= 2);
-    std::string output_path(argv[1]);
-    output_path += "/results.txt";
-    fout.open(output_path.c_str(), std::fstream::in | std::fstream::out | std::fstream::app);
-    BOOST_ASSERT(fout);
-
-    fout << "[section " << BOOST_COMPILER << "]\n"
-        << "[table:id Performance Table ( "<< BOOST_COMPILER << ")\n"
-        << "[[From->To] [lexical_cast] [std::stringstream with construction] "
-        << "[std::stringstream without construction][scanf/printf]]\n";
-
-
-    // From std::string to ...
-    string_like_test_set<to_string_conv>("string");
-
-    // From ... to std::string
-    perf_test<std::string, structure_sprintf>("string->char",                'c', "%c");
-    perf_test<std::string, structure_sprintf>("string->signed char",     static_cast<signed char>('c'), "%hhd");
-    perf_test<std::string, structure_sprintf>("string->unsigned char", static_cast<unsigned char>('c'), "%hhu");
-
-    perf_test<std::string, structure_sprintf>("int->string",                 100, "%d");
-    perf_test<std::string, structure_sprintf>("short->string",               static_cast<short>(100), "%hd");
-    perf_test<std::string, structure_sprintf>("long int->string",            100l, "%ld");
-    perf_test<std::string, structure_sprintf>("long long->string",           100ll, "%lld");
-
-    perf_test<std::string, structure_sprintf>("unsigned int->string",        static_cast<unsigned short>(100u), "%u");
-    perf_test<std::string, structure_sprintf>("unsigned short->string",      100u, "%hu");
-    perf_test<std::string, structure_sprintf>("unsigned long int->string",   100ul, "%lu");
-    perf_test<std::string, structure_sprintf>("unsigned long long->string",  static_cast<boost::ulong_long_type>(100), "%llu");
-
-    // perf_test<bool, structure_sscanf>("bool->string", std::string("1"), "%");
-
-    perf_test<std::string, structure_sprintf>("float->string",       1.123f, "%f");
-    perf_test<std::string, structure_sprintf>("double->string",      1.123, "%lf");
-    perf_test<std::string, structure_sprintf>("long double->string", 1.123L, "%Lf");
-
-
-    string_like_test_set<to_char_conv>("char*");
-    string_like_test_set<to_uchar_conv>("unsigned char*");
-    string_like_test_set<to_schar_conv>("signed char*");
-    string_like_test_set<to_iterator_range>("iterator_range<char*>");
-    string_like_test_set<to_array_50>("array<char, 50>");
-
-    perf_test<int, structure_fake>("int->int", 100, "");
-    perf_test<double, structure_fake>("float->double", 100.0f, "");
-    perf_test<signed char, structure_fake>("char->signed char", 'c', "");
-
-
-    fout << "]\n"
-        << "[endsect]\n\n";
-    return 0;
-}
-
-
diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
index 3acf6b4..f79e724 100644
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -1,5 +1,5 @@
 # Copyright (C) 2001-2003 Douglas Gregor
-# Copyright (C) 2011-2013 Antony Polukhin
+# Copyright (C) 2011-2014 Antony Polukhin
 #
 # 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)
@@ -22,53 +22,10 @@ project
         <toolset>gcc:<cxxflags>-Wno-uninitialized
     ;
 
-# Thanks to Steven Watanabe for helping with <nowchar> feature
-feature.feature nowchar : on :
- composite optional propagated link-incompatible ;
-feature.compose <nowchar>on : <cxxflags>/Zc:wchar_t- ;
-
 test-suite conversion
   : [ run implicit_cast.cpp ]
     [ compile-fail implicit_cast_fail.cpp ]
     [ run cast_test.cpp ]
     [ run numeric_cast_test.cpp ]
-    [ run lexical_cast_test.cpp ]
-    [ run lexical_cast_loopback_test.cpp ]
-    [ run lexical_cast_abstract_test.cpp ]
-    [ run lexical_cast_noncopyable_test.cpp ]
-    [ run lexical_cast_vc8_bug_test.cpp ]
-    [ run lexical_cast_wchars_test.cpp ]
-    [ run lexical_cast_float_types_test.cpp ]
-    [ run lexical_cast_inf_nan_test.cpp ]
-    [ run lexical_cast_containers_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-long-long <toolset>clang:<cxxflags>-Wno-long-long ]
-    [ run lexical_cast_empty_input_test.cpp ]
-    [ run lexical_cast_pointers_test.cpp ]
-    [ compile lexical_cast_typedefed_wchar_test.cpp : <toolset>msvc:<nowchar>on ]
-    [ run lexical_cast_typedefed_wchar_test_runtime.cpp : : : <toolset>msvc:<nowchar>on <toolset>msvc,<stdlib>stlport:<build>no ]
-    [ run lexical_cast_no_locale_test.cpp : : : <define>BOOST_NO_STD_LOCALE <define>BOOST_LEXICAL_CAST_ASSUME_C_LOCALE ]
-    [ run lexical_cast_no_exceptions_test.cpp : : : <define>BOOST_NO_EXCEPTIONS
-      <toolset>gcc-4.3:<cxxflags>-fno-exceptions
-      <toolset>gcc-4.4:<cxxflags>-fno-exceptions
-      <toolset>gcc-4.5:<cxxflags>-fno-exceptions
-      <toolset>gcc-4.6:<cxxflags>-fno-exceptions
-      <toolset>gcc-4.7:<cxxflags>-fno-exceptions
-      <toolset>gcc-4.8:<cxxflags>-fno-exceptions
-      <toolset>clang:<cxxflags>-fno-exceptions
-    ]
-    [ run lexical_cast_iterator_range_test.cpp ]
-    [ run lexical_cast_arrays_test.cpp ]
-    [ run lexical_cast_integral_types_test.cpp ]
-    [ run lexical_cast_stream_detection_test.cpp ]
-    [ run lexical_cast_stream_traits_test.cpp ]
-    [ compile-fail lexical_cast_to_pointer_test.cpp ]
-    [ run lexical_cast_filesystem_test.cpp ../../filesystem/build//boost_filesystem/<link>static ]
-    [ run lexical_cast_try_lexical_convert.cpp ]
   ;
 
-# Assuring that examples compile and run. Adding sources from `example` directory to the `conversion` test suite. 
-for local p in [ glob ../example/*.cpp ]
-{
-    conversion += [ run $(p) ] ;
-}
-
-
diff --git a/test/cast_test.cpp b/test/cast_test.cpp
index ad6b18f..fa30df8 100644
--- a/test/cast_test.cpp
+++ b/test/cast_test.cpp
@@ -16,7 +16,7 @@
 #include <iostream>
 #include <climits>
 #include <cfloat>   // for DBL_MAX (Peter Schmid)
-#include <boost/cast.hpp>
+#include <boost/polymorphic_cast.hpp>
 
 #  if SCHAR_MAX == LONG_MAX
 #      error "This test program doesn't work if SCHAR_MAX == LONG_MAX"
diff --git a/test/lexical_cast_abstract_test.cpp b/test/lexical_cast_abstract_test.cpp
deleted file mode 100644
index 70cdeca..0000000
--- a/test/lexical_cast_abstract_test.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Sergey Shandar 2005, Alexander Nasonov, 2007.
-//
-//  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).
-//
-// Test abstract class. Bug 1358600:
-// http://sf.net/tracker/?func=detail&aid=1358600&group_id=7586&atid=107586
-
-#include <boost/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
-#include <boost/lexical_cast.hpp>
-#include <boost/test/unit_test.hpp>
-
-using namespace boost;
-
-void test_abstract();
-
-unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast unit test");
-    suite->add(BOOST_TEST_CASE(&test_abstract));
-
-    return suite;
-}
-
-class A
-{
-public:
-    virtual void out(std::ostream &) const = 0;
-};
-
-class B: public A
-{
-public:
-    virtual void out(std::ostream &O) const { O << "B"; }
-};
-
-std::ostream &operator<<(std::ostream &O, const A &a)
-{
-    a.out(O);
-    return O;
-}
-
-void test_abstract()
-{
-    const A &a = B();
-    BOOST_CHECK(boost::lexical_cast<std::string>(a) == "B");
-}
-
diff --git a/test/lexical_cast_arrays_test.cpp b/test/lexical_cast_arrays_test.cpp
deleted file mode 100644
index 013f401..0000000
--- a/test/lexical_cast_arrays_test.cpp
+++ /dev/null
@@ -1,377 +0,0 @@
-//  Testing boost::lexical_cast with boost::container::string.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 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/lexical_cast.hpp>
-
-#include <boost/test/unit_test.hpp>
-    
-#include <boost/array.hpp>
-
-void testing_boost_array_output_conversion();
-void testing_std_array_output_conversion();
-
-void testing_boost_array_input_conversion();
-void testing_std_array_input_conversion();
-
-using namespace boost;
-
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION)
-#define BOOST_LC_RUNU16
-#endif
-
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION)
-#define BOOST_LC_RUNU32
-#endif
-
-boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("Testing boost::lexical_cast with boost::array and std::array");
-
-    suite->add(BOOST_TEST_CASE(testing_boost_array_output_conversion));
-    suite->add(BOOST_TEST_CASE(testing_std_array_output_conversion));
-    suite->add(BOOST_TEST_CASE(testing_boost_array_input_conversion));
-    suite->add(BOOST_TEST_CASE(testing_std_array_input_conversion));
-
-    return suite;
-}
-
-template <template <class, std::size_t> class ArrayT, class T>
-static void testing_template_array_output_on_spec_value(T val) 
-{
-    typedef ArrayT<char, 300>             arr_type;
-    typedef ArrayT<char, 1>               short_arr_type;
-    typedef ArrayT<unsigned char, 300>    uarr_type;
-    typedef ArrayT<unsigned char, 1>      ushort_arr_type;
-    typedef ArrayT<signed char, 4>        sarr_type;
-    typedef ArrayT<signed char, 3>        sshort_arr_type;
-
-    std::string ethalon("100");
-    using namespace std;
-
-    {
-        arr_type res1 = lexical_cast<arr_type>(val);
-        BOOST_CHECK_EQUAL(&res1[0], ethalon);
-        const arr_type res2 = lexical_cast<arr_type>(val);
-        BOOST_CHECK_EQUAL(&res2[0], ethalon);
-        BOOST_CHECK_THROW(lexical_cast<short_arr_type>(val), boost::bad_lexical_cast);
-    }
-    
-    {
-        uarr_type res1 = lexical_cast<uarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
-        const uarr_type res2 = lexical_cast<uarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
-        BOOST_CHECK_THROW(lexical_cast<ushort_arr_type>(val), boost::bad_lexical_cast);
-    }
-    
-    {
-        sarr_type res1 = lexical_cast<sarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
-        const sarr_type res2 = lexical_cast<sarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
-        BOOST_CHECK_THROW(lexical_cast<sshort_arr_type>(val), boost::bad_lexical_cast);
-    }
-
-#if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
-    typedef ArrayT<wchar_t, 300> warr_type;
-    typedef ArrayT<wchar_t, 3> wshort_arr_type;
-    std::wstring wethalon(L"100");
-
-    {
-        warr_type res = lexical_cast<warr_type>(val);
-        BOOST_CHECK(&res[0] == wethalon);
-    }
-
-    {
-        const warr_type res = lexical_cast<warr_type>(val);
-        BOOST_CHECK(&res[0] == wethalon);
-    }
-    
-    BOOST_CHECK_THROW(lexical_cast<wshort_arr_type>(val), boost::bad_lexical_cast);
-
-#endif
-
-#ifdef BOOST_LC_RUNU16
-    typedef ArrayT<char16_t, 300> u16arr_type;
-    typedef ArrayT<char16_t, 3> u16short_arr_type;
-    std::u16string u16ethalon(u"100");
-
-    {
-        u16arr_type res = lexical_cast<u16arr_type>(val);
-        BOOST_CHECK(&res[0] == u16ethalon);
-    }
-
-    {
-        const u16arr_type res = lexical_cast<u16arr_type>(val);
-        BOOST_CHECK(&res[0] == u16ethalon);
-    }
-    
-    BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), boost::bad_lexical_cast);
-#endif
-
-#ifdef BOOST_LC_RUNU32
-    typedef ArrayT<char32_t, 300> u32arr_type;
-    typedef ArrayT<char32_t, 3> u32short_arr_type;
-    std::u32string u32ethalon(U"100");
-
-    {
-        u32arr_type res = lexical_cast<u32arr_type>(val);
-        BOOST_CHECK(&res[0] == u32ethalon);
-    }
-
-    {
-        const u32arr_type res = lexical_cast<u32arr_type>(val);
-        BOOST_CHECK(&res[0] == u32ethalon);
-    }
-    
-    BOOST_CHECK_THROW(lexical_cast<u32short_arr_type>(val), boost::bad_lexical_cast);
-#endif
-}
-
-
-template <template <class, std::size_t> class ArrayT>
-static void testing_template_array_output_on_char_value() 
-{
-    typedef ArrayT<char, 300>             arr_type;
-    typedef ArrayT<char, 1>               short_arr_type;
-    typedef ArrayT<unsigned char, 300>    uarr_type;
-    typedef ArrayT<unsigned char, 1>      ushort_arr_type;
-    typedef ArrayT<signed char, 4>        sarr_type;
-    typedef ArrayT<signed char, 3>        sshort_arr_type;
-
-    const char val[] = "100";
-    std::string ethalon("100");
-    using namespace std;
-
-    {
-        arr_type res1 = lexical_cast<arr_type>(val);
-        BOOST_CHECK_EQUAL(&res1[0], ethalon);
-        const arr_type res2 = lexical_cast<arr_type>(val);
-        BOOST_CHECK_EQUAL(&res2[0], ethalon);
-        BOOST_CHECK_THROW(lexical_cast<short_arr_type>(val), boost::bad_lexical_cast);
-    }
-    
-    {
-        uarr_type res1 = lexical_cast<uarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
-        const uarr_type res2 = lexical_cast<uarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
-        BOOST_CHECK_THROW(lexical_cast<ushort_arr_type>(val), boost::bad_lexical_cast);
-    }
-    
-    {
-        sarr_type res1 = lexical_cast<sarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
-        const sarr_type res2 = lexical_cast<sarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
-        BOOST_CHECK_THROW(lexical_cast<sshort_arr_type>(val), boost::bad_lexical_cast);
-    }
-
-#if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
-    typedef ArrayT<wchar_t, 4> warr_type;
-    typedef ArrayT<wchar_t, 3> wshort_arr_type;
-    std::wstring wethalon(L"100");
-
-    {
-        warr_type res = lexical_cast<warr_type>(val);
-        BOOST_CHECK(&res[0] == wethalon);
-        warr_type res3 = lexical_cast<warr_type>(wethalon);
-        BOOST_CHECK(&res3[0] == wethalon);
-    }
-
-    {
-        const warr_type res = lexical_cast<warr_type>(val);
-        BOOST_CHECK(&res[0] == wethalon);
-        const warr_type res3 = lexical_cast<warr_type>(wethalon);
-        BOOST_CHECK(&res3[0] == wethalon);
-    }
-    
-    BOOST_CHECK_THROW(lexical_cast<wshort_arr_type>(val), boost::bad_lexical_cast);
-
-#endif
-
-#ifdef BOOST_LC_RUNU16
-    typedef ArrayT<char16_t, 300> u16arr_type;
-    typedef ArrayT<char16_t, 3> u16short_arr_type;
-    std::u16string u16ethalon(u"100");
-
-    {
-#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
-        u16arr_type res = lexical_cast<u16arr_type>(val);
-        BOOST_CHECK(&res[0] == u16ethalon);  
-#endif
-
-        u16arr_type res3 = lexical_cast<u16arr_type>(u16ethalon);
-        BOOST_CHECK(&res3[0] == u16ethalon);
-    }
-
-    {
-#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
-        const u16arr_type res = lexical_cast<u16arr_type>(val);
-        BOOST_CHECK(&res[0] == u16ethalon);
-#endif
-        const u16arr_type res3 = lexical_cast<u16arr_type>(u16ethalon);
-        BOOST_CHECK(&res3[0] == u16ethalon);
-    }
-    
-    // Some compillers may throw std::bad_alloc here
-    BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), std::exception); 
-#endif
-
-#ifdef BOOST_LC_RUNU32
-    typedef ArrayT<char32_t, 300> u32arr_type;
-    typedef ArrayT<char32_t, 3> u32short_arr_type;
-    std::u32string u32ethalon(U"100");
-
-    {
-#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
-        u32arr_type res = lexical_cast<u32arr_type>(val);
-        BOOST_CHECK(&res[0] == u32ethalon);
-#endif
-        u32arr_type res3 = lexical_cast<u32arr_type>(u32ethalon);
-        BOOST_CHECK(&res3[0] == u32ethalon);
-    }
-
-    {
-#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
-        const u32arr_type res = lexical_cast<u32arr_type>(val);
-        BOOST_CHECK(&res[0] == u32ethalon);
-#endif
-        const u32arr_type res3 = lexical_cast<u32arr_type>(u32ethalon);
-        BOOST_CHECK(&res3[0] == u32ethalon);
-    }
-    
-    // Some compillers may throw std::bad_alloc here
-    BOOST_CHECK_THROW(lexical_cast<u32short_arr_type>(val), std::exception);
-#endif
-}
-
-
-void testing_boost_array_output_conversion()
-{   
-    testing_template_array_output_on_char_value<boost::array>();
-    testing_template_array_output_on_spec_value<boost::array>(100);
-    testing_template_array_output_on_spec_value<boost::array>(static_cast<short>(100));
-    testing_template_array_output_on_spec_value<boost::array>(static_cast<unsigned short>(100));
-    testing_template_array_output_on_spec_value<boost::array>(static_cast<unsigned int>(100));
-}
-
-void testing_std_array_output_conversion()
-{
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
-    testing_template_array_output_on_char_value<std::array>();
-    testing_template_array_output_on_spec_value<std::array>(100);
-    testing_template_array_output_on_spec_value<std::array>(static_cast<short>(100));
-    testing_template_array_output_on_spec_value<std::array>(static_cast<unsigned short>(100));
-    testing_template_array_output_on_spec_value<std::array>(static_cast<unsigned int>(100));
-#endif
-
-    BOOST_CHECK(true);
-}
-
-template <template <class, std::size_t> class ArrayT>
-static void testing_generic_array_input_conversion()
-{
-    {
-        ArrayT<char, 4> var_zero_terminated = {{ '1', '0', '0', '\0'}}; 
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated), "100");
-        BOOST_CHECK_EQUAL(lexical_cast<int>(var_zero_terminated), 100);
-
-        ArrayT<char, 3> var_none_terminated = {{ '1', '0', '0'}}; 
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated), "100");
-        BOOST_CHECK_EQUAL(lexical_cast<short>(var_none_terminated), static_cast<short>(100));
-
-        ArrayT<const char, 4> var_zero_terminated_const_char = {{ '1', '0', '0', '\0'}}; 
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_char), "100");
-
-        ArrayT<const char, 3> var_none_terminated_const_char = {{ '1', '0', '0'}}; 
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_char), "100");
-
-        const ArrayT<char, 4> var_zero_terminated_const_var = {{ '1', '0', '0', '\0'}}; 
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var), "100");
-
-        const ArrayT<char, 3> var_none_terminated_const_var = {{ '1', '0', '0'}}; 
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var), "100");
-
-        const ArrayT<const char, 4> var_zero_terminated_const_var_const_char = {{ '1', '0', '0', '\0'}}; 
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");
-
-        const ArrayT<const char, 3> var_none_terminated_const_var_const_char = {{ '1', '0', '0'}}; 
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
-        BOOST_CHECK_EQUAL(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
-    }
-
-    {
-        const ArrayT<const unsigned char, 4> var_zero_terminated_const_var_const_char = {{ '1', '0', '0', '\0'}}; 
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");
-
-        const ArrayT<const unsigned char, 3> var_none_terminated_const_var_const_char = {{ '1', '0', '0'}}; 
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
-    }
-
-    {
-        const ArrayT<const signed char, 4> var_zero_terminated_const_var_const_char = {{ '1', '0', '0', '\0'}}; 
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");
-
-        const ArrayT<const signed char, 3> var_none_terminated_const_var_const_char = {{ '1', '0', '0'}}; 
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
-        BOOST_CHECK_EQUAL(lexical_cast<unsigned int>(var_none_terminated_const_var_const_char), 100u);
-    }
-
-
-#if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
-    {
-        const ArrayT<const wchar_t, 4> var_zero_terminated_const_var_const_char = {{ L'1', L'0', L'0', L'\0'}}; 
-        BOOST_CHECK(lexical_cast<std::wstring>(var_zero_terminated_const_var_const_char) == L"100");
-
-        const ArrayT<const wchar_t, 3> var_none_terminated_const_var_const_char = {{ L'1', L'0', L'0'}}; 
-        BOOST_CHECK(lexical_cast<std::wstring>(var_none_terminated_const_var_const_char) == L"100");
-        BOOST_CHECK_EQUAL(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
-    }
-#endif
-
-#ifdef BOOST_LC_RUNU16
-    {
-        const ArrayT<const char16_t, 4> var_zero_terminated_const_var_const_char = {{ u'1', u'0', u'0', u'\0'}}; 
-        BOOST_CHECK(lexical_cast<std::u16string>(var_zero_terminated_const_var_const_char) == u"100");
-        BOOST_CHECK_EQUAL(lexical_cast<unsigned short>(var_zero_terminated_const_var_const_char), static_cast<unsigned short>(100));
-
-        const ArrayT<const char16_t, 3> var_none_terminated_const_var_const_char = {{ u'1', u'0', u'0'}}; 
-        BOOST_CHECK(lexical_cast<std::u16string>(var_none_terminated_const_var_const_char) == u"100");
-    }
-#endif
-
-#ifdef BOOST_LC_RUNU32
-    {
-        const ArrayT<const char32_t, 4> var_zero_terminated_const_var_const_char = {{ U'1', U'0', U'0', U'\0'}}; 
-        BOOST_CHECK(lexical_cast<std::u32string>(var_zero_terminated_const_var_const_char) == U"100");
-
-        const ArrayT<const char32_t, 3> var_none_terminated_const_var_const_char = {{ U'1', U'0', U'0'}}; 
-        BOOST_CHECK(lexical_cast<std::u32string>(var_none_terminated_const_var_const_char) == U"100");
-        BOOST_CHECK_EQUAL(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
-    }
-#endif
-}
-
-void testing_boost_array_input_conversion()
-{
-    testing_generic_array_input_conversion<boost::array>();
-}
-
-void testing_std_array_input_conversion()
-{
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
-    testing_generic_array_input_conversion<std::array>();
-#endif
-
-    BOOST_CHECK(true);
-}
-
diff --git a/test/lexical_cast_containers_test.cpp b/test/lexical_cast_containers_test.cpp
deleted file mode 100644
index 47bedc3..0000000
--- a/test/lexical_cast_containers_test.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-//  Testing boost::lexical_cast with boost::container::string.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 2011.
-//
-//  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/lexical_cast.hpp>
-#include <boost/test/unit_test.hpp>
-#include <boost/container/string.hpp>
-
-void testing_boost_containers_basic_string();
-void testing_boost_containers_string_std_string();
-void testing_boost_containers_string_widening();
-
-
-using namespace boost;
-
-boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("Testing boost::lexical_cast with boost::container::string");
-    suite->add(BOOST_TEST_CASE(testing_boost_containers_basic_string));
-    suite->add(BOOST_TEST_CASE(testing_boost_containers_string_std_string));
-    suite->add(BOOST_TEST_CASE(testing_boost_containers_string_widening));
-
-    return suite;
-}
-
-void testing_boost_containers_basic_string()
-{
-    BOOST_CHECK("100" == lexical_cast<boost::container::string>("100"));
-    BOOST_CHECK(L"100" == lexical_cast<boost::container::wstring>(L"100"));
-
-    BOOST_CHECK("100" == lexical_cast<boost::container::string>(100));
-    boost::container::string str("1000");
-    BOOST_CHECK(1000 == lexical_cast<int>(str));
-}
-
-#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
-#define BOOST_LCAST_NO_WCHAR_T
-#endif
-
-void testing_boost_containers_string_std_string()
-{
-    std::string std_str("std_str");
-    boost::container::string boost_str("boost_str");
-    BOOST_CHECK(boost::lexical_cast<std::string>(boost_str) == "boost_str");
-    BOOST_CHECK(boost::lexical_cast<boost::container::string>(std_str) == "std_str");
-
-#ifndef BOOST_LCAST_NO_WCHAR_T
-    std::wstring std_wstr(L"std_wstr");
-    boost::container::wstring boost_wstr(L"boost_wstr");
-
-    BOOST_CHECK(boost::lexical_cast<std::wstring>(boost_wstr) == L"boost_wstr");
-    BOOST_CHECK(boost::lexical_cast<boost::container::wstring>(std_wstr) == L"std_wstr");
-
-#endif
-
-}
-
-void testing_boost_containers_string_widening()
-{
-    const char char_array[] = "Test string";
-
-#ifndef BOOST_LCAST_NO_WCHAR_T
-    const wchar_t wchar_array[] = L"Test string";
-    BOOST_CHECK(boost::lexical_cast<boost::container::wstring>(char_array) == wchar_array);
-#endif
-
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
-    const char16_t char16_array[] = u"Test string";
-    BOOST_CHECK(boost::lexical_cast<boost::container::basic_string<char16_t> >(char_array) == char16_array);
-#endif
-
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
-    const char32_t char32_array[] = U"Test string";
-    BOOST_CHECK(boost::lexical_cast<boost::container::basic_string<char32_t> >(char_array) == char32_array);
-#endif
-}
diff --git a/test/lexical_cast_empty_input_test.cpp b/test/lexical_cast_empty_input_test.cpp
deleted file mode 100644
index d16fd02..0000000
--- a/test/lexical_cast_empty_input_test.cpp
+++ /dev/null
@@ -1,167 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 2011.
-//
-//  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/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
-#include <boost/lexical_cast.hpp>
-#include <boost/test/unit_test.hpp>
-#include <boost/range/iterator_range.hpp>
-
-using namespace boost;
-
-#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
-#define BOOST_LCAST_NO_WCHAR_T
-#endif
-
-template <class T>
-void do_test_on_empty_input(T& v)
-{
-    BOOST_CHECK_THROW(lexical_cast<int>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<float>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<double>(v), bad_lexical_cast);
-#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
-    BOOST_CHECK_THROW(lexical_cast<long double>(v), bad_lexical_cast);
-#endif
-    BOOST_CHECK_THROW(lexical_cast<unsigned int>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned short>(v), bad_lexical_cast);
-#if defined(BOOST_HAS_LONG_LONG)
-    BOOST_CHECK_THROW(lexical_cast<boost::ulong_long_type>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<boost::long_long_type>(v), bad_lexical_cast);
-#elif defined(BOOST_HAS_MS_INT64)
-    BOOST_CHECK_THROW(lexical_cast<unsigned __int64>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<__int64>(v), bad_lexical_cast);
-#endif
-}
-
-void test_empty_iterator_range()
-{
-
-    boost::iterator_range<char*> v;
-    do_test_on_empty_input(v);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(v), std::string());
-    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
-
-    boost::iterator_range<const char*> cv;
-    do_test_on_empty_input(cv);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(cv), std::string());
-    BOOST_CHECK_THROW(lexical_cast<char>(cv), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(cv), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(cv), bad_lexical_cast);
-
-    const boost::iterator_range<const char*> ccv;
-    do_test_on_empty_input(ccv);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(ccv), std::string());
-    BOOST_CHECK_THROW(lexical_cast<char>(ccv), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(ccv), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(ccv), bad_lexical_cast);
-}
-
-void test_empty_string()
-{
-    std::string v;
-    do_test_on_empty_input(v);
-    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
-
-#ifndef BOOST_LCAST_NO_WCHAR_T
-    std::wstring vw;
-    do_test_on_empty_input(vw);
-    BOOST_CHECK_THROW(lexical_cast<wchar_t>(vw), bad_lexical_cast);
-#endif
-
-// Currently, no compiler and STL library fully support char16_t and char32_t
-//#ifndef BOOST_NO_CXX11_CHAR16_T
-//    std::basic_string<char16_t> v16w;
-//    do_test_on_empty_input(v16w);
-//    BOOST_CHECK_THROW(lexical_cast<char16_t>(v16w), bad_lexical_cast);
-//#endif
-//#ifndef BOOST_NO_CXX11_CHAR32_T
-//    std::basic_string<char32_t> v32w;
-//    do_test_on_empty_input(v32w);
-//    BOOST_CHECK_THROW(lexical_cast<char32_t>(v32w), bad_lexical_cast);
-//#endif
-}
-
-struct Escape
-{
-    Escape(const std::string& s)
-        : str_(s)
-    {}
-
-    std::string str_;
-};
-
-inline std::ostream& operator<< (std::ostream& o, const Escape& rhs)
-{
-    return o << rhs.str_;
-}
-
-void test_empty_user_class()
-{
-    Escape v("");
-    do_test_on_empty_input(v);
-    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
-}
-
-namespace std {
-inline std::ostream & operator<<(std::ostream & out, const std::vector<long> & v)
-{
-    std::ostream_iterator<long> it(out);
-    std::copy(v.begin(), v.end(), it);
-    assert(out);
-    return out;
-}
-}
-
-void test_empty_vector()
-{
-    std::vector<long> v;
-    do_test_on_empty_input(v);
-    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
-}
-
-
-struct my_string {
-    friend std::ostream &operator<<(std::ostream& sout, my_string const&/* st*/) {
-            return sout << "";
-    }
-};
-
-void test_empty_zero_terminated_string()
-{
-    my_string st;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(st), std::string());;
-}
-
-unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast. Empty input unit test");
-    suite->add(BOOST_TEST_CASE(&test_empty_iterator_range));
-    suite->add(BOOST_TEST_CASE(&test_empty_string));
-    suite->add(BOOST_TEST_CASE(&test_empty_user_class));
-    suite->add(BOOST_TEST_CASE(&test_empty_vector));
-    suite->add(BOOST_TEST_CASE(&test_empty_zero_terminated_string));
-
-    return suite;
-}
diff --git a/test/lexical_cast_filesystem_test.cpp b/test/lexical_cast_filesystem_test.cpp
deleted file mode 100644
index 154d107..0000000
--- a/test/lexical_cast_filesystem_test.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 2013.
-//
-//  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).
-//
-// Test lexical_cast usage with long filesystem::path. Bug 7704.
-
-#include <boost/config.hpp>
-
-#include <boost/test/unit_test.hpp>
-#include <boost/lexical_cast.hpp>
-#include <boost/filesystem/path.hpp>
-
-using namespace boost;
-
-void test_filesystem();
-
-unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast unit test");
-    suite->add(BOOST_TEST_CASE(&test_filesystem));
-
-    return suite;
-}
-
-void test_filesystem()
-{
-    boost::filesystem::path p;
-    std::string s1 = "aaaaaaaaaaaaaaaaaaaaaaa";
-    p = boost::lexical_cast<boost::filesystem::path>(s1);
-    BOOST_CHECK(!p.empty());
-    BOOST_CHECK_EQUAL(p, s1);
-    p.clear();
-
-    const char ab[] = "aaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
-    p = boost::lexical_cast<boost::filesystem::path>(ab);
-    BOOST_CHECK(!p.empty());
-    BOOST_CHECK_EQUAL(p, ab);
-}
-
diff --git a/test/lexical_cast_float_types_test.cpp b/test/lexical_cast_float_types_test.cpp
deleted file mode 100644
index 557d146..0000000
--- a/test/lexical_cast_float_types_test.cpp
+++ /dev/null
@@ -1,527 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 2011.
-//
-//  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/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
-#include <boost/lexical_cast.hpp>
-
-#include <boost/cstdint.hpp>
-#include <boost/test/unit_test.hpp>
-#include <boost/test/floating_point_comparison.hpp>
-
-void test_conversion_from_to_float();
-void test_conversion_from_to_double();
-void test_conversion_from_to_long_double();
-
-using namespace boost;
-
-
-unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast float types unit test");
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_float));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_double));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_long_double));
-
-    return suite;
-}
-
-
-// Replace "-,999" with "-999".
-template<class CharT>
-std::basic_string<CharT> to_str_gcc_workaround(std::basic_string<CharT> str)
-{
-    std::locale loc;
-    std::numpunct<CharT> const& np = BOOST_USE_FACET(std::numpunct<CharT>, loc);
-    std::ctype<CharT> const& ct = BOOST_USE_FACET(std::ctype<CharT>, loc);
-
-    if(np.grouping().empty())
-        return str;
-
-    CharT prefix[3] = { ct.widen('-'), np.thousands_sep(), CharT() };
-
-    if(str.find(prefix) != 0)
-        return str;
-
-    prefix[1] = CharT();
-    str.replace(0, 2, prefix);
-    return str;
-}
-
-template<class CharT, class T>
-std::basic_string<CharT> to_str(T t)
-{
-    std::basic_ostringstream<CharT> o;
-    o << t;
-    return to_str_gcc_workaround(o.str());
-}
-
-
-template<class T>
-void test_conversion_from_to_float_for_locale()
-{
-    std::locale current_locale;
-    typedef std::numpunct<char> numpunct;
-    numpunct const& np = BOOST_USE_FACET(numpunct, current_locale);
-    if ( !np.grouping().empty() )
-    {
-        BOOST_CHECK_THROW(
-                lexical_cast<T>( std::string("100") + np.thousands_sep() + np.thousands_sep() + "0" )
-                , bad_lexical_cast);
-        BOOST_CHECK_THROW(lexical_cast<T>( std::string("100") + np.thousands_sep() ), bad_lexical_cast);
-        BOOST_CHECK_THROW(lexical_cast<T>( np.thousands_sep() + std::string("100") ), bad_lexical_cast);
-        BOOST_CHECK_THROW(lexical_cast<T>( std::string("1") + np.thousands_sep() + np.decimal_point() + "e10" ), bad_lexical_cast);
-        BOOST_CHECK_THROW(lexical_cast<T>( std::string("1e10") + np.thousands_sep() ), bad_lexical_cast);
-        BOOST_CHECK_THROW(lexical_cast<T>( std::string("1") + np.thousands_sep() + "e10" ), bad_lexical_cast);
-
-        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(100000) ), 100000, (std::numeric_limits<T>::epsilon()) );
-        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(10000000u) ), 10000000u, (std::numeric_limits<T>::epsilon()) );
-        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(100) ), 100, (std::numeric_limits<T>::epsilon()) );
-#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(100000) ), 100000, (std::numeric_limits<T>::epsilon()) );
-        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(10000000u) ), 10000000u, (std::numeric_limits<T>::epsilon()) );
-        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(100) ), 100, (std::numeric_limits<T>::epsilon()) );
-#endif
-        // Exception must not be thrown, when we are using no separators at all
-        BOOST_CHECK_CLOSE_FRACTION( lexical_cast<T>("30000"), static_cast<T>(30000), (std::numeric_limits<T>::epsilon()) );
-    }
-}
-
-
-
-
-/*
- * Converts char* [and wchar_t*] to float number type and checks, that generated
- * number does not exceeds allowed epsilon.
- */
-#ifndef BOOST_LCAST_NO_WCHAR_T
-#define CHECK_CLOSE_ABS_DIFF(VAL,PREFIX)                                                          \
-    converted_val = lexical_cast<test_t>(#VAL);                                                   \
-    BOOST_CHECK_CLOSE_FRACTION( (static_cast<bool>(VAL ## L)? VAL ## L : std::numeric_limits<test_t>::epsilon()), \
-                       (converted_val ? converted_val : std::numeric_limits<test_t>::epsilon()),\
-                       std::numeric_limits<test_t>::epsilon()                                     \
-                     );                                                                           \
-    BOOST_CHECK_EQUAL(converted_val, lexical_cast<test_t>(L## #VAL) );
-
-#else
-#define CHECK_CLOSE_ABS_DIFF(VAL,TYPE)                                                            \
-    converted_val = lexical_cast<test_t>(#VAL);                                                   \
-    BOOST_CHECK_CLOSE_FRACTION( (static_cast<bool>(VAL ## L)? VAL ## L : std::numeric_limits<test_t>::epsilon()), \
-                       (converted_val ? converted_val : std::numeric_limits<test_t>::epsilon()),\
-                       std::numeric_limits<test_t>::epsilon()                                     \
-                     );
-#endif
-
-template <class TestType>
-void test_converion_to_float_types()
-{
-    typedef TestType test_t;
-    test_t converted_val;
-
-    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<test_t>('1'), (std::numeric_limits<test_t>::epsilon()));
-    BOOST_CHECK_EQUAL(0.0, lexical_cast<test_t>('0'));
-
-    unsigned char const uc_one = '1';
-    unsigned char const uc_zero ='0';
-    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<test_t>(uc_one), (std::numeric_limits<test_t>::epsilon()));
-    BOOST_CHECK_EQUAL(0.0, lexical_cast<test_t>(uc_zero));
-
-    signed char const sc_one = '1';
-    signed char const sc_zero ='0';
-    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<test_t>(sc_one), (std::numeric_limits<test_t>::epsilon()));
-    BOOST_CHECK_EQUAL(0.0, lexical_cast<test_t>(sc_zero));
-
-    BOOST_CHECK_CLOSE_FRACTION(1e34L, lexical_cast<test_t>( "10000000000000000000000000000000000"), (std::numeric_limits<test_t>::epsilon()) );
-
-//    VC failes the next test
-//    BOOST_CHECK_CLOSE_FRACTION(1e-35L, lexical_cast<test_t>("0.00000000000000000000000000000000001"), (std::numeric_limits<test_t>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(
-                                    0.1111111111111111111111111111111111111111111111111111111111111111111111111L
-            , lexical_cast<test_t>("0.1111111111111111111111111111111111111111111111111111111111111111111111111")
-            , (std::numeric_limits<test_t>::epsilon()) );
-
-    CHECK_CLOSE_ABS_DIFF(1,test_t);
-    BOOST_CHECK_EQUAL(0,lexical_cast<test_t>("0"));
-    CHECK_CLOSE_ABS_DIFF(-1,test_t);
-
-    CHECK_CLOSE_ABS_DIFF(1.0, test_t);
-    CHECK_CLOSE_ABS_DIFF(0.0, test_t);
-    CHECK_CLOSE_ABS_DIFF(-1.0,test_t);
-
-    CHECK_CLOSE_ABS_DIFF(1e1, test_t);
-    CHECK_CLOSE_ABS_DIFF(0e1, test_t);
-    CHECK_CLOSE_ABS_DIFF(-1e1,test_t);
-
-    CHECK_CLOSE_ABS_DIFF(1.0e1, test_t);
-    CHECK_CLOSE_ABS_DIFF(0.0e1, test_t);
-    CHECK_CLOSE_ABS_DIFF(-1.0e1,test_t);
-
-    CHECK_CLOSE_ABS_DIFF(1e-1, test_t);
-    CHECK_CLOSE_ABS_DIFF(0e-1, test_t);
-    CHECK_CLOSE_ABS_DIFF(-1e-1,test_t);
-
-    CHECK_CLOSE_ABS_DIFF(1.0e-1, test_t);
-    CHECK_CLOSE_ABS_DIFF(0.0e-1, test_t);
-    CHECK_CLOSE_ABS_DIFF(-1.0e-1,test_t);
-
-    CHECK_CLOSE_ABS_DIFF(1E1, test_t);
-    CHECK_CLOSE_ABS_DIFF(0E1, test_t);
-    CHECK_CLOSE_ABS_DIFF(-1E1,test_t);
-
-    CHECK_CLOSE_ABS_DIFF(1.0E1, test_t);
-    CHECK_CLOSE_ABS_DIFF(0.0E1, test_t);
-    CHECK_CLOSE_ABS_DIFF(-1.0E1,test_t);
-
-    CHECK_CLOSE_ABS_DIFF(1E-1, test_t);
-    CHECK_CLOSE_ABS_DIFF(0E-1, test_t);
-    CHECK_CLOSE_ABS_DIFF(-1E-1,test_t);
-
-    CHECK_CLOSE_ABS_DIFF(1.0E-1, test_t);
-    CHECK_CLOSE_ABS_DIFF(0.0E-1, test_t);
-    CHECK_CLOSE_ABS_DIFF(-1.0E-1, test_t);
-
-    CHECK_CLOSE_ABS_DIFF(.0E-1, test_t);
-    CHECK_CLOSE_ABS_DIFF(.0E-1, test_t);
-    CHECK_CLOSE_ABS_DIFF(-.0E-1, test_t);
-
-    CHECK_CLOSE_ABS_DIFF(10.0, test_t);
-    CHECK_CLOSE_ABS_DIFF(00.0, test_t);
-    CHECK_CLOSE_ABS_DIFF(-10.0,test_t);
-
-    CHECK_CLOSE_ABS_DIFF(10e1, test_t);
-    CHECK_CLOSE_ABS_DIFF(00e1, test_t);
-    CHECK_CLOSE_ABS_DIFF(-10e1,test_t);
-
-    CHECK_CLOSE_ABS_DIFF(10.0e1, test_t);
-    CHECK_CLOSE_ABS_DIFF(00.0e1, test_t);
-    CHECK_CLOSE_ABS_DIFF(-10.0e1,test_t);
-
-    CHECK_CLOSE_ABS_DIFF(10e-1, test_t);
-    CHECK_CLOSE_ABS_DIFF(00e-1, test_t);
-    CHECK_CLOSE_ABS_DIFF(-10e-1,test_t);
-
-    CHECK_CLOSE_ABS_DIFF(10.0e-1, test_t);
-    CHECK_CLOSE_ABS_DIFF(00.0e-1, test_t);
-    CHECK_CLOSE_ABS_DIFF(-10.0e-1,test_t);
-
-    CHECK_CLOSE_ABS_DIFF(10E1, test_t);
-    CHECK_CLOSE_ABS_DIFF(00E1, test_t);
-    CHECK_CLOSE_ABS_DIFF(-10E1,test_t);
-
-    CHECK_CLOSE_ABS_DIFF(10.0E1, test_t);
-    CHECK_CLOSE_ABS_DIFF(00.0E1, test_t);
-    CHECK_CLOSE_ABS_DIFF(-10.0E1,test_t);
-
-    CHECK_CLOSE_ABS_DIFF(10E-1, test_t);
-    CHECK_CLOSE_ABS_DIFF(00E-1, test_t);
-    CHECK_CLOSE_ABS_DIFF(-10E-1,test_t);
-
-    CHECK_CLOSE_ABS_DIFF(10.0E-1, test_t);
-    CHECK_CLOSE_ABS_DIFF(00.0E-1, test_t);
-    CHECK_CLOSE_ABS_DIFF(-10.0E-1, test_t);
-
-    CHECK_CLOSE_ABS_DIFF(-10101.0E-011, test_t);
-    CHECK_CLOSE_ABS_DIFF(-10101093, test_t);
-    CHECK_CLOSE_ABS_DIFF(10101093, test_t);
-
-    CHECK_CLOSE_ABS_DIFF(-.34, test_t);
-    CHECK_CLOSE_ABS_DIFF(.34, test_t);
-    CHECK_CLOSE_ABS_DIFF(.34e10, test_t);
-
-    BOOST_CHECK_THROW(lexical_cast<test_t>("-1.e"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("-1.E"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1.e"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1.E"), bad_lexical_cast);
-
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0E"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("10E"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("10e"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e-"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0E-"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("10E-"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("10e-"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("e1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("e-1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("e-"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>(".e"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>(".11111111111111111111111111111111111111111111111111111111111111111111ee"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>(".11111111111111111111111111111111111111111111111111111111111111111111e-"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("."), bad_lexical_cast);
-
-    BOOST_CHECK_THROW(lexical_cast<test_t>("-B"), bad_lexical_cast);
-
-    // Following two tests are not valid for C++11 compilers    
-    //BOOST_CHECK_THROW(lexical_cast<test_t>("0xB"), bad_lexical_cast);
-    //BOOST_CHECK_THROW(lexical_cast<test_t>("0x0"), bad_lexical_cast);
-
-    BOOST_CHECK_THROW(lexical_cast<test_t>("--1.0"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e--1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0.0"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1e1e1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e-1e-1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>(" 1.0"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0 "), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>(""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("-"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>('\0'), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>('-'), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>('.'), bad_lexical_cast);
-}
-
-template <class T>
-void test_float_typess_for_overflows()
-{
-    typedef T test_t;
-    test_t minvalue = (std::numeric_limits<test_t>::min)();
-    std::string s_min_value = lexical_cast<std::string>(minvalue);
-    BOOST_CHECK_CLOSE_FRACTION(minvalue, lexical_cast<test_t>(minvalue), (std::numeric_limits<test_t>::epsilon()));
-    BOOST_CHECK_CLOSE_FRACTION(minvalue, lexical_cast<test_t>(s_min_value), (std::numeric_limits<test_t>::epsilon() * 2));
-
-    test_t maxvalue = (std::numeric_limits<test_t>::max)();
-    std::string s_max_value = lexical_cast<std::string>(maxvalue);
-    BOOST_CHECK_CLOSE_FRACTION(maxvalue, lexical_cast<test_t>(maxvalue), (std::numeric_limits<test_t>::epsilon()));
-    BOOST_CHECK_CLOSE_FRACTION(maxvalue, lexical_cast<test_t>(s_max_value), (std::numeric_limits<test_t>::epsilon()));
-
-#ifndef _LIBCPP_VERSION
-    // libc++ had a bug in implementation of stream conversions for values that must be represented as infinity. 
-    // http://llvm.org/bugs/show_bug.cgi?id=15723#c4
-    BOOST_CHECK_THROW(lexical_cast<test_t>(s_max_value+"1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>(s_max_value+"9"), bad_lexical_cast);
-
-    // VC9 can fail the following tests on floats and doubles when using stingstream...
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1"+s_max_value), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("9"+s_max_value), bad_lexical_cast);
-#endif
-
-    if ( is_same<test_t,float>::value )
-    {
-        BOOST_CHECK_THROW(lexical_cast<test_t>( (std::numeric_limits<double>::max)() ), bad_lexical_cast);
-        BOOST_CHECK(
-                (std::numeric_limits<double>::min)() - std::numeric_limits<test_t>::epsilon()
-                <= lexical_cast<test_t>( (std::numeric_limits<double>::min)() )
-                && lexical_cast<test_t>( (std::numeric_limits<double>::min)() )
-                <= (std::numeric_limits<double>::min)() + std::numeric_limits<test_t>::epsilon()
-        );
-    }
-
-    if ( sizeof(test_t) < sizeof(long double) )
-    {
-        BOOST_CHECK_THROW(lexical_cast<test_t>( (std::numeric_limits<long double>::max)() ), bad_lexical_cast);
-        BOOST_CHECK(
-                (std::numeric_limits<long double>::min)() - std::numeric_limits<test_t>::epsilon()
-                <= lexical_cast<test_t>( (std::numeric_limits<long double>::min)() )
-                && lexical_cast<test_t>( (std::numeric_limits<long double>::min)() )
-                <= (std::numeric_limits<long double>::min)() + std::numeric_limits<test_t>::epsilon()
-        );
-    }
-}
-
-#undef CHECK_CLOSE_ABS_DIFF
-
-// Epsilon is multiplied by 2 because of two lexical conversions
-#define TEST_TO_FROM_CAST_AROUND_TYPED(VAL,STRING_TYPE)                             \
-    test_value = VAL + std::numeric_limits<test_t>::epsilon() * i ;                 \
-    converted_val = lexical_cast<test_t>( lexical_cast<STRING_TYPE>(test_value) );  \
-    BOOST_CHECK_CLOSE_FRACTION(                                                     \
-            test_value,                                                             \
-            converted_val,                                                          \
-            std::numeric_limits<test_t>::epsilon() * 2                              \
-        );
-
-/*
- * For interval [ from_mult*epsilon+VAL, to_mult*epsilon+VAL ], converts float type
- * numbers to string[wstring] and then back to float type, then compares initial
- * values and generated.
- * Step is epsilon
- */
-#ifndef BOOST_LCAST_NO_WCHAR_T
-#   define TEST_TO_FROM_CAST_AROUND(VAL)                    \
-    for(i=from_mult; i<=to_mult; ++i) {                     \
-        TEST_TO_FROM_CAST_AROUND_TYPED(VAL, std::string)    \
-        TEST_TO_FROM_CAST_AROUND_TYPED(VAL, std::wstring)   \
-    }
-#else
-#   define TEST_TO_FROM_CAST_AROUND(VAL)                    \
-    for(i=from_mult; i<=to_mult; ++i) {                     \
-        TEST_TO_FROM_CAST_AROUND_TYPED(VAL, std::string)    \
-    }
-#endif
-
-template <class TestType>
-void test_converion_from_to_float_types()
-{
-    typedef TestType test_t;
-    test_t test_value;
-    test_t converted_val;
-
-    int i;
-    int from_mult = -50;
-    int to_mult = 50;
-
-    TEST_TO_FROM_CAST_AROUND( 0.0 );
-
-    long double val1;
-    for(val1 = 1.0e-10L; val1 < 1e11; val1*=10 )
-        TEST_TO_FROM_CAST_AROUND( val1 );
-
-    long double val2;
-    for(val2 = -1.0e-10L; val2 > -1e11; val2*=10 )
-        TEST_TO_FROM_CAST_AROUND( val2 );
-
-    from_mult = -100;
-    to_mult = 0;
-    TEST_TO_FROM_CAST_AROUND( (std::numeric_limits<test_t>::max)() );
-
-    from_mult = 0;
-    to_mult = 100;
-    TEST_TO_FROM_CAST_AROUND( (std::numeric_limits<test_t>::min)() );
-}
-
-#undef TEST_TO_FROM_CAST_AROUND
-#undef TEST_TO_FROM_CAST_AROUND_TYPED
-
-
-template<class T, class CharT>
-void test_conversion_from_float_to_char(CharT zero)
-{
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(0)) == zero + 0);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(1)) == zero + 1);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(2)) == zero + 2);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(3)) == zero + 3);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(4)) == zero + 4);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(5)) == zero + 5);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(6)) == zero + 6);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(7)) == zero + 7);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(8)) == zero + 8);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(9)) == zero + 9);
-
-    BOOST_CHECK_THROW(lexical_cast<CharT>(static_cast<T>(10)), bad_lexical_cast);
-
-    T t = (std::numeric_limits<T>::max)();
-    BOOST_CHECK_THROW(lexical_cast<CharT>(t), bad_lexical_cast);
-}
-
-template<class T, class CharT>
-void test_conversion_from_char_to_float(CharT zero)
-{
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 0)), static_cast<T>(0), (std::numeric_limits<T>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 1)), static_cast<T>(1), (std::numeric_limits<T>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 2)), static_cast<T>(2), (std::numeric_limits<T>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 3)), static_cast<T>(3), (std::numeric_limits<T>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 4)), static_cast<T>(4), (std::numeric_limits<T>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 5)), static_cast<T>(5), (std::numeric_limits<T>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 6)), static_cast<T>(6), (std::numeric_limits<T>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 7)), static_cast<T>(7), (std::numeric_limits<T>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 8)), static_cast<T>(8), (std::numeric_limits<T>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 9)), static_cast<T>(9), (std::numeric_limits<T>::epsilon()) );
-
-    BOOST_CHECK_THROW(lexical_cast<T>( static_cast<CharT>(zero + 10)), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>( static_cast<CharT>(zero - 1)), bad_lexical_cast);
-}
-
-struct restore_oldloc
-{
-    std::locale oldloc;
-    ~restore_oldloc() { std::locale::global(oldloc); }
-};
-
-template<class T>
-void test_conversion_from_to_float()
-{    char const zero = '0';
-    signed char const szero = '0';
-    unsigned char const uzero = '0';
-    test_conversion_from_float_to_char<T>(zero);
-    test_conversion_from_char_to_float<T>(zero);
-    test_conversion_from_float_to_char<T>(szero);
-    test_conversion_from_char_to_float<T>(szero);
-    test_conversion_from_float_to_char<T>(uzero);
-    test_conversion_from_char_to_float<T>(uzero);
-    #if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-    wchar_t const wzero = L'0';
-    test_conversion_from_float_to_char<T>(wzero);
-    test_conversion_from_char_to_float<T>(wzero);
-    #endif
-
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>("+1"), 1, std::numeric_limits<T>::epsilon());
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>("+9"), 9, std::numeric_limits<T>::epsilon());
-
-    BOOST_CHECK_THROW(lexical_cast<T>("++1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>("-+9"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>("--1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>("+-9"), bad_lexical_cast);
-
-    test_converion_to_float_types<T>();
-    test_float_typess_for_overflows<T>();
-    test_converion_from_to_float_types<T>();
-
-
-    typedef std::numpunct<char> numpunct;
-
-    restore_oldloc guard;
-    std::locale const& oldloc = guard.oldloc;
-
-    std::string grouping1 = BOOST_USE_FACET(numpunct, oldloc).grouping();
-    std::string grouping2(grouping1);
-
-    test_conversion_from_to_float_for_locale<T>();
-
-    try
-    {
-        std::locale newloc("");
-        std::locale::global(newloc);
-
-        grouping2 = BOOST_USE_FACET(numpunct, newloc).grouping();
-    }
-    catch(std::exception const& ex)
-    {
-        std::string msg("Failed to set system locale: ");
-        msg += ex.what();
-        BOOST_TEST_MESSAGE(msg);
-    }
-
-    if(grouping1 != grouping2)
-        test_conversion_from_to_float_for_locale<T>();
-
-    if(grouping1.empty() && grouping2.empty())
-        BOOST_TEST_MESSAGE("Formatting with thousands_sep has not been tested");
-}
-
-
-void test_conversion_from_to_float()
-{
-    test_conversion_from_to_float<float>();
-}
-void test_conversion_from_to_double()
-{
-    test_conversion_from_to_float<double>();
-}
-void test_conversion_from_to_long_double()
-{
-// We do not run tests on compilers with bugs
-#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
-    test_conversion_from_to_float<long double>();
-#endif
-    BOOST_CHECK(true);
-}
-
-
-
-
-
-
-
diff --git a/test/lexical_cast_inf_nan_test.cpp b/test/lexical_cast_inf_nan_test.cpp
deleted file mode 100644
index 2c79ea8..0000000
--- a/test/lexical_cast_inf_nan_test.cpp
+++ /dev/null
@@ -1,205 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 2011.
-//
-//  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/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
-#include <boost/lexical_cast.hpp>
-
-
-#include <boost/math/special_functions/sign.hpp>
-#include <boost/math/special_functions/fpclassify.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/test/unit_test.hpp>
-#include <boost/test/floating_point_comparison.hpp>
-
-#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
-#define BOOST_LCAST_NO_WCHAR_T
-#endif
-
-using namespace boost;
-
-template <class T>
-bool is_pos_inf(T value)
-{
-    return (boost::math::isinf)(value) && !(boost::math::signbit)(value);
-}
-
-template <class T>
-bool is_neg_inf(T value)
-{
-    return (boost::math::isinf)(value) && (boost::math::signbit)(value);
-}
-
-template <class T>
-bool is_pos_nan(T value)
-{
-    return (boost::math::isnan)(value) && !(boost::math::signbit)(value);
-}
-
-template <class T>
-bool is_neg_nan(T value)
-{
-    /* There is some strange behaviour on Itanium platform with -nan nuber for long double.
-    * It is a IA64 feature, or it is a boost::math feature, not a lexical_cast bug */
-#if defined(__ia64__) || defined(_M_IA64)
-    return (boost::math::isnan)(value)
-            && ( boost::is_same<T, long double >::value || (boost::math::signbit)(value) );
-#else
-    return (boost::math::isnan)(value) && (boost::math::signbit)(value);
-#endif
-}
-
-template <class T>
-void test_inf_nan_templated()
-{
-    typedef T test_t;
-
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("inf") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("INF") ) );
-
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-inf") ) );
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-INF") ) );
-
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+inf") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+INF") ) );
-
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("infinity") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("INFINITY") ) );
-
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-infinity") ) );
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-INFINITY") ) );
-
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+infinity") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+INFINITY") ) );
-
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("iNfiNity") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("INfinity") ) );
-
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-inFINITY") ) );
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-INFINITY") ) );
-
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("nan") ) );
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("NAN") ) );
-
-    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>("-nan") ) );
-    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>("-NAN") ) );
-
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+nan") ) );
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+NAN") ) );
-
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("nAn") ) );
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("NaN") ) );
-
-    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>("-nAn") ) );
-    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>("-NaN") ) );
-
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+Nan") ) );
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+nAN") ) );
-
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("nan()") ) );
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("NAN(some string)") ) );
-    BOOST_CHECK_THROW( lexical_cast<test_t>("NAN(some string"), bad_lexical_cast );
-
-    BOOST_CHECK(lexical_cast<std::string>( (boost::math::changesign)(std::numeric_limits<test_t >::infinity()))
-                == "-inf" );
-    BOOST_CHECK(lexical_cast<std::string>( std::numeric_limits<test_t >::infinity()) == "inf" );
-    BOOST_CHECK(lexical_cast<std::string>( std::numeric_limits<test_t >::quiet_NaN()) == "nan" );
-#if !defined(__ia64__) && !defined(_M_IA64)
-    BOOST_CHECK(lexical_cast<std::string>(
-                (boost::math::changesign)(std::numeric_limits<test_t >::quiet_NaN()))
-                == "-nan" );
-#endif
-
-#ifndef  BOOST_LCAST_NO_WCHAR_T
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"inf") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"INF") ) );
-
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-inf") ) );
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-INF") ) );
-
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+inf") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+INF") ) );
-
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"infinity") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"INFINITY") ) );
-
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-infinity") ) );
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-INFINITY") ) );
-
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+infinity") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+INFINITY") ) );
-
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-infINIty") ) );
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-INFiniTY") ) );
-
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+inFINIty") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+INfinITY") ) );
-
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"nan") ) );
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"NAN") ) );
-
-    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>(L"-nan") ) );
-    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>(L"-NAN") ) );
-
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"+nan") ) );
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"+NAN") ) );
-
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"nan()") ) );
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"NAN(some string)") ) );
-    BOOST_CHECK_THROW( lexical_cast<test_t>(L"NAN(some string"), bad_lexical_cast );
-
-    BOOST_CHECK(lexical_cast<std::wstring>( (boost::math::changesign)(std::numeric_limits<test_t >::infinity()))
-                == L"-inf" );
-    BOOST_CHECK(lexical_cast<std::wstring>( std::numeric_limits<test_t >::infinity()) == L"inf" );
-    BOOST_CHECK(lexical_cast<std::wstring>( std::numeric_limits<test_t >::quiet_NaN()) == L"nan" );
-#if !defined(__ia64__) && !defined(_M_IA64)
-    BOOST_CHECK(lexical_cast<std::wstring>(
-                (boost::math::changesign)(std::numeric_limits<test_t >::quiet_NaN()))
-                == L"-nan" );
-#endif
-
-#endif
-}
-
-void test_inf_nan_float()
-{
-    test_inf_nan_templated<float >();
-}
-
-void test_inf_nan_double()
-{
-    test_inf_nan_templated<double >();
-}
-
-void test_inf_nan_long_double()
-{
-// We do not run tests on compilers with bugs
-#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
-    test_inf_nan_templated<long double >();
-#endif
-    BOOST_CHECK(true);
-}
-
-unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast inf anf nan parsing unit test");
-    suite->add(BOOST_TEST_CASE(&test_inf_nan_float));
-    suite->add(BOOST_TEST_CASE(&test_inf_nan_double));
-    suite->add(BOOST_TEST_CASE(&test_inf_nan_long_double));
-
-    return suite;
-}
diff --git a/test/lexical_cast_integral_types_test.cpp b/test/lexical_cast_integral_types_test.cpp
deleted file mode 100644
index 551a349..0000000
--- a/test/lexical_cast_integral_types_test.cpp
+++ /dev/null
@@ -1,653 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Terje Sletteb and Kevlin Henney, 2005.
-//  Copyright Alexander Nasonov, 2006.
-//  Copyright Antony Polukhin, 2011-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).
-//
-// Note: The unit test no longer compile on MSVC 6, but lexical_cast itself works for it.
-
-//
-// We need this #define before any #includes: otherwise msvc will emit warnings
-// deep within std::string, resulting from our (perfectly legal) use of basic_string
-// with a custom traits class:
-//
-#define _SCL_SECURE_NO_WARNINGS
-
-#include <boost/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
-#include <boost/lexical_cast.hpp>
-
-#include <boost/cstdint.hpp>
-#include <boost/test/unit_test.hpp>
-#include <boost/test/floating_point_comparison.hpp>
-
-#include <boost/type_traits/integral_promotion.hpp>
-#include <boost/type_traits/make_unsigned.hpp>
-#include <string>
-#include <vector>
-#include <memory>
-
-#if (defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)) \
-    && !(defined(BOOST_MSVC) && BOOST_MSVC < 1300)
-#define LCAST_TEST_LONGLONG
-#endif
-
-#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
-#define BOOST_LCAST_NO_WCHAR_T
-#endif
-
-// Test all 65536 values if true:
-bool const lcast_test_small_integral_types_completely = false;
-
-// lcast_integral_test_counter: use when testing all values of an integral
-// types is not possible. Max. portable value is 32767.
-int const lcast_integral_test_counter=500;
-
-using namespace boost;
-
-
-
-void test_conversion_from_to_short();
-void test_conversion_from_to_ushort();
-void test_conversion_from_to_int();
-void test_conversion_from_to_uint();
-void test_conversion_from_to_long();
-void test_conversion_from_to_ulong();
-void test_conversion_from_to_intmax_t();
-void test_conversion_from_to_uintmax_t();
-#ifdef LCAST_TEST_LONGLONG
-void test_conversion_from_to_longlong();
-void test_conversion_from_to_ulonglong();
-#endif
-#ifdef BOOST_HAS_INT128
-void test_conversion_from_to_int128();
-void test_conversion_from_to_uint128();
-#endif
-void test_integral_conversions_on_min_max();
-
-
-unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast unit test on integral types");
-
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_short));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_ushort));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_int));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_uint));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_long));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_ulong));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_intmax_t));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_uintmax_t));
-#ifdef LCAST_TEST_LONGLONG
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_longlong));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_ulonglong));
-#endif
-#ifdef BOOST_HAS_INT128
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_int128));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_uint128));
-#endif
-    suite->add(BOOST_TEST_CASE(&test_integral_conversions_on_min_max));
-
-    return suite;
-}
-
-template<class T, class CharT>
-void test_conversion_from_integral_to_char(CharT zero)
-{
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(0)) == zero + 0);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(1)) == zero + 1);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(2)) == zero + 2);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(3)) == zero + 3);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(4)) == zero + 4);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(5)) == zero + 5);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(6)) == zero + 6);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(7)) == zero + 7);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(8)) == zero + 8);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(9)) == zero + 9);
-
-    BOOST_CHECK_THROW(lexical_cast<CharT>(static_cast<T>(10)), bad_lexical_cast);
-
-    T t = (std::numeric_limits<T>::max)();
-    BOOST_CHECK_THROW(lexical_cast<CharT>(t), bad_lexical_cast);
-}
-
-template<class T, class CharT>
-void test_conversion_from_char_to_integral(CharT zero)
-{
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 0)) == static_cast<T>(0) );
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 1)) == static_cast<T>(1) );
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 2)) == static_cast<T>(2) );
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 3)) == static_cast<T>(3) );
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 4)) == static_cast<T>(4) );
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 5)) == static_cast<T>(5) );
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 6)) == static_cast<T>(6) );
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 7)) == static_cast<T>(7) );
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 8)) == static_cast<T>(8) );
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 9)) == static_cast<T>(9) );
-
-    BOOST_CHECK_THROW(lexical_cast<T>( static_cast<CharT>(zero + 10)), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>( static_cast<CharT>(zero - 1)), bad_lexical_cast);
-}
-
-template<class T>
-void test_conversion_from_integral_to_integral()
-{
-    T t = 0;
-    BOOST_CHECK(lexical_cast<T>(t) == t);
-
-    // Next two variables are used to supress warnings.
-    int st = 32767; unsigned int ut = st;
-    t = st;
-    BOOST_CHECK(lexical_cast<short>(t) == st);
-    BOOST_CHECK(lexical_cast<unsigned short>(t) == ut);
-    BOOST_CHECK(lexical_cast<int>(t) == st);
-    BOOST_CHECK(lexical_cast<unsigned int>(t) == ut);
-    BOOST_CHECK(lexical_cast<long>(t) == st);
-    BOOST_CHECK(lexical_cast<unsigned long>(t) == ut);
-
-    t = (std::numeric_limits<T>::max)();
-    BOOST_CHECK(lexical_cast<T>(t) == t);
-
-    t = (std::numeric_limits<T>::min)();
-    BOOST_CHECK(lexical_cast<T>(t) == t);
-}
-
-
-
-
-// Replace "-,999" with "-999".
-template<class CharT>
-std::basic_string<CharT> to_str_gcc_workaround(std::basic_string<CharT> str)
-{
-    std::locale loc;
-    std::numpunct<CharT> const& np = BOOST_USE_FACET(std::numpunct<CharT>, loc);
-    std::ctype<CharT> const& ct = BOOST_USE_FACET(std::ctype<CharT>, loc);
-
-    if(np.grouping().empty())
-        return str;
-
-    CharT prefix[3] = { ct.widen('-'), np.thousands_sep(), CharT() };
-
-    if(str.find(prefix) != 0)
-        return str;
-
-    prefix[1] = CharT();
-    str.replace(0, 2, prefix);
-    return str;
-}
-
-template<class CharT, class T>
-std::basic_string<CharT> to_str(T t)
-{
-    std::basic_ostringstream<CharT> o;
-    o << t;
-    return to_str_gcc_workaround(o.str());
-}
-
-
-template<class T, class CharT>
-void test_conversion_from_integral_to_string(CharT)
-{
-    typedef std::numeric_limits<T> limits;
-    typedef std::basic_string<CharT> string_type;
-
-    T t;
-
-    t = (limits::min)();
-    BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
-
-    t = (limits::max)();
-    BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
-
-    if(limits::digits <= 16 && lcast_test_small_integral_types_completely)
-        // min and max have already been tested.
-        for(t = 1 + (limits::min)(); t != (limits::max)(); ++t)
-            BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
-    else
-    {
-        T const min_val = (limits::min)();
-        T const max_val = (limits::max)();
-        T const half_max_val = max_val / 2;
-        T const cnt = lcast_integral_test_counter; // to supress warnings
-        unsigned int const counter = cnt < half_max_val ? cnt : half_max_val;
-
-        unsigned int i;
-
-        // Test values around min:
-        t = min_val;
-        for(i = 0; i < counter; ++i, ++t)
-            BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
-
-        // Test values around max:
-        t = max_val;
-        for(i = 0; i < counter; ++i, --t)
-            BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
-
-        // Test values around zero:
-        if(limits::is_signed)
-            for(t = static_cast<T>(-counter); t < static_cast<T>(counter); ++t)
-                BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
-
-        // Test values around 100, 1000, 10000, ...
-        T ten_power = 100;
-        for(int e = 2; e < limits::digits10; ++e, ten_power *= 10)
-        {
-            // ten_power + 100 probably never overflows
-            for(t = ten_power - 100; t != ten_power + 100; ++t)
-                BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
-        }
-    }
-}
-
-template<class T, class CharT>
-void test_conversion_from_string_to_integral(CharT)
-{
-    typedef std::numeric_limits<T> limits;
-    typedef std::basic_string<CharT> string_type;
-
-    string_type s;
-    string_type const zero = to_str<CharT>(0);
-    string_type const nine = to_str<CharT>(9);
-    T const min_val = (limits::min)();
-    T const max_val = (limits::max)();
-
-    s = to_str<CharT>(min_val);
-    BOOST_CHECK_EQUAL(lexical_cast<T>(s), min_val);
-    if(limits::is_signed)
-    {
-        BOOST_CHECK_THROW(lexical_cast<T>(s + zero), bad_lexical_cast);
-        BOOST_CHECK_THROW(lexical_cast<T>(s + nine), bad_lexical_cast);
-    }
-
-    s = to_str<CharT>(max_val);
-    BOOST_CHECK_EQUAL(lexical_cast<T>(s), max_val);
-    {
-        BOOST_CHECK_THROW(lexical_cast<T>(s + zero), bad_lexical_cast);
-        BOOST_CHECK_THROW(lexical_cast<T>(s + nine), bad_lexical_cast);
-
-        s = to_str<CharT>(max_val);
-        for (int i =1; i <=10; ++i) {
-            s[s.size()-1] += 1;
-            BOOST_CHECK_THROW(lexical_cast<T>( s ), bad_lexical_cast);
-        }
-
-        s = to_str<CharT>(max_val);
-        std::locale loc;
-        typedef std::numpunct<char> numpunct;
-        if ( BOOST_USE_FACET(numpunct, loc).grouping().empty() ) {
-            // Following tests work well for locale C
-            BOOST_CHECK_EQUAL(lexical_cast<T>(to_str<CharT>(0)+s), max_val);
-            BOOST_CHECK_EQUAL(lexical_cast<T>(to_str<CharT>(0)+to_str<CharT>(0)+s), max_val);
-            BOOST_CHECK_EQUAL(lexical_cast<T>(to_str<CharT>(0)+to_str<CharT>(0)+to_str<CharT>(0)+s), max_val);
-        }
-
-        for (int i =1; i <=256; ++i) {
-            BOOST_CHECK_THROW(lexical_cast<T>( to_str<CharT>(i)+s ), bad_lexical_cast);
-        }
-
-        typedef BOOST_DEDUCED_TYPENAME boost::integral_promotion<T>::type promoted;
-        if ( !(boost::is_same<T, promoted>::value) )
-        {
-            promoted prom = max_val;
-            s = to_str<CharT>(max_val);
-            for (int i =1; i <=256; ++i) {
-                BOOST_CHECK_THROW(lexical_cast<T>( to_str<CharT>(prom+i) ), bad_lexical_cast);
-                BOOST_CHECK_THROW(lexical_cast<T>( to_str<CharT>(i)+s ), bad_lexical_cast);
-            }
-        }
-    }
-
-    if(limits::digits <= 16 && lcast_test_small_integral_types_completely)
-        // min and max have already been tested.
-        for(T t = 1 + min_val; t != max_val; ++t)
-            BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
-    else
-    {
-        T const half_max_val = max_val / 2;
-        T const cnt = lcast_integral_test_counter; // to supress warnings
-        unsigned int const counter = cnt < half_max_val ? cnt : half_max_val;
-
-        T t;
-        unsigned int i;
-
-        // Test values around min:
-        t = min_val;
-        for(i = 0; i < counter; ++i, ++t)
-            BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
-
-        // Test values around max:
-        t = max_val;
-        for(i = 0; i < counter; ++i, --t)
-            BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
-
-        // Test values around zero:
-        if(limits::is_signed)
-            for(t = static_cast<T>(-counter); t < static_cast<T>(counter); ++t)
-                BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
-
-        // Test values around 100, 1000, 10000, ...
-        T ten_power = 100;
-        for(int e = 2; e < limits::digits10; ++e, ten_power *= 10)
-        {
-            // ten_power + 100 probably never overflows
-            for(t = ten_power - 100; t != ten_power + 100; ++t)
-                BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
-        }
-    }
-}
-
-template<class T>
-void test_conversion_from_to_integral_for_locale()
-{
-    std::locale current_locale;
-    typedef std::numpunct<char> numpunct;
-    numpunct const& np = BOOST_USE_FACET(numpunct, current_locale);
-    if ( !np.grouping().empty() )
-    {
-        BOOST_CHECK_THROW(
-                lexical_cast<T>( std::string("100") + np.thousands_sep() + np.thousands_sep() + "0" )
-                , bad_lexical_cast);
-        BOOST_CHECK_THROW(lexical_cast<T>( std::string("100") + np.thousands_sep() ), bad_lexical_cast);
-        BOOST_CHECK_THROW(lexical_cast<T>( np.thousands_sep() + std::string("100") ), bad_lexical_cast);
-
-        // Exception must not be thrown, when we are using no separators at all
-        BOOST_CHECK( lexical_cast<T>("30000") == static_cast<T>(30000) );
-    }
-
-
-    test_conversion_from_integral_to_integral<T>();
-
-    // This is a part of test_conversion_from_integral_to_string<T>('0') method,
-    // but with BOOST_CHECK_EQUAL instead of BOOST_CHECK. It is required to see 
-    // what is produced by the to_str<char>(t) method in situations when result 
-    // is different. BOOST_CHECK does not work with wchar_t.
-    typedef std::numeric_limits<T> limits;
-    T t = (limits::min)();
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(t), to_str<char>(t));
-
-    test_conversion_from_integral_to_string<T>('0');
-    test_conversion_from_string_to_integral<T>('0');
-#if !defined(BOOST_LCAST_NO_WCHAR_T)
-    if (lexical_cast<std::wstring>(t) != to_str<wchar_t>(t)) {
-        // Something went wrong, and now we are attempting to find and print the 
-        // difference.
-        std::wstring wstr = to_str<wchar_t>(t);
-        std::string lcast_str = lexical_cast<std::string>(t);
-        std::string str;
-        str.reserve(wstr.size());
-        for (std::size_t i = 0; i < wstr.size(); ++i) {
-            str.push_back(static_cast<char>(wstr[i]));
-        }
-        
-        BOOST_CHECK_EQUAL(lcast_str.length(), lexical_cast<std::wstring>(t).length());
-        BOOST_CHECK_EQUAL(to_str<char>(t), str);
-        BOOST_CHECK_EQUAL(lcast_str, str);
-    }
-
-    test_conversion_from_integral_to_string<T>(L'0');
-    test_conversion_from_string_to_integral<T>(L'0');
-#endif
-}
-
-struct restore_oldloc
-{
-    std::locale oldloc;
-    ~restore_oldloc() { std::locale::global(oldloc); }
-};
-
-template<class T>
-void test_conversion_from_to_integral_minimal()
-{
-    char const zero = '0';
-    signed char const szero = '0';
-    unsigned char const uzero = '0';
-    test_conversion_from_integral_to_char<T>(zero);
-    test_conversion_from_char_to_integral<T>(zero);
-    test_conversion_from_integral_to_char<T>(szero);
-    test_conversion_from_char_to_integral<T>(szero);
-    test_conversion_from_integral_to_char<T>(uzero);
-    test_conversion_from_char_to_integral<T>(uzero);
-#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-    wchar_t const wzero = L'0';
-    test_conversion_from_integral_to_char<T>(wzero);
-    test_conversion_from_char_to_integral<T>(wzero);
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION)
-    char16_t const u16zero = u'0';
-    test_conversion_from_integral_to_char<T>(u16zero);
-    test_conversion_from_char_to_integral<T>(u16zero);
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION)
-    char32_t const u32zero = u'0';
-    test_conversion_from_integral_to_char<T>(u32zero);
-    test_conversion_from_char_to_integral<T>(u32zero);
-#endif
-
-    BOOST_CHECK(lexical_cast<T>("-1") == static_cast<T>(-1));
-    BOOST_CHECK(lexical_cast<T>("-9") == static_cast<T>(-9));
-    BOOST_CHECK(lexical_cast<T>(-1) == static_cast<T>(-1));
-    BOOST_CHECK(lexical_cast<T>(-9) == static_cast<T>(-9));
-
-    BOOST_CHECK_THROW(lexical_cast<T>("-1.0"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>("-9.0"), bad_lexical_cast);
-    BOOST_CHECK(lexical_cast<T>(-1.0) == static_cast<T>(-1));
-    BOOST_CHECK(lexical_cast<T>(-9.0) == static_cast<T>(-9));
-
-    BOOST_CHECK(lexical_cast<T>(static_cast<T>(1)) == static_cast<T>(1));
-    BOOST_CHECK(lexical_cast<T>(static_cast<T>(9)) == static_cast<T>(9));
-    BOOST_CHECK_THROW(lexical_cast<T>(1.1f), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>(1.1), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>(1.1L), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>(1.0001f), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>(1.0001), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>(1.0001L), bad_lexical_cast);
-
-    BOOST_CHECK(lexical_cast<T>("+1") == static_cast<T>(1) );
-    BOOST_CHECK(lexical_cast<T>("+9") == static_cast<T>(9) );
-    BOOST_CHECK(lexical_cast<T>("+10") == static_cast<T>(10) );
-    BOOST_CHECK(lexical_cast<T>("+90") == static_cast<T>(90) );
-    BOOST_CHECK_THROW(lexical_cast<T>("++1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>("-+9"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>("--1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>("+-9"), bad_lexical_cast);
-    // test_conversion_from_to_integral_for_locale
-
-    // Overflow test case from David W. Birdsall
-    std::string must_owerflow_str =             (sizeof(T) < 16 ?  "160000000000000000000" :  "1600000000000000000000000000000000000000");
-    std::string must_owerflow_negative_str =    (sizeof(T) < 16 ? "-160000000000000000000" : "-1600000000000000000000000000000000000000");
-    for (int i = 0; i < 15; ++i) {
-        BOOST_CHECK_THROW(lexical_cast<T>(must_owerflow_str), bad_lexical_cast);
-        BOOST_CHECK_THROW(lexical_cast<T>(must_owerflow_negative_str), bad_lexical_cast);
-
-        must_owerflow_str += '0';
-        must_owerflow_negative_str += '0';
-    }
-}
-
-template<class T>
-void test_conversion_from_to_integral()
-{
-    test_conversion_from_to_integral_minimal<T>();
-    typedef std::numpunct<char> numpunct;
-
-    restore_oldloc guard;
-    std::locale const& oldloc = guard.oldloc;
-
-    std::string grouping1 = BOOST_USE_FACET(numpunct, oldloc).grouping();
-    std::string grouping2(grouping1);
-
-    test_conversion_from_to_integral_for_locale<T>();
-
-    try
-    {
-        std::locale newloc("");
-        std::locale::global(newloc);
-
-        grouping2 = BOOST_USE_FACET(numpunct, newloc).grouping();
-    }
-    catch(std::exception const& ex)
-    {
-        std::string msg("Failed to set system locale: ");
-        msg += ex.what();
-        BOOST_TEST_MESSAGE(msg);
-    }
-
-    if(grouping1 != grouping2)
-        test_conversion_from_to_integral_for_locale<T>();
-
-    if(grouping1.empty() && grouping2.empty())
-        BOOST_TEST_MESSAGE("Formatting with thousands_sep has not been tested");
-}
-
-void test_conversion_from_to_short()
-{
-    test_conversion_from_to_integral<short>();
-}
-
-void test_conversion_from_to_ushort()
-{
-    test_conversion_from_to_integral<unsigned short>();
-}
-
-void test_conversion_from_to_int()
-{
-    test_conversion_from_to_integral<int>();
-}
-
-void test_conversion_from_to_uint()
-{
-    test_conversion_from_to_integral<unsigned int>();
-}
-
-void test_conversion_from_to_long()
-{
-    test_conversion_from_to_integral<long>();
-}
-
-void test_conversion_from_to_ulong()
-{
-    test_conversion_from_to_integral<unsigned long>();
-}
-
-void test_conversion_from_to_intmax_t()
-{
-    test_conversion_from_to_integral<boost::intmax_t>();
-}
-
-void test_conversion_from_to_uintmax_t()
-{
-    test_conversion_from_to_integral<boost::uintmax_t>();
-}
-
-#if defined(BOOST_HAS_LONG_LONG)
-
-void test_conversion_from_to_longlong()
-{
-    test_conversion_from_to_integral<boost::long_long_type>();
-}
-
-void test_conversion_from_to_ulonglong()
-{
-    test_conversion_from_to_integral<boost::ulong_long_type>();
-}
-
-#elif defined(BOOST_HAS_MS_INT64)
-
-void test_conversion_from_to_longlong()
-{
-    test_conversion_from_to_integral<__int64>();
-}
-
-void test_conversion_from_to_ulonglong()
-{
-    test_conversion_from_to_integral<unsigned __int64>();
-}
-
-#endif
-
-
-#ifdef BOOST_HAS_INT128
-
-template <bool Specialized, class T>
-struct test_if_specialized {
-    static void test() {}
-};
-
-template <class T>
-struct test_if_specialized<true, T> {
-    static void test() {
-        test_conversion_from_to_integral_minimal<T>();
-    }
-};
-
-void test_conversion_from_to_int128()
-{
-    test_if_specialized<
-        std::numeric_limits<boost::int128_type>::is_specialized, 
-        boost::int128_type
-    >::test();
-}
-
-void test_conversion_from_to_uint128()
-{
-    test_if_specialized<
-        std::numeric_limits<boost::int128_type>::is_specialized, 
-        boost::uint128_type
-    >::test();
-}
-#endif
-
-template <typename SignedT>
-void test_integral_conversions_on_min_max_impl()
-{
-    typedef SignedT signed_t;
-    typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned<signed_t>::type unsigned_t;
-    
-    typedef std::numeric_limits<signed_t> s_limits;
-    typedef std::numeric_limits<unsigned_t> uns_limits;
-
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned_t>((uns_limits::max)()), (uns_limits::max)());
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned_t>((uns_limits::min)()), (uns_limits::min)());
-
-    BOOST_CHECK_EQUAL(lexical_cast<signed_t>((s_limits::max)()), (s_limits::max)());
-    BOOST_CHECK_EQUAL(lexical_cast<signed_t>((uns_limits::min)()), static_cast<signed_t>((uns_limits::min)()));
-
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned_t>((s_limits::max)()), static_cast<unsigned_t>((s_limits::max)()));
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned_t>((s_limits::min)()), static_cast<unsigned_t>((s_limits::min)()));
-}
-
-void test_integral_conversions_on_min_max()
-{
-    test_integral_conversions_on_min_max_impl<int>();
-    test_integral_conversions_on_min_max_impl<short>();
-
-#ifdef _MSC_VER
-    test_integral_conversions_on_min_max_impl<long int>();
-
-#if defined(BOOST_HAS_LONG_LONG)
-    test_integral_conversions_on_min_max_impl<boost::long_long_type>();
-#elif defined(BOOST_HAS_MS_INT64)
-    test_integral_conversions_on_min_max_impl<__int64>();
-#endif
-
-#ifdef BOOST_HAS_INT128
-    test_integral_conversions_on_min_max_impl<boost::int128_type>();
-#endif
-#endif
-
-}
-
-
diff --git a/test/lexical_cast_iterator_range_test.cpp b/test/lexical_cast_iterator_range_test.cpp
deleted file mode 100644
index 1b4a3ef..0000000
--- a/test/lexical_cast_iterator_range_test.cpp
+++ /dev/null
@@ -1,245 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 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/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
-#include <boost/lexical_cast.hpp>
-
-#include <boost/test/unit_test.hpp>
-#include <boost/range/iterator_range.hpp>
-
-using namespace boost;
-
-#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
-#define BOOST_LCAST_NO_WCHAR_T
-#endif
-
-
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION)
-#define BOOST_LC_RUNU16
-#endif
-
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION)
-#define BOOST_LC_RUNU32
-#endif
-
-struct class_with_user_defined_sream_operators {
-    int i;
-
-    operator int() const {
-        return i;
-    }
-};
-
-template <class CharT>
-inline std::basic_istream<CharT>& operator >> (std::basic_istream<CharT>& istr, class_with_user_defined_sream_operators& rhs)
-{
-    return istr >> rhs.i;
-}
-
-
-template <class RngT>
-void do_test_iterator_range_impl(const RngT& rng)
-{
-    BOOST_CHECK_EQUAL(lexical_cast<int>(rng), 1);
-    BOOST_CHECK_EQUAL(lexical_cast<int>(rng.begin(), rng.size()), 1);
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned int>(rng), 1u);
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned int>(rng.begin(), rng.size()), 1u);
-    BOOST_CHECK_EQUAL(lexical_cast<short>(rng), 1);
-    BOOST_CHECK_EQUAL(lexical_cast<short>(rng.begin(), rng.size()), 1);
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned short>(rng), 1u);
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned short>(rng.begin(), rng.size()), 1u);
-    BOOST_CHECK_EQUAL(lexical_cast<long int>(rng), 1);
-    BOOST_CHECK_EQUAL(lexical_cast<long int>(rng.begin(), rng.size()), 1);
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned long int>(rng), 1u);
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned long int>(rng.begin(), rng.size()), 1u);
-
-#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
-    BOOST_CHECK_EQUAL(lexical_cast<float>(rng), 1.0f);
-    BOOST_CHECK_EQUAL(lexical_cast<float>(rng.begin(), rng.size()), 1.0f);
-    BOOST_CHECK_EQUAL(lexical_cast<double>(rng), 1.0);
-    BOOST_CHECK_EQUAL(lexical_cast<double>(rng.begin(), rng.size()), 1.0);
-#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
-    BOOST_CHECK_EQUAL(lexical_cast<long double>(rng), 1.0L);
-    BOOST_CHECK_EQUAL(lexical_cast<long double>(rng.begin(), rng.size()), 1.0L);
-#endif
-    BOOST_CHECK_EQUAL(lexical_cast<class_with_user_defined_sream_operators>(rng), 1);
-#endif
-#if defined(BOOST_HAS_LONG_LONG)
-    BOOST_CHECK_EQUAL(lexical_cast<boost::ulong_long_type>(rng), 1u);
-    BOOST_CHECK_EQUAL(lexical_cast<boost::ulong_long_type>(rng.begin(), rng.size()), 1u);
-    BOOST_CHECK_EQUAL(lexical_cast<boost::long_long_type>(rng), 1);
-    BOOST_CHECK_EQUAL(lexical_cast<boost::long_long_type>(rng.begin(), rng.size()), 1);
-#elif defined(BOOST_HAS_MS_INT64)
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned __int64>(rng), 1u);
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned __int64>(rng.begin(), rng.size()), 1u);
-    BOOST_CHECK_EQUAL(lexical_cast<__int64>(rng), 1);
-    BOOST_CHECK_EQUAL(lexical_cast<__int64>(rng.begin(), rng.size()), 1);
-#endif
-}
-
-template <class CharT>
-void test_it_range_using_any_chars(CharT* one, CharT* eleven)
-{
-    typedef CharT test_char_type;
-
-    // Zero terminated
-    iterator_range<test_char_type*> rng1(one, one + 1);
-    do_test_iterator_range_impl(rng1);
-
-    iterator_range<const test_char_type*> crng1(one, one + 1);
-    do_test_iterator_range_impl(crng1);
-
-    // Non zero terminated
-    iterator_range<test_char_type*> rng2(eleven, eleven + 1);
-    do_test_iterator_range_impl(rng2);
-
-    iterator_range<const test_char_type*> crng2(eleven, eleven + 1);
-    do_test_iterator_range_impl(crng2);
-}
-
-template <class CharT>
-void test_it_range_using_char(CharT* one, CharT* eleven)
-{
-    typedef CharT test_char_type;
-
-    iterator_range<test_char_type*> rng1(one, one + 1);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(rng1), "1");
-
-    iterator_range<const test_char_type*> crng1(one, one + 1);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(crng1), "1");
-
-    iterator_range<test_char_type*> rng2(eleven, eleven + 1);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(rng2), "1");
-
-    iterator_range<const test_char_type*> crng2(eleven, eleven + 1);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(crng2), "1");
-
-    BOOST_CHECK_EQUAL(lexical_cast<float>(rng1), 1.0f);
-    BOOST_CHECK_EQUAL(lexical_cast<double>(rng1), 1.0);
-#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
-    BOOST_CHECK_EQUAL(lexical_cast<long double>(rng1), 1.0L);
-#endif
-    BOOST_CHECK_EQUAL(lexical_cast<class_with_user_defined_sream_operators>(rng1), 1);
-
-    BOOST_CHECK_EQUAL(lexical_cast<float>(crng2), 1.0f);
-    BOOST_CHECK_EQUAL(lexical_cast<double>(crng2), 1.0);
-#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
-    BOOST_CHECK_EQUAL(lexical_cast<long double>(crng2), 1.0L);
-#endif
-    BOOST_CHECK_EQUAL(lexical_cast<class_with_user_defined_sream_operators>(crng2), 1);
-
-#ifndef BOOST_LCAST_NO_WCHAR_T
-    BOOST_CHECK(lexical_cast<std::wstring>(rng1) == L"1");
-    BOOST_CHECK(lexical_cast<std::wstring>(crng1) == L"1");
-    BOOST_CHECK(lexical_cast<std::wstring>(rng2) == L"1");
-    BOOST_CHECK(lexical_cast<std::wstring>(crng2) == L"1");
-#endif
-
-#if defined(BOOST_LC_RUNU16) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
-    typedef std::basic_string<char16_t> my_char16_string;
-    BOOST_CHECK(lexical_cast<my_char16_string>(rng1) == u"1");
-    BOOST_CHECK(lexical_cast<my_char16_string>(crng1) == u"1");
-    BOOST_CHECK(lexical_cast<my_char16_string>(rng2) == u"1");
-    BOOST_CHECK(lexical_cast<my_char16_string>(crng2) == u"1");
-#endif
-
-#if defined(BOOST_LC_RUNU32) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
-    typedef std::basic_string<char32_t> my_char32_string;
-    BOOST_CHECK(lexical_cast<my_char32_string>(rng1) == U"1");
-    BOOST_CHECK(lexical_cast<my_char32_string>(crng1) == U"1");
-    BOOST_CHECK(lexical_cast<my_char32_string>(rng2) == U"1");
-    BOOST_CHECK(lexical_cast<my_char32_string>(crng2) == U"1");
-#endif
-}
-
-void test_char_iterator_ranges()
-{
-    typedef char test_char_type;
-    test_char_type data1[] = "1";
-    test_char_type data2[] = "11";
-    test_it_range_using_any_chars(data1, data2);
-    test_it_range_using_char(data1, data2);
-}
-
-
-
-void test_unsigned_char_iterator_ranges()
-{
-    typedef unsigned char test_char_type;
-    test_char_type data1[] = "1";
-    test_char_type data2[] = "11";
-    test_it_range_using_any_chars(data1, data2);
-    test_it_range_using_char(data1, data2);
-}
-
-void test_signed_char_iterator_ranges()
-{
-    typedef signed char test_char_type;
-    test_char_type data1[] = "1";
-    test_char_type data2[] = "11";
-    test_it_range_using_any_chars(data1, data2);
-    test_it_range_using_char(data1, data2);
-}
-
-void test_wchar_iterator_ranges()
-{
-#ifndef BOOST_LCAST_NO_WCHAR_T
-    typedef wchar_t test_char_type;
-    test_char_type data1[] = L"1";
-    test_char_type data2[] = L"11";
-    test_it_range_using_any_chars(data1, data2);
-#endif
-
-    BOOST_CHECK(true);
-}
-
-void test_char16_iterator_ranges()
-{
-#if defined(BOOST_LC_RUNU16)
-    typedef char16_t test_char_type;
-    test_char_type data1[] = u"1";
-    test_char_type data2[] = u"11";
-    test_it_range_using_any_chars(data1, data2);
-#endif
-
-    BOOST_CHECK(true);
-}
-
-void test_char32_iterator_ranges()
-{
-#if defined(BOOST_LC_RUNU32)
-    typedef char32_t test_char_type;
-    test_char_type data1[] = U"1";
-    test_char_type data2[] = U"11";
-    test_it_range_using_any_chars(data1, data2);
-#endif
-
-    BOOST_CHECK(true);
-}
-
-unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite = BOOST_TEST_SUITE("lexical_cast. Testing conversions using iterator_range<>");
-    suite->add(BOOST_TEST_CASE(&test_char_iterator_ranges));
-    suite->add(BOOST_TEST_CASE(&test_unsigned_char_iterator_ranges));
-    suite->add(BOOST_TEST_CASE(&test_signed_char_iterator_ranges));
-    suite->add(BOOST_TEST_CASE(&test_wchar_iterator_ranges));
-    suite->add(BOOST_TEST_CASE(&test_char16_iterator_ranges));
-    suite->add(BOOST_TEST_CASE(&test_char32_iterator_ranges));
-
-    return suite;
-}
diff --git a/test/lexical_cast_loopback_test.cpp b/test/lexical_cast_loopback_test.cpp
deleted file mode 100644
index d50e3a0..0000000
--- a/test/lexical_cast_loopback_test.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Alexander Nasonov, 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).
-//
-//  Test round-tripping conversion FPT -> string -> FPT,
-//  where FPT is Floating Point Type.
-
-#include <boost/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
-#include <boost/lexical_cast.hpp>
-#include <boost/test/unit_test.hpp>
-
-using namespace boost;
-
-void test_round_conversion_float();
-void test_round_conversion_double();
-void test_round_conversion_long_double();
-
-unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast unit test");
-    suite->add(BOOST_TEST_CASE(&test_round_conversion_float));
-    suite->add(BOOST_TEST_CASE(&test_round_conversion_double));
-    suite->add(BOOST_TEST_CASE(&test_round_conversion_long_double));
-
-    return suite;
-}
-
-template<class T>
-void test_round_conversion()
-{
-    T epsilon = std::numeric_limits<T>::epsilon();
-    std::string const epsilon_s = boost::lexical_cast<std::string>(epsilon);
-    BOOST_CHECK(epsilon == lexical_cast<T>(epsilon_s));
-
-    T max_ = (std::numeric_limits<T>::max)();
-    std::string const max_s = boost::lexical_cast<std::string>(max_);
-    BOOST_CHECK(max_ == lexical_cast<T>(max_s));
-
-    T min_ = (std::numeric_limits<T>::min)();
-    std::string const min_s = boost::lexical_cast<std::string>(min_);
-    BOOST_CHECK(min_ == lexical_cast<T>(min_s));
-
-    T max_div137 = max_ / 137;
-    std::string max_div137_s = boost::lexical_cast<std::string>(max_div137);
-    BOOST_CHECK(max_div137 == lexical_cast<T>(max_div137_s));
-
-    T epsilon_mult137 = epsilon * 137;
-    std::string epsilon_mult137_s(lexical_cast<std::string>(epsilon_mult137));
-    BOOST_CHECK(epsilon_mult137 == lexical_cast<T>(epsilon_mult137_s));
-
-}
-
-// See bug http://tinyurl.com/vhpvo
-template<class T>
-void test_msvc_magic_values()
-{
-    T magic_msvc = 0.00010000433948393407;
-    std::string magic_msvc_s = boost::lexical_cast<std::string>(magic_msvc);
-    BOOST_CHECK(magic_msvc == lexical_cast<T>(magic_msvc_s));
-}
-
-void test_round_conversion_float()
-{
-    test_round_conversion<float>();
-}
-
-void test_round_conversion_double()
-{
-    test_round_conversion<double>();
-    test_msvc_magic_values<double>();
-}
-
-void test_round_conversion_long_double()
-{
-// We do not run tests on compilers with bugs
-#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
-    test_round_conversion<long double>();
-    test_msvc_magic_values<long double>();
-#endif
-    BOOST_CHECK(true);
-}
-
diff --git a/test/lexical_cast_no_exceptions_test.cpp b/test/lexical_cast_no_exceptions_test.cpp
deleted file mode 100644
index c470eda..0000000
--- a/test/lexical_cast_no_exceptions_test.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 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/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
-#include <boost/lexical_cast.hpp>
-#include <boost/test/unit_test.hpp>
-#include <boost/range/iterator_range.hpp>
-
-#ifndef BOOST_NO_EXCEPTIONS
-#error "This test must be compiled with -DBOOST_NO_EXCEPTIONS"
-#endif
-
-bool g_was_exception = false;
-
-namespace boost {
-
-void throw_exception(std::exception const & ) {
-    g_was_exception = true;
-}
-
-}
-
-using namespace boost;
-
-
-struct Escape
-{
-    Escape(){}
-    Escape(const std::string& s)
-        : str_(s)
-    {}
-
-    std::string str_;
-};
-
-inline std::ostream& operator<< (std::ostream& o, const Escape& rhs)
-{
-    return o << rhs.str_;
-}
-
-inline std::istream& operator>> (std::istream& i, Escape& rhs)
-{
-    return i >> rhs.str_;
-}
-
-void test_exceptions_off()
-{
-    Escape v("");
-
-    g_was_exception = false;
-    lexical_cast<char>(v);
-    BOOST_CHECK(g_was_exception);
-
-    g_was_exception = false;
-    lexical_cast<unsigned char>(v);
-    BOOST_CHECK(g_was_exception);
-
-    v = lexical_cast<Escape>(100);
-    BOOST_CHECK_EQUAL(lexical_cast<int>(v), 100);
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned int>(v), 100u);
-
-    v = lexical_cast<Escape>(0.0);
-    BOOST_CHECK_EQUAL(lexical_cast<double>(v), 0.0);
-
-    BOOST_CHECK_EQUAL(lexical_cast<short>(100), 100);
-    BOOST_CHECK_EQUAL(lexical_cast<float>(0.0), 0.0);
-
-    g_was_exception = false;
-    lexical_cast<short>(700000);
-    BOOST_CHECK(g_was_exception);
-}
-
-unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast. Testing with BOOST_NO_EXCEPTIONS");
-    suite->add(BOOST_TEST_CASE(&test_exceptions_off));
-
-    return suite;
-}
-
diff --git a/test/lexical_cast_no_locale_test.cpp b/test/lexical_cast_no_locale_test.cpp
deleted file mode 100644
index 01702db..0000000
--- a/test/lexical_cast_no_locale_test.cpp
+++ /dev/null
@@ -1,168 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 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/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
-#include <boost/lexical_cast.hpp>
-#include <boost/test/unit_test.hpp>
-#include <boost/range/iterator_range.hpp>
-
-using namespace boost;
-
-// Testing compilation and some basic usage with BOOST_NO_STD_LOCALE
-// Tests are mainly copyied from lexical_cast_empty_input_test.cpp (something
-// new added to test_empty_3)
-
-#ifndef BOOST_NO_STD_LOCALE
-#error "This test must be compiled with -DBOOST_NO_STD_LOCALE"
-#endif
-
-
-template <class T>
-void do_test_on_empty_input(T& v)
-{
-    BOOST_CHECK_THROW(lexical_cast<int>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<float>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<double>(v), bad_lexical_cast);
-#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
-    BOOST_CHECK_THROW(lexical_cast<long double>(v), bad_lexical_cast);
-#endif
-    BOOST_CHECK_THROW(lexical_cast<unsigned int>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned short>(v), bad_lexical_cast);
-#if defined(BOOST_HAS_LONG_LONG)
-    BOOST_CHECK_THROW(lexical_cast<boost::ulong_long_type>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<boost::long_long_type>(v), bad_lexical_cast);
-#elif defined(BOOST_HAS_MS_INT64)
-    BOOST_CHECK_THROW(lexical_cast<unsigned __int64>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<__int64>(v), bad_lexical_cast);
-#endif
-}
-
-void test_empty_1()
-{
-    boost::iterator_range<char*> v;
-    do_test_on_empty_input(v);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(v), std::string());
-    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
-
-    boost::iterator_range<const char*> cv;
-    do_test_on_empty_input(cv);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(cv), std::string());
-    BOOST_CHECK_THROW(lexical_cast<char>(cv), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(cv), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(cv), bad_lexical_cast);
-
-    const boost::iterator_range<const char*> ccv;
-    do_test_on_empty_input(ccv);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(ccv), std::string());
-    BOOST_CHECK_THROW(lexical_cast<char>(ccv), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(ccv), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(ccv), bad_lexical_cast);
-}
-
-void test_empty_2()
-{
-    std::string v;
-    do_test_on_empty_input(v);
-    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
-}
-
-struct Escape
-{
-    Escape(){}
-    Escape(const std::string& s)
-        : str_(s)
-    {}
-
-    std::string str_;
-};
-
-inline std::ostream& operator<< (std::ostream& o, const Escape& rhs)
-{
-    return o << rhs.str_;
-}
-
-inline std::istream& operator>> (std::istream& i, Escape& rhs)
-{
-    return i >> rhs.str_;
-}
-
-void test_empty_3()
-{
-    Escape v("");
-    do_test_on_empty_input(v);
-
-    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
-
-    v = lexical_cast<Escape>(100);
-    BOOST_CHECK_EQUAL(lexical_cast<int>(v), 100);
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned int>(v), 100u);
-
-    v = lexical_cast<Escape>(0.0);
-    BOOST_CHECK_EQUAL(lexical_cast<double>(v), 0.0);
-}
-
-namespace std {
-inline std::ostream & operator<<(std::ostream & out, const std::vector<long> & v)
-{
-    std::ostream_iterator<long> it(out);
-    std::copy(v.begin(), v.end(), it);
-    assert(out);
-    return out;
-}
-}
-
-void test_empty_4()
-{
-    std::vector<long> v;
-    do_test_on_empty_input(v);
-    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
-}
-
-
-struct my_string {
-    friend std::ostream &operator<<(std::ostream& sout, my_string const&/* st*/) {
-            return sout << "";
-    }
-};
-
-void test_empty_5()
-{
-    my_string st;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(st), std::string());;
-}
-
-unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast. Testing with BOOST_NO_STD_LOCALE");
-    suite->add(BOOST_TEST_CASE(&test_empty_1));
-    suite->add(BOOST_TEST_CASE(&test_empty_2));
-    suite->add(BOOST_TEST_CASE(&test_empty_3));
-    suite->add(BOOST_TEST_CASE(&test_empty_4));
-    suite->add(BOOST_TEST_CASE(&test_empty_5));
-
-    return suite;
-}
-
diff --git a/test/lexical_cast_noncopyable_test.cpp b/test/lexical_cast_noncopyable_test.cpp
deleted file mode 100644
index 1f120d9..0000000
--- a/test/lexical_cast_noncopyable_test.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Alexander Nasonov, 2007.
-//
-//  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).
-//
-//  Test that Source can be non-copyable.
-
-#include <boost/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
-#include <boost/lexical_cast.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/test/unit_test.hpp>
-
-using namespace boost;
-
-void test_noncopyable();
-
-unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast unit test");
-    suite->add(BOOST_TEST_CASE(&test_noncopyable));
-
-    return suite;
-}
-
-class Noncopyable : private boost::noncopyable
-{
-public:
-    Noncopyable() {}
-};
-
-inline std::ostream &operator<<(std::ostream &out, const Noncopyable&)
-{
-    return out << "Noncopyable";
-}
-
-void test_noncopyable()
-{
-    Noncopyable x;
-    BOOST_CHECK(boost::lexical_cast<std::string>(x) == "Noncopyable");
-}
-
diff --git a/test/lexical_cast_pointers_test.cpp b/test/lexical_cast_pointers_test.cpp
deleted file mode 100644
index d24a895..0000000
--- a/test/lexical_cast_pointers_test.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 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/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
-#include <boost/lexical_cast.hpp>
-#include <boost/test/unit_test.hpp>
-
-using namespace boost;
-
-#if defined(BOOST_NO_STRINGSTREAM)
-            typedef std::strstream ss_t;
-#else
-            typedef std::stringstream ss_t;
-#endif
-
-void test_void_pointers_conversions()
-{
-    void *p_to_null = NULL;
-    const void *cp_to_data = "Some data";
-    char nonconst_data[5];
-    void *p_to_data = nonconst_data;
-    ss_t ss;
-
-    ss << p_to_null;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(p_to_null), ss.str());
-    ss.str(std::string());
-
-    ss << cp_to_data;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(cp_to_data), ss.str());
-    ss.str(std::string());
-
-    ss << p_to_data;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(p_to_data), ss.str());
-    ss.str(std::string());
-}
-
-struct incomplete_type;
-
-void test_incomplete_type_pointers_conversions()
-{
-    incomplete_type *p_to_null = NULL;
-    const incomplete_type *cp_to_data = NULL;
-    char nonconst_data[5];
-    incomplete_type *p_to_data = reinterpret_cast<incomplete_type*>(nonconst_data);
-    ss_t ss;
-
-    ss << p_to_null;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(p_to_null), ss.str());
-    ss.str(std::string());
-
-    ss << cp_to_data;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(cp_to_data), ss.str());
-    ss.str(std::string());
-
-    ss << p_to_data;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(p_to_data), ss.str());
-    ss.str(std::string());
-}
-
-struct ble;
-typedef struct ble *meh;
-std::ostream& operator <<(std::ostream &o, meh) {
-  o << "yay";
-  return o;
-}
-
-void test_inomplete_type_with_overloaded_ostream_op() {
-    meh heh = NULL;
-    ss_t ss;
-    ss << heh;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(heh), ss.str());
-}
-
-unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast pinters test");
-    suite->add(BOOST_TEST_CASE(&test_void_pointers_conversions));
-    suite->add(BOOST_TEST_CASE(&test_incomplete_type_pointers_conversions));
-    suite->add(BOOST_TEST_CASE(&test_inomplete_type_with_overloaded_ostream_op));
-    return suite;
-}
diff --git a/test/lexical_cast_stream_detection_test.cpp b/test/lexical_cast_stream_detection_test.cpp
deleted file mode 100644
index 82bc562..0000000
--- a/test/lexical_cast_stream_detection_test.cpp
+++ /dev/null
@@ -1,307 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 2011-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/config.hpp>
-#include <boost/test/unit_test.hpp>
-
-#include <boost/lexical_cast.hpp>
-
-#include <iostream>
-
-
-///////////////////////// char streamable classes ///////////////////////////////////////////
-
-struct streamable_easy { enum ENU {value = 0}; };
-std::ostream& operator << (std::ostream& ostr, const streamable_easy&) {
-    return ostr << streamable_easy::value;
-}
-std::istream& operator >> (std::istream& istr, const streamable_easy&) {
-    int i; istr >> i; BOOST_CHECK_EQUAL(i, streamable_easy::value);
-    return istr;
-}
-
-struct streamable_medium { enum ENU {value = 1}; };
-template <class CharT>
-typename boost::enable_if<boost::is_same<CharT, char>, std::basic_ostream<CharT>&>::type 
-operator << (std::basic_ostream<CharT>& ostr, const streamable_medium&) {
-    return ostr << streamable_medium::value;
-}
-template <class CharT>
-typename boost::enable_if<boost::is_same<CharT, char>, std::basic_istream<CharT>&>::type 
-operator >> (std::basic_istream<CharT>& istr, const streamable_medium&) {
-    int i; istr >> i; BOOST_CHECK_EQUAL(i, streamable_medium::value);
-    return istr;
-}
-
-struct streamable_hard { enum ENU {value = 2}; };
-template <class CharT, class TraitsT>
-typename boost::enable_if<boost::is_same<CharT, char>, std::basic_ostream<CharT, TraitsT>&>::type 
-operator << (std::basic_ostream<CharT, TraitsT>& ostr, const streamable_hard&) {
-    return ostr << streamable_hard::value;
-}
-template <class CharT, class TraitsT>
-typename boost::enable_if<boost::is_same<CharT, char>, std::basic_istream<CharT, TraitsT>&>::type 
-operator >> (std::basic_istream<CharT, TraitsT>& istr, const streamable_hard&) {
-    int i; istr >> i; BOOST_CHECK_EQUAL(i, streamable_hard::value);
-    return istr;
-}
-
-struct streamable_hard2 { enum ENU {value = 3}; };
-template <class TraitsT>
-std::basic_ostream<char, TraitsT>& operator << (std::basic_ostream<char, TraitsT>& ostr, const streamable_hard2&) {
-    return ostr << streamable_hard2::value;
-}
-template <class TraitsT>
-std::basic_istream<char, TraitsT>& operator >> (std::basic_istream<char, TraitsT>& istr, const streamable_hard2&) {
-    int i; istr >> i; BOOST_CHECK_EQUAL(i, streamable_hard2::value);
-    return istr;
-}
-
-
-///////////////////////// wchar_t streamable classes ///////////////////////////////////////////
-
-struct wstreamable_easy { enum ENU {value = 4}; };
-std::wostream& operator << (std::wostream& ostr, const wstreamable_easy&) {
-    return ostr << wstreamable_easy::value;
-}
-std::wistream& operator >> (std::wistream& istr, const wstreamable_easy&) {
-    int i; istr >> i; BOOST_CHECK_EQUAL(i, wstreamable_easy::value);
-    return istr;
-}
-
-struct wstreamable_medium { enum ENU {value = 5}; };
-template <class CharT>
-typename boost::enable_if<boost::is_same<CharT, wchar_t>, std::basic_ostream<CharT>& >::type 
-operator << (std::basic_ostream<CharT>& ostr, const wstreamable_medium&) {
-    return ostr << wstreamable_medium::value;
-}
-template <class CharT>
-typename boost::enable_if<boost::is_same<CharT, wchar_t>, std::basic_istream<CharT>& >::type 
-operator >> (std::basic_istream<CharT>& istr, const wstreamable_medium&) {
-    int i; istr >> i; BOOST_CHECK_EQUAL(i, wstreamable_medium::value);
-    return istr;
-}
-
-struct wstreamable_hard { enum ENU {value = 6}; };
-template <class CharT, class TraitsT>
-typename boost::enable_if<boost::is_same<CharT, wchar_t>, std::basic_ostream<CharT, TraitsT>&>::type 
-operator << (std::basic_ostream<CharT, TraitsT>& ostr, const wstreamable_hard&) {
-    return ostr << wstreamable_hard::value;
-}
-template <class CharT, class TraitsT>
-typename boost::enable_if<boost::is_same<CharT, wchar_t>, std::basic_istream<CharT, TraitsT>&>::type 
-operator >> (std::basic_istream<CharT, TraitsT>& istr, const wstreamable_hard&) {
-    int i; istr >> i; BOOST_CHECK_EQUAL(i, wstreamable_hard::value);
-    return istr;
-}
-
-struct wstreamable_hard2 { enum ENU {value = 7}; };
-template <class TraitsT>
-std::basic_ostream<wchar_t, TraitsT>& operator << (std::basic_ostream<wchar_t, TraitsT>& ostr, const wstreamable_hard2&) {
-    return ostr << wstreamable_hard2::value;
-}
-template <class TraitsT>
-std::basic_istream<wchar_t, TraitsT>& operator >> (std::basic_istream<wchar_t, TraitsT>& istr, const wstreamable_hard2&) {
-    int i; istr >> i; BOOST_CHECK_EQUAL(i, wstreamable_hard2::value);
-    return istr;
-}
-
-///////////////////////// char and wchar_t streamable classes ///////////////////////////////////////////
-
-
-struct bistreamable_easy { enum ENU {value = 8}; };
-std::ostream& operator << (std::ostream& ostr, const bistreamable_easy&) {
-    return ostr << bistreamable_easy::value;
-}
-std::istream& operator >> (std::istream& istr, const bistreamable_easy&) {
-    int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_easy::value);
-    return istr;
-}
-
-std::wostream& operator << (std::wostream& ostr, const bistreamable_easy&) {
-    return ostr << bistreamable_easy::value + 100;
-}
-std::wistream& operator >> (std::wistream& istr, const bistreamable_easy&) {
-    int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_easy::value + 100);
-    return istr;
-}
-
-struct bistreamable_medium { enum ENU {value = 9}; };
-template <class CharT>
-std::basic_ostream<CharT>& operator << (std::basic_ostream<CharT>& ostr, const bistreamable_medium&) {
-    return ostr << bistreamable_medium::value + (sizeof(CharT) == 1 ? 0 : 100);
-}
-template <class CharT>
-std::basic_istream<CharT>& operator >> (std::basic_istream<CharT>& istr, const bistreamable_medium&) {
-    int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_medium::value + (sizeof(CharT) == 1 ? 0 : 100));
-    return istr;
-}
-
-struct bistreamable_hard { enum ENU {value = 10}; };
-template <class CharT, class TraitsT>
-std::basic_ostream<CharT, TraitsT>& operator << (std::basic_ostream<CharT, TraitsT>& ostr, const bistreamable_hard&) {
-    return ostr << bistreamable_hard::value + (sizeof(CharT) == 1 ? 0 : 100);
-}
-template <class CharT, class TraitsT>
-std::basic_istream<CharT, TraitsT>& operator >> (std::basic_istream<CharT, TraitsT>& istr, const bistreamable_hard&) {
-    int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_hard::value + (sizeof(CharT) == 1 ? 0 : 100));
-    return istr;
-}
-
-struct bistreamable_hard2 { enum ENU {value = 11}; };
-template <class TraitsT>
-std::basic_ostream<char, TraitsT>& operator << (std::basic_ostream<char, TraitsT>& ostr, const bistreamable_hard2&) {
-    return ostr << bistreamable_hard2::value;
-}
-template <class TraitsT>
-std::basic_istream<char, TraitsT>& operator >> (std::basic_istream<char, TraitsT>& istr, const bistreamable_hard2&) {
-    int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_hard2::value);
-    return istr;
-}
-
-template <class TraitsT>
-std::basic_ostream<wchar_t, TraitsT>& operator << (std::basic_ostream<wchar_t, TraitsT>& ostr, const bistreamable_hard2&) {
-    return ostr << bistreamable_hard2::value + 100;
-}
-template <class TraitsT>
-std::basic_istream<wchar_t, TraitsT>& operator >> (std::basic_istream<wchar_t, TraitsT>& istr, const bistreamable_hard2&) {
-    int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_hard2::value + 100);
-    return istr;
-}
-
-
-void test_ostream_character_detection();
-void test_istream_character_detection();
-void test_mixed_stream_character_detection();
-
-boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    boost::unit_test::test_suite *suite = 
-        BOOST_TEST_SUITE("lexical_cast stream character detection");
-    suite->add(BOOST_TEST_CASE(&test_ostream_character_detection));
-    suite->add(BOOST_TEST_CASE(&test_istream_character_detection));
-    suite->add(BOOST_TEST_CASE(&test_mixed_stream_character_detection));
-    
-    return suite;
-}
-
-template <class T>
-static void test_ostr_impl() {
-    T streamable;
-    BOOST_CHECK_EQUAL(T::value,  boost::lexical_cast<int>(streamable));
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(T::value),  boost::lexical_cast<std::string>(streamable));
-}
-
-template <class T>
-static void test_wostr_impl() {
-    T streamable;
-    BOOST_CHECK_EQUAL(T::value,  boost::lexical_cast<int>(streamable));
-    // BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(T::value), boost::lexical_cast<std::string>(streamable)); // Shall not compile???
-    BOOST_CHECK(boost::lexical_cast<std::wstring>(T::value) == boost::lexical_cast<std::wstring>(streamable));
-}
-
-template <class T>
-static void test_bistr_impl() {
-    T streamable;
-
-    BOOST_CHECK_EQUAL(T::value,  boost::lexical_cast<int>(streamable));
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(T::value),  boost::lexical_cast<std::string>(streamable));
-
-    BOOST_CHECK(boost::lexical_cast<std::wstring>(T::value + 100) == boost::lexical_cast<std::wstring>(streamable));
-}
-
-void test_ostream_character_detection() {
-    test_ostr_impl<streamable_easy>();
-    test_ostr_impl<streamable_medium>();
-    test_ostr_impl<streamable_hard>();
-    test_ostr_impl<streamable_hard2>();
-    
-    test_wostr_impl<wstreamable_easy>();
-    test_wostr_impl<wstreamable_medium>();
-    test_wostr_impl<wstreamable_hard>();
-    test_wostr_impl<wstreamable_hard2>();
-    
-    test_bistr_impl<bistreamable_easy>();
-    test_bistr_impl<bistreamable_medium>();
-    test_bistr_impl<bistreamable_hard>();
-    test_bistr_impl<bistreamable_hard2>();
-}
-
-
-template <class T>
-static void test_istr_impl() {
-    boost::lexical_cast<T>(T::value);
-    boost::lexical_cast<T>(boost::lexical_cast<std::string>(T::value));
-}
-
-template <class T>
-static void test_wistr_impl() {
-    boost::lexical_cast<T>(T::value);
-    //boost::lexical_cast<T>(boost::lexical_cast<std::string>(T::value)); // Shall not compile???
-    boost::lexical_cast<T>(boost::lexical_cast<std::wstring>(T::value));
-}
-
-template <class T>
-static void test_bistr_instr_impl() {
-    boost::lexical_cast<T>(T::value);
-    boost::lexical_cast<T>(boost::lexical_cast<std::string>(T::value));
-    boost::lexical_cast<T>(boost::lexical_cast<std::wstring>(T::value + 100));
-}
-
-void test_istream_character_detection() {
-    test_istr_impl<streamable_easy>();
-    test_istr_impl<streamable_medium>();
-    test_istr_impl<streamable_hard>();
-    test_istr_impl<streamable_hard2>();
-    
-    test_wistr_impl<wstreamable_easy>();
-    test_wistr_impl<wstreamable_medium>();
-    test_wistr_impl<wstreamable_hard>();
-    test_wistr_impl<wstreamable_hard2>();
-    
-    test_bistr_instr_impl<bistreamable_easy>();
-    test_bistr_instr_impl<bistreamable_medium>();
-    test_bistr_instr_impl<bistreamable_hard>();
-    test_bistr_instr_impl<bistreamable_hard2>();
-}
-
-
-
-
-
-
-struct wistreamble_ostreamable { enum ENU {value = 200}; };
-std::ostream& operator << (std::ostream& ostr, const wistreamble_ostreamable&) {
-    return ostr << wistreamble_ostreamable::value;
-}
-std::wistream& operator >> (std::wistream& istr, const wistreamble_ostreamable&) {
-    int i; istr >> i; BOOST_CHECK_EQUAL(i, wistreamble_ostreamable::value);
-    return istr;
-}
-
-struct istreamble_wostreamable { enum ENU {value = 201}; };
-std::wostream& operator << (std::wostream& ostr, const istreamble_wostreamable&) {
-    return ostr << istreamble_wostreamable::value;
-}
-std::istream& operator >> (std::istream& istr, const istreamble_wostreamable&) {
-    int i; istr >> i; BOOST_CHECK_EQUAL(i, istreamble_wostreamable::value);
-    return istr;
-}
-
-void test_mixed_stream_character_detection() {
-    //boost::lexical_cast<std::wstring>(std::string("qwe")); // TODO: ALLOW IT AS EXTENSION!
-    
-    boost::lexical_cast<wistreamble_ostreamable>(wistreamble_ostreamable::value);
-    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(wistreamble_ostreamable()), wistreamble_ostreamable::value);
-    
-    boost::lexical_cast<istreamble_wostreamable>(istreamble_wostreamable::value);
-    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(istreamble_wostreamable()), istreamble_wostreamable::value);
-}
diff --git a/test/lexical_cast_stream_traits_test.cpp b/test/lexical_cast_stream_traits_test.cpp
deleted file mode 100644
index e041fa9..0000000
--- a/test/lexical_cast_stream_traits_test.cpp
+++ /dev/null
@@ -1,158 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 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/config.hpp>
-
-#include <boost/lexical_cast.hpp>
-
-#include <boost/test/unit_test.hpp>
-
-template <class T>
-static void test_optimized_types_to_string_const()
-{
-    namespace de = boost::detail;
-    typedef de::lexical_cast_stream_traits<T, std::string> trait_1;
-    BOOST_CHECK(!trait_1::is_source_input_not_optimized_t::value);
-    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_1::src_char_t, char>::value));
-    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_1::target_char_t, char>::value));
-    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_1::char_type, char>::value));
-    BOOST_CHECK(!trait_1::is_string_widening_required_t::value);
-    BOOST_CHECK(!trait_1::is_source_input_not_optimized_t::value);
-        
-    typedef de::lexical_cast_stream_traits<const T, std::string> trait_2;
-    BOOST_CHECK(!trait_2::is_source_input_not_optimized_t::value);
-    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_2::src_char_t, char>::value));
-    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_2::target_char_t, char>::value));
-    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_2::char_type, char>::value));
-    BOOST_CHECK(!trait_2::is_string_widening_required_t::value);
-    BOOST_CHECK(!trait_2::is_source_input_not_optimized_t::value);
-
-    typedef de::lexical_cast_stream_traits<T, std::wstring> trait_3;
-    BOOST_CHECK(!trait_3::is_source_input_not_optimized_t::value);
-    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_3::src_char_t, char>::value));
-    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_3::target_char_t, wchar_t>::value));
-    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_3::char_type, wchar_t>::value));
-
-    BOOST_CHECK((boost::detail::is_character<BOOST_DEDUCED_TYPENAME trait_3::no_cv_src>::value != trait_3::is_string_widening_required_t::value));
-
-    BOOST_CHECK(!trait_3::is_source_input_not_optimized_t::value);
-}    
-
-
-template <class T>
-static void test_optimized_types_to_string()
-{
-    test_optimized_types_to_string_const<T>();
-
-    namespace de = boost::detail;
-    typedef de::lexical_cast_stream_traits<std::string, T> trait_4;
-    BOOST_CHECK(!trait_4::is_source_input_not_optimized_t::value);
-    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_4::src_char_t, char>::value));
-    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_4::target_char_t, char>::value));
-    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_4::char_type, char>::value));
-    BOOST_CHECK(!trait_4::is_string_widening_required_t::value);
-    BOOST_CHECK(!trait_4::is_source_input_not_optimized_t::value);
-        
-    typedef de::lexical_cast_stream_traits<const std::string, T> trait_5;
-    BOOST_CHECK(!trait_5::is_source_input_not_optimized_t::value);
-    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_5::src_char_t, char>::value));
-    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_5::target_char_t, char>::value));
-    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_5::char_type, char>::value));
-    BOOST_CHECK(!trait_5::is_string_widening_required_t::value);
-    BOOST_CHECK(!trait_5::is_source_input_not_optimized_t::value);
-
-    typedef de::lexical_cast_stream_traits<const std::wstring, T> trait_6;
-    BOOST_CHECK(!trait_6::is_source_input_not_optimized_t::value);
-    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_6::src_char_t, wchar_t>::value));
-    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_6::target_char_t, char>::value));
-    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_6::char_type, wchar_t>::value));
-    BOOST_CHECK(!trait_6::is_string_widening_required_t::value);
-}
-
-void test_metafunctions()
-{
-    test_optimized_types_to_string<bool>();
-    test_optimized_types_to_string<char>();
-    test_optimized_types_to_string<unsigned char>();
-    test_optimized_types_to_string<signed char>();
-    test_optimized_types_to_string<short>();
-    test_optimized_types_to_string<unsigned short>();
-    test_optimized_types_to_string<int>();
-    test_optimized_types_to_string<unsigned int>();
-    test_optimized_types_to_string<long>();
-    test_optimized_types_to_string<unsigned long>();
-
-#if defined(BOOST_HAS_LONG_LONG)
-    test_optimized_types_to_string<boost::ulong_long_type>();
-    test_optimized_types_to_string<boost::long_long_type>();
-#elif defined(BOOST_HAS_MS_INT64)
-    test_optimized_types_to_string<unsigned __int64>();
-    test_optimized_types_to_string<__int64>();
-#endif
-
-#if !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__)
-    test_optimized_types_to_string<float>();
-#endif
-    
-    test_optimized_types_to_string<std::string>();
-    test_optimized_types_to_string<char*>();
-    //test_optimized_types_to_string<char[5]>();
-    //test_optimized_types_to_string<char[1]>();
-    test_optimized_types_to_string<unsigned char*>();
-    //test_optimized_types_to_string<unsigned char[5]>();
-    //test_optimized_types_to_string<unsigned char[1]>();
-    test_optimized_types_to_string<signed char*>();
-    //test_optimized_types_to_string<signed char[5]>();
-    //test_optimized_types_to_string<signed char[1]>();
-    test_optimized_types_to_string<boost::array<char, 1> >();
-    test_optimized_types_to_string<boost::array<char, 5> >();
-    test_optimized_types_to_string<boost::array<unsigned char, 1> >();
-    test_optimized_types_to_string<boost::array<unsigned char, 5> >();
-    test_optimized_types_to_string<boost::array<signed char, 1> >();
-    test_optimized_types_to_string<boost::array<signed char, 5> >();
-    test_optimized_types_to_string<boost::iterator_range<char*> >();
-    test_optimized_types_to_string<boost::iterator_range<unsigned char*> >();
-    test_optimized_types_to_string<boost::iterator_range<signed char*> >();
-
-    test_optimized_types_to_string_const<boost::array<const char, 1> >();
-    test_optimized_types_to_string_const<boost::array<const char, 5> >();
-    test_optimized_types_to_string_const<boost::array<const unsigned char, 1> >();
-    test_optimized_types_to_string_const<boost::array<const unsigned char, 5> >();
-    test_optimized_types_to_string_const<boost::array<const signed char, 1> >();
-    test_optimized_types_to_string_const<boost::array<const signed char, 5> >();
-    test_optimized_types_to_string_const<boost::iterator_range<const char*> >();
-    test_optimized_types_to_string_const<boost::iterator_range<const unsigned char*> >();
-    test_optimized_types_to_string_const<boost::iterator_range<const signed char*> >();
-
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
-    test_optimized_types_to_string<std::array<char, 1> >();
-    test_optimized_types_to_string<std::array<char, 5> >();
-    test_optimized_types_to_string<std::array<unsigned char, 1> >();
-    test_optimized_types_to_string<std::array<unsigned char, 5> >();
-    test_optimized_types_to_string<std::array<signed char, 1> >();
-    test_optimized_types_to_string<std::array<signed char, 5> >();
-    
-    test_optimized_types_to_string_const<std::array<const char, 1> >();
-    test_optimized_types_to_string_const<std::array<const char, 5> >();
-    test_optimized_types_to_string_const<std::array<const unsigned char, 1> >();
-    test_optimized_types_to_string_const<std::array<const unsigned char, 5> >();
-    test_optimized_types_to_string_const<std::array<const signed char, 1> >();
-    test_optimized_types_to_string_const<std::array<const signed char, 5> >();
-#endif
-}
-
-boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    boost::unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast traits tests");
-    suite->add(BOOST_TEST_CASE(&test_metafunctions));
-    return suite;
-}
-
diff --git a/test/lexical_cast_test.cpp b/test/lexical_cast_test.cpp
deleted file mode 100644
index f27e6df..0000000
--- a/test/lexical_cast_test.cpp
+++ /dev/null
@@ -1,643 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Terje Sletteb and Kevlin Henney, 2005.
-//  Copyright Alexander Nasonov, 2006.
-//  Copyright Antony Polukhin, 2011-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).
-//
-// Note: The unit test no longer compile on MSVC 6, but lexical_cast itself works for it.
-
-//
-// We need this #define before any #includes: otherwise msvc will emit warnings
-// deep within std::string, resulting from our (perfectly legal) use of basic_string
-// with a custom traits class:
-//
-#define _SCL_SECURE_NO_WARNINGS
-
-#include <boost/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
-#include <boost/lexical_cast.hpp>
-
-#include <boost/cstdint.hpp>
-#include <boost/test/unit_test.hpp>
-#include <boost/test/floating_point_comparison.hpp>
-
-#include <boost/type_traits/integral_promotion.hpp>
-#include <string>
-#include <vector>
-#include <algorithm> // std::transform
-#include <memory>
-
-#if (defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)) \
-    && !(defined(BOOST_MSVC) && BOOST_MSVC < 1300)
-#define LCAST_TEST_LONGLONG
-#endif
-
-#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
-#define BOOST_LCAST_NO_WCHAR_T
-#endif
-
-template<class CharT>
-struct my_traits : std::char_traits<CharT>
-{
-};
-
-template<class CharT>
-struct my_allocator : std::allocator<CharT>
-{
-};
-
-using namespace boost;
-
-void test_conversion_to_char();
-void test_conversion_to_int();
-void test_conversion_to_double();
-void test_conversion_to_bool();
-void test_conversion_with_nonconst_char();
-void test_conversion_to_string();
-void test_conversion_from_to_wchar_t_alias();
-void test_conversion_from_wchar_t();
-void test_conversion_to_wchar_t();
-void test_conversion_from_wstring();
-void test_conversion_to_wstring();
-void test_bad_lexical_cast();
-void test_no_whitespace_stripping();
-void test_volatile_types_conversions();
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-void test_traits();
-void test_wtraits();
-void test_allocator();
-void test_wallocator();
-#endif
-void test_char_types_conversions();
-void operators_overload_test();
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-void test_char16_conversions();
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-void test_char32_conversions();
-#endif
-void test_getting_pointer_to_function();
-
-unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast unit test");
-    suite->add(BOOST_TEST_CASE(test_conversion_to_char));
-    suite->add(BOOST_TEST_CASE(test_conversion_to_int));
-    suite->add(BOOST_TEST_CASE(test_conversion_to_double));
-    suite->add(BOOST_TEST_CASE(test_conversion_to_bool));
-    suite->add(BOOST_TEST_CASE(test_conversion_from_to_wchar_t_alias));
-    suite->add(BOOST_TEST_CASE(test_conversion_to_string));
-    suite->add(BOOST_TEST_CASE(test_conversion_with_nonconst_char));
-#ifndef BOOST_LCAST_NO_WCHAR_T
-    suite->add(BOOST_TEST_CASE(test_conversion_from_wchar_t));
-    suite->add(BOOST_TEST_CASE(test_conversion_to_wchar_t));
-    suite->add(BOOST_TEST_CASE(test_conversion_from_wstring));
-    suite->add(BOOST_TEST_CASE(test_conversion_to_wstring));
-#endif
-    suite->add(BOOST_TEST_CASE(test_bad_lexical_cast));
-    suite->add(BOOST_TEST_CASE(test_no_whitespace_stripping));
-    suite->add(BOOST_TEST_CASE(test_volatile_types_conversions));
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    suite->add(BOOST_TEST_CASE(&test_traits));
-    suite->add(BOOST_TEST_CASE(&test_wtraits));
-    suite->add(BOOST_TEST_CASE(&test_allocator));
-    suite->add(BOOST_TEST_CASE(&test_wallocator));
-#endif
-
-    suite->add(BOOST_TEST_CASE(&test_char_types_conversions));
-    suite->add(BOOST_TEST_CASE(&operators_overload_test));
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-    suite->add(BOOST_TEST_CASE(&test_char16_conversions));
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-    suite->add(BOOST_TEST_CASE(&test_char32_conversions));
-#endif
-    suite->add(BOOST_TEST_CASE(&test_getting_pointer_to_function));
-
-    return suite;
-}
-
-void test_conversion_to_char()
-{
-    BOOST_CHECK_EQUAL('A', lexical_cast<char>('A'));
-    BOOST_CHECK_EQUAL(' ', lexical_cast<char>(' '));
-    BOOST_CHECK_EQUAL('1', lexical_cast<char>(1));
-    BOOST_CHECK_EQUAL('0', lexical_cast<char>(0));
-    BOOST_CHECK_THROW(lexical_cast<char>(123), bad_lexical_cast);
-    BOOST_CHECK_EQUAL('1', lexical_cast<char>(1.0));
-    BOOST_CHECK_EQUAL('1', lexical_cast<char>(true));
-    BOOST_CHECK_EQUAL('0', lexical_cast<char>(false));
-    BOOST_CHECK_EQUAL('A', lexical_cast<char>("A"));
-    BOOST_CHECK_EQUAL(' ', lexical_cast<char>(" "));
-    BOOST_CHECK_THROW(lexical_cast<char>(""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<char>("Test"), bad_lexical_cast);
-    BOOST_CHECK_EQUAL('A', lexical_cast<char>(std::string("A")));
-    BOOST_CHECK_EQUAL(' ', lexical_cast<char>(std::string(" ")));
-    BOOST_CHECK_THROW(
-        lexical_cast<char>(std::string("")), bad_lexical_cast);
-    BOOST_CHECK_THROW(
-        lexical_cast<char>(std::string("Test")), bad_lexical_cast);
-}
-
-void test_conversion_to_int()
-{
-    BOOST_CHECK_EQUAL(1, lexical_cast<int>('1'));
-    BOOST_CHECK_EQUAL(0, lexical_cast<int>('0'));
-    BOOST_CHECK_THROW(lexical_cast<int>('A'), bad_lexical_cast);
-    BOOST_CHECK_EQUAL(1, lexical_cast<int>(1));
-    BOOST_CHECK_EQUAL(1, lexical_cast<int>(1.0));
-
-    BOOST_CHECK_EQUAL(
-        (std::numeric_limits<int>::max)(),
-        lexical_cast<int>((std::numeric_limits<int>::max)()));
-
-    BOOST_CHECK_EQUAL(
-        (std::numeric_limits<int>::min)(),
-        lexical_cast<int>((std::numeric_limits<int>::min)()));
-
-    BOOST_CHECK_THROW(lexical_cast<int>(1.23), bad_lexical_cast);
-
-    BOOST_CHECK_THROW(lexical_cast<int>(1e20), bad_lexical_cast);
-    BOOST_CHECK_EQUAL(1, lexical_cast<int>(true));
-    BOOST_CHECK_EQUAL(0, lexical_cast<int>(false));
-    BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
-    BOOST_CHECK_THROW(
-        lexical_cast<int>(" 123"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<int>(""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<int>("Test"), bad_lexical_cast);
-    BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
-    BOOST_CHECK_EQUAL(123, lexical_cast<int>(std::string("123")));
-    BOOST_CHECK_THROW(
-        lexical_cast<int>(std::string(" 123")), bad_lexical_cast);
-    BOOST_CHECK_THROW(
-        lexical_cast<int>(std::string("")), bad_lexical_cast);
-    BOOST_CHECK_THROW(
-        lexical_cast<int>(std::string("Test")), bad_lexical_cast);
-}
-
-void test_conversion_with_nonconst_char()
-{
-    std::vector<char> buffer;
-    buffer.push_back('1');
-    buffer.push_back('\0');
-    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer[0]), 1);
-
-    std::vector<unsigned char> buffer2;
-    buffer2.push_back('1');
-    buffer2.push_back('\0');
-    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer2[0]), 1);
-
-    std::vector<unsigned char> buffer3;
-    buffer3.push_back('1');
-    buffer3.push_back('\0');
-    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer3[0]), 1);
-
-#ifndef BOOST_LCAST_NO_WCHAR_T
-    std::vector<wchar_t> buffer4;
-    buffer4.push_back(L'1');
-    buffer4.push_back(L'\0');
-    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer4[0]), 1);
-#endif
-}
-
-void test_conversion_to_double()
-{
-    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<double>('1'), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_THROW(lexical_cast<double>('A'), bad_lexical_cast);
-    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<double>(1), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_CLOSE_FRACTION(1.23, lexical_cast<double>(1.23), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_CLOSE_FRACTION(1.234567890, lexical_cast<double>(1.234567890), std::numeric_limits<double>::epsilon());
-    BOOST_CHECK_CLOSE_FRACTION(1.234567890, lexical_cast<double>("1.234567890"), std::numeric_limits<double>::epsilon());
-    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<double>(true), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_CLOSE_FRACTION(0.0, lexical_cast<double>(false), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_CLOSE_FRACTION(1.23, lexical_cast<double>("1.23"), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_THROW(lexical_cast<double>(""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<double>("Test"), bad_lexical_cast);
-    BOOST_CHECK_CLOSE_FRACTION(1.23, lexical_cast<double>(std::string("1.23")), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_THROW(
-        lexical_cast<double>(std::string("")), bad_lexical_cast);
-    BOOST_CHECK_THROW(
-        lexical_cast<double>(std::string("Test")), bad_lexical_cast);
-}
-
-void test_conversion_to_bool()
-{
-    BOOST_CHECK_EQUAL(true, lexical_cast<bool>('1'));
-    BOOST_CHECK_EQUAL(false, lexical_cast<bool>('0'));
-    BOOST_CHECK_THROW(lexical_cast<bool>('A'), bad_lexical_cast);
-    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(1));
-    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(0));
-    BOOST_CHECK_THROW(lexical_cast<bool>(123), bad_lexical_cast);
-    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(1.0));
-    BOOST_CHECK_THROW(lexical_cast<bool>(-123), bad_lexical_cast);
-    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(0.0));
-    BOOST_CHECK_THROW(lexical_cast<bool>(1234), bad_lexical_cast);
-#if !defined(_CRAYC)
-    // Looks like a bug in CRAY compiler (throws bad_lexical_cast)
-    // TODO: localize the bug and report it to developers.
-    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(true));
-    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(false));
-#endif
-    BOOST_CHECK_EQUAL(true, lexical_cast<bool>("1"));
-    BOOST_CHECK_EQUAL(false, lexical_cast<bool>("0"));
-    BOOST_CHECK_THROW(lexical_cast<bool>(""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("Test"), bad_lexical_cast);
-    BOOST_CHECK_EQUAL(true, lexical_cast<bool>("1"));
-    BOOST_CHECK_EQUAL(false, lexical_cast<bool>("0"));
-    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(std::string("1")));
-    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(std::string("0")));
-
-    BOOST_CHECK_THROW(lexical_cast<bool>(1.0001L), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>(2), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>(2u), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>(-1), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>(-2), bad_lexical_cast);
-
-
-    BOOST_CHECK_THROW(
-        lexical_cast<bool>(std::string("")), bad_lexical_cast);
-    BOOST_CHECK_THROW(
-        lexical_cast<bool>(std::string("Test")), bad_lexical_cast);
-
-    BOOST_CHECK(lexical_cast<bool>("+1") == true);
-    BOOST_CHECK(lexical_cast<bool>("+0") == false);
-    BOOST_CHECK(lexical_cast<bool>("-0") == false);
-    BOOST_CHECK_THROW(lexical_cast<bool>("--0"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("-+-0"), bad_lexical_cast);
-
-    BOOST_CHECK(lexical_cast<bool>("0") == false);
-    BOOST_CHECK(lexical_cast<bool>("1") == true);
-    BOOST_CHECK(lexical_cast<bool>("00") == false);
-    BOOST_CHECK(lexical_cast<bool>("00000000000") == false);
-    BOOST_CHECK(lexical_cast<bool>("000000000001") == true);
-    BOOST_CHECK(lexical_cast<bool>("+00") == false );
-    BOOST_CHECK(lexical_cast<bool>("-00") == false );
-    BOOST_CHECK(lexical_cast<bool>("+00000000001") == true );
-
-    BOOST_CHECK_THROW(lexical_cast<bool>("020"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("00200"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("-00200"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("+00200"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("000000000002"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("-1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("-0000000001"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("00000000011"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("001001"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("-00000000010"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("-000000000100"), bad_lexical_cast);
-}
-
-void test_conversion_to_string()
-{
-    char buf[] = "hello";
-    char* str = buf;
-    BOOST_CHECK_EQUAL(str, lexical_cast<std::string>(str));
-    BOOST_CHECK_EQUAL("A", lexical_cast<std::string>('A'));
-    BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(' '));
-    BOOST_CHECK_EQUAL("123", lexical_cast<std::string>(123));
-    BOOST_CHECK_EQUAL("1.23", lexical_cast<std::string>(1.23));
-    BOOST_CHECK_EQUAL("1.111111111", lexical_cast<std::string>(1.111111111));
-    BOOST_CHECK_EQUAL("1", lexical_cast<std::string>(true));
-    BOOST_CHECK_EQUAL("0", lexical_cast<std::string>(false));
-    BOOST_CHECK_EQUAL("Test", lexical_cast<std::string>("Test"));
-    BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(" "));
-    BOOST_CHECK_EQUAL("", lexical_cast<std::string>(""));
-    BOOST_CHECK_EQUAL("Test", lexical_cast<std::string>(std::string("Test")));
-    BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(std::string(" ")));
-    BOOST_CHECK_EQUAL("", lexical_cast<std::string>(std::string("")));
-}
-
-void test_conversion_from_to_wchar_t_alias()
-{
-    BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned short>("123"));
-    BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned int>("123"));
-    BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned long>("123"));
-    BOOST_CHECK_EQUAL(std::string("123"),
-        lexical_cast<std::string>(static_cast<unsigned short>(123)));
-    BOOST_CHECK_EQUAL(std::string("123"), lexical_cast<std::string>(123u));
-    BOOST_CHECK_EQUAL(std::string("123"), lexical_cast<std::string>(123ul));
-}
-
-void test_conversion_from_wchar_t()
-{
-#ifndef BOOST_LCAST_NO_WCHAR_T
-#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-    BOOST_CHECK_EQUAL(1, lexical_cast<int>(L'1'));
-    BOOST_CHECK_THROW(lexical_cast<int>(L'A'), bad_lexical_cast);
-#endif
-
-    BOOST_CHECK_EQUAL(123, lexical_cast<int>(L"123"));
-    BOOST_CHECK_THROW(lexical_cast<int>(L""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<int>(L"Test"), bad_lexical_cast);
-
-#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-    BOOST_CHECK_EQUAL(1.0, lexical_cast<double>(L'1'));
-    BOOST_CHECK_THROW(lexical_cast<double>(L'A'), bad_lexical_cast);
-#endif
-
-    BOOST_CHECK_EQUAL(1.23, lexical_cast<double>(L"1.23"));
-    BOOST_CHECK_THROW(lexical_cast<double>(L""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<double>(L"Test"), bad_lexical_cast);
-
-#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(L'1'));
-    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(L'0'));
-    BOOST_CHECK_THROW(lexical_cast<bool>(L'A'), bad_lexical_cast);
-#endif
-    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(L"1"));
-    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(L"0"));
-    BOOST_CHECK_THROW(lexical_cast<bool>(L""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>(L"Test"), bad_lexical_cast);
-#endif
-}
-
-void test_conversion_to_wchar_t()
-{
-#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-    BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(1));
-    BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(0));
-    BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>('1'));
-    BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>('0'));
-    BOOST_CHECK_THROW(lexical_cast<wchar_t>(123), bad_lexical_cast);
-    BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(1.0));
-    BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(0.0));
-    BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(true));
-    BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(false));
-    BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(L'A'));
-    BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(L' '));
-    BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(L"A"));
-    BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(L" "));
-    BOOST_CHECK_THROW(lexical_cast<wchar_t>(L""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<wchar_t>(L"Test"), bad_lexical_cast);
-    BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(std::wstring(L"A")));
-    BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(std::wstring(L" ")));
-    BOOST_CHECK_THROW(
-        lexical_cast<wchar_t>(std::wstring(L"")), bad_lexical_cast);
-    BOOST_CHECK_THROW(
-        lexical_cast<wchar_t>(std::wstring(L"Test")), bad_lexical_cast);
-#endif
-    BOOST_CHECK(true);
-}
-
-void test_conversion_from_wstring()
-{
-#ifndef BOOST_LCAST_NO_WCHAR_T
-    BOOST_CHECK_EQUAL(123, lexical_cast<int>(std::wstring(L"123")));
-    BOOST_CHECK_THROW(
-        lexical_cast<int>(std::wstring(L"")), bad_lexical_cast);
-    BOOST_CHECK_THROW(
-        lexical_cast<int>(std::wstring(L"Test")), bad_lexical_cast);
-
-    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(std::wstring(L"1")));
-    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(std::wstring(L"0")));
-    BOOST_CHECK_THROW(
-        lexical_cast<bool>(std::wstring(L"")), bad_lexical_cast);
-    BOOST_CHECK_THROW(
-        lexical_cast<bool>(std::wstring(L"Test")), bad_lexical_cast);
-#endif
-    BOOST_CHECK(true);
-}
-
-void test_conversion_to_wstring()
-{
-#ifndef BOOST_LCAST_NO_WCHAR_T
-    wchar_t buf[] = L"hello";
-    wchar_t* str = buf;
-    BOOST_CHECK(str == lexical_cast<std::wstring>(str));
-    BOOST_CHECK(L"123" == lexical_cast<std::wstring>(123));
-    BOOST_CHECK(L"1.23" == lexical_cast<std::wstring>(1.23));
-    BOOST_CHECK(L"1" == lexical_cast<std::wstring>(true));
-    BOOST_CHECK(L"0" == lexical_cast<std::wstring>(false));
-#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-    BOOST_CHECK(L"A" == lexical_cast<std::wstring>(L'A'));
-    BOOST_CHECK(L" " == lexical_cast<std::wstring>(L' '));
-    BOOST_CHECK(L"A" == lexical_cast<std::wstring>('A'));
-#endif
-    BOOST_CHECK(L"Test" == lexical_cast<std::wstring>(L"Test"));
-    BOOST_CHECK(L" " == lexical_cast<std::wstring>(L" "));
-    BOOST_CHECK(L"" == lexical_cast<std::wstring>(L""));
-    BOOST_CHECK(L"Test" == lexical_cast<std::wstring>(std::wstring(L"Test")));
-    BOOST_CHECK(L" " == lexical_cast<std::wstring>(std::wstring(L" ")));
-    BOOST_CHECK(L"" == lexical_cast<std::wstring>(std::wstring(L"")));
-#endif
-    BOOST_CHECK(true);
-}
-
-void test_bad_lexical_cast()
-{
-    try
-    {
-        lexical_cast<int>(std::string("Test"));
-
-        BOOST_CHECK(false); // Exception expected
-    }
-    catch(const bad_lexical_cast &e)
-    {
-        BOOST_CHECK(e.source_type() == typeid(std::string));
-        BOOST_CHECK(e.target_type() == typeid(int));
-    }
-}
-
-void test_no_whitespace_stripping()
-{
-    BOOST_CHECK_THROW(lexical_cast<int>(" 123"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<int>("123 "), bad_lexical_cast);
-}
-
-void test_volatile_types_conversions()
-{
-    volatile int i1 = 100000;
-    BOOST_CHECK_EQUAL("100000", boost::lexical_cast<std::string>(i1));
-
-    volatile const int i2 = 100000;
-    BOOST_CHECK_EQUAL("100000", boost::lexical_cast<std::string>(i2));
-
-    volatile const long int i3 = 1000000;
-    BOOST_CHECK_EQUAL("1000000", boost::lexical_cast<std::string>(i3));
-}
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-void test_traits()
-{
-    typedef std::basic_string<char, my_traits<char> > my_string;
-
-    my_string const s("s");
-    BOOST_CHECK(boost::lexical_cast<char>(s) == s[0]);
-    BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
-    BOOST_CHECK(boost::lexical_cast<my_string>(-1) == "-1");
-}
-
-void test_wtraits()
-{
-    typedef std::basic_string<wchar_t, my_traits<wchar_t> > my_string;
-
-    my_string const s(L"s");
-    BOOST_CHECK(boost::lexical_cast<wchar_t>(s) == s[0]);
-    BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
-    //BOOST_CHECK(boost::lexical_cast<my_string>(-1) == L"-1");
-    // Commented out because gcc 3.3 doesn't support this:
-    // basic_ostream<wchar_t, my_traits<wchar_t> > o; o << -1;
-}
-
-void test_allocator()
-{
-// Following test cause compilation error on MSVC2012:
-// (Reason: cannot convert from 'std::_Wrap_alloc<_Alloc>' to 'const my_allocator<CharT>')
-// 
-// MSVC developer is notified about this issue
-#if !defined(_MSC_VER) || (_MSC_VER < 1700)
-    typedef std::basic_string< char
-                             , std::char_traits<char>
-                             , my_allocator<char>
-                             > my_string;
-
-    my_string s("s");
-    BOOST_CHECK(boost::lexical_cast<char>(s) == s[0]);
-    BOOST_CHECK(boost::lexical_cast<std::string>(s) == "s");
-    BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
-    BOOST_CHECK(boost::lexical_cast<my_string>(1) == "1");
-    BOOST_CHECK(boost::lexical_cast<my_string>("s") == s);
-    BOOST_CHECK(boost::lexical_cast<my_string>(std::string("s")) == s);
-#endif
-}
-
-void test_wallocator()
-{
-// Following test cause compilation error on MSVC2012:
-// (Reason: cannot convert from 'std::_Wrap_alloc<_Alloc>' to 'const my_allocator<CharT>')
-// 
-// MSVC developer is notified about this issue
-#if !defined(_MSC_VER) || (_MSC_VER < 1700)
-    typedef std::basic_string< wchar_t
-                             , std::char_traits<wchar_t>
-                             , my_allocator<wchar_t>
-                             > my_string;
-
-    my_string s(L"s");
-    BOOST_CHECK(boost::lexical_cast<wchar_t>(s) == s[0]);
-    BOOST_CHECK(boost::lexical_cast<std::wstring>(s) == L"s");
-    BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
-    BOOST_CHECK(boost::lexical_cast<my_string>(1) == L"1");
-    BOOST_CHECK(boost::lexical_cast<my_string>(L"s") == s);
-    BOOST_CHECK(boost::lexical_cast<my_string>(std::wstring(L"s")) == s);
-#endif
-}
-
-#endif
-
-
-void test_char_types_conversions()
-{
-    const char c_arr[]            = "Test array of chars";
-    const unsigned char uc_arr[]  = "Test array of chars";
-    const signed char sc_arr[]    = "Test array of chars";
-
-    BOOST_CHECK(boost::lexical_cast<std::string>(c_arr) == std::string(c_arr));
-    BOOST_CHECK(boost::lexical_cast<std::string>(uc_arr) == std::string(c_arr));
-    BOOST_CHECK(boost::lexical_cast<std::string>(sc_arr) == std::string(c_arr));
-
-    BOOST_CHECK(boost::lexical_cast<char>(c_arr[0]) == c_arr[0]);
-    BOOST_CHECK(boost::lexical_cast<char>(uc_arr[0]) == c_arr[0]);
-    BOOST_CHECK(boost::lexical_cast<char>(sc_arr[0]) == c_arr[0]);
-
-    BOOST_CHECK(boost::lexical_cast<unsigned char>(c_arr[0]) == uc_arr[0]);
-    BOOST_CHECK(boost::lexical_cast<unsigned char>(uc_arr[0]) == uc_arr[0]);
-    BOOST_CHECK(boost::lexical_cast<unsigned char>(sc_arr[0]) == uc_arr[0]);
-
-    BOOST_CHECK(boost::lexical_cast<signed char>(c_arr[0]) == sc_arr[0]);
-    BOOST_CHECK(boost::lexical_cast<signed char>(uc_arr[0]) == sc_arr[0]);
-    BOOST_CHECK(boost::lexical_cast<signed char>(sc_arr[0]) == sc_arr[0]);
-
-#ifndef BOOST_LCAST_NO_WCHAR_T
-    const wchar_t wc_arr[]=L"Test array of chars";
-
-    BOOST_CHECK(boost::lexical_cast<std::wstring>(wc_arr) == std::wstring(wc_arr));
-    BOOST_CHECK(boost::lexical_cast<wchar_t>(wc_arr[0]) == wc_arr[0]);
-
-#endif
-}
-
-
-
-struct foo_operators_test
-{
-  foo_operators_test() : f(2) {}
-  int f;
-};
-
-template <typename OStream>
-OStream& operator<<(OStream& ostr, const foo_operators_test& foo)
-{
-  ostr << foo.f;
-  return ostr;
-}
-
-template <typename IStream>
-IStream& operator>>(IStream& istr, foo_operators_test& foo)
-{
-  istr >> foo.f;
-  return istr;
-}
-
-void operators_overload_test()
-{
-    foo_operators_test foo;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(foo), "2");
-    BOOST_CHECK_EQUAL((boost::lexical_cast<foo_operators_test>("2")).f, 2);
-
-    // Must compile
-    (void)boost::lexical_cast<foo_operators_test>(foo);
-}
-
-
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-void test_char16_conversions()
-{
-    BOOST_CHECK(u"100" == lexical_cast<std::u16string>(u"100"));
-    BOOST_CHECK(u"1" == lexical_cast<std::u16string>(u'1'));
-}
-#endif
-
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-void test_char32_conversions()
-{
-    BOOST_CHECK(U"100" == lexical_cast<std::u32string>(U"100"));
-    BOOST_CHECK(U"1" == lexical_cast<std::u32string>(U'1'));
-}
-#endif
-
-void test_getting_pointer_to_function()
-{
-    // Just checking that &lexical_cast<To, From> is not ambiguous
-    typedef char char_arr[4];    
-    typedef int(*f1)(const char_arr&);
-    f1 p1 = &boost::lexical_cast<int, char_arr>;
-    BOOST_CHECK(p1);
-
-    typedef int(*f2)(const std::string&);
-    f2 p2 = &boost::lexical_cast<int, std::string>;
-    BOOST_CHECK(p2);
-
-    typedef std::string(*f3)(const int&);
-    f3 p3 = &boost::lexical_cast<std::string, int>;
-    BOOST_CHECK(p3);
-
-    std::vector<int> values;
-    std::vector<std::string> ret;
-    std::transform(values.begin(), values.end(), ret.begin(), boost::lexical_cast<std::string, int>);
-}
-
-
diff --git a/test/lexical_cast_to_pointer_test.cpp b/test/lexical_cast_to_pointer_test.cpp
deleted file mode 100644
index dcd5e55..0000000
--- a/test/lexical_cast_to_pointer_test.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-//  //  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 2013.
-//
-//  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/lexical_cast.hpp>
-#include <boost/type.hpp>
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-
-int test_main(int, char*[])
-{
-    boost::lexical_cast<char*>("Hello");
-    BOOST_CHECK(false); // suppressing warning about 'boost::unit_test::{anonymous}::unit_test_log' defined but not used
-    return 0;
-}
-
diff --git a/test/lexical_cast_try_lexical_convert.cpp b/test/lexical_cast_try_lexical_convert.cpp
deleted file mode 100644
index 1c795c2..0000000
--- a/test/lexical_cast_try_lexical_convert.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 2014.
-//
-//  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/config.hpp>
-
-#include <boost/lexical_cast.hpp>
-#include <boost/test/unit_test.hpp>
-
-using namespace boost::conversion;
-
-void try_uncommon_cases()
-{
-    std::string sres;
-    const bool res1 = try_lexical_convert(std::string("Test string"), sres);
-    BOOST_CHECK(res1);
-    BOOST_CHECK_EQUAL(sres, "Test string");
-
-    volatile int vires;
-    const bool res2 = try_lexical_convert(100, vires);
-    BOOST_CHECK(res2);
-    BOOST_CHECK_EQUAL(vires, 100);
-
-    const bool res3 = try_lexical_convert("Test string", sres);
-    BOOST_CHECK(res3);
-    BOOST_CHECK_EQUAL(sres, "Test string");
-
-    const bool res4 = try_lexical_convert("Test string", sizeof("Test string") - 1, sres);
-    BOOST_CHECK(res4);
-    BOOST_CHECK_EQUAL(sres, "Test string");
-
-    int ires;
-    BOOST_CHECK(!try_lexical_convert("Test string", ires));
-    BOOST_CHECK(!try_lexical_convert(1.1, ires));
-    BOOST_CHECK(!try_lexical_convert(-1.9, ires));
-    BOOST_CHECK(!try_lexical_convert("1.1", ires));
-    BOOST_CHECK(!try_lexical_convert("1000000000000000000000000000000000000000", ires));
-}
-
-
-void try_common_cases()
-{
-    int ires = 0;
-    const bool res1 = try_lexical_convert(std::string("100"), ires);
-    BOOST_CHECK(res1);
-    BOOST_CHECK_EQUAL(ires, 100);
-
-    ires = 0;
-    const bool res2 = try_lexical_convert("-100", ires);
-    BOOST_CHECK(res2);
-    BOOST_CHECK_EQUAL(ires, -100);
-
-    float fres = 1.0f;
-    const bool res3 = try_lexical_convert("0.0", fres);
-    BOOST_CHECK(res3);
-    BOOST_CHECK_EQUAL(fres, 0.0f);
-
-    fres = 1.0f;
-    const bool res4 = try_lexical_convert("0.0", sizeof("0.0") - 1, fres);
-    BOOST_CHECK(res4);
-    BOOST_CHECK_EQUAL(fres, 0.0f);
-}
-
-boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    boost::unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("Tests for try_lexical_convert");
-    suite->add(BOOST_TEST_CASE(&try_uncommon_cases));
-    suite->add(BOOST_TEST_CASE(&try_common_cases));
-
-    return suite;
-}
diff --git a/test/lexical_cast_typedefed_wchar_test.cpp b/test/lexical_cast_typedefed_wchar_test.cpp
deleted file mode 100644
index 2dc0098..0000000
--- a/test/lexical_cast_typedefed_wchar_test.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 2011.
-//
-//  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/config.hpp>
-
-#include <boost/static_assert.hpp>
-#include <boost/lexical_cast.hpp>
-
-#include <boost/date_time/gregorian/gregorian.hpp>
-#include <boost/date_time/posix_time/posix_time.hpp>
-
-void parseDate()
-{
-  std::locale locale;
-  boost::date_time::format_date_parser<boost::gregorian::date, wchar_t> parser(L"", locale);
-  boost::date_time::special_values_parser<boost::gregorian::date, wchar_t> svp;
-
-  boost::gregorian::date date = parser.parse_date(L"", L"", svp);
-  (void)date;
-}
-
-
-int main()
-{
-#ifdef BOOST_MSVC
-    BOOST_STATIC_ASSERT((boost::is_same<wchar_t, unsigned short>::value));
-#endif
-
-    parseDate();
-    return ::boost::lexical_cast<int>(L"1000") == 1000;
-}
-
-
diff --git a/test/lexical_cast_typedefed_wchar_test_runtime.cpp b/test/lexical_cast_typedefed_wchar_test_runtime.cpp
deleted file mode 100644
index adb024e..0000000
--- a/test/lexical_cast_typedefed_wchar_test_runtime.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 2011.
-//
-//  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/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
-#include <boost/lexical_cast.hpp>
-
-#include <boost/test/unit_test.hpp>
-using namespace boost;
-
-void test_typedefed_wchar_t_runtime()
-{
-#ifndef BOOST_LCAST_NO_WCHAR_T
-#ifdef BOOST_MSVC
-    BOOST_STATIC_ASSERT((boost::is_same<wchar_t, unsigned short>::value));
-
-
-    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(L'A'), 65);
-    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(L'B'), 66);
-
-    BOOST_CHECK_EQUAL(boost::lexical_cast<wchar_t>(L"65"), 65);
-    BOOST_CHECK_EQUAL(boost::lexical_cast<wchar_t>(L"66"), 66);
-#endif
-#endif
-    BOOST_CHECK(1);
-}
-
-unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast typedefed wchar_t runtime test");
-    suite->add(BOOST_TEST_CASE(&test_typedefed_wchar_t_runtime));
-
-    return suite;
-}
diff --git a/test/lexical_cast_vc8_bug_test.cpp b/test/lexical_cast_vc8_bug_test.cpp
deleted file mode 100644
index 35c7403..0000000
--- a/test/lexical_cast_vc8_bug_test.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Alexander Nasonov, 2007.
-//
-//  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).
-//
-// This tests now must pass on vc8, because lexical_cast
-// implementation has changed and it does not use stringstream for casts
-// to integral types
-
-#include <boost/config.hpp>
-#include <boost/lexical_cast.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/test/unit_test.hpp>
-
-#include <string>
-
-using namespace boost;
-
-// See also test_conversion_from_string_to_integral(CharT)
-// in libs/conversion/lexical_cast_test.cpp
-template<class T, class CharT>
-void test_too_long_number(CharT zero)
-{
-    typedef std::numeric_limits<T> limits;
-
-    std::basic_string<CharT> s;
-
-    std::basic_ostringstream<CharT> o;
-    o << (limits::max)() << zero;
-    s = o.str();
-    BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
-    s[s.size()-1] += static_cast<CharT>(9); // '0' -> '9'
-    BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
-
-    if(limits::is_signed)
-    {
-        std::basic_ostringstream<CharT> o;
-        o << (limits::min)() << zero;
-        s = o.str();
-        BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
-        s[s.size()-1] += static_cast<CharT>(9); // '0' -> '9'
-        BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
-    }
-}
-
-void test_vc8_bug()
-{
-    test_too_long_number<boost::intmax_t>('0');
-    test_too_long_number<boost::uintmax_t>('0');
-#if !defined(BOOST_LCAST_NO_WCHAR_T)
-    test_too_long_number<boost::intmax_t>(L'0');
-    test_too_long_number<boost::uintmax_t>(L'0');
-#endif
-}
-
-unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast vc8 bug unit test");
-    suite->add(BOOST_TEST_CASE(test_vc8_bug));
-    return suite;
-}
diff --git a/test/lexical_cast_wchars_test.cpp b/test/lexical_cast_wchars_test.cpp
deleted file mode 100644
index 41fc400..0000000
--- a/test/lexical_cast_wchars_test.cpp
+++ /dev/null
@@ -1,137 +0,0 @@
-//  Unit test for boost::lexical_cast.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 2011-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/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
-#include <boost/lexical_cast.hpp>
-#include <boost/test/unit_test.hpp>
-
-using namespace boost;
-
-#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
-#define BOOST_LCAST_NO_WCHAR_T
-#endif
-
-template <class CharT>
-void test_impl(const CharT* wc_arr)
-{
-    typedef CharT                       wide_char;
-    typedef std::basic_string<CharT>    wide_string;
-    const char c_arr[]            = "Test array of chars";
-    const unsigned char uc_arr[]  = "Test array of chars";
-    const signed char sc_arr[]    = "Test array of chars";
-
-    // Following tests depend on realization of std::locale
-    // and pass for popular compilers and STL realizations
-    BOOST_CHECK(boost::lexical_cast<wide_char>(c_arr[0]) == wc_arr[0]);
-    BOOST_CHECK(boost::lexical_cast<wide_string>(c_arr) == wide_string(wc_arr));
-
-    BOOST_CHECK(boost::lexical_cast<wide_string>(sc_arr) == wide_string(wc_arr) );
-    BOOST_CHECK(boost::lexical_cast<wide_string>(uc_arr) == wide_string(wc_arr) );
-
-    BOOST_CHECK_EQUAL(boost::lexical_cast<wide_char>(uc_arr[0]), wc_arr[0]);
-    BOOST_CHECK_EQUAL(boost::lexical_cast<wide_char>(sc_arr[0]), wc_arr[0]);
-}
-
-
-void test_char_types_conversions_wchar_t()
-{
-#ifndef BOOST_LCAST_NO_WCHAR_T
-    test_impl(L"Test array of chars");
-    wchar_t c = boost::detail::lcast_char_constants<wchar_t>::zero;
-    BOOST_CHECK_EQUAL(L'0', c);
-
-    c = boost::detail::lcast_char_constants<wchar_t>::minus;
-    BOOST_CHECK_EQUAL(L'-', c);
-
-    c = boost::detail::lcast_char_constants<wchar_t>::plus;
-    BOOST_CHECK_EQUAL(L'+', c);
-
-    c = boost::detail::lcast_char_constants<wchar_t>::lowercase_e;
-    BOOST_CHECK_EQUAL(L'e', c);
-
-    c = boost::detail::lcast_char_constants<wchar_t>::capital_e;
-    BOOST_CHECK_EQUAL(L'E', c);
-
-    c = boost::detail::lcast_char_constants<wchar_t>::c_decimal_separator;
-    BOOST_CHECK_EQUAL(L'.', c);
-#endif
-
-    BOOST_CHECK(true);
-}
-
-void test_char_types_conversions_char16_t()
-{
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
-    test_impl(u"Test array of chars");
-    char16_t c = boost::detail::lcast_char_constants<char16_t>::zero;
-    BOOST_CHECK_EQUAL(u'0', c);
-
-    c = boost::detail::lcast_char_constants<char16_t>::minus;
-    BOOST_CHECK_EQUAL(u'-', c);
-
-    c = boost::detail::lcast_char_constants<char16_t>::plus;
-    BOOST_CHECK_EQUAL(u'+', c);
-
-    c = boost::detail::lcast_char_constants<char16_t>::lowercase_e;
-    BOOST_CHECK_EQUAL(u'e', c);
-
-    c = boost::detail::lcast_char_constants<char16_t>::capital_e;
-    BOOST_CHECK_EQUAL(u'E', c);
-
-    c = boost::detail::lcast_char_constants<char16_t>::c_decimal_separator;
-    BOOST_CHECK_EQUAL(u'.', c);
-#endif
-
-    BOOST_CHECK(true);
-}
-
-void test_char_types_conversions_char32_t()
-{
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
-    test_impl(U"Test array of chars");
-    char32_t c = boost::detail::lcast_char_constants<char32_t>::zero;
-    BOOST_CHECK_EQUAL(U'0', c);
-
-    c = boost::detail::lcast_char_constants<char32_t>::minus;
-    BOOST_CHECK_EQUAL(U'-', c);
-
-    c = boost::detail::lcast_char_constants<char32_t>::plus;
-    BOOST_CHECK_EQUAL(U'+', c);
-
-    c = boost::detail::lcast_char_constants<char32_t>::lowercase_e;
-    BOOST_CHECK_EQUAL(U'e', c);
-
-    c = boost::detail::lcast_char_constants<char32_t>::capital_e;
-    BOOST_CHECK_EQUAL(U'E', c);
-
-    c = boost::detail::lcast_char_constants<char32_t>::c_decimal_separator;
-    BOOST_CHECK_EQUAL(U'.', c);
-#endif
-
-    BOOST_CHECK(true);
-}
-
-unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast char => wide characters unit test (widening test)");
-    suite->add(BOOST_TEST_CASE(&test_char_types_conversions_wchar_t));
-    suite->add(BOOST_TEST_CASE(&test_char_types_conversions_char16_t));
-    suite->add(BOOST_TEST_CASE(&test_char_types_conversions_char32_t));
-
-    return suite;
-}
