<h2>Editing File: /opt/rh/gcc-toolset-11/root/usr/include/c++/11/charconv</h2><form method='post'><textarea name='content' class='file-edit'>// Primitive numeric conversions (to_chars and from_chars) -*- C++ -*-

// Copyright (C) 2017-2021 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// &lt;http://www.gnu.org/licenses/&gt;.

/** @file include/charconv
 *  This is a Standard C++ Library header.
 */

#ifndef _GLIBCXX_CHARCONV
#define _GLIBCXX_CHARCONV 1

#pragma GCC system_header

// As an extension we support &lt;charconv&gt; in C++14, but this header should not
// be included by any other library headers in C++14 mode. This ensures that
// the names defined in this header are not added to namespace std unless a
// user explicitly includes &lt;charconv&gt; in C++14 code.
#if __cplusplus &gt;= 201402L

#include &lt;type_traits&gt;
#include &lt;bit&gt;			// for __bit_width
#include &lt;cctype&gt;		// for isdigit
#include &lt;bits/charconv.h&gt;	// for __to_chars_len, __to_chars_10_impl
#include &lt;bits/error_constants.h&gt; // for std::errc
#include &lt;ext/numeric_traits.h&gt;

#if _GLIBCXX_HAVE_USELOCALE
# define __cpp_lib_to_chars 201611L
#endif

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  /// Result type of std::to_chars
  struct to_chars_result
  {
    char* ptr;
    errc ec;

#if __cplusplus &gt; 201703L &amp;&amp; __cpp_impl_three_way_comparison &gt;= 201907L
    friend bool
    operator==(const to_chars_result&amp;, const to_chars_result&amp;) = default;
#endif
  };

  /// Result type of std::from_chars
  struct from_chars_result
  {
    const char* ptr;
    errc ec;

#if __cplusplus &gt; 201703L &amp;&amp; __cpp_impl_three_way_comparison &gt;= 201907L
    friend bool
    operator==(const from_chars_result&amp;, const from_chars_result&amp;) = default;
#endif
  };

namespace __detail
{
  template&lt;typename _Tp&gt;
    using __integer_to_chars_result_type
      = enable_if_t&lt;__or_&lt;__is_signed_integer&lt;_Tp&gt;,
			  __is_unsigned_integer&lt;_Tp&gt;,
			  is_same&lt;char, remove_cv_t&lt;_Tp&gt;&gt;&gt;::value,
		    to_chars_result&gt;;

  // Pick an unsigned type of suitable size. This is used to reduce the
  // number of specializations of __to_chars_len, __to_chars etc. that
  // get instantiated. For example, to_chars&lt;char&gt; and to_chars&lt;short&gt;
  // and to_chars&lt;unsigned&gt; will all use the same code, and so will
  // to_chars&lt;long&gt; when sizeof(int) == sizeof(long).
  template&lt;typename _Tp&gt;
    struct __to_chars_unsigned_type : __make_unsigned_selector_base
    {
      using _UInts = _List&lt;unsigned int, unsigned long, unsigned long long
#if _GLIBCXX_USE_INT128
	, unsigned __int128
#endif
	&gt;;
      using type = typename __select&lt;sizeof(_Tp), _UInts&gt;::__type;
    };

  template&lt;typename _Tp&gt;
    using __unsigned_least_t = typename __to_chars_unsigned_type&lt;_Tp&gt;::type;

  // Generic implementation for arbitrary bases.
  // Defined in &lt;bits/charconv.h&gt;.
  template&lt;typename _Tp&gt;
    constexpr unsigned
    __to_chars_len(_Tp __value, int __base /* = 10 */) noexcept;

  template&lt;typename _Tp&gt;
    constexpr unsigned
    __to_chars_len_2(_Tp __value) noexcept
    { return std::__bit_width(__value); }

  // Generic implementation for arbitrary bases.
  template&lt;typename _Tp&gt;
    to_chars_result
    __to_chars(char* __first, char* __last, _Tp __val, int __base) noexcept
    {
      static_assert(is_integral&lt;_Tp&gt;::value, &quot;implementation bug&quot;);
      static_assert(is_unsigned&lt;_Tp&gt;::value, &quot;implementation bug&quot;);

      to_chars_result __res;

      const unsigned __len = __to_chars_len(__val, __base);

      if (__builtin_expect((__last - __first) &lt; __len, 0))
	{
	  __res.ptr = __last;
	  __res.ec = errc::value_too_large;
	  return __res;
	}

      unsigned __pos = __len - 1;

      static constexpr char __digits[] = {
	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
	'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
	'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
	'u', 'v', 'w', 'x', 'y', 'z'
      };

      while (__val &gt;= (unsigned)__base)
	{
	  auto const __quo = __val / __base;
	  auto const __rem = __val % __base;
	  __first[__pos--] = __digits[__rem];
	  __val = __quo;
	}
      *__first = __digits[__val];

      __res.ptr = __first + __len;
      __res.ec = {};
      return __res;
    }

  template&lt;typename _Tp&gt;
    __integer_to_chars_result_type&lt;_Tp&gt;
    __to_chars_16(char* __first, char* __last, _Tp __val) noexcept
    {
      static_assert(is_integral&lt;_Tp&gt;::value, &quot;implementation bug&quot;);
      static_assert(is_unsigned&lt;_Tp&gt;::value, &quot;implementation bug&quot;);

      to_chars_result __res;

      const unsigned __len = (__to_chars_len_2(__val) + 3) / 4;

      if (__builtin_expect((__last - __first) &lt; __len, 0))
	{
	  __res.ptr = __last;
	  __res.ec = errc::value_too_large;
	  return __res;
	}

      static constexpr char __digits[] = {
	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
	'a', 'b', 'c', 'd', 'e', 'f'
      };
      unsigned __pos = __len - 1;
      while (__val &gt;= 0x100)
	{
	  auto __num = __val &amp; 0xF;
	  __val &gt;&gt;= 4;
	  __first[__pos] = __digits[__num];
	  __num = __val &amp; 0xF;
	  __val &gt;&gt;= 4;
	  __first[__pos - 1] = __digits[__num];
	  __pos -= 2;
	}
      if (__val &gt;= 0x10)
	{
	  const auto __num = __val &amp; 0xF;
	  __val &gt;&gt;= 4;
	  __first[1] = __digits[__num];
	  __first[0] = __digits[__val];
	}
      else
	__first[0] = __digits[__val];
      __res.ptr = __first + __len;
      __res.ec = {};
      return __res;
    }

  template&lt;typename _Tp&gt;
    inline __integer_to_chars_result_type&lt;_Tp&gt;
    __to_chars_10(char* __first, char* __last, _Tp __val) noexcept
    {
      static_assert(is_integral&lt;_Tp&gt;::value, &quot;implementation bug&quot;);
      static_assert(is_unsigned&lt;_Tp&gt;::value, &quot;implementation bug&quot;);

      to_chars_result __res;

      const unsigned __len = __to_chars_len(__val, 10);

      if (__builtin_expect((__last - __first) &lt; __len, 0))
	{
	  __res.ptr = __last;
	  __res.ec = errc::value_too_large;
	  return __res;
	}

      __detail::__to_chars_10_impl(__first, __len, __val);
      __res.ptr = __first + __len;
      __res.ec = {};
      return __res;
    }

  template&lt;typename _Tp&gt;
    __integer_to_chars_result_type&lt;_Tp&gt;
    __to_chars_8(char* __first, char* __last, _Tp __val) noexcept
    {
      static_assert(is_integral&lt;_Tp&gt;::value, &quot;implementation bug&quot;);
      static_assert(is_unsigned&lt;_Tp&gt;::value, &quot;implementation bug&quot;);

      to_chars_result __res;
      unsigned __len;

      if _GLIBCXX17_CONSTEXPR (__gnu_cxx::__int_traits&lt;_Tp&gt;::__digits &lt;= 16)
	{
	  __len = __val &gt; 077777u ? 6u
	    : __val &gt; 07777u ? 5u
	    : __val &gt; 0777u ? 4u
	    : __val &gt; 077u ? 3u
	    : __val &gt; 07u ? 2u
	    : 1u;
	}
      else
	__len = (__to_chars_len_2(__val) + 2) / 3;

      if (__builtin_expect((__last - __first) &lt; __len, 0))
	{
	  __res.ptr = __last;
	  __res.ec = errc::value_too_large;
	  return __res;
	}

      unsigned __pos = __len - 1;
      while (__val &gt;= 0100)
	{
	  auto __num = __val &amp; 7;
	  __val &gt;&gt;= 3;
	  __first[__pos] = '0' + __num;
	  __num = __val &amp; 7;
	  __val &gt;&gt;= 3;
	  __first[__pos - 1] = '0' + __num;
	  __pos -= 2;
	}
      if (__val &gt;= 010)
	{
	  auto const __num = __val &amp; 7;
	  __val &gt;&gt;= 3;
	  __first[1] = '0' + __num;
	  __first[0] = '0' + __val;
	}
      else
	__first[0] = '0' + __val;
      __res.ptr = __first + __len;
      __res.ec = {};
      return __res;
    }

  template&lt;typename _Tp&gt;
    __integer_to_chars_result_type&lt;_Tp&gt;
    __to_chars_2(char* __first, char* __last, _Tp __val) noexcept
    {
      static_assert(is_integral&lt;_Tp&gt;::value, &quot;implementation bug&quot;);
      static_assert(is_unsigned&lt;_Tp&gt;::value, &quot;implementation bug&quot;);

      to_chars_result __res;

      const unsigned __len = __to_chars_len_2(__val);

      if (__builtin_expect((__last - __first) &lt; __len, 0))
	{
	  __res.ptr = __last;
	  __res.ec = errc::value_too_large;
	  return __res;
	}

      unsigned __pos = __len - 1;

      while (__pos)
	{
	  __first[__pos--] = '0' + (__val &amp; 1);
	  __val &gt;&gt;= 1;
	}
      // First digit is always '1' because __to_chars_len_2 skips
      // leading zero bits and std::to_chars handles zero values
      // directly.
      __first[0] = '1';

      __res.ptr = __first + __len;
      __res.ec = {};
      return __res;
    }

} // namespace __detail

  template&lt;typename _Tp&gt;
    __detail::__integer_to_chars_result_type&lt;_Tp&gt;
    __to_chars_i(char* __first, char* __last, _Tp __value, int __base = 10)
    {
      __glibcxx_assert(2 &lt;= __base &amp;&amp; __base &lt;= 36);

      using _Up = __detail::__unsigned_least_t&lt;_Tp&gt;;
      _Up __unsigned_val = __value;

      if (__first == __last) [[__unlikely__]]
	return { __last, errc::value_too_large };

      if (__value == 0)
	{
	  *__first = '0';
	  return { __first + 1, errc{} };
	}
      else if _GLIBCXX17_CONSTEXPR (std::is_signed&lt;_Tp&gt;::value)
	if (__value &lt; 0)
	  {
	    *__first++ = '-';
	    __unsigned_val = _Up(~__value) + _Up(1);
	  }

      switch (__base)
      {
      case 16:
	return __detail::__to_chars_16(__first, __last, __unsigned_val);
      case 10:
	return __detail::__to_chars_10(__first, __last, __unsigned_val);
      case 8:
	return __detail::__to_chars_8(__first, __last, __unsigned_val);
      case 2:
	return __detail::__to_chars_2(__first, __last, __unsigned_val);
      default:
	return __detail::__to_chars(__first, __last, __unsigned_val, __base);
      }
    }

#define _GLIBCXX_TO_CHARS(T) \
  inline to_chars_result \
  to_chars(char* __first, char* __last, T __value, int __base = 10) \
  { return std::__to_chars_i&lt;T&gt;(__first, __last, __value, __base); }
_GLIBCXX_TO_CHARS(char)
_GLIBCXX_TO_CHARS(signed char)
_GLIBCXX_TO_CHARS(unsigned char)
_GLIBCXX_TO_CHARS(signed short)
_GLIBCXX_TO_CHARS(unsigned short)
_GLIBCXX_TO_CHARS(signed int)
_GLIBCXX_TO_CHARS(unsigned int)
_GLIBCXX_TO_CHARS(signed long)
_GLIBCXX_TO_CHARS(unsigned long)
_GLIBCXX_TO_CHARS(signed long long)
_GLIBCXX_TO_CHARS(unsigned long long)
#if defined(__GLIBCXX_TYPE_INT_N_0)
_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_0)
_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_0)
#endif
#if defined(__GLIBCXX_TYPE_INT_N_1)
_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_1)
_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_1)
#endif
#if defined(__GLIBCXX_TYPE_INT_N_2)
_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_2)
_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_2)
#endif
#if defined(__GLIBCXX_TYPE_INT_N_3)
_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_3)
_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_3)
#endif
#undef _GLIBCXX_TO_CHARS

  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 3266. to_chars(bool) should be deleted
  to_chars_result to_chars(char*, char*, bool, int = 10) = delete;

namespace __detail
{
  template&lt;typename _Tp&gt;
    bool
    __raise_and_add(_Tp&amp; __val, int __base, unsigned char __c)
    {
      if (__builtin_mul_overflow(__val, __base, &amp;__val)
	  || __builtin_add_overflow(__val, __c, &amp;__val))
	return false;
      return true;
    }

  /// std::from_chars implementation for integers in base 2.
  template&lt;typename _Tp&gt;
    bool
    __from_chars_binary(const char*&amp; __first, const char* __last, _Tp&amp; __val)
    {
      static_assert(is_integral&lt;_Tp&gt;::value, &quot;implementation bug&quot;);
      static_assert(is_unsigned&lt;_Tp&gt;::value, &quot;implementation bug&quot;);

      const ptrdiff_t __len = __last - __first;
      ptrdiff_t __i = 0;
      while (__i &lt; __len &amp;&amp; __first[__i] == '0')
	++__i;
      const ptrdiff_t __leading_zeroes = __i;

      while (__i &lt; __len)
	{
	  const unsigned char __c = (unsigned)__first[__i] - '0';
	  if (__c &lt; 2)
	    __val = (__val &lt;&lt; 1) | __c;
	  else
	    break;
	  __i++;
	}
      __first += __i;
      return (__i - __leading_zeroes) &lt;= __gnu_cxx::__int_traits&lt;_Tp&gt;::__digits;
    }

  /// std::from_chars implementation for integers in bases 3 to 10.
  template&lt;typename _Tp&gt;
    bool
    __from_chars_digit(const char*&amp; __first, const char* __last, _Tp&amp; __val,
		       int __base)
    {
      static_assert(is_integral&lt;_Tp&gt;::value, &quot;implementation bug&quot;);
      static_assert(is_unsigned&lt;_Tp&gt;::value, &quot;implementation bug&quot;);

      auto __matches = [__base](char __c) {
	  return '0' &lt;= __c &amp;&amp; __c &lt;= ('0' + (__base - 1));
      };

      while (__first != __last)
	{
	  const char __c = *__first;
	  if (__matches(__c))
	  {
	    if (!__raise_and_add(__val, __base, __c - '0'))
	      {
		while (++__first != __last &amp;&amp; __matches(*__first))
		  ;
		return false;
	      }
	    __first++;
	  }
	  else
	    return true;
	}
      return true;
    }

  constexpr unsigned char
  __from_chars_alpha_to_num(char __c)
  {
    switch (__c)
    {
    case 'a':
    case 'A':
      return 10;
    case 'b':
    case 'B':
      return 11;
    case 'c':
    case 'C':
      return 12;
    case 'd':
    case 'D':
      return 13;
    case 'e':
    case 'E':
      return 14;
    case 'f':
    case 'F':
      return 15;
    case 'g':
    case 'G':
      return 16;
    case 'h':
    case 'H':
      return 17;
    case 'i':
    case 'I':
      return 18;
    case 'j':
    case 'J':
      return 19;
    case 'k':
    case 'K':
      return 20;
    case 'l':
    case 'L':
      return 21;
    case 'm':
    case 'M':
      return 22;
    case 'n':
    case 'N':
      return 23;
    case 'o':
    case 'O':
      return 24;
    case 'p':
    case 'P':
      return 25;
    case 'q':
    case 'Q':
      return 26;
    case 'r':
    case 'R':
      return 27;
    case 's':
    case 'S':
      return 28;
    case 't':
    case 'T':
      return 29;
    case 'u':
    case 'U':
      return 30;
    case 'v':
    case 'V':
      return 31;
    case 'w':
    case 'W':
      return 32;
    case 'x':
    case 'X':
      return 33;
    case 'y':
    case 'Y':
      return 34;
    case 'z':
    case 'Z':
      return 35;
    }
    return __gnu_cxx::__int_traits&lt;unsigned char&gt;::__max;
  }

  /// std::from_chars implementation for integers in bases 11 to 26.
  template&lt;typename _Tp&gt;
    bool
    __from_chars_alnum(const char*&amp; __first, const char* __last, _Tp&amp; __val,
		       int __base)
    {
      bool __valid = true;
      while (__first != __last)
	{
	  unsigned char __c = *__first;
	  if (std::isdigit(__c))
	    __c -= '0';
	  else
	    {
	      __c = __from_chars_alpha_to_num(__c);
	      if (__c &gt;= __base)
		break;
	    }

	  if (__builtin_expect(__valid, 1))
	    __valid = __raise_and_add(__val, __base, __c);
	  __first++;
	}
      return __valid;
    }

  template&lt;typename _Tp&gt;
    using __integer_from_chars_result_type
      = enable_if_t&lt;__or_&lt;__is_signed_integer&lt;_Tp&gt;,
			  __is_unsigned_integer&lt;_Tp&gt;,
			  is_same&lt;char, remove_cv_t&lt;_Tp&gt;&gt;&gt;::value,
		    from_chars_result&gt;;

} // namespace __detail

  /// std::from_chars for integral types.
  template&lt;typename _Tp&gt;
    __detail::__integer_from_chars_result_type&lt;_Tp&gt;
    from_chars(const char* __first, const char* __last, _Tp&amp; __value,
	       int __base = 10)
    {
      __glibcxx_assert(2 &lt;= __base &amp;&amp; __base &lt;= 36);

      from_chars_result __res{__first, {}};

      int __sign = 1;
      if _GLIBCXX17_CONSTEXPR (std::is_signed&lt;_Tp&gt;::value)
	if (__first != __last &amp;&amp; *__first == '-')
	  {
	    __sign = -1;
	    ++__first;
	  }

      using _Up = __detail::__unsigned_least_t&lt;_Tp&gt;;
      _Up __val = 0;

      const auto __start = __first;
      bool __valid;
      if (__base == 2)
	__valid = __detail::__from_chars_binary(__first, __last, __val);
      else if (__base &lt;= 10)
	__valid = __detail::__from_chars_digit(__first, __last, __val, __base);
      else
	__valid = __detail::__from_chars_alnum(__first, __last, __val, __base);

      if (__builtin_expect(__first == __start, 0))
	__res.ec = errc::invalid_argument;
      else
	{
	  __res.ptr = __first;
	  if (!__valid)
	    __res.ec = errc::result_out_of_range;
	  else
	    {
	      if _GLIBCXX17_CONSTEXPR (std::is_signed&lt;_Tp&gt;::value)
		{
		  _Tp __tmp;
		  if (__builtin_mul_overflow(__val, __sign, &amp;__tmp))
		    __res.ec = errc::result_out_of_range;
		  else
		    __value = __tmp;
		}
	      else
		{
		  if _GLIBCXX17_CONSTEXPR (__gnu_cxx::__int_traits&lt;_Up&gt;::__max
		      &gt; __gnu_cxx::__int_traits&lt;_Tp&gt;::__max)
		    {
		      if (__val &gt; __gnu_cxx::__int_traits&lt;_Tp&gt;::__max)
			__res.ec = errc::result_out_of_range;
		      else
			__value = __val;
		    }
		  else
		    __value = __val;
		}
	    }
	}
      return __res;
    }

  /// floating-point format for primitive numerical conversion
  enum class chars_format
  {
    scientific = 1, fixed = 2, hex = 4, general = fixed | scientific
  };

  constexpr chars_format
  operator|(chars_format __lhs, chars_format __rhs) noexcept
  { return (chars_format)((unsigned)__lhs | (unsigned)__rhs); }

  constexpr chars_format
  operator&amp;(chars_format __lhs, chars_format __rhs) noexcept
  { return (chars_format)((unsigned)__lhs &amp; (unsigned)__rhs); }

  constexpr chars_format
  operator^(chars_format __lhs, chars_format __rhs) noexcept
  { return (chars_format)((unsigned)__lhs ^ (unsigned)__rhs); }

  constexpr chars_format
  operator~(chars_format __fmt) noexcept
  { return (chars_format)~(unsigned)__fmt; }

  constexpr chars_format&amp;
  operator|=(chars_format&amp; __lhs, chars_format __rhs) noexcept
  { return __lhs = __lhs | __rhs; }

  constexpr chars_format&amp;
  operator&amp;=(chars_format&amp; __lhs, chars_format __rhs) noexcept
  { return __lhs = __lhs &amp; __rhs; }

  constexpr chars_format&amp;
  operator^=(chars_format&amp; __lhs, chars_format __rhs) noexcept
  { return __lhs = __lhs ^ __rhs; }

#if _GLIBCXX_HAVE_USELOCALE
  from_chars_result
  from_chars(const char* __first, const char* __last, float&amp; __value,
	     chars_format __fmt = chars_format::general) noexcept;

  from_chars_result
  from_chars(const char* __first, const char* __last, double&amp; __value,
	     chars_format __fmt = chars_format::general) noexcept;

  from_chars_result
  from_chars(const char* __first, const char* __last, long double&amp; __value,
	     chars_format __fmt = chars_format::general) noexcept;
#endif

#if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 &amp;&amp; _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 \
    &amp;&amp; __SIZE_WIDTH__ &gt;= 32
  // Floating-point std::to_chars

  // Overloads for float.
  to_chars_result to_chars(char* __first, char* __last, float __value) noexcept;
  to_chars_result to_chars(char* __first, char* __last, float __value,
			   chars_format __fmt) noexcept;
  to_chars_result to_chars(char* __first, char* __last, float __value,
			   chars_format __fmt, int __precision) noexcept;

  // Overloads for double.
  to_chars_result to_chars(char* __first, char* __last, double __value) noexcept;
  to_chars_result to_chars(char* __first, char* __last, double __value,
			   chars_format __fmt) noexcept;
  to_chars_result to_chars(char* __first, char* __last, double __value,
			   chars_format __fmt, int __precision) noexcept;

  // Overloads for long double.
  to_chars_result to_chars(char* __first, char* __last, long double __value)
    noexcept;
  to_chars_result to_chars(char* __first, char* __last, long double __value,
			   chars_format __fmt) noexcept;
  to_chars_result to_chars(char* __first, char* __last, long double __value,
			   chars_format __fmt, int __precision) noexcept;
#endif

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++14
#endif // _GLIBCXX_CHARCONV
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Frh%2Fgcc-toolset-11%2Froot%2Fusr%2Finclude%2Fc%2B%2B%2F11'>Back to Directory</a>