diff -adru a/libstdc++-v3/config/locale/dragonfly/c_locale.h b/libstdc++-v3/config/locale/dragonfly/c_locale.h
--- a/libstdc++-v3/config/locale/dragonfly/c_locale.h	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/config/locale/dragonfly/c_locale.h	2021-04-09 13:06:24.493112800 +0800
@@ -55,7 +55,7 @@
   // fall back to the unsafe vsprintf which, in general, can be dangerous
   // and should be avoided.
   inline int
-  __convert_from_v(const __c_locale& __cloc, char* __out,
+  __convert_from_v(const __c_locale& __cloc, char* ___out,
 		   const int __size __attribute__ ((__unused__)),
 		   const char* __fmt, ...)
   {
@@ -65,9 +65,9 @@
     __builtin_va_start(__args, __fmt);
 
 #if _GLIBCXX_USE_C99_STDIO
-    const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
+    const int __ret = __builtin_vsnprintf(___out, __size, __fmt, __args);
 #else
-    const int __ret = __builtin_vsprintf(__out, __fmt, __args);
+    const int __ret = __builtin_vsprintf(___out, __fmt, __args);
 #endif
 
     __builtin_va_end(__args);
diff -adru a/libstdc++-v3/config/locale/generic/c_locale.h b/libstdc++-v3/config/locale/generic/c_locale.h
--- a/libstdc++-v3/config/locale/generic/c_locale.h	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/config/locale/generic/c_locale.h	2021-04-09 13:06:24.493112800 +0800
@@ -53,7 +53,7 @@
   // fall back to the unsafe vsprintf which, in general, can be dangerous
   // and should be avoided.
   inline int
-  __convert_from_v(const __c_locale&, char* __out,
+  __convert_from_v(const __c_locale&, char* ___out,
 		   const int __size __attribute__((__unused__)),
 		   const char* __fmt, ...)
   {
@@ -71,9 +71,9 @@
     __builtin_va_start(__args, __fmt);
 
 #if _GLIBCXX_USE_C99_STDIO && !_GLIBCXX_HAVE_BROKEN_VSNPRINTF
-    const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
+    const int __ret = __builtin_vsnprintf(___out, __size, __fmt, __args);
 #else
-    const int __ret = __builtin_vsprintf(__out, __fmt, __args);
+    const int __ret = __builtin_vsprintf(___out, __fmt, __args);
 #endif
 
     __builtin_va_end(__args);
diff -adru a/libstdc++-v3/config/locale/gnu/c_locale.h b/libstdc++-v3/config/locale/gnu/c_locale.h
--- a/libstdc++-v3/config/locale/gnu/c_locale.h	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/config/locale/gnu/c_locale.h	2021-04-09 13:06:24.493112800 +0800
@@ -67,7 +67,7 @@
   // and should be avoided.
   inline int
   __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
-		   char* __out,
+		   char* ___out,
 		   const int __size __attribute__ ((__unused__)),
 		   const char* __fmt, ...)
   {
@@ -89,9 +89,9 @@
     __builtin_va_start(__args, __fmt);
 
 #if _GLIBCXX_USE_C99_STDIO
-    const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
+    const int __ret = __builtin_vsnprintf(___out, __size, __fmt, __args);
 #else
-    const int __ret = __builtin_vsprintf(__out, __fmt, __args);
+    const int __ret = __builtin_vsprintf(___out, __fmt, __args);
 #endif
 
     __builtin_va_end(__args);
diff -adru a/libstdc++-v3/include/bits/basic_string.h b/libstdc++-v3/include/bits/basic_string.h
--- a/libstdc++-v3/include/bits/basic_string.h	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/bits/basic_string.h	2021-04-09 13:06:24.087003600 +0800
@@ -6527,13 +6527,13 @@
 
   template<>
     basic_istream<char>&
-    getline(basic_istream<char>& __in, basic_string<char>& __str,
+    getline(basic_istream<char>& ___in, basic_string<char>& __str,
 	    char __delim);
 
 #ifdef _GLIBCXX_USE_WCHAR_T
   template<>
     basic_istream<wchar_t>&
-    getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
+    getline(basic_istream<wchar_t>& ___in, basic_string<wchar_t>& __str,
 	    wchar_t __delim);
 #endif  
 
diff -adru a/libstdc++-v3/include/bits/basic_string.tcc b/libstdc++-v3/include/bits/basic_string.tcc
--- a/libstdc++-v3/include/bits/basic_string.tcc	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/bits/basic_string.tcc	2021-04-09 13:06:24.087003600 +0800
@@ -1465,7 +1465,7 @@
   // 21.3.7.9 basic_string::getline and operators
   template<typename _CharT, typename _Traits, typename _Alloc>
     basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __in,
+    operator>>(basic_istream<_CharT, _Traits>& ___in,
 	       basic_string<_CharT, _Traits, _Alloc>& __str)
     {
       typedef basic_istream<_CharT, _Traits>		__istream_type;
@@ -1478,7 +1478,7 @@
 
       __size_type __extracted = 0;
       typename __ios_base::iostate __err = __ios_base::goodbit;
-      typename __istream_type::sentry __cerb(__in, false);
+      typename __istream_type::sentry __cerb(___in, false);
       if (__cerb)
 	{
 	  __try
@@ -1487,12 +1487,12 @@
 	      __str.erase();
 	      _CharT __buf[128];
 	      __size_type __len = 0;	      
-	      const streamsize __w = __in.width();
+	      const streamsize __w = ___in.width();
 	      const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
 		                              : __str.max_size();
-	      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+	      const __ctype_type& __ct = use_facet<__ctype_type>(___in.getloc());
 	      const __int_type __eof = _Traits::eof();
-	      __int_type __c = __in.rdbuf()->sgetc();
+	      __int_type __c = ___in.rdbuf()->sgetc();
 
 	      while (__extracted < __n
 		     && !_Traits::eq_int_type(__c, __eof)
@@ -1506,17 +1506,17 @@
 		    }
 		  __buf[__len++] = _Traits::to_char_type(__c);
 		  ++__extracted;
-		  __c = __in.rdbuf()->snextc();
+		  __c = ___in.rdbuf()->snextc();
 		}
 	      __str.append(__buf, __len);
 
 	      if (_Traits::eq_int_type(__c, __eof))
 		__err |= __ios_base::eofbit;
-	      __in.width(0);
+	      ___in.width(0);
 	    }
 	  __catch(__cxxabiv1::__forced_unwind&)
 	    {
-	      __in._M_setstate(__ios_base::badbit);
+	      ___in._M_setstate(__ios_base::badbit);
 	      __throw_exception_again;
 	    }
 	  __catch(...)
@@ -1524,20 +1524,20 @@
 	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
 	      // 91. Description of operator>> and getline() for string<>
 	      // might cause endless loop
-	      __in._M_setstate(__ios_base::badbit);
+	      ___in._M_setstate(__ios_base::badbit);
 	    }
 	}
       // 211.  operator>>(istream&, string&) doesn't set failbit
       if (!__extracted)
 	__err |= __ios_base::failbit;
       if (__err)
-	__in.setstate(__err);
-      return __in;
+	___in.setstate(__err);
+      return ___in;
     }
 
   template<typename _CharT, typename _Traits, typename _Alloc>
     basic_istream<_CharT, _Traits>&
-    getline(basic_istream<_CharT, _Traits>& __in,
+    getline(basic_istream<_CharT, _Traits>& ___in,
 	    basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
     {
       typedef basic_istream<_CharT, _Traits>		__istream_type;
@@ -1549,7 +1549,7 @@
       __size_type __extracted = 0;
       const __size_type __n = __str.max_size();
       typename __ios_base::iostate __err = __ios_base::goodbit;
-      typename __istream_type::sentry __cerb(__in, true);
+      typename __istream_type::sentry __cerb(___in, true);
       if (__cerb)
 	{
 	  __try
@@ -1557,7 +1557,7 @@
 	      __str.erase();
 	      const __int_type __idelim = _Traits::to_int_type(__delim);
 	      const __int_type __eof = _Traits::eof();
-	      __int_type __c = __in.rdbuf()->sgetc();
+	      __int_type __c = ___in.rdbuf()->sgetc();
 
 	      while (__extracted < __n
 		     && !_Traits::eq_int_type(__c, __eof)
@@ -1565,7 +1565,7 @@
 		{
 		  __str += _Traits::to_char_type(__c);
 		  ++__extracted;
-		  __c = __in.rdbuf()->snextc();
+		  __c = ___in.rdbuf()->snextc();
 		}
 
 	      if (_Traits::eq_int_type(__c, __eof))
@@ -1573,14 +1573,14 @@
 	      else if (_Traits::eq_int_type(__c, __idelim))
 		{
 		  ++__extracted;		  
-		  __in.rdbuf()->sbumpc();
+		  ___in.rdbuf()->sbumpc();
 		}
 	      else
 		__err |= __ios_base::failbit;
 	    }
 	  __catch(__cxxabiv1::__forced_unwind&)
 	    {
-	      __in._M_setstate(__ios_base::badbit);
+	      ___in._M_setstate(__ios_base::badbit);
 	      __throw_exception_again;
 	    }
 	  __catch(...)
@@ -1588,14 +1588,14 @@
 	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
 	      // 91. Description of operator>> and getline() for string<>
 	      // might cause endless loop
-	      __in._M_setstate(__ios_base::badbit);
+	      ___in._M_setstate(__ios_base::badbit);
 	    }
 	}
       if (!__extracted)
 	__err |= __ios_base::failbit;
       if (__err)
-	__in.setstate(__err);
-      return __in;
+	___in.setstate(__err);
+      return ___in;
     }
 
   // Inhibit implicit instantiations for required instantiations,
diff -adru a/libstdc++-v3/include/bits/istream.tcc b/libstdc++-v3/include/bits/istream.tcc
--- a/libstdc++-v3/include/bits/istream.tcc	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/bits/istream.tcc	2021-04-09 13:06:24.102579900 +0800
@@ -44,21 +44,21 @@
 
   template<typename _CharT, typename _Traits>
     basic_istream<_CharT, _Traits>::sentry::
-    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
+    sentry(basic_istream<_CharT, _Traits>& ___in, bool __noskip) : _M_ok(false)
     {
       ios_base::iostate __err = ios_base::goodbit;
-      if (__in.good())
+      if (___in.good())
 	__try
 	  {
-	    if (__in.tie())
-	      __in.tie()->flush();
-	    if (!__noskip && bool(__in.flags() & ios_base::skipws))
+	    if (___in.tie())
+	      ___in.tie()->flush();
+	    if (!__noskip && bool(___in.flags() & ios_base::skipws))
 	      {
 		const __int_type __eof = traits_type::eof();
-		__streambuf_type* __sb = __in.rdbuf();
+		__streambuf_type* __sb = ___in.rdbuf();
 		__int_type __c = __sb->sgetc();
 
-		const __ctype_type& __ct = __check_facet(__in._M_ctype);
+		const __ctype_type& __ct = __check_facet(___in._M_ctype);
 		while (!traits_type::eq_int_type(__c, __eof)
 		       && __ct.is(ctype_base::space,
 				  traits_type::to_char_type(__c)))
@@ -73,18 +73,18 @@
 	  }
 	__catch(__cxxabiv1::__forced_unwind&)
 	  {
-	    __in._M_setstate(ios_base::badbit);
+	    ___in._M_setstate(ios_base::badbit);
 	    __throw_exception_again;
 	  }
 	__catch(...)
-	  { __in._M_setstate(ios_base::badbit); }
+	  { ___in._M_setstate(ios_base::badbit); }
 
-      if (__in.good() && __err == ios_base::goodbit)
+      if (___in.good() && __err == ios_base::goodbit)
 	_M_ok = true;
       else
 	{
 	  __err |= ios_base::failbit;
-	  __in.setstate(__err);
+	  ___in.setstate(__err);
 	}
     }
 
@@ -928,18 +928,18 @@
   // 27.6.1.2.3 Character extraction templates
   template<typename _CharT, typename _Traits>
     basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
+    operator>>(basic_istream<_CharT, _Traits>& ___in, _CharT& __c)
     {
       typedef basic_istream<_CharT, _Traits>		__istream_type;
       typedef typename __istream_type::int_type         __int_type;
 
-      typename __istream_type::sentry __cerb(__in, false);
+      typename __istream_type::sentry __cerb(___in, false);
       if (__cerb)
 	{
 	  ios_base::iostate __err = ios_base::goodbit;
 	  __try
 	    {
-	      const __int_type __cb = __in.rdbuf()->sbumpc();
+	      const __int_type __cb = ___in.rdbuf()->sbumpc();
 	      if (!_Traits::eq_int_type(__cb, _Traits::eof()))
 		__c = _Traits::to_char_type(__cb);
 	      else
@@ -947,20 +947,20 @@
 	    }
 	  __catch(__cxxabiv1::__forced_unwind&)
 	    {
-	      __in._M_setstate(ios_base::badbit);
+	      ___in._M_setstate(ios_base::badbit);
 	      __throw_exception_again;
 	    }
 	  __catch(...)
-	    { __in._M_setstate(ios_base::badbit); }
+	    { ___in._M_setstate(ios_base::badbit); }
 	  if (__err)
-	    __in.setstate(__err);
+	    ___in.setstate(__err);
 	}
-      return __in;
+      return ___in;
     }
 
   template<typename _CharT, typename _Traits>
     basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
+    operator>>(basic_istream<_CharT, _Traits>& ___in, _CharT* __s)
     {
       typedef basic_istream<_CharT, _Traits>		__istream_type;
       typedef basic_streambuf<_CharT, _Traits>          __streambuf_type;
@@ -970,20 +970,20 @@
 
       streamsize __extracted = 0;
       ios_base::iostate __err = ios_base::goodbit;
-      typename __istream_type::sentry __cerb(__in, false);
+      typename __istream_type::sentry __cerb(___in, false);
       if (__cerb)
 	{
 	  __try
 	    {
 	      // Figure out how many characters to extract.
-	      streamsize __num = __in.width();
+	      streamsize __num = ___in.width();
 	      if (__num <= 0)
 		__num = __gnu_cxx::__numeric_traits<streamsize>::__max;
 
-	      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+	      const __ctype_type& __ct = use_facet<__ctype_type>(___in.getloc());
 
 	      const int_type __eof = _Traits::eof();
-	      __streambuf_type* __sb = __in.rdbuf();
+	      __streambuf_type* __sb = ___in.rdbuf();
 	      int_type __c = __sb->sgetc();
 
 	      while (__extracted < __num - 1
@@ -1001,36 +1001,36 @@
 	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
 	      // 68.  Extractors for char* should store null at end
 	      *__s = char_type();
-	      __in.width(0);
+	      ___in.width(0);
 	    }
 	  __catch(__cxxabiv1::__forced_unwind&)
 	    {
-	      __in._M_setstate(ios_base::badbit);
+	      ___in._M_setstate(ios_base::badbit);
 	      __throw_exception_again;
 	    }
 	  __catch(...)
-	    { __in._M_setstate(ios_base::badbit); }
+	    { ___in._M_setstate(ios_base::badbit); }
 	}
       if (!__extracted)
 	__err |= ios_base::failbit;
       if (__err)
-	__in.setstate(__err);
-      return __in;
+	___in.setstate(__err);
+      return ___in;
     }
 
   // 27.6.1.4 Standard basic_istream manipulators
   template<typename _CharT, typename _Traits>
     basic_istream<_CharT, _Traits>&
-    ws(basic_istream<_CharT, _Traits>& __in)
+    ws(basic_istream<_CharT, _Traits>& ___in)
     {
       typedef basic_istream<_CharT, _Traits>		__istream_type;
       typedef basic_streambuf<_CharT, _Traits>          __streambuf_type;
       typedef typename __istream_type::int_type		__int_type;
       typedef ctype<_CharT>				__ctype_type;
 
-      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+      const __ctype_type& __ct = use_facet<__ctype_type>(___in.getloc());
       const __int_type __eof = _Traits::eof();
-      __streambuf_type* __sb = __in.rdbuf();
+      __streambuf_type* __sb = ___in.rdbuf();
       __int_type __c = __sb->sgetc();
 
       while (!_Traits::eq_int_type(__c, __eof)
@@ -1038,8 +1038,8 @@
 	__c = __sb->snextc();
 
        if (_Traits::eq_int_type(__c, __eof))
-	 __in.setstate(ios_base::eofbit);
-      return __in;
+	 ___in.setstate(ios_base::eofbit);
+      return ___in;
     }
 
   // Inhibit implicit instantiations for required instantiations,
diff -adru a/libstdc++-v3/include/bits/iterator_concepts.h b/libstdc++-v3/include/bits/iterator_concepts.h
--- a/libstdc++-v3/include/bits/iterator_concepts.h	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/bits/iterator_concepts.h	2021-04-09 13:06:24.102579900 +0800
@@ -486,13 +486,13 @@
       using __iter_concept = typename __iter_concept_impl<_Iter>::type;
 
   template<typename _In>
-    concept __indirectly_readable_impl = requires(const _In __in)
+    concept __indirectly_readable_impl = requires(const _In ___in)
       {
 	typename iter_value_t<_In>;
 	typename iter_reference_t<_In>;
 	typename iter_rvalue_reference_t<_In>;
-	{ *__in } -> same_as<iter_reference_t<_In>>;
-	{ ranges::iter_move(__in) } -> same_as<iter_rvalue_reference_t<_In>>;
+	{ *___in } -> same_as<iter_reference_t<_In>>;
+	{ ranges::iter_move(___in) } -> same_as<iter_rvalue_reference_t<_In>>;
       }
       && common_reference_with<iter_reference_t<_In>&&, iter_value_t<_In>&>
       && common_reference_with<iter_reference_t<_In>&&,
diff -adru a/libstdc++-v3/include/bits/locale_conv.h b/libstdc++-v3/include/bits/locale_conv.h
--- a/libstdc++-v3/include/bits/locale_conv.h	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/bits/locale_conv.h	2021-04-09 13:06:24.118223200 +0800
@@ -315,10 +315,10 @@
       {
 	if (!_M_with_cvtstate)
 	  _M_state = state_type();
-	wide_string __out{ _M_wide_err_string.get_allocator() };
-	if (__str_codecvt_in(__first, __last, __out, *_M_cvt, _M_state,
+	wide_string ___out{ _M_wide_err_string.get_allocator() };
+	if (__str_codecvt_in(__first, __last, ___out, *_M_cvt, _M_state,
 			     _M_count))
-	  return __out;
+	  return ___out;
 	if (_M_with_strings)
 	  return _M_wide_err_string;
 	__throw_range_error("wstring_convert::from_bytes");
@@ -351,10 +351,10 @@
       {
 	if (!_M_with_cvtstate)
 	  _M_state = state_type();
-	byte_string __out{ _M_byte_err_string.get_allocator() };
-	if (__str_codecvt_out(__first, __last, __out, *_M_cvt, _M_state,
+	byte_string ___out{ _M_byte_err_string.get_allocator() };
+	if (__str_codecvt_out(__first, __last, ___out, *_M_cvt, _M_state,
 			      _M_count))
-	  return __out;
+	  return ___out;
 	if (_M_with_strings)
 	  return _M_byte_err_string;
 	__throw_range_error("wstring_convert::to_bytes");
@@ -447,13 +447,13 @@
       { return _M_buf && _M_conv_put() && !_M_buf->pubsync() ? 0 : -1; }
 
       typename _Wide_streambuf::int_type
-      overflow(typename _Wide_streambuf::int_type __out)
+      overflow(typename _Wide_streambuf::int_type ___out)
       {
 	if (!_M_buf || !_M_conv_put())
 	  return _Tr::eof();
-	else if (!_Tr::eq_int_type(__out, _Tr::eof()))
-	  return this->sputc(__out);
-	return _Tr::not_eof(__out);
+	else if (!_Tr::eq_int_type(___out, _Tr::eof()))
+	  return this->sputc(___out);
+	return _Tr::not_eof(___out);
       }
 
       typename _Wide_streambuf::int_type
diff -adru a/libstdc++-v3/include/bits/locale_facets.h b/libstdc++-v3/include/bits/locale_facets.h
--- a/libstdc++-v3/include/bits/locale_facets.h	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/bits/locale_facets.h	2021-04-09 13:06:24.133848700 +0800
@@ -1988,7 +1988,7 @@
        *  except if the value is 1, sets @a v to true, if the value is 0, sets
        *  @a v to false, and otherwise set err to ios_base::failbit.
        *
-       *  @param  __in  Start of input stream.
+       *  @param  ___in  Start of input stream.
        *  @param  __end  End of input stream.
        *  @param  __io  Source of locale and flags.
        *  @param  __err  Error flags to set.
@@ -1996,9 +1996,9 @@
        *  @return  Iterator after reading.
       */
       iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
+      get(iter_type ___in, iter_type __end, ios_base& __io,
 	  ios_base::iostate& __err, bool& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
+      { return this->do_get(___in, __end, __io, __err, __v); }
 
       //@{
       /**
@@ -2025,7 +2025,7 @@
        *  Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
        *  Sets err to ios_base::eofbit if the stream is emptied.
        *
-       *  @param  __in  Start of input stream.
+       *  @param  ___in  Start of input stream.
        *  @param  __end  End of input stream.
        *  @param  __io  Source of locale and flags.
        *  @param  __err  Error flags to set.
@@ -2033,35 +2033,35 @@
        *  @return  Iterator after reading.
       */
       iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
+      get(iter_type ___in, iter_type __end, ios_base& __io,
 	  ios_base::iostate& __err, long& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
+      { return this->do_get(___in, __end, __io, __err, __v); }
 
       iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
+      get(iter_type ___in, iter_type __end, ios_base& __io,
 	  ios_base::iostate& __err, unsigned short& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
+      { return this->do_get(___in, __end, __io, __err, __v); }
 
       iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
+      get(iter_type ___in, iter_type __end, ios_base& __io,
 	  ios_base::iostate& __err, unsigned int& __v)   const
-      { return this->do_get(__in, __end, __io, __err, __v); }
+      { return this->do_get(___in, __end, __io, __err, __v); }
 
       iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
+      get(iter_type ___in, iter_type __end, ios_base& __io,
 	  ios_base::iostate& __err, unsigned long& __v)  const
-      { return this->do_get(__in, __end, __io, __err, __v); }
+      { return this->do_get(___in, __end, __io, __err, __v); }
 
 #ifdef _GLIBCXX_USE_LONG_LONG
       iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
+      get(iter_type ___in, iter_type __end, ios_base& __io,
 	  ios_base::iostate& __err, long long& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
+      { return this->do_get(___in, __end, __io, __err, __v); }
 
       iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
+      get(iter_type ___in, iter_type __end, ios_base& __io,
 	  ios_base::iostate& __err, unsigned long long& __v)  const
-      { return this->do_get(__in, __end, __io, __err, __v); }
+      { return this->do_get(___in, __end, __io, __err, __v); }
 #endif
       //@}
 
@@ -2085,7 +2085,7 @@
        *  Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
        *  Sets err to ios_base::eofbit if the stream is emptied.
        *
-       *  @param  __in  Start of input stream.
+       *  @param  ___in  Start of input stream.
        *  @param  __end  End of input stream.
        *  @param  __io  Source of locale and flags.
        *  @param  __err  Error flags to set.
@@ -2093,19 +2093,19 @@
        *  @return  Iterator after reading.
       */
       iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
+      get(iter_type ___in, iter_type __end, ios_base& __io,
 	  ios_base::iostate& __err, float& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
+      { return this->do_get(___in, __end, __io, __err, __v); }
 
       iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
+      get(iter_type ___in, iter_type __end, ios_base& __io,
 	  ios_base::iostate& __err, double& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
+      { return this->do_get(___in, __end, __io, __err, __v); }
 
       iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
+      get(iter_type ___in, iter_type __end, ios_base& __io,
 	  ios_base::iostate& __err, long double& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
+      { return this->do_get(___in, __end, __io, __err, __v); }
       //@}
 
       /**
@@ -2128,7 +2128,7 @@
        *  Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
        *  Sets err to ios_base::eofbit if the stream is emptied.
        *
-       *  @param  __in  Start of input stream.
+       *  @param  ___in  Start of input stream.
        *  @param  __end  End of input stream.
        *  @param  __io  Source of locale and flags.
        *  @param  __err  Error flags to set.
@@ -2136,9 +2136,9 @@
        *  @return  Iterator after reading.
       */
       iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
+      get(iter_type ___in, iter_type __end, ios_base& __io,
 	  ios_base::iostate& __err, void*& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
+      { return this->do_get(___in, __end, __io, __err, __v); }
 
     protected:
       /// Destructor.
diff -adru a/libstdc++-v3/include/bits/ostream.tcc b/libstdc++-v3/include/bits/ostream.tcc
--- a/libstdc++-v3/include/bits/ostream.tcc	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/bits/ostream.tcc	2021-04-09 13:06:24.133848700 +0800
@@ -318,10 +318,10 @@
 
   template<typename _CharT, typename _Traits>
     basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
+    operator<<(basic_ostream<_CharT, _Traits>& ___out, const char* __s)
     {
       if (!__s)
-	__out.setstate(ios_base::badbit);
+	___out.setstate(ios_base::badbit);
       else
 	{
 	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
@@ -339,18 +339,18 @@
 
 	      _CharT *__ws = __pg.__get();
 	      for (size_t  __i = 0; __i < __clen; ++__i)
-		__ws[__i] = __out.widen(__s[__i]);
-	      __ostream_insert(__out, __ws, __clen);
+		__ws[__i] = ___out.widen(__s[__i]);
+	      __ostream_insert(___out, __ws, __clen);
 	    }
 	  __catch(__cxxabiv1::__forced_unwind&)
 	    {
-	      __out._M_setstate(ios_base::badbit);
+	      ___out._M_setstate(ios_base::badbit);
 	      __throw_exception_again;
 	    }
 	  __catch(...)
-	    { __out._M_setstate(ios_base::badbit); }
+	    { ___out._M_setstate(ios_base::badbit); }
 	}
-      return __out;
+      return ___out;
     }
 
   // Inhibit implicit instantiations for required instantiations,
diff -adru a/libstdc++-v3/include/bits/ostream_insert.h b/libstdc++-v3/include/bits/ostream_insert.h
--- a/libstdc++-v3/include/bits/ostream_insert.h	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/bits/ostream_insert.h	2021-04-09 13:06:24.165094700 +0800
@@ -41,31 +41,31 @@
 
   template<typename _CharT, typename _Traits>
     inline void
-    __ostream_write(basic_ostream<_CharT, _Traits>& __out,
+    __ostream_write(basic_ostream<_CharT, _Traits>& ___out,
 		    const _CharT* __s, streamsize __n)
     {
       typedef basic_ostream<_CharT, _Traits>       __ostream_type;      
       typedef typename __ostream_type::ios_base    __ios_base;
 
-      const streamsize __put = __out.rdbuf()->sputn(__s, __n);
+      const streamsize __put = ___out.rdbuf()->sputn(__s, __n);
       if (__put != __n)
-	__out.setstate(__ios_base::badbit);
+	___out.setstate(__ios_base::badbit);
     }
 
   template<typename _CharT, typename _Traits>
     inline void
-    __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
+    __ostream_fill(basic_ostream<_CharT, _Traits>& ___out, streamsize __n)
     {
       typedef basic_ostream<_CharT, _Traits>       __ostream_type;      
       typedef typename __ostream_type::ios_base    __ios_base;
 
-      const _CharT __c = __out.fill();
+      const _CharT __c = ___out.fill();
       for (; __n > 0; --__n)
 	{
-	  const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
+	  const typename _Traits::int_type __put = ___out.rdbuf()->sputc(__c);
 	  if (_Traits::eq_int_type(__put, _Traits::eof()))
 	    {
-	      __out.setstate(__ios_base::badbit);
+	      ___out.setstate(__ios_base::badbit);
 	      break;
 	    }
 	}
@@ -73,43 +73,43 @@
 
   template<typename _CharT, typename _Traits>
     basic_ostream<_CharT, _Traits>&
-    __ostream_insert(basic_ostream<_CharT, _Traits>& __out,
+    __ostream_insert(basic_ostream<_CharT, _Traits>& ___out,
 		     const _CharT* __s, streamsize __n)
     {
       typedef basic_ostream<_CharT, _Traits>       __ostream_type;
       typedef typename __ostream_type::ios_base    __ios_base;
 
-      typename __ostream_type::sentry __cerb(__out);
+      typename __ostream_type::sentry __cerb(___out);
       if (__cerb)
 	{
 	  __try
 	    {
-	      const streamsize __w = __out.width();
+	      const streamsize __w = ___out.width();
 	      if (__w > __n)
 		{
-		  const bool __left = ((__out.flags()
+		  const bool __left = ((___out.flags()
 					& __ios_base::adjustfield)
 				       == __ios_base::left);
 		  if (!__left)
-		    __ostream_fill(__out, __w - __n);
-		  if (__out.good())
-		    __ostream_write(__out, __s, __n);
-		  if (__left && __out.good())
-		    __ostream_fill(__out, __w - __n);
+		    __ostream_fill(___out, __w - __n);
+		  if (___out.good())
+		    __ostream_write(___out, __s, __n);
+		  if (__left && ___out.good())
+		    __ostream_fill(___out, __w - __n);
 		}
 	      else
-		__ostream_write(__out, __s, __n);
-	      __out.width(0);
+		__ostream_write(___out, __s, __n);
+	      ___out.width(0);
 	    }
 	  __catch(__cxxabiv1::__forced_unwind&)
 	    {
-	      __out._M_setstate(__ios_base::badbit);
+	      ___out._M_setstate(__ios_base::badbit);
 	      __throw_exception_again;
 	    }
 	  __catch(...)
-	    { __out._M_setstate(__ios_base::badbit); }
+	    { ___out._M_setstate(__ios_base::badbit); }
 	}
-      return __out;
+      return ___out;
     }
 
   // Inhibit implicit instantiations for required instantiations,
diff -adru a/libstdc++-v3/include/bits/ranges_algo.h b/libstdc++-v3/include/bits/ranges_algo.h
--- a/libstdc++-v3/include/bits/ranges_algo.h	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/bits/ranges_algo.h	2021-04-09 13:06:24.180713200 +0800
@@ -1752,7 +1752,7 @@
 	&& indirectly_copyable<_Iter, _Out>
 	&& uniform_random_bit_generator<remove_reference_t<_Gen>>
       _Out
-      operator()(_Iter __first, _Sent __last, _Out __out,
+      operator()(_Iter __first, _Sent __last, _Out ___out,
 		 iter_difference_t<_Iter> __n, _Gen&& __g) const
       {
 	if constexpr (forward_iterator<_Iter>)
@@ -1761,7 +1761,7 @@
 	    // which may take linear time.
 	    auto __lasti = ranges::next(__first, __last);
 	    return std::sample(std::move(__first), std::move(__lasti),
-			       std::move(__out), __n, std::forward<_Gen>(__g));
+			       std::move(___out), __n, std::forward<_Gen>(__g));
 	  }
 	else
 	  {
@@ -1772,7 +1772,7 @@
 	    iter_difference_t<_Iter> __sample_sz = 0;
 	    while (__first != __last && __sample_sz != __n)
 	      {
-		__out[__sample_sz++] = *__first;
+		___out[__sample_sz++] = *__first;
 		++__first;
 	      }
 	    for (auto __pop_sz = __sample_sz; __first != __last;
@@ -1780,9 +1780,9 @@
 	      {
 		const auto __k = __d(__g, __param_type{0, __pop_sz});
 		if (__k < __n)
-		  __out[__k] = *__first;
+		  ___out[__k] = *__first;
 	      }
-	    return __out + __sample_sz;
+	    return ___out + __sample_sz;
 	  }
       }
 
@@ -1791,11 +1791,11 @@
 	&& indirectly_copyable<iterator_t<_Range>, _Out>
 	&& uniform_random_bit_generator<remove_reference_t<_Gen>>
       _Out
-      operator()(_Range&& __r, _Out __out,
+      operator()(_Range&& __r, _Out ___out,
 		 range_difference_t<_Range> __n, _Gen&& __g) const
       {
 	return (*this)(ranges::begin(__r), ranges::end(__r),
-		       std::move(__out), __n,
+		       std::move(___out), __n,
 		       std::forward<_Gen>(__g));
       }
   };
@@ -2172,11 +2172,11 @@
 				      projected<iterator_t<_Range2>, _Proj2>>
       constexpr partial_sort_copy_result<borrowed_iterator_t<_Range1>,
 					 borrowed_iterator_t<_Range2>>
-      operator()(_Range1&& __r, _Range2&& __out, _Comp __comp = {},
+      operator()(_Range1&& __r, _Range2&& ___out, _Comp __comp = {},
 		 _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
       {
 	return (*this)(ranges::begin(__r), ranges::end(__r),
-		       ranges::begin(__out), ranges::end(__out),
+		       ranges::begin(___out), ranges::end(___out),
 		       std::move(__comp),
 		       std::move(__proj1), std::move(__proj2));
       }
diff -adru a/libstdc++-v3/include/bits/ranges_algobase.h b/libstdc++-v3/include/bits/ranges_algobase.h
--- a/libstdc++-v3/include/bits/ranges_algobase.h	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/bits/ranges_algobase.h	2021-04-09 13:06:24.211960800 +0800
@@ -219,34 +219,34 @@
       using __detail::__is_normal_iterator;
       if constexpr (__is_move_iterator<_Iter> && same_as<_Iter, _Sent>)
 	{
-	  auto [__in, __out]
+	  auto [___in, ___out]
 	    = ranges::__copy_or_move<true>(std::move(__first).base(),
 					   std::move(__last).base(),
 					   std::move(__result));
-	  return {move_iterator{std::move(__in)}, std::move(__out)};
+	  return {move_iterator{std::move(___in)}, std::move(___out)};
 	}
       else if constexpr (__is_reverse_iterator<_Iter> && same_as<_Iter, _Sent>
 			 && __is_reverse_iterator<_Out>)
 	{
-	  auto [__in,__out]
+	  auto [___in,___out]
 	    = ranges::__copy_or_move_backward<_IsMove>(std::move(__last).base(),
 						       std::move(__first).base(),
 						       std::move(__result).base());
-	  return {reverse_iterator{std::move(__in)},
-		  reverse_iterator{std::move(__out)}};
+	  return {reverse_iterator{std::move(___in)},
+		  reverse_iterator{std::move(___out)}};
 	}
       else if constexpr (__is_normal_iterator<_Iter> && same_as<_Iter, _Sent>)
 	{
-	  auto [__in,__out]
+	  auto [___in,___out]
 	    = ranges::__copy_or_move<_IsMove>(__first.base(), __last.base(),
 					      __result);
-	  return {decltype(__first){__in}, std::move(__out)};
+	  return {decltype(__first){___in}, std::move(___out)};
 	}
       else if constexpr (__is_normal_iterator<_Out>)
 	{
-	  auto [__in,__out]
+	  auto [___in,___out]
 	    = ranges::__copy_or_move<_IsMove>(__first, __last, __result.base());
-	  return {std::move(__in), decltype(__result){__out}};
+	  return {std::move(___in), decltype(__result){___out}};
 	}
       else if constexpr (sized_sentinel_for<_Sent, _Iter>)
 	{
@@ -362,28 +362,28 @@
       if constexpr (__is_reverse_iterator<_Iter> && same_as<_Iter, _Sent>
 		    && __is_reverse_iterator<_Out>)
 	{
-	  auto [__in,__out]
+	  auto [___in,___out]
 	    = ranges::__copy_or_move<_IsMove>(std::move(__last).base(),
 					      std::move(__first).base(),
 					      std::move(__result).base());
-	  return {reverse_iterator{std::move(__in)},
-		  reverse_iterator{std::move(__out)}};
+	  return {reverse_iterator{std::move(___in)},
+		  reverse_iterator{std::move(___out)}};
 	}
       else if constexpr (__is_normal_iterator<_Iter> && same_as<_Iter, _Sent>)
 	{
-	  auto [__in,__out]
+	  auto [___in,___out]
 	    = ranges::__copy_or_move_backward<_IsMove>(__first.base(),
 						       __last.base(),
 						       std::move(__result));
-	  return {decltype(__first){__in}, std::move(__out)};
+	  return {decltype(__first){___in}, std::move(___out)};
 	}
       else if constexpr (__is_normal_iterator<_Out>)
 	{
-	  auto [__in,__out]
+	  auto [___in,___out]
 	    = ranges::__copy_or_move_backward<_IsMove>(std::move(__first),
 						       std::move(__last),
 						       __result.base());
-	  return {std::move(__in), decltype(__result){__out}};
+	  return {std::move(___in), decltype(__result){___out}};
 	}
       else if constexpr (sized_sentinel_for<_Sent, _Iter>)
 	{
diff -adru a/libstdc++-v3/include/bits/ranges_uninitialized.h b/libstdc++-v3/include/bits/ranges_uninitialized.h
--- a/libstdc++-v3/include/bits/ranges_uninitialized.h	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/bits/ranges_uninitialized.h	2021-04-09 13:06:24.227577300 +0800
@@ -361,10 +361,10 @@
 	  {
 	    auto __d1 = __ilast - __ifirst;
 	    auto __d2 = __olast - __ofirst;
-	    auto [__in, __out]
+	    auto [___in, ___out]
 	      = ranges::copy_n(std::make_move_iterator(std::move(__ifirst)),
 			       std::min(__d1, __d2), __ofirst);
-	    return {std::move(__in).base(), __out};
+	    return {std::move(___in).base(), ___out};
 	  }
 	else
 	  {
@@ -412,10 +412,10 @@
 						 iter_rvalue_reference_t<_Iter>>)
 	  {
 	    auto __d = __olast - __ofirst;
-	    auto [__in, __out]
+	    auto [___in, ___out]
 	      = ranges::copy_n(std::make_move_iterator(std::move(__ifirst)),
 			       std::min(__n, __d), __ofirst);
-	    return {std::move(__in).base(), __out};
+	    return {std::move(___in).base(), ___out};
 	  }
 	else
 	  {
diff -adru a/libstdc++-v3/include/bits/regex.h b/libstdc++-v3/include/bits/regex.h
--- a/libstdc++-v3/include/bits/regex.h	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/bits/regex.h	2021-04-09 13:06:24.258821000 +0800
@@ -1946,7 +1946,7 @@
        */
       template<typename _Out_iter>
 	_Out_iter
-	format(_Out_iter __out, const char_type* __fmt_first,
+	format(_Out_iter ___out, const char_type* __fmt_first,
 	       const char_type* __fmt_last,
 	       match_flag_type __flags = regex_constants::format_default) const;
 
@@ -1955,10 +1955,10 @@
        */
       template<typename _Out_iter, typename _St, typename _Sa>
 	_Out_iter
-	format(_Out_iter __out, const basic_string<char_type, _St, _Sa>& __fmt,
+	format(_Out_iter ___out, const basic_string<char_type, _St, _Sa>& __fmt,
 	       match_flag_type __flags = regex_constants::format_default) const
 	{
-	  return format(__out, __fmt.data(), __fmt.data() + __fmt.size(),
+	  return format(___out, __fmt.data(), __fmt.data() + __fmt.size(),
 			__flags);
 	}
 
@@ -2460,46 +2460,46 @@
   /**
    * @brief Search for a regular expression within a range for multiple times,
    and replace the matched parts through filling a format string.
-   * @param __out   [OUT] The output iterator.
+   * @param ___out   [OUT] The output iterator.
    * @param __first [IN]  The start of the string to search.
    * @param __last  [IN]  One-past-the-end of the string to search.
    * @param __e     [IN]  The regular expression to search for.
    * @param __fmt   [IN]  The format string.
    * @param __flags [IN]  Search and replace policy flags.
    *
-   * @returns __out
+   * @returns ___out
    * @throws an exception of type regex_error.
    */
   template<typename _Out_iter, typename _Bi_iter,
 	   typename _Rx_traits, typename _Ch_type,
 	   typename _St, typename _Sa>
     inline _Out_iter
-    regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
+    regex_replace(_Out_iter ___out, _Bi_iter __first, _Bi_iter __last,
 		  const basic_regex<_Ch_type, _Rx_traits>& __e,
 		  const basic_string<_Ch_type, _St, _Sa>& __fmt,
 		  regex_constants::match_flag_type __flags
 		  = regex_constants::match_default)
     {
-      return regex_replace(__out, __first, __last, __e, __fmt.c_str(), __flags);
+      return regex_replace(___out, __first, __last, __e, __fmt.c_str(), __flags);
     }
 
   /**
    * @brief Search for a regular expression within a range for multiple times,
    and replace the matched parts through filling a format C-string.
-   * @param __out   [OUT] The output iterator.
+   * @param ___out   [OUT] The output iterator.
    * @param __first [IN]  The start of the string to search.
    * @param __last  [IN]  One-past-the-end of the string to search.
    * @param __e     [IN]  The regular expression to search for.
    * @param __fmt   [IN]  The format C-string.
    * @param __flags [IN]  Search and replace policy flags.
    *
-   * @returns __out
+   * @returns ___out
    * @throws an exception of type regex_error.
    */
   template<typename _Out_iter, typename _Bi_iter,
 	   typename _Rx_traits, typename _Ch_type>
     _Out_iter
-    regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
+    regex_replace(_Out_iter ___out, _Bi_iter __first, _Bi_iter __last,
 		  const basic_regex<_Ch_type, _Rx_traits>& __e,
 		  const _Ch_type* __fmt,
 		  regex_constants::match_flag_type __flags
diff -adru a/libstdc++-v3/include/bits/regex.tcc b/libstdc++-v3/include/bits/regex.tcc
--- a/libstdc++-v3/include/bits/regex.tcc	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/bits/regex.tcc	2021-04-09 13:06:24.274441600 +0800
@@ -352,7 +352,7 @@
   template<typename _Out_iter>
     _Out_iter
     match_results<_Bi_iter, _Alloc>::
-    format(_Out_iter __out,
+    format(_Out_iter ___out,
 	   const match_results<_Bi_iter, _Alloc>::char_type* __fmt_first,
 	   const match_results<_Bi_iter, _Alloc>::char_type* __fmt_last,
 	   match_flag_type __flags) const
@@ -367,7 +367,7 @@
 	{
 	  auto& __sub = (*this)[__idx];
 	  if (__sub.matched)
-	    __out = std::copy(__sub.first, __sub.second, __out);
+	    ___out = std::copy(__sub.first, __sub.second, ___out);
 	};
 
       if (__flags & regex_constants::format_sed)
@@ -381,7 +381,7 @@
 		  if (__fctyp.is(__ctype_type::digit, *__fmt_first))
 		    __output(__traits.value(*__fmt_first, 10));
 		  else
-		    *__out++ = *__fmt_first;
+		    *___out++ = *__fmt_first;
 		  continue;
 		}
 	      if (*__fmt_first == '\\')
@@ -394,10 +394,10 @@
 		  __output(0);
 		  continue;
 		}
-	      *__out++ = *__fmt_first;
+	      *___out++ = *__fmt_first;
 	    }
 	  if (__escaping)
-	    *__out++ = '\\';
+	    *___out++ = '\\';
 	}
       else
 	{
@@ -407,7 +407,7 @@
 	      if (__next == __fmt_last)
 		break;
 
-	      __out = std::copy(__fmt_first, __next, __out);
+	      ___out = std::copy(__fmt_first, __next, ___out);
 
 	      auto __eat = [&](char __ch) -> bool
 		{
@@ -420,22 +420,22 @@
 		};
 
 	      if (++__next == __fmt_last)
-		*__out++ = '$';
+		*___out++ = '$';
 	      else if (__eat('$'))
-		*__out++ = '$';
+		*___out++ = '$';
 	      else if (__eat('&'))
 		__output(0);
 	      else if (__eat('`'))
 		{
 		  auto& __sub = _M_prefix();
 		  if (__sub.matched)
-		    __out = std::copy(__sub.first, __sub.second, __out);
+		    ___out = std::copy(__sub.first, __sub.second, ___out);
 		}
 	      else if (__eat('\''))
 		{
 		  auto& __sub = _M_suffix();
 		  if (__sub.matched)
-		    __out = std::copy(__sub.first, __sub.second, __out);
+		    ___out = std::copy(__sub.first, __sub.second, ___out);
 		}
 	      else if (__fctyp.is(__ctype_type::digit, *__next))
 		{
@@ -450,18 +450,18 @@
 		    __output(__num);
 		}
 	      else
-		*__out++ = '$';
+		*___out++ = '$';
 	      __fmt_first = __next;
 	    }
-	  __out = std::copy(__fmt_first, __fmt_last, __out);
+	  ___out = std::copy(__fmt_first, __fmt_last, ___out);
 	}
-      return __out;
+      return ___out;
     }
 
   template<typename _Out_iter, typename _Bi_iter,
 	   typename _Rx_traits, typename _Ch_type>
     _Out_iter
-    regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
+    regex_replace(_Out_iter ___out, _Bi_iter __first, _Bi_iter __last,
 		  const basic_regex<_Ch_type, _Rx_traits>& __e,
 		  const _Ch_type* __fmt,
 		  regex_constants::match_flag_type __flags)
@@ -472,7 +472,7 @@
       if (__i == __end)
 	{
 	  if (!(__flags & regex_constants::format_no_copy))
-	    __out = std::copy(__first, __last, __out);
+	    ___out = std::copy(__first, __last, ___out);
 	}
       else
 	{
@@ -481,17 +481,17 @@
 	  for (; __i != __end; ++__i)
 	    {
 	      if (!(__flags & regex_constants::format_no_copy))
-		__out = std::copy(__i->prefix().first, __i->prefix().second,
-				  __out);
-	      __out = __i->format(__out, __fmt, __fmt + __len, __flags);
+		___out = std::copy(__i->prefix().first, __i->prefix().second,
+				  ___out);
+	      ___out = __i->format(___out, __fmt, __fmt + __len, __flags);
 	      __last = __i->suffix();
 	      if (__flags & regex_constants::format_first_only)
 		break;
 	    }
 	  if (!(__flags & regex_constants::format_no_copy))
-	    __out = std::copy(__last.first, __last.second, __out);
+	    ___out = std::copy(__last.first, __last.second, ___out);
 	}
-      return __out;
+      return ___out;
     }
 
   template<typename _Bi_iter,
diff -adru a/libstdc++-v3/include/bits/stl_algo.h b/libstdc++-v3/include/bits/stl_algo.h
--- a/libstdc++-v3/include/bits/stl_algo.h	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/bits/stl_algo.h	2021-04-09 13:06:24.290065600 +0800
@@ -5765,7 +5765,7 @@
            typename _Size, typename _UniformRandomBitGenerator>
     _RandomAccessIterator
     __sample(_InputIterator __first, _InputIterator __last, input_iterator_tag,
-	     _RandomAccessIterator __out, random_access_iterator_tag,
+	     _RandomAccessIterator ___out, random_access_iterator_tag,
 	     _Size __n, _UniformRandomBitGenerator&& __g)
     {
       using __distrib_type = uniform_int_distribution<_Size>;
@@ -5774,7 +5774,7 @@
       _Size __sample_sz = 0;
       while (__first != __last && __sample_sz != __n)
 	{
-	  __out[__sample_sz++] = *__first;
+	  ___out[__sample_sz++] = *__first;
 	  ++__first;
 	}
       for (auto __pop_sz = __sample_sz; __first != __last;
@@ -5782,9 +5782,9 @@
 	{
 	  const auto __k = __d(__g, __param_type{0, __pop_sz});
 	  if (__k < __n)
-	    __out[__k] = *__first;
+	    ___out[__k] = *__first;
 	}
-      return __out + __sample_sz;
+      return ___out + __sample_sz;
     }
 
   /// Selection sampling algorithm.
@@ -5793,7 +5793,7 @@
     _OutputIterator
     __sample(_ForwardIterator __first, _ForwardIterator __last,
 	     forward_iterator_tag,
-	     _OutputIterator __out, _Cat,
+	     _OutputIterator ___out, _Cat,
 	     _Size __n, _UniformRandomBitGenerator&& __g)
     {
       using __distrib_type = uniform_int_distribution<_Size>;
@@ -5803,7 +5803,7 @@
       using __uc_type = common_type_t<typename _Gen::result_type, _USize>;
 
       if (__first == __last)
-	return __out;
+	return ___out;
 
       __distrib_type __d{};
       _Size __unsampled_sz = std::distance(__first, __last);
@@ -5825,7 +5825,7 @@
 	      --__unsampled_sz;
 	      if (__p.first < __n)
 		{
-		  *__out++ = *__first;
+		  *___out++ = *__first;
 		  --__n;
 		}
 
@@ -5836,7 +5836,7 @@
 	      --__unsampled_sz;
 	      if (__p.second < __n)
 		{
-		  *__out++ = *__first;
+		  *___out++ = *__first;
 		  --__n;
 		}
 
@@ -5849,10 +5849,10 @@
       for (; __n != 0; ++__first)
 	if (__d(__g, __param_type{0, --__unsampled_sz}) < __n)
 	  {
-	    *__out++ = *__first;
+	    *___out++ = *__first;
 	    --__n;
 	  }
-      return __out;
+      return ___out;
     }
 
 #if __cplusplus > 201402L
@@ -5862,7 +5862,7 @@
            typename _Distance, typename _UniformRandomBitGenerator>
     _SampleIterator
     sample(_PopulationIterator __first, _PopulationIterator __last,
-	   _SampleIterator __out, _Distance __n,
+	   _SampleIterator ___out, _Distance __n,
 	   _UniformRandomBitGenerator&& __g)
     {
       using __pop_cat = typename
@@ -5881,7 +5881,7 @@
 
       typename iterator_traits<_PopulationIterator>::difference_type __d = __n;
       return _GLIBCXX_STD_A::
-	__sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d,
+	__sample(__first, __last, __pop_cat{}, ___out, __samp_cat{}, __d,
 		 std::forward<_UniformRandomBitGenerator>(__g));
     }
 #endif // C++17
diff -adru a/libstdc++-v3/include/experimental/algorithm b/libstdc++-v3/include/experimental/algorithm
--- a/libstdc++-v3/include/experimental/algorithm	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/experimental/algorithm	2021-04-09 13:06:24.321284500 +0800
@@ -59,7 +59,7 @@
            typename _Distance, typename _UniformRandomNumberGenerator>
     _SampleIterator
     sample(_PopulationIterator __first, _PopulationIterator __last,
-	   _SampleIterator __out, _Distance __n,
+	   _SampleIterator ___out, _Distance __n,
 	   _UniformRandomNumberGenerator&& __g)
     {
       using __pop_cat = typename
@@ -78,7 +78,7 @@
 
       typename iterator_traits<_PopulationIterator>::difference_type __d = __n;
       return _GLIBCXX_STD_A::
-	__sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d,
+	__sample(__first, __last, __pop_cat{}, ___out, __samp_cat{}, __d,
 		 std::forward<_UniformRandomNumberGenerator>(__g));
     }
 
@@ -86,9 +86,9 @@
            typename _Distance>
     inline _SampleIterator
     sample(_PopulationIterator __first, _PopulationIterator __last,
-	   _SampleIterator __out, _Distance __n)
+	   _SampleIterator ___out, _Distance __n)
     {
-      return experimental::sample(__first, __last, __out, __n,
+      return experimental::sample(__first, __last, ___out, __n,
 				  _S_randint_engine());
     }
 
diff -adru a/libstdc++-v3/include/experimental/internet b/libstdc++-v3/include/experimental/internet
--- a/libstdc++-v3/include/experimental/internet	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/experimental/internet	2021-04-09 13:06:24.321284500 +0800
@@ -751,9 +751,9 @@
     if (__p == nullptr)
       return __make_address_v6(__str, nullptr, __ec);
     char __buf[64];
-    char* __out = __buf;
+    char* ___out = __buf;
     bool __skip_leading_zero = true;
-    while (__str < __p && __out < std::end(__buf))
+    while (__str < __p && ___out < std::end(__buf))
       {
 	if (!__skip_leading_zero || *__str != '0')
 	  {
@@ -761,18 +761,18 @@
 	      __skip_leading_zero = true;
 	    else
 	      __skip_leading_zero = false;
-	    *__out = *__str;
+	    *___out = *__str;
 	  }
 	__str++;
       }
-    if (__out == std::end(__buf))
+    if (___out == std::end(__buf))
       {
 	__ec = std::make_error_code(std::errc::invalid_argument);
 	return {};
       }
     else
       {
-	*__out = '\0';
+	*___out = '\0';
 	return __make_address_v6(__buf, __p + 1, __ec);
       }
   }
@@ -788,10 +788,10 @@
     if (__pos == string::npos)
       return __make_address_v6(__str.c_str(), nullptr, __ec);
     char __buf[64];
-    char* __out = __buf;
+    char* ___out = __buf;
     bool __skip_leading_zero = true;
     size_t __n = 0;
-    while (__n < __pos && __out < std::end(__buf))
+    while (__n < __pos && ___out < std::end(__buf))
       {
 	if (!__skip_leading_zero || __str[__n] != '0')
 	  {
@@ -799,18 +799,18 @@
 	      __skip_leading_zero = true;
 	    else
 	      __skip_leading_zero = false;
-	    *__out = __str[__n];
+	    *___out = __str[__n];
 	  }
 	__n++;
       }
-    if (__out == std::end(__buf))
+    if (___out == std::end(__buf))
       {
 	__ec = std::make_error_code(std::errc::invalid_argument);
 	return {};
       }
     else
       {
-	*__out = '\0';
+	*___out = '\0';
 	return __make_address_v6(__buf, __str.c_str() + __pos + 1, __ec);
       }
   }
@@ -823,20 +823,20 @@
   make_address_v6(string_view __str, error_code& __ec) noexcept
   {
     char __buf[64];
-    char* __out = __buf;
+    char* ___out = __buf;
     char* __scope = nullptr;
     bool __skip_leading_zero = true;
     size_t __n = 0;
-    while (__n < __str.length() && __out < std::end(__buf))
+    while (__n < __str.length() && ___out < std::end(__buf))
       {
 	if (__str[__n] == '%')
 	  {
 	    if (__scope)
-	      __out = std::end(__buf);
+	      ___out = std::end(__buf);
 	    else
 	      {
-		*__out = '\0';
-		__scope = ++__out;
+		*___out = '\0';
+		__scope = ++___out;
 		__skip_leading_zero = true;
 	      }
 	  }
@@ -846,19 +846,19 @@
 	      __skip_leading_zero = true;
 	    else
 	      __skip_leading_zero = false;
-	    *__out = __str[__n];
-	    __out++;
+	    *___out = __str[__n];
+	    ___out++;
 	  }
 	__n++;
       }
-    if (__out == std::end(__buf))
+    if (___out == std::end(__buf))
       {
 	__ec = std::make_error_code(std::errc::invalid_argument);
 	return {};
       }
     else
       {
-	*__out = '\0';
+	*___out = '\0';
 	return __make_address_v6(__buf, __scope, __ec);
       }
   }
diff -adru a/libstdc++-v3/include/ext/algorithm b/libstdc++-v3/include/ext/algorithm
--- a/libstdc++-v3/include/ext/algorithm	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/ext/algorithm	2021-04-09 13:06:24.336926700 +0800
@@ -258,7 +258,7 @@
 	   typename _Distance>
     _OutputIterator
     random_sample_n(_ForwardIterator __first, _ForwardIterator __last,
-                    _OutputIterator __out, const _Distance __n)
+                    _OutputIterator ___out, const _Distance __n)
     {
       // concept requirements
       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
@@ -273,14 +273,14 @@
 	{
 	  if ((std::rand() % __remaining) < __m)
 	    {
-	      *__out = *__first;
-	      ++__out;
+	      *___out = *__first;
+	      ++___out;
 	      --__m;
 	    }
 	  --__remaining;
 	  ++__first;
 	}
-      return __out;
+      return ___out;
     }
 
   /**
@@ -292,7 +292,7 @@
 	   typename _Distance, typename _RandomNumberGenerator>
     _OutputIterator
     random_sample_n(_ForwardIterator __first, _ForwardIterator __last,
-                   _OutputIterator __out, const _Distance __n,
+                   _OutputIterator ___out, const _Distance __n,
 		   _RandomNumberGenerator& __rand)
     {
       // concept requirements
@@ -310,44 +310,44 @@
 	{
 	  if (__rand(__remaining) < __m)
 	    {
-	      *__out = *__first;
-	      ++__out;
+	      *___out = *__first;
+	      ++___out;
 	      --__m;
 	    }
 	  --__remaining;
 	  ++__first;
 	}
-      return __out;
+      return ___out;
     }
 
   template<typename _InputIterator, typename _RandomAccessIterator,
 	   typename _Distance>
     _RandomAccessIterator
     __random_sample(_InputIterator __first, _InputIterator __last,
-		    _RandomAccessIterator __out,
+		    _RandomAccessIterator ___out,
 		    const _Distance __n)
     {
       _Distance __m = 0;
       _Distance __t = __n;
       for ( ; __first != __last && __m < __n; ++__m, ++__first)
-	__out[__m] = *__first;
+	___out[__m] = *__first;
 
       while (__first != __last)
 	{
 	  ++__t;
 	  _Distance __M = std::rand() % (__t);
 	  if (__M < __n)
-	    __out[__M] = *__first;
+	    ___out[__M] = *__first;
 	  ++__first;
 	}
-      return __out + __m;
+      return ___out + __m;
     }
 
   template<typename _InputIterator, typename _RandomAccessIterator,
 	   typename _RandomNumberGenerator, typename _Distance>
     _RandomAccessIterator
     __random_sample(_InputIterator __first, _InputIterator __last,
-		    _RandomAccessIterator __out,
+		    _RandomAccessIterator ___out,
 		    _RandomNumberGenerator& __rand,
 		    const _Distance __n)
     {
@@ -358,17 +358,17 @@
       _Distance __m = 0;
       _Distance __t = __n;
       for ( ; __first != __last && __m < __n; ++__m, ++__first)
-	__out[__m] = *__first;
+	___out[__m] = *__first;
 
       while (__first != __last)
 	{
 	  ++__t;
 	  _Distance __M = __rand(__t);
 	  if (__M < __n)
-	    __out[__M] = *__first;
+	    ___out[__M] = *__first;
 	  ++__first;
 	}
-      return __out + __m;
+      return ___out + __m;
     }
 
   /**
diff -adru a/libstdc++-v3/include/ext/pb_ds/detail/debug_map_base.hpp b/libstdc++-v3/include/ext/pb_ds/detail/debug_map_base.hpp
--- a/libstdc++-v3/include/ext/pb_ds/detail/debug_map_base.hpp	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/ext/pb_ds/detail/debug_map_base.hpp	2021-04-09 13:06:24.352521200 +0800
@@ -57,9 +57,9 @@
     // Need std::pair ostream extractor.
     template<typename _CharT, typename _Traits, typename _Tp1, typename _Tp2>
     inline std::basic_ostream<_CharT, _Traits>&
-    operator<<(std::basic_ostream<_CharT, _Traits>& __out,
+    operator<<(std::basic_ostream<_CharT, _Traits>& ___out,
 	       const std::pair<_Tp1, _Tp2>& p)
-    { return (__out << '(' << p.first << ',' << p.second << ')'); }
+    { return (___out << '(' << p.first << ',' << p.second << ')'); }
 
 #define PB_DS_CLASS_T_DEC \
     template<typename Key, typename Eq_Fn, typename Const_Key_Reference>
diff -adru a/libstdc++-v3/include/ext/random.tcc b/libstdc++-v3/include/ext/random.tcc
--- a/libstdc++-v3/include/ext/random.tcc	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/ext/random.tcc	2021-04-09 13:06:24.368141600 +0800
@@ -208,38 +208,38 @@
   namespace {
 
     template<size_t __shift>
-      inline void __rshift(uint32_t *__out, const uint32_t *__in)
+      inline void __rshift(uint32_t *___out, const uint32_t *___in)
       {
-	uint64_t __th = ((static_cast<uint64_t>(__in[3]) << 32)
-			 | static_cast<uint64_t>(__in[2]));
-	uint64_t __tl = ((static_cast<uint64_t>(__in[1]) << 32)
-			 | static_cast<uint64_t>(__in[0]));
+	uint64_t __th = ((static_cast<uint64_t>(___in[3]) << 32)
+			 | static_cast<uint64_t>(___in[2]));
+	uint64_t __tl = ((static_cast<uint64_t>(___in[1]) << 32)
+			 | static_cast<uint64_t>(___in[0]));
 
 	uint64_t __oh = __th >> (__shift * 8);
 	uint64_t __ol = __tl >> (__shift * 8);
 	__ol |= __th << (64 - __shift * 8);
-	__out[1] = static_cast<uint32_t>(__ol >> 32);
-	__out[0] = static_cast<uint32_t>(__ol);
-	__out[3] = static_cast<uint32_t>(__oh >> 32);
-	__out[2] = static_cast<uint32_t>(__oh);
+	___out[1] = static_cast<uint32_t>(__ol >> 32);
+	___out[0] = static_cast<uint32_t>(__ol);
+	___out[3] = static_cast<uint32_t>(__oh >> 32);
+	___out[2] = static_cast<uint32_t>(__oh);
       }
 
 
     template<size_t __shift>
-      inline void __lshift(uint32_t *__out, const uint32_t *__in)
+      inline void __lshift(uint32_t *___out, const uint32_t *___in)
       {
-	uint64_t __th = ((static_cast<uint64_t>(__in[3]) << 32)
-			 | static_cast<uint64_t>(__in[2]));
-	uint64_t __tl = ((static_cast<uint64_t>(__in[1]) << 32)
-			 | static_cast<uint64_t>(__in[0]));
+	uint64_t __th = ((static_cast<uint64_t>(___in[3]) << 32)
+			 | static_cast<uint64_t>(___in[2]));
+	uint64_t __tl = ((static_cast<uint64_t>(___in[1]) << 32)
+			 | static_cast<uint64_t>(___in[0]));
 
 	uint64_t __oh = __th << (__shift * 8);
 	uint64_t __ol = __tl << (__shift * 8);
 	__oh |= __tl >> (64 - __shift * 8);
-	__out[1] = static_cast<uint32_t>(__ol >> 32);
-	__out[0] = static_cast<uint32_t>(__ol);
-	__out[3] = static_cast<uint32_t>(__oh >> 32);
-	__out[2] = static_cast<uint32_t>(__oh);
+	___out[1] = static_cast<uint32_t>(__ol >> 32);
+	___out[0] = static_cast<uint32_t>(__ol);
+	___out[3] = static_cast<uint32_t>(__oh >> 32);
+	___out[2] = static_cast<uint32_t>(__oh);
       }
 
 
diff -adru a/libstdc++-v3/include/ext/vstring.tcc b/libstdc++-v3/include/ext/vstring.tcc
--- a/libstdc++-v3/include/ext/vstring.tcc	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/ext/vstring.tcc	2021-04-09 13:06:24.399411900 +0800
@@ -549,7 +549,7 @@
   template<typename _CharT, typename _Traits, typename _Alloc,
            template <typename, typename, typename> class _Base>
     basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __in,
+    operator>>(basic_istream<_CharT, _Traits>& ___in,
 	       __gnu_cxx::__versa_string<_CharT, _Traits,
 	                                 _Alloc, _Base>& __str)
     {
@@ -564,7 +564,7 @@
 
       __size_type __extracted = 0;
       typename __ios_base::iostate __err = __ios_base::goodbit;
-      typename __istream_type::sentry __cerb(__in, false);
+      typename __istream_type::sentry __cerb(___in, false);
       if (__cerb)
 	{
 	  __try
@@ -573,12 +573,12 @@
 	      __str.erase();
 	      _CharT __buf[128];
 	      __size_type __len = 0;
-	      const streamsize __w = __in.width();
+	      const streamsize __w = ___in.width();
 	      const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
 		                              : __str.max_size();
-	      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+	      const __ctype_type& __ct = use_facet<__ctype_type>(___in.getloc());
 	      const __int_type __eof = _Traits::eof();
-	      __int_type __c = __in.rdbuf()->sgetc();
+	      __int_type __c = ___in.rdbuf()->sgetc();
 
 	      while (__extracted < __n
 		     && !_Traits::eq_int_type(__c, __eof)
@@ -592,17 +592,17 @@
 		    }
 		  __buf[__len++] = _Traits::to_char_type(__c);
 		  ++__extracted;
-		  __c = __in.rdbuf()->snextc();
+		  __c = ___in.rdbuf()->snextc();
 		}
 	      __str.append(__buf, __len);
 
 	      if (_Traits::eq_int_type(__c, __eof))
 		__err |= __ios_base::eofbit;
-	      __in.width(0);
+	      ___in.width(0);
 	    }
 	  __catch(__cxxabiv1::__forced_unwind&)
 	    {
-	      __in._M_setstate(__ios_base::badbit);
+	      ___in._M_setstate(__ios_base::badbit);
 	      __throw_exception_again;
 	    }
 	  __catch(...)
@@ -610,21 +610,21 @@
 	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
 	      // 91. Description of operator>> and getline() for string<>
 	      // might cause endless loop
-	      __in._M_setstate(__ios_base::badbit);
+	      ___in._M_setstate(__ios_base::badbit);
 	    }
 	}
       // 211.  operator>>(istream&, string&) doesn't set failbit
       if (!__extracted)
 	__err |= __ios_base::failbit;
       if (__err)
-	__in.setstate(__err);
-      return __in;
+	___in.setstate(__err);
+      return ___in;
     }      
 
   template<typename _CharT, typename _Traits, typename _Alloc,
            template <typename, typename, typename> class _Base>
     basic_istream<_CharT, _Traits>&
-    getline(basic_istream<_CharT, _Traits>& __in,
+    getline(basic_istream<_CharT, _Traits>& ___in,
 	    __gnu_cxx::__versa_string<_CharT, _Traits, _Alloc, _Base>& __str,
 	    _CharT __delim)
     {
@@ -638,7 +638,7 @@
       __size_type __extracted = 0;
       const __size_type __n = __str.max_size();
       typename __ios_base::iostate __err = __ios_base::goodbit;
-      typename __istream_type::sentry __cerb(__in, true);
+      typename __istream_type::sentry __cerb(___in, true);
       if (__cerb)
 	{
 	  __try
@@ -649,7 +649,7 @@
 	      __size_type __len = 0;
 	      const __int_type __idelim = _Traits::to_int_type(__delim);
 	      const __int_type __eof = _Traits::eof();
-	      __int_type __c = __in.rdbuf()->sgetc();
+	      __int_type __c = ___in.rdbuf()->sgetc();
 
 	      while (__extracted < __n
 		     && !_Traits::eq_int_type(__c, __eof)
@@ -662,7 +662,7 @@
 		    }
 		  __buf[__len++] = _Traits::to_char_type(__c);
 		  ++__extracted;
-		  __c = __in.rdbuf()->snextc();
+		  __c = ___in.rdbuf()->snextc();
 		}
 	      __str.append(__buf, __len);
 
@@ -671,14 +671,14 @@
 	      else if (_Traits::eq_int_type(__c, __idelim))
 		{
 		  ++__extracted;		  
-		  __in.rdbuf()->sbumpc();
+		  ___in.rdbuf()->sbumpc();
 		}
 	      else
 		__err |= __ios_base::failbit;
 	    }
 	  __catch(__cxxabiv1::__forced_unwind&)
 	    {
-	      __in._M_setstate(__ios_base::badbit);
+	      ___in._M_setstate(__ios_base::badbit);
 	      __throw_exception_again;
 	    }
 	  __catch(...)
@@ -686,14 +686,14 @@
 	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
 	      // 91. Description of operator>> and getline() for string<>
 	      // might cause endless loop
-	      __in._M_setstate(__ios_base::badbit);
+	      ___in._M_setstate(__ios_base::badbit);
 	    }
 	}
       if (!__extracted)
 	__err |= __ios_base::failbit;
       if (__err)
-	__in.setstate(__err);
-      return __in;
+	___in.setstate(__err);
+      return ___in;
     }      
 
 _GLIBCXX_END_NAMESPACE_VERSION
diff -adru a/libstdc++-v3/include/parallel/algo.h b/libstdc++-v3/include/parallel/algo.h
--- a/libstdc++-v3/include/parallel/algo.h	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/parallel/algo.h	2021-04-09 13:06:24.399411900 +0800
@@ -289,67 +289,67 @@
   // Sequential fallback
   template<typename _IIter, typename _OutputIterator>
     inline _OutputIterator
-    unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out,
+    unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator ___out,
 		__gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_A::unique_copy(__begin1, __end1, __out); }
+    { return _GLIBCXX_STD_A::unique_copy(__begin1, __end1, ___out); }
 
   // Sequential fallback
   template<typename _IIter, typename _OutputIterator,
 	   typename _Predicate>
     inline _OutputIterator
-    unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out,
+    unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator ___out,
 		_Predicate __pred, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_A::unique_copy(__begin1, __end1, __out, __pred); }
+    { return _GLIBCXX_STD_A::unique_copy(__begin1, __end1, ___out, __pred); }
 
   // Sequential fallback for input iterator case
   template<typename _IIter, typename _OutputIterator,
 	   typename _Predicate, typename _IteratorTag1, typename _IteratorTag2>
     inline _OutputIterator
     __unique_copy_switch(_IIter __begin, _IIter __last,
-		       _OutputIterator __out, _Predicate __pred,
+		       _OutputIterator ___out, _Predicate __pred,
 		       _IteratorTag1, _IteratorTag2)
-    { return _GLIBCXX_STD_A::unique_copy(__begin, __last, __out, __pred); }
+    { return _GLIBCXX_STD_A::unique_copy(__begin, __last, ___out, __pred); }
 
   // Parallel unique_copy for random access iterators
   template<typename _RAIter, typename _RandomAccessOutputIterator,
 	   typename _Predicate>
     _RandomAccessOutputIterator
     __unique_copy_switch(_RAIter __begin, _RAIter __last,
-			 _RandomAccessOutputIterator __out, _Predicate __pred,
+			 _RandomAccessOutputIterator ___out, _Predicate __pred,
 			 random_access_iterator_tag, random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
 	    static_cast<__gnu_parallel::_SequenceIndex>(__last - __begin)
 	    > __gnu_parallel::_Settings::get().unique_copy_minimal_n))
 	return __gnu_parallel::__parallel_unique_copy(
-		 __begin, __last, __out, __pred);
+		 __begin, __last, ___out, __pred);
       else
-	return _GLIBCXX_STD_A::unique_copy(__begin, __last, __out, __pred);
+	return _GLIBCXX_STD_A::unique_copy(__begin, __last, ___out, __pred);
     }
 
   // Public interface
   template<typename _IIter, typename _OutputIterator>
     inline _OutputIterator
-    unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out)
+    unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator ___out)
     {
       typedef typename std::iterator_traits<_IIter>::value_type _ValueType;
 
       return __unique_copy_switch(
-	       __begin1, __end1, __out, equal_to<_ValueType>(),
+	       __begin1, __end1, ___out, equal_to<_ValueType>(),
 	       std::__iterator_category(__begin1),
-	       std::__iterator_category(__out));
+	       std::__iterator_category(___out));
     }
 
   // Public interface
   template<typename _IIter, typename _OutputIterator, typename _Predicate>
     inline _OutputIterator
-    unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out,
+    unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator ___out,
 		_Predicate __pred)
     {
       return __unique_copy_switch(
-	       __begin1, __end1, __out, __pred,
+	       __begin1, __end1, ___out, __pred,
 	       std::__iterator_category(__begin1),
-	       std::__iterator_category(__out));
+	       std::__iterator_category(___out));
     }
 
   // Sequential fallback
@@ -358,9 +358,9 @@
     inline _OutputIterator
     set_union(_IIter1 __begin1, _IIter1 __end1,
 	      _IIter2 __begin2, _IIter2 __end2,
-	      _OutputIterator __out, __gnu_parallel::sequential_tag)
+	      _OutputIterator ___out, __gnu_parallel::sequential_tag)
     { return _GLIBCXX_STD_A::set_union(
-	       __begin1, __end1, __begin2, __end2, __out); }
+	       __begin1, __end1, __begin2, __end2, ___out); }
 
   // Sequential fallback
   template<typename _IIter1, typename _IIter2,
@@ -368,10 +368,10 @@
     inline _OutputIterator
     set_union(_IIter1 __begin1, _IIter1 __end1,
 	      _IIter2 __begin2, _IIter2 __end2,
-	      _OutputIterator __out, _Predicate __pred,
+	      _OutputIterator ___out, _Predicate __pred,
 	      __gnu_parallel::sequential_tag)
     { return _GLIBCXX_STD_A::set_union(__begin1, __end1,
-				       __begin2, __end2, __out, __pred); }
+				       __begin2, __end2, ___out, __pred); }
 
   // Sequential fallback for input iterator case
   template<typename _IIter1, typename _IIter2, typename _Predicate,
@@ -412,17 +412,17 @@
 	   typename _OutputIterator>
     inline _OutputIterator
     set_union(_IIter1 __begin1, _IIter1 __end1,
-	      _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out)
+	      _IIter2 __begin2, _IIter2 __end2, _OutputIterator ___out)
     {
       typedef typename std::iterator_traits<_IIter1>::value_type _ValueType1;
       typedef typename std::iterator_traits<_IIter2>::value_type _ValueType2;
 
       return __set_union_switch(
-	       __begin1, __end1, __begin2, __end2, __out,
+	       __begin1, __end1, __begin2, __end2, ___out,
 	       __gnu_parallel::_Less<_ValueType1, _ValueType2>(),
 	       std::__iterator_category(__begin1),
 	       std::__iterator_category(__begin2),
-	       std::__iterator_category(__out));
+	       std::__iterator_category(___out));
     }
 
   // Public interface
@@ -431,13 +431,13 @@
     inline _OutputIterator
     set_union(_IIter1 __begin1, _IIter1 __end1,
 	      _IIter2 __begin2, _IIter2 __end2,
-	      _OutputIterator __out, _Predicate __pred)
+	      _OutputIterator ___out, _Predicate __pred)
     {
       return __set_union_switch(
-	       __begin1, __end1, __begin2, __end2, __out, __pred,
+	       __begin1, __end1, __begin2, __end2, ___out, __pred,
 	       std::__iterator_category(__begin1),
 	       std::__iterator_category(__begin2),
-	       std::__iterator_category(__out));
+	       std::__iterator_category(___out));
     }
 
   // Sequential fallback.
@@ -446,9 +446,9 @@
     inline _OutputIterator
     set_intersection(_IIter1 __begin1, _IIter1 __end1,
 		     _IIter2 __begin2, _IIter2 __end2,
-		     _OutputIterator __out, __gnu_parallel::sequential_tag)
+		     _OutputIterator ___out, __gnu_parallel::sequential_tag)
     { return _GLIBCXX_STD_A::set_intersection(__begin1, __end1,
-					      __begin2, __end2, __out); }
+					      __begin2, __end2, ___out); }
 
   // Sequential fallback.
   template<typename _IIter1, typename _IIter2,
@@ -456,10 +456,10 @@
     inline _OutputIterator
     set_intersection(_IIter1 __begin1, _IIter1 __end1,
 		     _IIter2 __begin2, _IIter2 __end2,
-		     _OutputIterator __out, _Predicate __pred,
+		     _OutputIterator ___out, _Predicate __pred,
 		     __gnu_parallel::sequential_tag)
     { return _GLIBCXX_STD_A::set_intersection(
-	       __begin1, __end1, __begin2, __end2, __out, __pred); }
+	       __begin1, __end1, __begin2, __end2, ___out, __pred); }
 
   // Sequential fallback for input iterator case
   template<typename _IIter1, typename _IIter2,
@@ -506,17 +506,17 @@
     inline _OutputIterator
     set_intersection(_IIter1 __begin1, _IIter1 __end1,
 		     _IIter2 __begin2, _IIter2 __end2,
-		     _OutputIterator __out)
+		     _OutputIterator ___out)
     {
       typedef typename std::iterator_traits<_IIter1>::value_type _ValueType1;
       typedef typename std::iterator_traits<_IIter2>::value_type _ValueType2;
 
       return __set_intersection_switch(
-	       __begin1, __end1, __begin2, __end2, __out,
+	       __begin1, __end1, __begin2, __end2, ___out,
 	       __gnu_parallel::_Less<_ValueType1, _ValueType2>(),
 	       std::__iterator_category(__begin1),
 	       std::__iterator_category(__begin2),
-	       std::__iterator_category(__out));
+	       std::__iterator_category(___out));
     }
 
   template<typename _IIter1, typename _IIter2,
@@ -524,13 +524,13 @@
     inline _OutputIterator
     set_intersection(_IIter1 __begin1, _IIter1 __end1,
 		     _IIter2 __begin2, _IIter2 __end2,
-		     _OutputIterator __out, _Predicate __pred)
+		     _OutputIterator ___out, _Predicate __pred)
     {
       return __set_intersection_switch(
-	       __begin1, __end1, __begin2, __end2, __out, __pred,
+	       __begin1, __end1, __begin2, __end2, ___out, __pred,
 	       std::__iterator_category(__begin1),
 	       std::__iterator_category(__begin2),
-	       std::__iterator_category(__out));
+	       std::__iterator_category(___out));
     }
 
   // Sequential fallback
@@ -539,10 +539,10 @@
     inline _OutputIterator
     set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1,
 			     _IIter2 __begin2, _IIter2 __end2,
-			     _OutputIterator __out,
+			     _OutputIterator ___out,
 			     __gnu_parallel::sequential_tag)
     { return _GLIBCXX_STD_A::set_symmetric_difference(
-	       __begin1, __end1, __begin2, __end2, __out); }
+	       __begin1, __end1, __begin2, __end2, ___out); }
 
   // Sequential fallback
   template<typename _IIter1, typename _IIter2,
@@ -550,10 +550,10 @@
     inline _OutputIterator
     set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1,
 			     _IIter2 __begin2, _IIter2 __end2,
-			     _OutputIterator __out, _Predicate __pred,
+			     _OutputIterator ___out, _Predicate __pred,
 			     __gnu_parallel::sequential_tag)
     { return _GLIBCXX_STD_A::set_symmetric_difference(
-	       __begin1, __end1, __begin2, __end2, __out, __pred); }
+	       __begin1, __end1, __begin2, __end2, ___out, __pred); }
 
   // Sequential fallback for input iterator case
   template<typename _IIter1, typename _IIter2,
@@ -600,17 +600,17 @@
     inline _OutputIterator
     set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1,
 			     _IIter2 __begin2, _IIter2 __end2,
-			     _OutputIterator __out)
+			     _OutputIterator ___out)
     {
       typedef typename std::iterator_traits<_IIter1>::value_type _ValueType1;
       typedef typename std::iterator_traits<_IIter2>::value_type _ValueType2;
 
       return __set_symmetric_difference_switch(
-	       __begin1, __end1, __begin2, __end2, __out,
+	       __begin1, __end1, __begin2, __end2, ___out,
 	       __gnu_parallel::_Less<_ValueType1, _ValueType2>(),
 	       std::__iterator_category(__begin1),
 	       std::__iterator_category(__begin2),
-	       std::__iterator_category(__out));
+	       std::__iterator_category(___out));
     }
 
   // Public interface.
@@ -619,13 +619,13 @@
     inline _OutputIterator
     set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1,
 			     _IIter2 __begin2, _IIter2 __end2,
-			     _OutputIterator __out, _Predicate __pred)
+			     _OutputIterator ___out, _Predicate __pred)
     {
       return __set_symmetric_difference_switch(
-	       __begin1, __end1, __begin2, __end2, __out, __pred,
+	       __begin1, __end1, __begin2, __end2, ___out, __pred,
 	       std::__iterator_category(__begin1),
 	       std::__iterator_category(__begin2),
-	       std::__iterator_category(__out));
+	       std::__iterator_category(___out));
     }
 
   // Sequential fallback.
@@ -634,9 +634,9 @@
     inline _OutputIterator
     set_difference(_IIter1 __begin1, _IIter1 __end1,
 		   _IIter2 __begin2, _IIter2 __end2,
-		   _OutputIterator __out, __gnu_parallel::sequential_tag)
+		   _OutputIterator ___out, __gnu_parallel::sequential_tag)
     { return _GLIBCXX_STD_A::set_difference(
-	       __begin1,__end1, __begin2, __end2, __out); }
+	       __begin1,__end1, __begin2, __end2, ___out); }
 
   // Sequential fallback.
   template<typename _IIter1, typename _IIter2,
@@ -644,10 +644,10 @@
     inline _OutputIterator
     set_difference(_IIter1 __begin1, _IIter1 __end1,
 		   _IIter2 __begin2, _IIter2 __end2,
-		   _OutputIterator __out, _Predicate __pred,
+		   _OutputIterator ___out, _Predicate __pred,
 		   __gnu_parallel::sequential_tag)
     { return _GLIBCXX_STD_A::set_difference(__begin1, __end1,
-					    __begin2, __end2, __out, __pred); }
+					    __begin2, __end2, ___out, __pred); }
 
   // Sequential fallback for input iterator case.
   template<typename _IIter1, typename _IIter2, typename _Predicate,
@@ -692,17 +692,17 @@
     inline _OutputIterator
     set_difference(_IIter1 __begin1, _IIter1 __end1,
 		   _IIter2 __begin2, _IIter2 __end2,
-		   _OutputIterator __out)
+		   _OutputIterator ___out)
     {
       typedef typename std::iterator_traits<_IIter1>::value_type _ValueType1;
       typedef typename std::iterator_traits<_IIter2>::value_type _ValueType2;
 
       return __set_difference_switch(
-	       __begin1, __end1, __begin2, __end2, __out,
+	       __begin1, __end1, __begin2, __end2, ___out,
 	       __gnu_parallel::_Less<_ValueType1, _ValueType2>(),
 	       std::__iterator_category(__begin1),
 	       std::__iterator_category(__begin2),
-	       std::__iterator_category(__out));
+	       std::__iterator_category(___out));
     }
 
   // Public interface
@@ -711,13 +711,13 @@
     inline _OutputIterator
     set_difference(_IIter1 __begin1, _IIter1 __end1,
 		   _IIter2 __begin2, _IIter2 __end2,
-		   _OutputIterator __out, _Predicate __pred)
+		   _OutputIterator ___out, _Predicate __pred)
     {
       return __set_difference_switch(
-	       __begin1, __end1, __begin2, __end2, __out, __pred,
+	       __begin1, __end1, __begin2, __end2, ___out, __pred,
 	       std::__iterator_category(__begin1),
 	       std::__iterator_category(__begin2),
-	       std::__iterator_category(__out));
+	       std::__iterator_category(___out));
     }
 
   // Sequential fallback
diff -adru a/libstdc++-v3/include/parallel/multiway_merge.h b/libstdc++-v3/include/parallel/multiway_merge.h
--- a/libstdc++-v3/include/parallel/multiway_merge.h	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/parallel/multiway_merge.h	2021-04-09 13:06:24.415033600 +0800
@@ -1372,7 +1372,7 @@
    *     for (int __j = 0; __i < 10; ++__j)
    *       sequences[__i][__j] = __j;
    *
-   *   int __out[33];
+   *   int ___out[33];
    *   std::vector<std::pair<int*> > seqs;
    *   for (int __i = 0; __i < 10; ++__i)
    *     { seqs.push(std::make_pair<int*>(sequences[__i],
@@ -1733,7 +1733,7 @@
    *     for (int __j = 0; __i < 11; ++__j)
    *       sequences[__i][__j] = __j; // __last one is sentinel!
    *
-   *   int __out[33];
+   *   int ___out[33];
    *   std::vector<std::pair<int*> > seqs;
    *   for (int __i = 0; __i < 10; ++__i)
    *     { seqs.push(std::make_pair<int*>(sequences[__i],
diff -adru a/libstdc++-v3/include/parallel/set_operations.h b/libstdc++-v3/include/parallel/set_operations.h
--- a/libstdc++-v3/include/parallel/set_operations.h	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/parallel/set_operations.h	2021-04-09 13:06:24.415033600 +0800
@@ -130,12 +130,12 @@
       }
 
       _OutputIterator
-      __first_empty(_IIter __c, _IIter __d, _OutputIterator __out) const
-      { return std::copy(__c, __d, __out); }
+      __first_empty(_IIter __c, _IIter __d, _OutputIterator ___out) const
+      { return std::copy(__c, __d, ___out); }
 
       _OutputIterator
-      __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const
-      { return std::copy(__a, __b, __out); }
+      __second_empty(_IIter __a, _IIter __b, _OutputIterator ___out) const
+      { return std::copy(__a, __b, ___out); }
     };
 
 
@@ -198,12 +198,12 @@
       }
 
       _OutputIterator
-      __first_empty(_IIter, _IIter, _OutputIterator __out) const
-      { return __out; }
+      __first_empty(_IIter, _IIter, _OutputIterator ___out) const
+      { return ___out; }
 
       _OutputIterator
-      __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const
-      { return std::copy(__a, __b, __out); }
+      __second_empty(_IIter __a, _IIter __b, _OutputIterator ___out) const
+      { return std::copy(__a, __b, ___out); }
     };
 
 
@@ -265,12 +265,12 @@
       }
 
       _OutputIterator
-      __first_empty(_IIter, _IIter, _OutputIterator __out) const
-      { return __out; }
+      __first_empty(_IIter, _IIter, _OutputIterator ___out) const
+      { return ___out; }
 
       _OutputIterator
-      __second_empty(_IIter, _IIter, _OutputIterator __out) const
-      { return __out; }
+      __second_empty(_IIter, _IIter, _OutputIterator ___out) const
+      { return ___out; }
     };
 
   template<class _IIter, class _OutputIterator, class _Compare>
@@ -335,12 +335,12 @@
       }
 
       _OutputIterator
-      __first_empty(_IIter __c, _IIter __d, _OutputIterator __out) const
-      { return std::copy(__c, __d, __out); }
+      __first_empty(_IIter __c, _IIter __d, _OutputIterator ___out) const
+      { return std::copy(__c, __d, ___out); }
 
       _OutputIterator
-      __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const
-      { return std::copy(__a, __b, __out); }
+      __second_empty(_IIter __a, _IIter __b, _OutputIterator ___out) const
+      { return std::copy(__a, __b, ___out); }
     };
 
   template<typename _IIter,
diff -adru a/libstdc++-v3/include/parallel/unique_copy.h b/libstdc++-v3/include/parallel/unique_copy.h
--- a/libstdc++-v3/include/parallel/unique_copy.h	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/parallel/unique_copy.h	2021-04-09 13:06:24.415033600 +0800
@@ -85,7 +85,7 @@
 	// Check for length without duplicates
 	// Needed for position in output
 	_DifferenceType __i = 0;
-	_OutputIterator __out = __result;
+	_OutputIterator ___out = __result;
 
 	if (__iam == 0)
           {
@@ -93,7 +93,7 @@
             __end = __borders[__iam + 1];
 
             ++__i;
-            *__out++ = *__first;
+            *___out++ = *__first;
 
             for (_IIter __iter = __first + __begin; __iter < __first + __end;
 		 ++__iter)
@@ -101,7 +101,7 @@
         	if (!__binary_pred(*__iter, *(__iter - 1)))
                   {
                     ++__i;
-                    *__out++ = *__iter;
+                    *___out++ = *__iter;
                   }
               }
           }
diff -adru a/libstdc++-v3/include/pstl/parallel_backend_serial.h b/libstdc++-v3/include/pstl/parallel_backend_serial.h
--- a/libstdc++-v3/include/pstl/parallel_backend_serial.h	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/pstl/parallel_backend_serial.h	2021-04-09 13:06:24.430626900 +0800
@@ -110,10 +110,10 @@
           typename _RandomAccessIterator3, typename _Compare, typename _LeafMerge>
 void
 __parallel_merge(_ExecutionPolicy&&, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
-                 _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _RandomAccessIterator3 __out,
+                 _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _RandomAccessIterator3 ___out,
                  _Compare __comp, _LeafMerge __leaf_merge)
 {
-    __leaf_merge(__first1, __last1, __first2, __last2, __out, __comp);
+    __leaf_merge(__first1, __last1, __first2, __last2, ___out, __comp);
 }
 
 template <class _ExecutionPolicy, typename _F1, typename _F2>
diff -adru a/libstdc++-v3/include/std/istream b/libstdc++-v3/include/std/istream
--- a/libstdc++-v3/include/std/istream	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/std/istream	2021-04-09 13:06:24.430626900 +0800
@@ -738,7 +738,7 @@
   //@{
   /**
    *  @brief  Character extractors
-   *  @param  __in  An input stream.
+   *  @param  ___in  An input stream.
    *  @param  __c  A character reference.
    *  @return  in
    *
@@ -749,25 +749,25 @@
   */
   template<typename _CharT, typename _Traits>
     basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
+    operator>>(basic_istream<_CharT, _Traits>& ___in, _CharT& __c);
 
   template<class _Traits>
     inline basic_istream<char, _Traits>&
-    operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
-    { return (__in >> reinterpret_cast<char&>(__c)); }
+    operator>>(basic_istream<char, _Traits>& ___in, unsigned char& __c)
+    { return (___in >> reinterpret_cast<char&>(__c)); }
 
   template<class _Traits>
     inline basic_istream<char, _Traits>&
-    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
-    { return (__in >> reinterpret_cast<char&>(__c)); }
+    operator>>(basic_istream<char, _Traits>& ___in, signed char& __c)
+    { return (___in >> reinterpret_cast<char&>(__c)); }
   //@}
 
   //@{
   /**
    *  @brief  Character string extractors
-   *  @param  __in  An input stream.
+   *  @param  ___in  An input stream.
    *  @param  __s  A pointer to a character array.
-   *  @return  __in
+   *  @return  ___in
    *
    *  Behaves like one of the formatted arithmetic extractors described in
    *  std::basic_istream.  After constructing a sentry object with good
@@ -791,22 +791,22 @@
   */
   template<typename _CharT, typename _Traits>
     basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
+    operator>>(basic_istream<_CharT, _Traits>& ___in, _CharT* __s);
 
   // Explicit specialization declaration, defined in src/istream.cc.
   template<>
     basic_istream<char>&
-    operator>>(basic_istream<char>& __in, char* __s);
+    operator>>(basic_istream<char>& ___in, char* __s);
 
   template<class _Traits>
     inline basic_istream<char, _Traits>&
-    operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
-    { return (__in >> reinterpret_cast<char*>(__s)); }
+    operator>>(basic_istream<char, _Traits>& ___in, unsigned char* __s)
+    { return (___in >> reinterpret_cast<char*>(__s)); }
 
   template<class _Traits>
     inline basic_istream<char, _Traits>&
-    operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
-    { return (__in >> reinterpret_cast<char*>(__s)); }
+    operator>>(basic_istream<char, _Traits>& ___in, signed char* __s)
+    { return (___in >> reinterpret_cast<char*>(__s)); }
   //@}
 
   /**
diff -adru a/libstdc++-v3/include/std/ostream b/libstdc++-v3/include/std/ostream
--- a/libstdc++-v3/include/std/ostream	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/std/ostream	2021-04-09 13:06:24.446256700 +0800
@@ -488,14 +488,14 @@
   //@{
   /**
    *  @brief  Character inserters
-   *  @param  __out  An output stream.
+   *  @param  ___out  An output stream.
    *  @param  __c  A character.
    *  @return  out
    *
    *  Behaves like one of the formatted arithmetic inserters described in
    *  std::basic_ostream.  After constructing a sentry object with good
    *  status, this function inserts a single character and any required
-   *  padding (as determined by [22.2.2.2.2]).  @c __out.width(0) is then
+   *  padding (as determined by [22.2.2.2.2]).  @c ___out.width(0) is then
    *  called.
    *
    *  If @p __c is of type @c char and the character type of the stream is not
@@ -503,30 +503,30 @@
   */
   template<typename _CharT, typename _Traits>
     inline basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
-    { return __ostream_insert(__out, &__c, 1); }
+    operator<<(basic_ostream<_CharT, _Traits>& ___out, _CharT __c)
+    { return __ostream_insert(___out, &__c, 1); }
 
   template<typename _CharT, typename _Traits>
     inline basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
-    { return (__out << __out.widen(__c)); }
+    operator<<(basic_ostream<_CharT, _Traits>& ___out, char __c)
+    { return (___out << ___out.widen(__c)); }
 
   // Specialization
   template<typename _Traits>
     inline basic_ostream<char, _Traits>&
-    operator<<(basic_ostream<char, _Traits>& __out, char __c)
-    { return __ostream_insert(__out, &__c, 1); }
+    operator<<(basic_ostream<char, _Traits>& ___out, char __c)
+    { return __ostream_insert(___out, &__c, 1); }
 
   // Signed and unsigned
   template<typename _Traits>
     inline basic_ostream<char, _Traits>&
-    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
-    { return (__out << static_cast<char>(__c)); }
+    operator<<(basic_ostream<char, _Traits>& ___out, signed char __c)
+    { return (___out << static_cast<char>(__c)); }
 
   template<typename _Traits>
     inline basic_ostream<char, _Traits>&
-    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
-    { return (__out << static_cast<char>(__c)); }
+    operator<<(basic_ostream<char, _Traits>& ___out, unsigned char __c)
+    { return (___out << static_cast<char>(__c)); }
 
 #if __cplusplus > 201703L
   // The following deleted overloads prevent formatting character values as
@@ -573,7 +573,7 @@
   //@{
   /**
    *  @brief  String inserters
-   *  @param  __out  An output stream.
+   *  @param  ___out  An output stream.
    *  @param  __s  A character string.
    *  @return  out
    *  @pre  @p __s must be a non-NULL pointer
@@ -582,47 +582,47 @@
    *  std::basic_ostream.  After constructing a sentry object with good
    *  status, this function inserts @c traits::length(__s) characters starting
    *  at @p __s, widened if necessary, followed by any required padding (as
-   *  determined by [22.2.2.2.2]).  @c __out.width(0) is then called.
+   *  determined by [22.2.2.2.2]).  @c ___out.width(0) is then called.
   */
   template<typename _CharT, typename _Traits>
     inline basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
+    operator<<(basic_ostream<_CharT, _Traits>& ___out, const _CharT* __s)
     {
       if (!__s)
-	__out.setstate(ios_base::badbit);
+	___out.setstate(ios_base::badbit);
       else
-	__ostream_insert(__out, __s,
+	__ostream_insert(___out, __s,
 			 static_cast<streamsize>(_Traits::length(__s)));
-      return __out;
+      return ___out;
     }
 
   template<typename _CharT, typename _Traits>
     basic_ostream<_CharT, _Traits> &
-    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
+    operator<<(basic_ostream<_CharT, _Traits>& ___out, const char* __s);
 
   // Partial specializations
   template<typename _Traits>
     inline basic_ostream<char, _Traits>&
-    operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
+    operator<<(basic_ostream<char, _Traits>& ___out, const char* __s)
     {
       if (!__s)
-	__out.setstate(ios_base::badbit);
+	___out.setstate(ios_base::badbit);
       else
-	__ostream_insert(__out, __s,
+	__ostream_insert(___out, __s,
 			 static_cast<streamsize>(_Traits::length(__s)));
-      return __out;
+      return ___out;
     }
 
   // Signed and unsigned
   template<typename _Traits>
     inline basic_ostream<char, _Traits>&
-    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
-    { return (__out << reinterpret_cast<const char*>(__s)); }
+    operator<<(basic_ostream<char, _Traits>& ___out, const signed char* __s)
+    { return (___out << reinterpret_cast<const char*>(__s)); }
 
   template<typename _Traits>
     inline basic_ostream<char, _Traits> &
-    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
-    { return (__out << reinterpret_cast<const char*>(__s)); }
+    operator<<(basic_ostream<char, _Traits>& ___out, const unsigned char* __s)
+    { return (___out << reinterpret_cast<const char*>(__s)); }
 
 #if __cplusplus > 201703L
    // The following deleted overloads prevent formatting strings as
diff -adru a/libstdc++-v3/include/std/thread b/libstdc++-v3/include/std/thread
--- a/libstdc++-v3/include/std/thread	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/std/thread	2021-04-09 13:06:24.446256700 +0800
@@ -112,7 +112,7 @@
 
       template<class _CharT, class _Traits>
 	friend basic_ostream<_CharT, _Traits>&
-	operator<<(basic_ostream<_CharT, _Traits>& __out, id __id);
+	operator<<(basic_ostream<_CharT, _Traits>& ___out, id __id);
     };
 
   private:
@@ -345,12 +345,12 @@
 
   template<class _CharT, class _Traits>
     inline basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id)
+    operator<<(basic_ostream<_CharT, _Traits>& ___out, thread::id __id)
     {
       if (__id == thread::id())
-	return __out << "thread::id of a non-executing thread";
+	return ___out << "thread::id of a non-executing thread";
       else
-	return __out << __id._M_thread;
+	return ___out << __id._M_thread;
     }
 
   /** @namespace std::this_thread
diff -adru a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple
--- a/libstdc++-v3/include/std/tuple	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/std/tuple	2021-04-09 13:06:24.446256700 +0800
@@ -230,23 +230,23 @@
       _Tuple_impl& operator=(const _Tuple_impl&) = delete;
 
       constexpr
-      _Tuple_impl(_Tuple_impl&& __in)
+      _Tuple_impl(_Tuple_impl&& ___in)
       noexcept(__and_<is_nothrow_move_constructible<_Head>,
 	              is_nothrow_move_constructible<_Inherited>>::value)
-      : _Inherited(std::move(_M_tail(__in))),
-	_Base(std::forward<_Head>(_M_head(__in))) { }
+      : _Inherited(std::move(_M_tail(___in))),
+	_Base(std::forward<_Head>(_M_head(___in))) { }
 
       template<typename... _UElements>
-        constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
-	: _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
-	  _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
+        constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& ___in)
+	: _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(___in)),
+	  _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(___in)) { }
 
       template<typename _UHead, typename... _UTails>
-        constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+        constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& ___in)
 	: _Inherited(std::move
-		     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
+		     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(___in))),
 	  _Base(std::forward<_UHead>
-		(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
+		(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(___in))) { }
 
       template<typename _Alloc>
 	_GLIBCXX20_CONSTEXPR
@@ -273,66 +273,66 @@
       template<typename _Alloc>
 	_GLIBCXX20_CONSTEXPR
         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-	            const _Tuple_impl& __in)
-	: _Inherited(__tag, __a, _M_tail(__in)),
-          _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
+	            const _Tuple_impl& ___in)
+	: _Inherited(__tag, __a, _M_tail(___in)),
+          _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(___in)) { }
 
       template<typename _Alloc>
 	_GLIBCXX20_CONSTEXPR
 	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-	            _Tuple_impl&& __in)
-	: _Inherited(__tag, __a, std::move(_M_tail(__in))),
+	            _Tuple_impl&& ___in)
+	: _Inherited(__tag, __a, std::move(_M_tail(___in))),
 	  _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
-	        std::forward<_Head>(_M_head(__in))) { }
+	        std::forward<_Head>(_M_head(___in))) { }
 
       template<typename _Alloc, typename _UHead, typename... _UTails>
 	_GLIBCXX20_CONSTEXPR
 	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-		    const _Tuple_impl<_Idx, _UHead, _UTails...>& __in)
+		    const _Tuple_impl<_Idx, _UHead, _UTails...>& ___in)
 	: _Inherited(__tag, __a,
-		     _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)),
+		     _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(___in)),
 	  _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a),
-		_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)) { }
+		_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(___in)) { }
 
       template<typename _Alloc, typename _UHead, typename... _UTails>
 	_GLIBCXX20_CONSTEXPR
 	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-	            _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+	            _Tuple_impl<_Idx, _UHead, _UTails...>&& ___in)
 	: _Inherited(__tag, __a, std::move
-		     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
+		     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(___in))),
 	  _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
                 std::forward<_UHead>
-		(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
+		(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(___in))) { }
 
       template<typename... _UElements>
 	_GLIBCXX20_CONSTEXPR
         void
-        _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in)
+        _M_assign(const _Tuple_impl<_Idx, _UElements...>& ___in)
         {
-	  _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
+	  _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(___in);
 	  _M_tail(*this)._M_assign(
-	      _Tuple_impl<_Idx, _UElements...>::_M_tail(__in));
+	      _Tuple_impl<_Idx, _UElements...>::_M_tail(___in));
 	}
 
       template<typename _UHead, typename... _UTails>
 	_GLIBCXX20_CONSTEXPR
         void
-        _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+        _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& ___in)
         {
 	  _M_head(*this) = std::forward<_UHead>
-	    (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
+	    (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(___in));
 	  _M_tail(*this)._M_assign(
-	      std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)));
+	      std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(___in)));
 	}
 
     protected:
       _GLIBCXX20_CONSTEXPR
       void
-      _M_swap(_Tuple_impl& __in)
+      _M_swap(_Tuple_impl& ___in)
       {
 	using std::swap;
-	swap(_M_head(*this), _M_head(__in));
-	_Inherited::_M_swap(_M_tail(__in));
+	swap(_M_head(*this), _M_head(___in));
+	_Inherited::_M_swap(_M_tail(___in));
       }
     };
 
@@ -370,17 +370,17 @@
       _Tuple_impl& operator=(const _Tuple_impl&) = delete;
 
       constexpr
-      _Tuple_impl(_Tuple_impl&& __in)
+      _Tuple_impl(_Tuple_impl&& ___in)
       noexcept(is_nothrow_move_constructible<_Head>::value)
-      : _Base(std::forward<_Head>(_M_head(__in))) { }
+      : _Base(std::forward<_Head>(_M_head(___in))) { }
 
       template<typename _UHead>
-        constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
-	: _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
+        constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& ___in)
+	: _Base(_Tuple_impl<_Idx, _UHead>::_M_head(___in)) { }
 
       template<typename _UHead>
-        constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
-	: _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
+        constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& ___in)
+	: _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(___in)))
 	{ }
 
       template<typename _Alloc>
@@ -403,55 +403,55 @@
       template<typename _Alloc>
 	_GLIBCXX20_CONSTEXPR
         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-	            const _Tuple_impl& __in)
-	: _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
+	            const _Tuple_impl& ___in)
+	: _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(___in)) { }
 
       template<typename _Alloc>
 	_GLIBCXX20_CONSTEXPR
 	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-	            _Tuple_impl&& __in)
+	            _Tuple_impl&& ___in)
 	: _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
-	        std::forward<_Head>(_M_head(__in))) { }
+	        std::forward<_Head>(_M_head(___in))) { }
 
       template<typename _Alloc, typename _UHead>
 	_GLIBCXX20_CONSTEXPR
 	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-	            const _Tuple_impl<_Idx, _UHead>& __in)
+	            const _Tuple_impl<_Idx, _UHead>& ___in)
 	: _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a),
-		_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
+		_Tuple_impl<_Idx, _UHead>::_M_head(___in)) { }
 
       template<typename _Alloc, typename _UHead>
 	_GLIBCXX20_CONSTEXPR
 	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-	            _Tuple_impl<_Idx, _UHead>&& __in)
+	            _Tuple_impl<_Idx, _UHead>&& ___in)
 	: _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
-                std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
+                std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(___in)))
 	{ }
 
       template<typename _UHead>
 	_GLIBCXX20_CONSTEXPR
         void
-        _M_assign(const _Tuple_impl<_Idx, _UHead>& __in)
+        _M_assign(const _Tuple_impl<_Idx, _UHead>& ___in)
         {
-	  _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
+	  _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(___in);
 	}
 
       template<typename _UHead>
 	_GLIBCXX20_CONSTEXPR
         void
-        _M_assign(_Tuple_impl<_Idx, _UHead>&& __in)
+        _M_assign(_Tuple_impl<_Idx, _UHead>&& ___in)
         {
 	  _M_head(*this)
-	    = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
+	    = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(___in));
 	}
 
     protected:
       _GLIBCXX20_CONSTEXPR
       void
-      _M_swap(_Tuple_impl& __in)
+      _M_swap(_Tuple_impl& ___in)
       {
 	using std::swap;
-	swap(_M_head(*this), _M_head(__in));
+	swap(_M_head(*this), _M_head(___in));
       }
     };
 
@@ -671,9 +671,9 @@
 			   && !__use_other_ctor<const tuple<_UElements...>&>(),
 	       _ImplicitCtor<_Valid, const _UElements&...> = true>
 	constexpr
-	tuple(const tuple<_UElements...>& __in)
+	tuple(const tuple<_UElements...>& ___in)
 	noexcept(__nothrow_constructible<const _UElements&...>())
-	: _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+	: _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(___in))
 	{ }
 
       template<typename... _UElements,
@@ -681,9 +681,9 @@
 			   && !__use_other_ctor<const tuple<_UElements...>&>(),
 	       _ExplicitCtor<_Valid, const _UElements&...> = false>
 	explicit constexpr
-	tuple(const tuple<_UElements...>& __in)
+	tuple(const tuple<_UElements...>& ___in)
 	noexcept(__nothrow_constructible<const _UElements&...>())
-	: _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+	: _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(___in))
 	{ }
 
       template<typename... _UElements,
@@ -691,18 +691,18 @@
 			     && !__use_other_ctor<tuple<_UElements...>&&>(),
 	       _ImplicitCtor<_Valid, _UElements...> = true>
 	constexpr
-	tuple(tuple<_UElements...>&& __in)
+	tuple(tuple<_UElements...>&& ___in)
 	noexcept(__nothrow_constructible<_UElements...>())
-	: _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
+	: _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(___in)) { }
 
       template<typename... _UElements,
 	       bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
 			     && !__use_other_ctor<tuple<_UElements...>&&>(),
 	       _ExplicitCtor<_Valid, _UElements...> = false>
 	explicit constexpr
-	tuple(tuple<_UElements...>&& __in)
+	tuple(tuple<_UElements...>&& ___in)
 	noexcept(__nothrow_constructible<_UElements...>())
-	: _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
+	: _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(___in)) { }
 
       // Allocator-extended constructors.
 
@@ -748,13 +748,13 @@
 
       template<typename _Alloc>
 	_GLIBCXX20_CONSTEXPR
-	tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
-	: _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
+	tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& ___in)
+	: _Inherited(__tag, __a, static_cast<const _Inherited&>(___in)) { }
 
       template<typename _Alloc>
 	_GLIBCXX20_CONSTEXPR
-	tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
-	: _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
+	tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& ___in)
+	: _Inherited(__tag, __a, static_cast<_Inherited&&>(___in)) { }
 
       template<typename _Alloc, typename... _UElements,
 	       bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
@@ -762,9 +762,9 @@
 	       _ImplicitCtor<_Valid, const _UElements&...> = true>
 	_GLIBCXX20_CONSTEXPR
 	tuple(allocator_arg_t __tag, const _Alloc& __a,
-	      const tuple<_UElements...>& __in)
+	      const tuple<_UElements...>& ___in)
 	: _Inherited(__tag, __a,
-	             static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+	             static_cast<const _Tuple_impl<0, _UElements...>&>(___in))
 	{ }
 
       template<typename _Alloc, typename... _UElements,
@@ -774,9 +774,9 @@
 	_GLIBCXX20_CONSTEXPR
 	explicit
 	tuple(allocator_arg_t __tag, const _Alloc& __a,
-	      const tuple<_UElements...>& __in)
+	      const tuple<_UElements...>& ___in)
 	: _Inherited(__tag, __a,
-	             static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+	             static_cast<const _Tuple_impl<0, _UElements...>&>(___in))
 	{ }
 
       template<typename _Alloc, typename... _UElements,
@@ -785,9 +785,9 @@
 	       _ImplicitCtor<_Valid, _UElements...> = true>
 	_GLIBCXX20_CONSTEXPR
 	tuple(allocator_arg_t __tag, const _Alloc& __a,
-	      tuple<_UElements...>&& __in)
+	      tuple<_UElements...>&& ___in)
 	: _Inherited(__tag, __a,
-	             static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
+	             static_cast<_Tuple_impl<0, _UElements...>&&>(___in))
 	{ }
 
       template<typename _Alloc, typename... _UElements,
@@ -797,9 +797,9 @@
 	_GLIBCXX20_CONSTEXPR
 	explicit
 	tuple(allocator_arg_t __tag, const _Alloc& __a,
-	      tuple<_UElements...>&& __in)
+	      tuple<_UElements...>&& ___in)
 	: _Inherited(__tag, __a,
-	             static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
+	             static_cast<_Tuple_impl<0, _UElements...>&&>(___in))
 	{ }
 
       // tuple assignment
@@ -808,10 +808,10 @@
       tuple&
       operator=(typename conditional<__assignable<const _Elements&...>(),
 				     const tuple&,
-				     const __nonesuch&>::type __in)
+				     const __nonesuch&>::type ___in)
       noexcept(__nothrow_assignable<const _Elements&...>())
       {
-	this->_M_assign(__in);
+	this->_M_assign(___in);
 	return *this;
       }
 
@@ -819,39 +819,39 @@
       tuple&
       operator=(typename conditional<__assignable<_Elements...>(),
 				     tuple&&,
-				     __nonesuch&&>::type __in)
+				     __nonesuch&&>::type ___in)
       noexcept(__nothrow_assignable<_Elements...>())
       {
-	this->_M_assign(std::move(__in));
+	this->_M_assign(std::move(___in));
 	return *this;
       }
 
       template<typename... _UElements>
 	_GLIBCXX20_CONSTEXPR
 	__enable_if_t<__assignable<const _UElements&...>(), tuple&>
-	operator=(const tuple<_UElements...>& __in)
+	operator=(const tuple<_UElements...>& ___in)
 	noexcept(__nothrow_assignable<const _UElements&...>())
 	{
-	  this->_M_assign(__in);
+	  this->_M_assign(___in);
 	  return *this;
 	}
 
       template<typename... _UElements>
 	_GLIBCXX20_CONSTEXPR
 	__enable_if_t<__assignable<_UElements...>(), tuple&>
-	operator=(tuple<_UElements...>&& __in)
+	operator=(tuple<_UElements...>&& ___in)
 	noexcept(__nothrow_assignable<_UElements...>())
 	{
-	  this->_M_assign(std::move(__in));
+	  this->_M_assign(std::move(___in));
 	  return *this;
 	}
 
       // tuple swap
       _GLIBCXX20_CONSTEXPR
       void
-      swap(tuple& __in)
+      swap(tuple& ___in)
       noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value)
-      { _Inherited::_M_swap(__in); }
+      { _Inherited::_M_swap(___in); }
     };
 
 #if __cpp_deduction_guides >= 201606
@@ -1002,60 +1002,60 @@
       template<typename _U1, typename _U2,
 	       _ImplicitCtor<true, const _U1&, const _U2&> = true>
 	constexpr
-	tuple(const tuple<_U1, _U2>& __in)
+	tuple(const tuple<_U1, _U2>& ___in)
 	noexcept(__nothrow_constructible<const _U1&, const _U2&>())
-	: _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
+	: _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(___in)) { }
 
       template<typename _U1, typename _U2,
 	       _ExplicitCtor<true, const _U1&, const _U2&> = false>
 	explicit constexpr
-	tuple(const tuple<_U1, _U2>& __in)
+	tuple(const tuple<_U1, _U2>& ___in)
 	noexcept(__nothrow_constructible<const _U1&, const _U2&>())
-	: _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
+	: _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(___in)) { }
 
       template<typename _U1, typename _U2,
 	       _ImplicitCtor<true, _U1, _U2> = true>
 	constexpr
-	tuple(tuple<_U1, _U2>&& __in)
+	tuple(tuple<_U1, _U2>&& ___in)
 	noexcept(__nothrow_constructible<_U1, _U2>())
-	: _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
+	: _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(___in)) { }
 
       template<typename _U1, typename _U2,
 	       _ExplicitCtor<true, _U1, _U2> = false>
 	explicit constexpr
-	tuple(tuple<_U1, _U2>&& __in)
+	tuple(tuple<_U1, _U2>&& ___in)
 	noexcept(__nothrow_constructible<_U1, _U2>())
-	: _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
+	: _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(___in)) { }
 
       template<typename _U1, typename _U2,
 	       _ImplicitCtor<true, const _U1&, const _U2&> = true>
 	constexpr
-	tuple(const pair<_U1, _U2>& __in)
+	tuple(const pair<_U1, _U2>& ___in)
 	noexcept(__nothrow_constructible<const _U1&, const _U2&>())
-	: _Inherited(__in.first, __in.second) { }
+	: _Inherited(___in.first, ___in.second) { }
 
       template<typename _U1, typename _U2,
 	       _ExplicitCtor<true, const _U1&, const _U2&> = false>
 	explicit constexpr
-	tuple(const pair<_U1, _U2>& __in)
+	tuple(const pair<_U1, _U2>& ___in)
 	noexcept(__nothrow_constructible<const _U1&, const _U2&>())
-	: _Inherited(__in.first, __in.second) { }
+	: _Inherited(___in.first, ___in.second) { }
 
       template<typename _U1, typename _U2,
 	       _ImplicitCtor<true, _U1, _U2> = true>
 	constexpr
-	tuple(pair<_U1, _U2>&& __in)
+	tuple(pair<_U1, _U2>&& ___in)
 	noexcept(__nothrow_constructible<_U1, _U2>())
-	: _Inherited(std::forward<_U1>(__in.first),
-		     std::forward<_U2>(__in.second)) { }
+	: _Inherited(std::forward<_U1>(___in.first),
+		     std::forward<_U2>(___in.second)) { }
 
       template<typename _U1, typename _U2,
 	       _ExplicitCtor<true, _U1, _U2> = false>
 	explicit constexpr
-	tuple(pair<_U1, _U2>&& __in)
+	tuple(pair<_U1, _U2>&& ___in)
 	noexcept(__nothrow_constructible<_U1, _U2>())
-	: _Inherited(std::forward<_U1>(__in.first),
-		     std::forward<_U2>(__in.second)) { }
+	: _Inherited(std::forward<_U1>(___in.first),
+		     std::forward<_U2>(___in.second)) { }
 
       // Allocator-extended constructors.
 
@@ -1098,21 +1098,21 @@
 
       template<typename _Alloc>
 	_GLIBCXX20_CONSTEXPR
-	tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
-	: _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
+	tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& ___in)
+	: _Inherited(__tag, __a, static_cast<const _Inherited&>(___in)) { }
 
       template<typename _Alloc>
 	_GLIBCXX20_CONSTEXPR
-	tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
-	: _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
+	tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& ___in)
+	: _Inherited(__tag, __a, static_cast<_Inherited&&>(___in)) { }
 
       template<typename _Alloc, typename _U1, typename _U2,
 	       _ImplicitCtor<true, const _U1&, const _U2&> = true>
 	_GLIBCXX20_CONSTEXPR
 	tuple(allocator_arg_t __tag, const _Alloc& __a,
-	      const tuple<_U1, _U2>& __in)
+	      const tuple<_U1, _U2>& ___in)
 	: _Inherited(__tag, __a,
-	             static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
+	             static_cast<const _Tuple_impl<0, _U1, _U2>&>(___in))
 	{ }
 
       template<typename _Alloc, typename _U1, typename _U2,
@@ -1120,55 +1120,55 @@
 	explicit
 	_GLIBCXX20_CONSTEXPR
 	tuple(allocator_arg_t __tag, const _Alloc& __a,
-	      const tuple<_U1, _U2>& __in)
+	      const tuple<_U1, _U2>& ___in)
 	: _Inherited(__tag, __a,
-	             static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
+	             static_cast<const _Tuple_impl<0, _U1, _U2>&>(___in))
 	{ }
 
       template<typename _Alloc, typename _U1, typename _U2,
 	       _ImplicitCtor<true, _U1, _U2> = true>
 	_GLIBCXX20_CONSTEXPR
-	tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
-	: _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
+	tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& ___in)
+	: _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(___in))
 	{ }
 
       template<typename _Alloc, typename _U1, typename _U2,
 	       _ExplicitCtor<true, _U1, _U2> = false>
 	explicit
 	_GLIBCXX20_CONSTEXPR
-	tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
-	: _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
+	tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& ___in)
+	: _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(___in))
 	{ }
 
       template<typename _Alloc, typename _U1, typename _U2,
 	       _ImplicitCtor<true, const _U1&, const _U2&> = true>
 	_GLIBCXX20_CONSTEXPR
 	tuple(allocator_arg_t __tag, const _Alloc& __a,
-	      const pair<_U1, _U2>& __in)
-	: _Inherited(__tag, __a, __in.first, __in.second) { }
+	      const pair<_U1, _U2>& ___in)
+	: _Inherited(__tag, __a, ___in.first, ___in.second) { }
 
       template<typename _Alloc, typename _U1, typename _U2,
 	       _ExplicitCtor<true, const _U1&, const _U2&> = false>
 	explicit
 	_GLIBCXX20_CONSTEXPR
 	tuple(allocator_arg_t __tag, const _Alloc& __a,
-	      const pair<_U1, _U2>& __in)
-	: _Inherited(__tag, __a, __in.first, __in.second) { }
+	      const pair<_U1, _U2>& ___in)
+	: _Inherited(__tag, __a, ___in.first, ___in.second) { }
 
       template<typename _Alloc, typename _U1, typename _U2,
 	       _ImplicitCtor<true, _U1, _U2> = true>
 	_GLIBCXX20_CONSTEXPR
-	tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
-	: _Inherited(__tag, __a, std::forward<_U1>(__in.first),
-		     std::forward<_U2>(__in.second)) { }
+	tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& ___in)
+	: _Inherited(__tag, __a, std::forward<_U1>(___in.first),
+		     std::forward<_U2>(___in.second)) { }
 
       template<typename _Alloc, typename _U1, typename _U2,
 	       _ExplicitCtor<true, _U1, _U2> = false>
 	explicit
 	_GLIBCXX20_CONSTEXPR
-	tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
-	: _Inherited(__tag, __a, std::forward<_U1>(__in.first),
-		     std::forward<_U2>(__in.second)) { }
+	tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& ___in)
+	: _Inherited(__tag, __a, std::forward<_U1>(___in.first),
+		     std::forward<_U2>(___in.second)) { }
 
       // Tuple assignment.
 
@@ -1176,10 +1176,10 @@
       tuple&
       operator=(typename conditional<__assignable<const _T1&, const _T2&>(),
 				     const tuple&,
-				     const __nonesuch&>::type __in)
+				     const __nonesuch&>::type ___in)
       noexcept(__nothrow_assignable<const _T1&, const _T2&>())
       {
-	this->_M_assign(__in);
+	this->_M_assign(___in);
 	return *this;
       }
 
@@ -1187,61 +1187,61 @@
       tuple&
       operator=(typename conditional<__assignable<_T1, _T2>(),
 				     tuple&&,
-				     __nonesuch&&>::type __in)
+				     __nonesuch&&>::type ___in)
       noexcept(__nothrow_assignable<_T1, _T2>())
       {
-	this->_M_assign(std::move(__in));
+	this->_M_assign(std::move(___in));
 	return *this;
       }
 
       template<typename _U1, typename _U2>
 	_GLIBCXX20_CONSTEXPR
 	__enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&>
-	operator=(const tuple<_U1, _U2>& __in)
+	operator=(const tuple<_U1, _U2>& ___in)
 	noexcept(__nothrow_assignable<const _U1&, const _U2&>())
 	{
-	  this->_M_assign(__in);
+	  this->_M_assign(___in);
 	  return *this;
 	}
 
       template<typename _U1, typename _U2>
 	_GLIBCXX20_CONSTEXPR
 	__enable_if_t<__assignable<_U1, _U2>(), tuple&>
-	operator=(tuple<_U1, _U2>&& __in)
+	operator=(tuple<_U1, _U2>&& ___in)
 	noexcept(__nothrow_assignable<_U1, _U2>())
 	{
-	  this->_M_assign(std::move(__in));
+	  this->_M_assign(std::move(___in));
 	  return *this;
 	}
 
       template<typename _U1, typename _U2>
 	_GLIBCXX20_CONSTEXPR
 	__enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&>
-	operator=(const pair<_U1, _U2>& __in)
+	operator=(const pair<_U1, _U2>& ___in)
 	noexcept(__nothrow_assignable<const _U1&, const _U2&>())
 	{
-	  this->_M_head(*this) = __in.first;
-	  this->_M_tail(*this)._M_head(*this) = __in.second;
+	  this->_M_head(*this) = ___in.first;
+	  this->_M_tail(*this)._M_head(*this) = ___in.second;
 	  return *this;
 	}
 
       template<typename _U1, typename _U2>
 	_GLIBCXX20_CONSTEXPR
 	__enable_if_t<__assignable<_U1, _U2>(), tuple&>
-	operator=(pair<_U1, _U2>&& __in)
+	operator=(pair<_U1, _U2>&& ___in)
 	noexcept(__nothrow_assignable<_U1, _U2>())
 	{
-	  this->_M_head(*this) = std::forward<_U1>(__in.first);
-	  this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
+	  this->_M_head(*this) = std::forward<_U1>(___in.first);
+	  this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(___in.second);
 	  return *this;
 	}
 
       _GLIBCXX20_CONSTEXPR
       void
-      swap(tuple& __in)
+      swap(tuple& ___in)
       noexcept(__and_<__is_nothrow_swappable<_T1>,
 		      __is_nothrow_swappable<_T2>>::value)
-      { _Inherited::_M_swap(__in); }
+      { _Inherited::_M_swap(___in); }
     };
 
 
diff -adru a/libstdc++-v3/include/std/utility b/libstdc++-v3/include/std/utility
--- a/libstdc++-v3/include/std/utility	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/std/utility	2021-04-09 13:06:24.461869800 +0800
@@ -220,23 +220,23 @@
 
   template<std::size_t _Int, class _Tp1, class _Tp2>
     constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
-    get(std::pair<_Tp1, _Tp2>& __in) noexcept
-    { return __pair_get<_Int>::__get(__in); }
+    get(std::pair<_Tp1, _Tp2>& ___in) noexcept
+    { return __pair_get<_Int>::__get(___in); }
 
   template<std::size_t _Int, class _Tp1, class _Tp2>
     constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
-    get(std::pair<_Tp1, _Tp2>&& __in) noexcept
-    { return __pair_get<_Int>::__move_get(std::move(__in)); }
+    get(std::pair<_Tp1, _Tp2>&& ___in) noexcept
+    { return __pair_get<_Int>::__move_get(std::move(___in)); }
 
   template<std::size_t _Int, class _Tp1, class _Tp2>
     constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
-    get(const std::pair<_Tp1, _Tp2>& __in) noexcept
-    { return __pair_get<_Int>::__const_get(__in); }
+    get(const std::pair<_Tp1, _Tp2>& ___in) noexcept
+    { return __pair_get<_Int>::__const_get(___in); }
 
   template<std::size_t _Int, class _Tp1, class _Tp2>
     constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
-    get(const std::pair<_Tp1, _Tp2>&& __in) noexcept
-    { return __pair_get<_Int>::__const_move_get(std::move(__in)); }
+    get(const std::pair<_Tp1, _Tp2>&& ___in) noexcept
+    { return __pair_get<_Int>::__const_move_get(std::move(___in)); }
 
 #if __cplusplus >= 201402L
 
diff -adru a/libstdc++-v3/include/tr1/regex b/libstdc++-v3/include/tr1/regex
--- a/libstdc++-v3/include/tr1/regex	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/tr1/regex	2021-04-09 13:06:24.461869800 +0800
@@ -2005,7 +2005,7 @@
        */
       template<typename _Out_iter>
         _Out_iter
-        format(_Out_iter __out, const string_type& __fmt,
+        format(_Out_iter ___out, const string_type& __fmt,
 	       regex_constants::match_flag_type __flags
 	       = regex_constants::format_default) const;
 
@@ -2401,7 +2401,7 @@
   template<typename _Out_iter, typename _Bi_iter,
 	   typename _Rx_traits, typename _Ch_type>
     inline _Out_iter
-    regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
+    regex_replace(_Out_iter ___out, _Bi_iter __first, _Bi_iter __last,
 		  const basic_regex<_Ch_type, _Rx_traits>& __e,
 		  const basic_string<_Ch_type>& __fmt,
 		  regex_constants::match_flag_type __flags
diff -adru a/libstdc++-v3/include/tr1/tuple b/libstdc++-v3/include/tr1/tuple
--- a/libstdc++-v3/include/tr1/tuple	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/tr1/tuple	2021-04-09 13:06:24.477491100 +0800
@@ -102,26 +102,26 @@
       : _Inherited(__tail...), _M_head(__head) { }
 
       template<typename... _UElements>
-      _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
-      : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
+      _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& ___in)
+      : _Inherited(___in._M_tail()), _M_head(___in._M_head) { }
 
-      _Tuple_impl(const _Tuple_impl& __in)
-      : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
+      _Tuple_impl(const _Tuple_impl& ___in)
+      : _Inherited(___in._M_tail()), _M_head(___in._M_head) { }
      
       template<typename... _UElements>
         _Tuple_impl&
-        operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
+        operator=(const _Tuple_impl<_Idx, _UElements...>& ___in)
         {
-	  _M_head = __in._M_head;
-	  _M_tail() = __in._M_tail();
+	  _M_head = ___in._M_head;
+	  _M_tail() = ___in._M_tail();
 	  return *this;
 	}
 
       _Tuple_impl&
-      operator=(const _Tuple_impl& __in)
+      operator=(const _Tuple_impl& ___in)
       {
-	_M_head = __in._M_head;
-	_M_tail() = __in._M_tail();
+	_M_head = ___in._M_head;
+	_M_tail() = ___in._M_tail();
 	return *this;
       }
     };
@@ -139,24 +139,24 @@
       : _Inherited(__elements...) { }
 
       template<typename... _UElements>
-        tuple(const tuple<_UElements...>& __in)
-	: _Inherited(__in) { }
+        tuple(const tuple<_UElements...>& ___in)
+	: _Inherited(___in) { }
 
-      tuple(const tuple& __in)
-      : _Inherited(__in) { }
+      tuple(const tuple& ___in)
+      : _Inherited(___in) { }
 
       template<typename... _UElements>
         tuple&
-        operator=(const tuple<_UElements...>& __in)
+        operator=(const tuple<_UElements...>& ___in)
         {
-	  static_cast<_Inherited&>(*this) = __in;
+	  static_cast<_Inherited&>(*this) = ___in;
 	  return *this;
 	}
 
       tuple&
-      operator=(const tuple& __in)
+      operator=(const tuple& ___in)
       {
-	static_cast<_Inherited&>(*this) = __in;
+	static_cast<_Inherited&>(*this) = ___in;
 	return *this;
       }
     };
@@ -178,41 +178,41 @@
       : _Inherited(__a1, __a2) { }
 
       template<typename _U1, typename _U2>
-        tuple(const tuple<_U1, _U2>& __in)
-	: _Inherited(__in) { }
+        tuple(const tuple<_U1, _U2>& ___in)
+	: _Inherited(___in) { }
 
-      tuple(const tuple& __in)
-      : _Inherited(__in) { }
+      tuple(const tuple& ___in)
+      : _Inherited(___in) { }
 
       template<typename _U1, typename _U2>
-        tuple(const pair<_U1, _U2>& __in)
+        tuple(const pair<_U1, _U2>& ___in)
 	: _Inherited(_Tuple_impl<0, 
 		     typename __add_c_ref<_U1>::type,
-		     typename __add_c_ref<_U2>::type>(__in.first, 
-						      __in.second))
+		     typename __add_c_ref<_U2>::type>(___in.first, 
+						      ___in.second))
         { }
   
       template<typename _U1, typename _U2>
         tuple&
-        operator=(const tuple<_U1, _U2>& __in)
+        operator=(const tuple<_U1, _U2>& ___in)
         {
-	  static_cast<_Inherited&>(*this) = __in;
+	  static_cast<_Inherited&>(*this) = ___in;
 	  return *this;
 	}
 
       tuple&
-      operator=(const tuple& __in)
+      operator=(const tuple& ___in)
       {
-	static_cast<_Inherited&>(*this) = __in;
+	static_cast<_Inherited&>(*this) = ___in;
 	return *this;
       }
 
       template<typename _U1, typename _U2>
         tuple&
-        operator=(const pair<_U1, _U2>& __in)
+        operator=(const pair<_U1, _U2>& ___in)
         {
-	  this->_M_head = __in.first;
-	  this->_M_tail()._M_head = __in.second;
+	  this->_M_head = ___in.first;
+	  this->_M_tail()._M_head = ___in.second;
 	  return *this;
 	}
     };
diff -adru a/libstdc++-v3/include/tr1/utility b/libstdc++-v3/include/tr1/utility
--- a/libstdc++-v3/include/tr1/utility	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/tr1/utility	2021-04-09 13:06:24.477491100 +0800
@@ -93,13 +93,13 @@
 
   template<int _Int, class _Tp1, class _Tp2>
     inline typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
-    get(std::pair<_Tp1, _Tp2>& __in)
-    { return __pair_get<_Int>::__get(__in); }
+    get(std::pair<_Tp1, _Tp2>& ___in)
+    { return __pair_get<_Int>::__get(___in); }
 
   template<int _Int, class _Tp1, class _Tp2>
     inline const typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
-    get(const std::pair<_Tp1, _Tp2>& __in)
-    { return __pair_get<_Int>::__const_get(__in); }
+    get(const std::pair<_Tp1, _Tp2>& ___in)
+    { return __pair_get<_Int>::__const_get(___in); }
 }
 
 _GLIBCXX_END_NAMESPACE_VERSION
diff -adru a/libstdc++-v3/include/tr2/bool_set b/libstdc++-v3/include/tr2/bool_set
--- a/libstdc++-v3/include/tr2/bool_set	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/tr2/bool_set	2021-04-09 13:06:24.493112800 +0800
@@ -131,18 +131,18 @@
 
     template<typename CharT, typename Traits>
       friend std::basic_ostream<CharT, Traits>&
-      operator<<(std::basic_ostream<CharT, Traits>& __out, bool_set __b)
+      operator<<(std::basic_ostream<CharT, Traits>& ___out, bool_set __b)
       {
 	int __a = __b._M_b;
-	__out << __a;
+	___out << __a;
       }
 
     template<typename CharT, typename Traits>
       friend std::basic_istream<CharT, Traits>&
-      operator>>(std::basic_istream<CharT, Traits>& __in, bool_set& __b)
+      operator>>(std::basic_istream<CharT, Traits>& ___in, bool_set& __b)
       {
 	long __c;
-	__in >> __c;
+	___in >> __c;
 	if (__c >= _S_false && __c < _S_empty)
 	  __b._M_b = static_cast<_Bool_set_val>(__c);
       }
diff -adru a/libstdc++-v3/include/tr2/bool_set.tcc b/libstdc++-v3/include/tr2/bool_set.tcc
--- a/libstdc++-v3/include/tr2/bool_set.tcc	2021-04-08 19:56:30.000000000 +0800
+++ b/libstdc++-v3/include/tr2/bool_set.tcc	2021-04-09 13:06:24.493112800 +0800
@@ -100,9 +100,9 @@
        *  @param  v  Value to format and insert.
        *  @return  Iterator after reading.
       iter_type
-      get(iter_type __in, iter_type __end, ios_base& __io,
+      get(iter_type ___in, iter_type __end, ios_base& __io,
 	  ios_base::iostate& __err, bool& __v) const
-      { return this->do_get(__in, __end, __io, __err, __v); }
+      { return this->do_get(___in, __end, __io, __err, __v); }
        */
 /*
   template<typename _CharT, typename _InIter>
diff -Naur gcc-10.1.0-orig/libstdc++-v3/scripts/gen_includers.pl gcc-10.1.0/libstdc++-v3/scripts/gen_includers.pl
--- gcc-10.1.0-orig/libstdc++-v3/scripts/gen_includers.pl	2020-05-07 13:50:02.000000000 +0300
+++ gcc-10.1.0/libstdc++-v3/scripts/gen_includers.pl	2020-05-08 17:20:01.806557600 +0300
@@ -15,8 +15,8 @@
 $bind_v_template_args = "typename result_of<_Mu<_T1> _CV(_T1, tuple<_GLIBCXX_BIND_TEMPLATE_ARGS>)>::type";
 $bind_v_args = "_Mu<_T1>()(_M_arg1, ::std::tr1::tie(_GLIBCXX_BIND_ARGS))";
 $tuple_add_cref = "typename __add_c_ref<_T1>::type __a1";
-$tuple_copy_init = "_M_arg1(__in._M_arg1)";
-$tuple_assign = "_M_arg1 = __in._M_arg1;";
+$tuple_copy_init = "_M_arg1(___in._M_arg1)";
+$tuple_assign = "_M_arg1 = ___in._M_arg1;";
 $template_params_null_class = "typename _T1 = _NullClass";
 $template_args_stripped = "typename __strip_reference_wrapper<_T1>::__type";
 $template_params_u = "typename _U1";
@@ -42,8 +42,8 @@
   $bind_v_template_args .= ", typename result_of<_Mu<_T$num_args> _CV(_T$num_args, tuple<_GLIBCXX_BIND_TEMPLATE_ARGS>)>::type";
   $bind_v_args .= ", _Mu<_T$num_args>()(_M_arg$num_args, ::std::tr1::tie(_GLIBCXX_BIND_ARGS))";
   $tuple_add_cref .= ", typename __add_c_ref<_T$num_args>::type __a$num_args";
-  $tuple_copy_init .= ", _M_arg$num_args(__in._M_arg$num_args)";
-  $tuple_assign .= " _M_arg$num_args = __in._M_arg$num_args;";
+  $tuple_copy_init .= ", _M_arg$num_args(___in._M_arg$num_args)";
+  $tuple_assign .= " _M_arg$num_args = ___in._M_arg$num_args;";
   $template_params_null_class .= ", typename _T$num_args = _NullClass";
   $template_args_stripped .= ", typename __strip_reference_wrapper<_T$num_args>::__type";
   $template_params_u .= ", typename _U$num_args";
diff -Naur gcc-10.1.0-orig/libstdc++-v3/src/c++11/snprintf_lite.cc gcc-10.1.0/libstdc++-v3/src/c++11/snprintf_lite.cc
--- gcc-10.1.0-orig/libstdc++-v3/src/c++11/snprintf_lite.cc	2020-05-07 13:50:02.000000000 +0300
+++ gcc-10.1.0/libstdc++-v3/src/c++11/snprintf_lite.cc	2020-05-08 17:31:40.727583100 +0300
@@ -74,14 +74,14 @@
     // Long enough for decimal representation.
     int __ilen = 3 * sizeof(__val);
     char *__cs = static_cast<char*>(__builtin_alloca(__ilen));
-    char* __out = __cs + __ilen;
+    char* ___out = __cs + __ilen;
     do
       {
-	*--__out = "0123456789"[__val % 10];
+	*--___out = "0123456789"[__val % 10];
 	__val /= 10;
       }
     while (__val != 0);
-    size_t __len = __cs + __ilen - __out;
+    size_t __len = __cs + __ilen - ___out;
     if (__bufsize < __len)
       return -1;
 
diff -Naur gcc-10.1.0-orig/libstdc++-v3/src/c++98/istream.cc gcc-10.1.0/libstdc++-v3/src/c++98/istream.cc
--- gcc-10.1.0-orig/libstdc++-v3/src/c++98/istream.cc	2020-05-07 13:50:02.000000000 +0300
+++ gcc-10.1.0/libstdc++-v3/src/c++98/istream.cc	2020-05-08 17:23:04.885820200 +0300
@@ -194,7 +194,7 @@
 
   template<>
     basic_istream<char>&
-    operator>>(basic_istream<char>& __in, char* __s)
+    operator>>(basic_istream<char>& ___in, char* __s)
     {
       typedef basic_istream<char>       	__istream_type;
       typedef __istream_type::int_type		__int_type;
@@ -205,20 +205,20 @@
 
       streamsize __extracted = 0;
       ios_base::iostate __err = ios_base::goodbit;
-      __istream_type::sentry __cerb(__in, false);
+      __istream_type::sentry __cerb(___in, false);
       if (__cerb)
 	{
 	  __try
 	    {
 	      // Figure out how many characters to extract.
-	      streamsize __num = __in.width();
+	      streamsize __num = ___in.width();
 	      if (__num <= 0)
 		__num = __gnu_cxx::__numeric_traits<streamsize>::__max;
 
-	      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+	      const __ctype_type& __ct = use_facet<__ctype_type>(___in.getloc());
 
 	      const __int_type __eof = __traits_type::eof();
-	      __streambuf_type* __sb = __in.rdbuf();
+	      __streambuf_type* __sb = ___in.rdbuf();
 	      __int_type __c = __sb->sgetc();
 
 	      while (__extracted < __num - 1
@@ -256,21 +256,21 @@
 	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
 	      // 68.  Extractors for char* should store null at end
 	      *__s = __char_type();
-	      __in.width(0);
+	      ___in.width(0);
 	    }
 	  __catch(__cxxabiv1::__forced_unwind&)
 	    {
-	      __in._M_setstate(ios_base::badbit);
+	      ___in._M_setstate(ios_base::badbit);
 	      __throw_exception_again;
 	    }
 	  __catch(...)
-	    { __in._M_setstate(ios_base::badbit); }
+	    { ___in._M_setstate(ios_base::badbit); }
 	}
       if (!__extracted)
 	__err |= ios_base::failbit;
       if (__err)
-	__in.setstate(__err);
-      return __in;
+	___in.setstate(__err);
+      return ___in;
     }
 
 #ifdef _GLIBCXX_USE_WCHAR_T
diff -Naur gcc-10.1.0-orig/libstdc++-v3/src/c++98/istream-string.cc gcc-10.1.0/libstdc++-v3/src/c++98/istream-string.cc
--- gcc-10.1.0-orig/libstdc++-v3/src/c++98/istream-string.cc	2020-05-07 13:50:02.000000000 +0300
+++ gcc-10.1.0/libstdc++-v3/src/c++98/istream-string.cc	2020-05-08 17:22:00.781026800 +0300
@@ -40,7 +40,7 @@
 
   template<>
     basic_istream<char>&
-    operator>>(basic_istream<char>& __in, basic_string<char>& __str)
+    operator>>(basic_istream<char>& ___in, basic_string<char>& __str)
     {
       typedef basic_istream<char>       	__istream_type;
       typedef __istream_type::int_type		__int_type;
@@ -52,18 +52,18 @@
 
       __size_type __extracted = 0;
       ios_base::iostate __err = ios_base::goodbit;
-      __istream_type::sentry __cerb(__in, false);
+      __istream_type::sentry __cerb(___in, false);
       if (__cerb)
 	{
 	  __try
 	    {
 	      __str.erase();
-	      const streamsize __w = __in.width();
+	      const streamsize __w = ___in.width();
 	      const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
 		                              : __str.max_size();
-	      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+	      const __ctype_type& __ct = use_facet<__ctype_type>(___in.getloc());
 	      const __int_type __eof = __traits_type::eof();
-	      __streambuf_type* __sb = __in.rdbuf();
+	      __streambuf_type* __sb = ___in.rdbuf();
 	      __int_type __c = __sb->sgetc();
 
 	      while (__extracted < __n
@@ -95,11 +95,11 @@
 
 	      if (__traits_type::eq_int_type(__c, __eof))
 		__err |= ios_base::eofbit;
-	      __in.width(0);
+	      ___in.width(0);
 	    }
 	  __catch(__cxxabiv1::__forced_unwind&)
 	    {
-	      __in._M_setstate(ios_base::badbit);
+	      ___in._M_setstate(ios_base::badbit);
 	      __throw_exception_again;
 	    }
 	  __catch(...)
@@ -107,19 +107,19 @@
 	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
 	      // 91. Description of operator>> and getline() for string<>
 	      // might cause endless loop
-	      __in._M_setstate(ios_base::badbit);
+	      ___in._M_setstate(ios_base::badbit);
 	    }
 	}
       if (!__extracted)
 	__err |= ios_base::failbit;
       if (__err)
-	__in.setstate(__err);
-      return __in;
+	___in.setstate(__err);
+      return ___in;
     }
 
   template<>
     basic_istream<char>&
-    getline(basic_istream<char>& __in, basic_string<char>& __str,
+    getline(basic_istream<char>& ___in, basic_string<char>& __str,
 	    char __delim)
     {
       typedef basic_istream<char>       	__istream_type;
@@ -133,7 +133,7 @@
       __size_type __extracted = 0;
       const __size_type __n = __str.max_size();
       ios_base::iostate __err = ios_base::goodbit;
-      __istream_type::sentry __cerb(__in, true);
+      __istream_type::sentry __cerb(___in, true);
       if (__cerb)
 	{
 	  __try
@@ -141,7 +141,7 @@
 	      __str.erase();
 	      const __int_type __idelim = __traits_type::to_int_type(__delim);
 	      const __int_type __eof = __traits_type::eof();
-	      __streambuf_type* __sb = __in.rdbuf();
+	      __streambuf_type* __sb = ___in.rdbuf();
 	      __int_type __c = __sb->sgetc();
 
 	      while (__extracted < __n
@@ -183,7 +183,7 @@
 	    }
 	  __catch(__cxxabiv1::__forced_unwind&)
 	    {
-	      __in._M_setstate(ios_base::badbit);
+	      ___in._M_setstate(ios_base::badbit);
 	      __throw_exception_again;
 	    }
 	  __catch(...)
@@ -191,20 +191,20 @@
 	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
 	      // 91. Description of operator>> and getline() for string<>
 	      // might cause endless loop
-	      __in._M_setstate(ios_base::badbit);
+	      ___in._M_setstate(ios_base::badbit);
 	    }
 	}
       if (!__extracted)
 	__err |= ios_base::failbit;
       if (__err)
-	__in.setstate(__err);
-      return __in;
+	___in.setstate(__err);
+      return ___in;
     }
 
 #ifdef _GLIBCXX_USE_WCHAR_T
   template<>
     basic_istream<wchar_t>&
-    getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
+    getline(basic_istream<wchar_t>& ___in, basic_string<wchar_t>& __str,
 	    wchar_t __delim)
     {
       typedef basic_istream<wchar_t>       	__istream_type;
@@ -218,7 +218,7 @@
       __size_type __extracted = 0;
       const __size_type __n = __str.max_size();
       ios_base::iostate __err = ios_base::goodbit;
-      __istream_type::sentry __cerb(__in, true);
+      __istream_type::sentry __cerb(___in, true);
       if (__cerb)
 	{
 	  __try
@@ -226,7 +226,7 @@
 	      __str.erase();
 	      const __int_type __idelim = __traits_type::to_int_type(__delim);
 	      const __int_type __eof = __traits_type::eof();
-	      __streambuf_type* __sb = __in.rdbuf();
+	      __streambuf_type* __sb = ___in.rdbuf();
 	      __int_type __c = __sb->sgetc();
 
 	      while (__extracted < __n
@@ -268,7 +268,7 @@
 	    }
 	  __catch(__cxxabiv1::__forced_unwind&)
 	    {
-	      __in._M_setstate(ios_base::badbit);
+	      ___in._M_setstate(ios_base::badbit);
 	      __throw_exception_again;
 	    }
 	  __catch(...)
@@ -276,14 +276,14 @@
 	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
 	      // 91. Description of operator>> and getline() for string<>
 	      // might cause endless loop
-	      __in._M_setstate(ios_base::badbit);
+	      ___in._M_setstate(ios_base::badbit);
 	    }
 	}
       if (!__extracted)
 	__err |= ios_base::failbit;
       if (__err)
-	__in.setstate(__err);
-      return __in;
+	___in.setstate(__err);
+      return ___in;
     }
 #endif
 
diff -Naur gcc-10.1.0-orig/libstdc++-v3/testsuite/performance/27_io/ifstream_extract_chars.cc gcc-10.1.0/libstdc++-v3/testsuite/performance/27_io/ifstream_extract_chars.cc
--- gcc-10.1.0-orig/libstdc++-v3/testsuite/performance/27_io/ifstream_extract_chars.cc	2020-05-07 13:50:03.000000000 +0300
+++ gcc-10.1.0/libstdc++-v3/testsuite/performance/27_io/ifstream_extract_chars.cc	2020-05-08 17:24:18.822634600 +0300
@@ -47,7 +47,7 @@
       out << line;
   }
   
-  // operator>>(basic_istream<char>& __in, basic_string<char>& __str)
+  // operator>>(basic_istream<char>& ___in, basic_string<char>& __str)
   {
     start_counters(time, resource);
     for (int iter = 0; iter < 25; ++iter)
@@ -62,7 +62,7 @@
     clear_counters(time, resource);
   }
   
-  // operator>>(basic_istream<char>& __in, char* __s)
+  // operator>>(basic_istream<char>& ___in, char* __s)
   {
     start_counters(time, resource);
     for (int iter = 0; iter < 25; ++iter)
diff -Naur gcc-10.1.0-orig/libstdc++-v3/testsuite/performance/27_io/ifstream_getline-2.cc gcc-10.1.0/libstdc++-v3/testsuite/performance/27_io/ifstream_getline-2.cc
--- gcc-10.1.0-orig/libstdc++-v3/testsuite/performance/27_io/ifstream_getline-2.cc	2020-05-07 13:50:03.000000000 +0300
+++ gcc-10.1.0/libstdc++-v3/testsuite/performance/27_io/ifstream_getline-2.cc	2020-05-08 17:24:27.481493000 +0300
@@ -63,7 +63,7 @@
     clear_counters(time, resource);
   }
 
-  // getline(basic_istream<_CharT, _Traits>& __in,
+  // getline(basic_istream<_CharT, _Traits>& ___in,
   //         basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
   {
     ifstream file(filename);
