non-gcc: Remove trailing whitespace

I've tried to build stage3 with -Wleading-whitespace=blanks -Wtrailing-whitespace=blank -Wno-error=leading-whitespace=blanks -Wno-error=trailing-whitespace=blank added to STRICT_WARN and that expectably resulted in about 2744 unique trailing whitespace warnings and 124837 leading whitespace warnings when excluding *.md files (which obviously is in big part a generator issue). Others from that are generator related, I think those need to be solved later. The following patch just fixes up the easy case (trailing whitespace), which could be easily automated: for i in `find . -name \*.h -o -name \*.cc -o -name \*.c | xargs grep -l '[ ]$' | grep -v testsuite/`; do sed -i -e 's/[ ]*$//' $i; done I've excluded files which I knew are obviously generated or go FE. Is there anything else we'd want to avoid the changes? Due to patch size, I've split it between gcc/ part and rest (include/, libiberty/, libgcc/, libcpp/, libstdc++-v3/; this part). 2024-10-24 Jakub Jelinek <jakub@redhat.com> include/ * dyn-string.h: Remove trailing whitespace. * libiberty.h: Likewise. * xregex.h: Likewise. * splay-tree.h: Likewise. * partition.h: Likewise. * plugin-api.h: Likewise. * demangle.h: Likewise. * vtv-change-permission.h: Likewise. * fibheap.h: Likewise. * hsa_ext_image.h: Likewise. * hashtab.h: Likewise. * libcollector.h: Likewise. * sort.h: Likewise. * symcat.h: Likewise. * hsa_ext_amd.h: Likewise. libcpp/ * directives.cc: Remove trailing whitespace. * mkdeps.cc: Likewise. * line-map.cc: Likewise. * internal.h: Likewise. * files.cc: Likewise. * init.cc: Likewise. * makeucnid.cc: Likewise. * system.h: Likewise. * include/line-map.h: Likewise. * include/symtab.h: Likewise. * include/cpplib.h: Likewise. * expr.cc: Likewise. * charset.cc: Likewise. * macro.cc: Likewise. * errors.cc: Likewise. * lex.cc: Likewise. * traditional.cc: Likewise. libgcc/ * crtstuff.c: Remove trailing whitespace. * libgcov.h: Likewise. * config/alpha/crtfastmath.c: Likewise. * config/alpha/vms-gcc_shell_handler.c: Likewise. * config/alpha/vms-unwind.h: Likewise. * config/pa/linux-atomic.c: Likewise. * config/pa/linux-unwind.h: Likewise. * config/pa/quadlib.c: Likewise. * config/pa/fptr.c: Likewise. * config/s390/32/_fixsfdi.c: Likewise. * config/s390/32/_fixunssfdi.c: Likewise. * config/s390/32/_fixunsdfdi.c: Likewise. * config/c6x/pr-support.c: Likewise. * config/lm32/_udivsi3.c: Likewise. * config/lm32/libgcc_lm32.h: Likewise. * config/lm32/_udivmodsi4.c: Likewise. * config/lm32/_mulsi3.c: Likewise. * config/lm32/_modsi3.c: Likewise. * config/lm32/_umodsi3.c: Likewise. * config/lm32/_divsi3.c: Likewise. * config/darwin-crt3.c: Likewise. * config/msp430/mpy.c: Likewise. * config/ia64/tf-signs.c: Likewise. * config/ia64/fde-vms.c: Likewise. * config/ia64/unwind-ia64.c: Likewise. * config/ia64/vms-unwind.h: Likewise. * config/ia64/sfp-exceptions.c: Likewise. * config/ia64/quadlib.c: Likewise. * config/ia64/unwind-ia64.h: Likewise. * config/rl78/vregs.h: Likewise. * config/arm/bpabi.c: Likewise. * config/arm/unwind-arm.c: Likewise. * config/arm/pr-support.c: Likewise. * config/arm/linux-atomic.c: Likewise. * config/arm/bpabi-lib.h: Likewise. * config/frv/frvend.c: Likewise. * config/frv/cmovw.c: Likewise. * config/frv/frvbegin.c: Likewise. * config/frv/cmovd.c: Likewise. * config/frv/cmovh.c: Likewise. * config/aarch64/cpuinfo.c: Likewise. * config/i386/crtfastmath.c: Likewise. * config/i386/cygming-crtend.c: Likewise. * config/i386/32/tf-signs.c: Likewise. * config/i386/crtprec.c: Likewise. * config/i386/sfp-exceptions.c: Likewise. * config/i386/w32-unwind.h: Likewise. * config/m32r/initfini.c: Likewise. * config/sparc/crtfastmath.c: Likewise. * config/gcn/amdgcn_veclib.h: Likewise. * config/nios2/linux-atomic.c: Likewise. * config/nios2/linux-unwind.h: Likewise. * config/nios2/lib2-mul.c: Likewise. * config/nios2/lib2-nios2.h: Likewise. * config/xtensa/unwind-dw2-xtensa.c: Likewise. * config/rs6000/darwin-fallback.c: Likewise. * config/rs6000/ibm-ldouble.c: Likewise. * config/rs6000/sfp-machine.h: Likewise. * config/rs6000/darwin-asm.h: Likewise. * config/rs6000/darwin-crt2.c: Likewise. * config/rs6000/aix-unwind.h: Likewise. * config/rs6000/sfp-exceptions.c: Likewise. * config/gthr-vxworks.c: Likewise. * config/riscv/atomic.c: Likewise. * config/visium/memcpy.c: Likewise. * config/darwin-crt-tm.c: Likewise. * config/stormy16/lib2funcs.c: Likewise. * config/arc/ieee-754/divtab-arc-sf.c: Likewise. * config/arc/ieee-754/divtab-arc-df.c: Likewise. * config/arc/initfini.c: Likewise. * config/sol2/gmon.c: Likewise. * config/microblaze/divsi3_table.c: Likewise. * config/m68k/fpgnulib.c: Likewise. * libgcov-driver.c: Likewise. * unwind-dw2.c: Likewise. * fp-bit.c: Likewise. * dfp-bit.h: Likewise. * dfp-bit.c: Likewise. * libgcov-driver-system.c: Likewise. libgcc/config/libbid/ * _le_td.c: Remove trailing whitespace. * bid128_compare.c: Likewise. * bid_div_macros.h: Likewise. * bid64_to_bid128.c: Likewise. * bid64_to_uint32.c: Likewise. * bid128_to_uint64.c: Likewise. * bid64_div.c: Likewise. * bid128_round_integral.c: Likewise. * bid_binarydecimal.c: Likewise. * bid128_string.c: Likewise. * bid_flag_operations.c: Likewise. * bid128_to_int64.c: Likewise. * _mul_sd.c: Likewise. * bid64_mul.c: Likewise. * bid128_noncomp.c: Likewise. * _gt_dd.c: Likewise. * bid64_add.c: Likewise. * bid64_string.c: Likewise. * bid_from_int.c: Likewise. * bid128.c: Likewise. * _ge_dd.c: Likewise. * _ne_sd.c: Likewise. * _dd_to_td.c: Likewise. * _unord_sd.c: Likewise. * bid64_to_uint64.c: Likewise. * _gt_sd.c: Likewise. * _sd_to_td.c: Likewise. * _addsub_td.c: Likewise. * _ne_td.c: Likewise. * bid_dpd.c: Likewise. * bid128_add.c: Likewise. * bid128_next.c: Likewise. * _lt_sd.c: Likewise. * bid64_next.c: Likewise. * bid128_mul.c: Likewise. * _lt_dd.c: Likewise. * _ge_td.c: Likewise. * _unord_dd.c: Likewise. * bid64_sqrt.c: Likewise. * bid_sqrt_macros.h: Likewise. * bid64_fma.c: Likewise. * _sd_to_dd.c: Likewise. * bid_conf.h: Likewise. * bid64_noncomp.c: Likewise. * bid_gcc_intrinsics.h: Likewise. * _gt_td.c: Likewise. * _ge_sd.c: Likewise. * bid128_minmax.c: Likewise. * bid128_quantize.c: Likewise. * bid32_to_bid64.c: Likewise. * bid_round.c: Likewise. * _td_to_sd.c: Likewise. * bid_inline_add.h: Likewise. * bid128_fma.c: Likewise. * _eq_td.c: Likewise. * bid32_to_bid128.c: Likewise. * bid64_rem.c: Likewise. * bid128_2_str_tables.c: Likewise. * _mul_dd.c: Likewise. * _dd_to_sd.c: Likewise. * bid128_div.c: Likewise. * _lt_td.c: Likewise. * bid64_compare.c: Likewise. * bid64_to_int32.c: Likewise. * _unord_td.c: Likewise. * bid128_rem.c: Likewise. * bid_internal.h: Likewise. * bid64_to_int64.c: Likewise. * _eq_dd.c: Likewise. * _td_to_dd.c: Likewise. * bid128_to_int32.c: Likewise. * bid128_to_uint32.c: Likewise. * _ne_dd.c: Likewise. * bid64_quantize.c: Likewise. * _le_dd.c: Likewise. * bid64_round_integral.c: Likewise. * _le_sd.c: Likewise. * bid64_minmax.c: Likewise. libgcc/config/avr/libf7/ * f7-renames.h: Remove trailing whitespace. libstdc++-v3/ * include/debug/debug.h: Remove trailing whitespace. * include/parallel/base.h: Likewise. * include/parallel/types.h: Likewise. * include/parallel/settings.h: Likewise. * include/parallel/multiseq_selection.h: Likewise. * include/parallel/partition.h: Likewise. * include/parallel/random_number.h: Likewise. * include/parallel/find_selectors.h: Likewise. * include/parallel/partial_sum.h: Likewise. * include/parallel/list_partition.h: Likewise. * include/parallel/search.h: Likewise. * include/parallel/algorithmfwd.h: Likewise. * include/parallel/random_shuffle.h: Likewise. * include/parallel/multiway_mergesort.h: Likewise. * include/parallel/sort.h: Likewise. * include/parallel/algobase.h: Likewise. * include/parallel/numericfwd.h: Likewise. * include/parallel/multiway_merge.h: Likewise. * include/parallel/losertree.h: Likewise. * include/bits/basic_ios.h: Likewise. * include/bits/stringfwd.h: Likewise. * include/bits/ostream_insert.h: Likewise. * include/bits/stl_heap.h: Likewise. * include/bits/unordered_map.h: Likewise. * include/bits/hashtable_policy.h: Likewise. * include/bits/stl_iterator_base_funcs.h: Likewise. * include/bits/valarray_before.h: Likewise. * include/bits/regex.h: Likewise. * include/bits/postypes.h: Likewise. * include/bits/stl_iterator.h: Likewise. * include/bits/localefwd.h: Likewise. * include/bits/stl_algo.h: Likewise. * include/bits/ios_base.h: Likewise. * include/bits/stl_function.h: Likewise. * include/bits/basic_string.h: Likewise. * include/bits/hashtable.h: Likewise. * include/bits/valarray_after.h: Likewise. * include/bits/char_traits.h: Likewise. * include/bits/gslice.h: Likewise. * include/bits/locale_facets_nonio.h: Likewise. * include/bits/mask_array.h: Likewise. * include/bits/specfun.h: Likewise. * include/bits/random.h: Likewise. * include/bits/slice_array.h: Likewise. * include/bits/valarray_array.h: Likewise. * include/tr1/float.h: Likewise. * include/tr1/functional_hash.h: Likewise. * include/tr1/math.h: Likewise. * include/tr1/hashtable_policy.h: Likewise. * include/tr1/stdio.h: Likewise. * include/tr1/complex.h: Likewise. * include/tr1/stdbool.h: Likewise. * include/tr1/stdarg.h: Likewise. * include/tr1/inttypes.h: Likewise. * include/tr1/fenv.h: Likewise. * include/tr1/stdlib.h: Likewise. * include/tr1/wchar.h: Likewise. * include/tr1/tgmath.h: Likewise. * include/tr1/limits.h: Likewise. * include/tr1/wctype.h: Likewise. * include/tr1/stdint.h: Likewise. * include/tr1/ctype.h: Likewise. * include/tr1/random.h: Likewise. * include/tr1/shared_ptr.h: Likewise. * include/ext/mt_allocator.h: Likewise. * include/ext/sso_string_base.h: Likewise. * include/ext/debug_allocator.h: Likewise. * include/ext/vstring_fwd.h: Likewise. * include/ext/pointer.h: Likewise. * include/ext/pod_char_traits.h: Likewise. * include/ext/malloc_allocator.h: Likewise. * include/ext/vstring.h: Likewise. * include/ext/bitmap_allocator.h: Likewise. * include/ext/pool_allocator.h: Likewise. * include/ext/type_traits.h: Likewise. * include/ext/ropeimpl.h: Likewise. * include/ext/codecvt_specializations.h: Likewise. * include/ext/throw_allocator.h: Likewise. * include/ext/extptr_allocator.h: Likewise. * include/ext/atomicity.h: Likewise. * include/ext/concurrence.h: Likewise. * include/c_compatibility/wchar.h: Likewise. * include/c_compatibility/stdint.h: Likewise. * include/backward/hash_fun.h: Likewise. * include/backward/binders.h: Likewise. * include/backward/hashtable.h: Likewise. * include/backward/auto_ptr.h: Likewise. * libsupc++/eh_arm.cc: Likewise. * libsupc++/unwind-cxx.h: Likewise. * libsupc++/si_class_type_info.cc: Likewise. * libsupc++/vec.cc: Likewise. * libsupc++/class_type_info.cc: Likewise. * libsupc++/vmi_class_type_info.cc: Likewise. * libsupc++/guard_error.cc: Likewise. * libsupc++/bad_typeid.cc: Likewise. * libsupc++/eh_personality.cc: Likewise. * libsupc++/atexit_arm.cc: Likewise. * libsupc++/pmem_type_info.cc: Likewise. * libsupc++/vterminate.cc: Likewise. * libsupc++/eh_terminate.cc: Likewise. * libsupc++/bad_cast.cc: Likewise. * libsupc++/exception_ptr.h: Likewise. * libsupc++/eh_throw.cc: Likewise. * libsupc++/bad_alloc.cc: Likewise. * libsupc++/nested_exception.cc: Likewise. * libsupc++/pointer_type_info.cc: Likewise. * libsupc++/pbase_type_info.cc: Likewise. * libsupc++/bad_array_new.cc: Likewise. * libsupc++/pure.cc: Likewise. * libsupc++/eh_exception.cc: Likewise. * libsupc++/bad_array_length.cc: Likewise. * libsupc++/cxxabi.h: Likewise. * libsupc++/guard.cc: Likewise. * libsupc++/eh_catch.cc: Likewise. * libsupc++/cxxabi_forced.h: Likewise. * libsupc++/tinfo.h: Likewise.
author: Jakub Jelinek <jakub@redhat.com> 2024-10-25 09:44:10 +0200
committer: Jakub Jelinek <jakub@gcc.gnu.org> 2024-10-25 10:03:17 +0200
commit: 45ab93d9afaead934a6501f070d6ac60a6bf9dd2 (patch)
tree: 16dad9bf8b15968fac3956c2a664274af3e3678f /libstdc++-v3
parent: 50332a4fdd3243899c395712c43daaef82c8180b (diff)
download: gcc-45ab93d9afaead934a6501f070d6ac60a6bf9dd2.zip
gcc-45ab93d9afaead934a6501f070d6ac60a6bf9dd2.tar.gz
gcc-45ab93d9afaead934a6501f070d6ac60a6bf9dd2.tar.bz2
116 files changed, 1034 insertions, 1034 deletions
diff --git a/libstdc++-v3/include/backward/auto_ptr.h b/libstdc++-v3/include/backward/auto_ptr.h
index 271a64d..659bbfb 100644
--- a/libstdc++-v3/include/backward/auto_ptr.h
+++ b/libstdc++-v3/include/backward/auto_ptr.h
@@ -48,7 +48,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     struct auto_ptr_ref
     {
       _Tp1* _M_ptr;
-      
+
       explicit
       auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
     } _GLIBCXX11_DEPRECATED;
@@ -94,11 +94,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     {
     private:
       _Tp* _M_ptr;
-      
+
     public:
       /// The pointed-to type.
       typedef _Tp element_type;
-      
+
       /**
        *  @brief  An %auto_ptr is usually constructed from a raw pointer.
        *  @param  __p  A pointer (defaults to NULL).
@@ -174,7 +174,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        *  prohibited.  [17.4.3.6]/2
        */
       ~auto_ptr() { delete _M_ptr; }
-      
+
       /**
        *  @brief  Smart pointer dereferencing.
        *
@@ -184,12 +184,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        *  what happens when you dereference one of those...)
        */
       element_type&
-      operator*() const throw() 
+      operator*() const throw()
       {
 	__glibcxx_assert(_M_ptr != 0);
-	return *_M_ptr; 
+	return *_M_ptr;
       }
-      
+
       /**
        *  @brief  Smart pointer dereferencing.
        *
@@ -197,12 +197,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        *  automatically cause to be dereferenced.
        */
       element_type*
-      operator->() const throw() 
+      operator->() const throw()
       {
 	__glibcxx_assert(_M_ptr != 0);
-	return _M_ptr; 
+	return _M_ptr;
       }
-      
+
       /**
        *  @brief  Bypassing the smart pointer.
        *  @return  The raw pointer being managed.
@@ -215,7 +215,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        */
       element_type*
       get() const throw() { return _M_ptr; }
-      
+
       /**
        *  @brief  Bypassing the smart pointer.
        *  @return  The raw pointer being managed.
@@ -234,7 +234,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	_M_ptr = 0;
 	return __tmp;
       }
-      
+
       /**
        *  @brief  Forcibly deletes the managed object.
        *  @param  __p  A pointer (defaults to NULL).
@@ -251,8 +251,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	    _M_ptr = __p;
 	  }
       }
-      
-      /** 
+
+      /**
        *  @brief  Automatic conversions
        *
        *  These operations are supposed to convert an %auto_ptr into and from
@@ -269,7 +269,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        */
       auto_ptr(auto_ptr_ref<element_type> __ref) throw()
       : _M_ptr(__ref._M_ptr) { }
-      
+
       auto_ptr&
       operator=(auto_ptr_ref<element_type> __ref) throw()
       {
@@ -280,7 +280,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  }
 	return *this;
       }
-      
+
       template<typename _Tp1>
         operator auto_ptr_ref<_Tp1>() throw()
         { return auto_ptr_ref<_Tp1>(this->release()); }
diff --git a/libstdc++-v3/include/backward/binders.h b/libstdc++-v3/include/backward/binders.h
index ab670a8..e0e1d89 100644
--- a/libstdc++-v3/include/backward/binders.h
+++ b/libstdc++-v3/include/backward/binders.h
@@ -173,7 +173,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     {
       typedef typename _Operation::second_argument_type _Arg2_type;
       return binder2nd<_Operation>(__fn, _Arg2_type(__x));
-    } 
+    }
   /** @}  */
 
 _GLIBCXX_END_NAMESPACE_VERSION
diff --git a/libstdc++-v3/include/backward/hash_fun.h b/libstdc++-v3/include/backward/hash_fun.h
index fe311ba..2c474bd 100644
--- a/libstdc++-v3/include/backward/hash_fun.h
+++ b/libstdc++-v3/include/backward/hash_fun.h
@@ -94,7 +94,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   template<>
     struct hash<char>
-    { 
+    {
       size_t
       operator()(char __x) const
       { return __x; }
@@ -102,7 +102,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   template<>
     struct hash<unsigned char>
-    { 
+    {
       size_t
       operator()(unsigned char __x) const
       { return __x; }
@@ -134,15 +134,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   template<>
     struct hash<int>
-    { 
-      size_t 
-      operator()(int __x) const 
+    {
+      size_t
+      operator()(int __x) const
       { return __x; }
     };
 
   template<>
     struct hash<unsigned int>
-    { 
+    {
       size_t
       operator()(unsigned int __x) const
       { return __x; }
diff --git a/libstdc++-v3/include/backward/hashtable.h b/libstdc++-v3/include/backward/hashtable.h
index 536962b..4f1f63a 100644
--- a/libstdc++-v3/include/backward/hashtable.h
+++ b/libstdc++-v3/include/backward/hashtable.h
@@ -77,7 +77,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       _Val _M_val;
     };
 
-  template<class _Val, class _Key, class _HashFcn, class _ExtractKey, 
+  template<class _Val, class _Key, class _HashFcn, class _ExtractKey,
 	   class _EqualKey, class _Alloc = std::allocator<_Val> >
     class hashtable;
 
@@ -108,7 +108,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef std::size_t size_type;
       typedef _Val& reference;
       typedef _Val* pointer;
-      
+
       _Node* _M_cur;
       _Hashtable* _M_ht;
 
@@ -160,7 +160,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef std::size_t size_type;
       typedef const _Val& reference;
       typedef const _Val* pointer;
-      
+
       const _Node* _M_cur;
       const _Hashtable* _M_ht;
 
@@ -233,7 +233,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     return pos == __last ? *(__last - 1) : *pos;
   }
 
-  // Forward declaration of operator==.  
+  // Forward declaration of operator==.
   template<class _Val, class _Key, class _HF, class _Ex,
 	   class _Eq, class _All>
     class hashtable;
@@ -251,7 +251,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   // allocator type are identical.  This is because, for hashtables,
   // this extra storage is negligible.  Additionally, a base class
   // wouldn't serve any other purposes; it wouldn't, for example,
-  // simplify the exception-handling code.  
+  // simplify the exception-handling code.
   template<class _Val, class _Key, class _HashFcn,
 	   class _ExtractKey, class _EqualKey, class _Alloc>
     class hashtable
@@ -312,7 +312,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       _ExtractKey           _M_get_key;
       _Vector_type          _M_buckets;
       size_type             _M_num_elements;
-      
+
     public:
       typedef _Hashtable_iterator<_Val, _Key, _HashFcn, _ExtractKey,
 				  _EqualKey, _Alloc>
@@ -542,7 +542,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       {
 	const size_type __n = _M_bkt_num_key(__key);
 	size_type __result = 0;
-	
+
 	for (const _Node* __cur = _M_buckets[__n]; __cur;
 	     __cur = __cur->_M_next)
 	  if (_M_equals(_M_get_key(__cur->_M_val), __key))
@@ -558,7 +558,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       size_type
       erase(const key_type& __key);
-      
+
       void
       erase(const iterator& __it);
 
@@ -632,7 +632,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	_Alloc_traits::destroy(__a, &__n->_M_val);
 	_M_put_node(__n);
       }
-      
+
       void
       _M_erase_bucket(const size_type __n, _Node* __first, _Node* __last);
 
@@ -716,7 +716,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  // Check same length of lists
 	  for (; __cur1 && __cur2;
 	       __cur1 = __cur1->_M_next, __cur2 = __cur2->_M_next)
-	    { } 
+	    { }
 	  if (__cur1 || __cur2)
 	    return false;
 	  // Now check one's elements are in the other
@@ -761,11 +761,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     {
       const size_type __n = _M_bkt_num(__obj);
       _Node* __first = _M_buckets[__n];
-      
+
       for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
 	if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj)))
 	  return std::pair<iterator, bool>(iterator(__cur, this), false);
-      
+
       _Node* __tmp = _M_new_node(__obj);
       __tmp->_M_next = __first;
       _M_buckets[__n] = __tmp;
@@ -780,7 +780,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     {
       const size_type __n = _M_bkt_num(__obj);
       _Node* __first = _M_buckets[__n];
-      
+
       for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
 	if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj)))
 	  {
@@ -807,11 +807,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       size_type __n = _M_bkt_num(__obj);
       _Node* __first = _M_buckets[__n];
-      
+
       for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
 	if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj)))
 	  return __cur->_M_val;
-      
+
       _Node* __tmp = _M_new_node(__obj);
       __tmp->_M_next = __first;
       _M_buckets[__n] = __tmp;
@@ -943,7 +943,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	{
 	  const size_type __n = _M_bkt_num(__p->_M_val);
 	  _Node* __cur = _M_buckets[__n];
-	  
+
 	  if (__cur == __p)
 	    {
 	      _M_buckets[__n] = __cur->_M_next;
@@ -1141,7 +1141,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	      {
 		_Node* __local_copy = _M_new_node(__cur->_M_val);
 		_M_buckets[__i] = __local_copy;
-		
+
 		for (_Node* __next = __cur->_M_next;
 		     __next;
 		     __cur = __next, __next = __cur->_M_next)
diff --git a/libstdc++-v3/include/bits/basic_ios.h b/libstdc++-v3/include/bits/basic_ios.h
index 8954ad1..0fb9502 100644
--- a/libstdc++-v3/include/bits/basic_ios.h
+++ b/libstdc++-v3/include/bits/basic_ios.h
@@ -55,7 +55,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   /**
    *  @brief Template class basic_ios, virtual base class for all
-   *  stream classes. 
+   *  stream classes.
    *  @ingroup io
    *
    *  @tparam _CharT  Type of character stream.
@@ -473,7 +473,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        *  accessible to users.
       */
       basic_ios()
-      : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false), 
+      : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
 	_M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
       { }
 
diff --git a/libstdc++-v3/include/bits/basic_string.h b/libstdc++-v3/include/bits/basic_string.h
index 28b3e53..e2ae626 100644
--- a/libstdc++-v3/include/bits/basic_string.h
+++ b/libstdc++-v3/include/bits/basic_string.h
@@ -1228,7 +1228,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
       { _M_set_length(0); }
 
       /**
-       *  Returns true if the %string is empty.  Equivalent to 
+       *  Returns true if the %string is empty.  Equivalent to
        *  <code>*this == ""</code>.
        */
       _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
@@ -4156,7 +4156,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
     basic_istream<wchar_t>&
     getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
 	    wchar_t __delim);
-#endif  
+#endif
 
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace
@@ -4414,7 +4414,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
   inline string
   to_string(float __val)
   {
-    const int __n = 
+    const int __n =
       __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
     return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
 					   "%f", __val);
@@ -4424,7 +4424,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
   inline string
   to_string(double __val)
   {
-    const int __n = 
+    const int __n =
       __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
     return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
 					   "%f", __val);
@@ -4434,7 +4434,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
   inline string
   to_string(long double __val)
   {
-    const int __n = 
+    const int __n =
       __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
     return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
 					   "%Lf", __val);
@@ -4443,12 +4443,12 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
 #endif // _GLIBCXX_USE_C99_STDIO
 
 #if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_C99_WCHAR
-  inline int 
+  inline int
   stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
   { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
 					__idx, __base); }
 
-  inline long 
+  inline long
   stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
   { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
 			     __idx, __base); }
diff --git a/libstdc++-v3/include/bits/char_traits.h b/libstdc++-v3/include/bits/char_traits.h
index fa922e5..1cd05e5 100644
--- a/libstdc++-v3/include/bits/char_traits.h
+++ b/libstdc++-v3/include/bits/char_traits.h
@@ -107,7 +107,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    *
    *  See https://gcc.gnu.org/onlinedocs/libstdc++/manual/strings.html#strings.string.character_types
    *  for advice on how to make use of this class for @a unusual character
-   *  types. Also, check out include/ext/pod_char_traits.h.  
+   *  types. Also, check out include/ext/pod_char_traits.h.
    */
   template<typename _CharT>
     struct char_traits
@@ -945,7 +945,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       static _GLIBCXX20_CONSTEXPR char_type*
       copy(char_type* __s1, const char_type* __s2, size_t __n)
-      { 
+      {
 	if (__n == 0)
 	  return __s1;
 #if __cplusplus >= 202002L
diff --git a/libstdc++-v3/include/bits/gslice.h b/libstdc++-v3/include/bits/gslice.h
index 90e21fd..4300a19 100644
--- a/libstdc++-v3/include/bits/gslice.h
+++ b/libstdc++-v3/include/bits/gslice.h
@@ -79,7 +79,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
      *  @param  __l  Array of dimension lengths.
      *  @param  __s  Array of dimension strides between array elements.
      */
-    gslice(size_t __o, const valarray<size_t>& __l, 
+    gslice(size_t __o, const valarray<size_t>& __l,
 	   const valarray<size_t>& __s);
 
     // XXX: the IS says the copy-ctor and copy-assignment operators are
@@ -100,7 +100,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
     ///  Return array of sizes of slice dimensions.
     valarray<size_t> size() const;
-    
+
     ///  Return array of array strides for each dimension.
     valarray<size_t> stride() const;
 
@@ -122,7 +122,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       void
       _M_increment_use()
       { ++_M_count; }
-      
+
       size_t
       _M_decrement_use()
       { return --_M_count; }
diff --git a/libstdc++-v3/include/bits/hashtable.h b/libstdc++-v3/include/bits/hashtable.h
index efc155b..f1a5490 100644
--- a/libstdc++-v3/include/bits/hashtable.h
+++ b/libstdc++-v3/include/bits/hashtable.h
@@ -177,7 +177,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    *  Pattern" (CRTP) technique, but uses a reconstructed, not
    *  explicitly passed, template pattern.
    *
-   *  Base class templates are: 
+   *  Base class templates are:
    *    - __detail::_Hashtable_base
    *    - __detail::_Map_base
    *    - __detail::_Insert
@@ -1705,7 +1705,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	{
 	  __x._M_buckets = _M_buckets;
 	  _M_buckets = &_M_single_bucket;
-	}	
+	}
       else
 	std::swap(_M_buckets, __x._M_buckets);
 
diff --git a/libstdc++-v3/include/bits/hashtable_policy.h b/libstdc++-v3/include/bits/hashtable_policy.h
index a91a9cf..5d79e2b 100644
--- a/libstdc++-v3/include/bits/hashtable_policy.h
+++ b/libstdc++-v3/include/bits/hashtable_policy.h
@@ -1042,7 +1042,7 @@ namespace __detail
       insert(const_iterator __hint, const value_type& __v)
       {
 	__hashtable& __h = _M_conjure_hashtable();
-	__node_gen_type __node_gen(__h);	
+	__node_gen_type __node_gen(__h);
 	return __h._M_insert(__hint, __v, __node_gen, __unique_keys{});
       }
 
diff --git a/libstdc++-v3/include/bits/ios_base.h b/libstdc++-v3/include/bits/ios_base.h
index 1418b18..f5cbfb3 100644
--- a/libstdc++-v3/include/bits/ios_base.h
+++ b/libstdc++-v3/include/bits/ios_base.h
@@ -56,8 +56,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   // as permitted (but not required) in the standard, in order to provide
   // better type safety in iostream calls.  A side effect is that in C++98
   // expressions involving them are not compile-time constants.
-  enum _Ios_Fmtflags 
-    { 
+  enum _Ios_Fmtflags
+    {
       _S_boolalpha 	= 1L << 0,
       _S_dec 		= 1L << 1,
       _S_fixed 		= 1L << 2,
@@ -125,7 +125,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #endif
 
   enum __attribute__((__flag_enum__)) _Ios_Openmode
-    { 
+    {
       _S_app 		= 1L << 0,
       _S_ate 		= 1L << 1,
       _S_bin 		= 1L << 2,
@@ -177,7 +177,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
 
   enum _Ios_Iostate
-    { 
+    {
       _S_goodbit 		= 0,
       _S_badbit 		= 1L << 0,
       _S_eofbit 		= 1L << 1,
@@ -223,12 +223,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   { return __a = __a ^ __b; }
 
 
-  enum _Ios_Seekdir 
-    { 
+  enum _Ios_Seekdir
+    {
       _S_beg = 0,
       _S_cur = _GLIBCXX_STDIO_SEEK_CUR,
       _S_end = _GLIBCXX_STDIO_SEEK_END,
-      _S_ios_seekdir_end = 1L << 16 
+      _S_ios_seekdir_end = 1L << 16
     };
 
 #if __cplusplus >= 201103L
@@ -282,7 +282,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #endif
   public:
 
-    /** 
+    /**
      *  @brief These are thrown to indicate problems with io.
      *  @ingroup exceptions
      *
@@ -611,7 +611,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       // 0 => OK to delete.
       int
-      _M_remove_reference() 
+      _M_remove_reference()
       {
         // Be race-detector-friendly.  For more info see bits/c++config.
         _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_refcount);
diff --git a/libstdc++-v3/include/bits/locale_facets_nonio.h b/libstdc++-v3/include/bits/locale_facets_nonio.h
index 298ffc1..5a90e1e 100644
--- a/libstdc++-v3/include/bits/locale_facets_nonio.h
+++ b/libstdc++-v3/include/bits/locale_facets_nonio.h
@@ -143,7 +143,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     private:
       __timepunct_cache&
       operator=(const __timepunct_cache&);
-      
+
       explicit
       __timepunct_cache(const __timepunct_cache&);
     };
@@ -1034,7 +1034,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
     private:
       __moneypunct_cache&
       operator=(const __moneypunct_cache&);
-      
+
       explicit
       __moneypunct_cache(const __moneypunct_cache&);
     };
@@ -1646,7 +1646,7 @@ _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11
       template<bool _Intl>
         iter_type
         _M_extract(iter_type __s, iter_type __end, ios_base& __io,
-		   ios_base::iostate& __err, string& __digits) const;     
+		   ios_base::iostate& __err, string& __digits) const;
     };
 
   template<typename _CharT, typename _InIter>
diff --git a/libstdc++-v3/include/bits/localefwd.h b/libstdc++-v3/include/bits/localefwd.h
index cee5c4d..3ba6e26 100644
--- a/libstdc++-v3/include/bits/localefwd.h
+++ b/libstdc++-v3/include/bits/localefwd.h
@@ -47,7 +47,7 @@ namespace std _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
-  /** 
+  /**
    *  @defgroup locales Locales
    *
    *  Classes and functions for internationalization and localization.
diff --git a/libstdc++-v3/include/bits/mask_array.h b/libstdc++-v3/include/bits/mask_array.h
index 341b828..63ea937 100644
--- a/libstdc++-v3/include/bits/mask_array.h
+++ b/libstdc++-v3/include/bits/mask_array.h
@@ -71,7 +71,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       ///  Copy constructor.  Both slices refer to the same underlying array.
       mask_array (const mask_array&);
-      
+
       ///  Assignment operator.  Assigns elements to corresponding elements
       ///  of @a a.
       mask_array& operator=(const mask_array&);
diff --git a/libstdc++-v3/include/bits/ostream_insert.h b/libstdc++-v3/include/bits/ostream_insert.h
index c92504e..7302b81 100644
--- a/libstdc++-v3/include/bits/ostream_insert.h
+++ b/libstdc++-v3/include/bits/ostream_insert.h
@@ -52,7 +52,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     __ostream_write(basic_ostream<_CharT, _Traits>& __out,
 		    const _CharT* __s, streamsize __n)
     {
-      typedef basic_ostream<_CharT, _Traits>       __ostream_type;      
+      typedef basic_ostream<_CharT, _Traits>       __ostream_type;
       typedef typename __ostream_type::ios_base    __ios_base;
 
       const streamsize __put = __out.rdbuf()->sputn(__s, __n);
@@ -64,7 +64,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     inline void
     __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
     {
-      typedef basic_ostream<_CharT, _Traits>       __ostream_type;      
+      typedef basic_ostream<_CharT, _Traits>       __ostream_type;
       typedef typename __ostream_type::ios_base    __ios_base;
 
       const _CharT __c = __out.fill();
diff --git a/libstdc++-v3/include/bits/postypes.h b/libstdc++-v3/include/bits/postypes.h
index cf5f301..8a2f4db 100644
--- a/libstdc++-v3/include/bits/postypes.h
+++ b/libstdc++-v3/include/bits/postypes.h
@@ -61,7 +61,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    *  implementation defined type.
    *  Note: In versions of GCC up to and including GCC 3.3, streamoff
    *  was typedef long.
-  */  
+  */
 #ifdef __INT64_TYPE__
   typedef __INT64_TYPE__          streamoff;
 #else
diff --git a/libstdc++-v3/include/bits/random.h b/libstdc++-v3/include/bits/random.h
index 5fda21a..1f39f0a 100644
--- a/libstdc++-v3/include/bits/random.h
+++ b/libstdc++-v3/include/bits/random.h
@@ -348,7 +348,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * A random number generator that produces pseudorandom numbers via
    * linear function:
    * @f[
-   *     x_{i+1}\leftarrow(ax_{i} + c) \bmod m 
+   *     x_{i+1}\leftarrow(ax_{i} + c) \bmod m
    * @f]
    *
    * The template parameter @p _UIntType must be an unsigned integral type
@@ -562,7 +562,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * This algorithm was originally invented by Makoto Matsumoto and
    * Takuji Nishimura.
    *
-   * @tparam __w  Word size, the number of bits in each element of 
+   * @tparam __w  Word size, the number of bits in each element of
    *              the state vector.
    * @tparam __n  The degree of recursion.
    * @tparam __m  The period parameter.
@@ -800,7 +800,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * A discrete random number generator that produces pseudorandom
    * numbers using:
    * @f[
-   *     x_{i}\leftarrow(x_{i - s} - x_{i - r} - carry_{i-1}) \bmod m 
+   *     x_{i}\leftarrow(x_{i - s} - x_{i - r} - carry_{i-1}) \bmod m
    * @f]
    *
    * The size of the state is @f$r@f$
@@ -2108,7 +2108,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * The formula for the normal probability density function is
    * @f[
    *     p(x|\mu,\sigma) = \frac{1}{\sigma \sqrt{2 \pi}}
-   *            e^{- \frac{{x - \mu}^ {2}}{2 \sigma ^ {2}} } 
+   *            e^{- \frac{{x - \mu}^ {2}}{2 \sigma ^ {2}} }
    * @f]
    *
    * @headerfile random
@@ -2335,7 +2335,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * The formula for the normal probability mass function is
    * @f[
    *     p(x|m,s) = \frac{1}{sx\sqrt{2\pi}}
-   *                \exp{-\frac{(\ln{x} - m)^2}{2s^2}} 
+   *                \exp{-\frac{(\ln{x} - m)^2}{2s^2}}
    * @f]
    *
    * @headerfile random
@@ -2560,7 +2560,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * The formula for the gamma probability density function is:
    * @f[
    *     p(x|\alpha,\beta) = \frac{1}{\beta\Gamma(\alpha)}
-   *                         (x/\beta)^{\alpha - 1} e^{-x/\beta} 
+   *                         (x/\beta)^{\alpha - 1} e^{-x/\beta}
    * @f]
    *
    * @headerfile random
@@ -3247,7 +3247,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * @f[
    *     p(x|m,n) = \frac{\Gamma((m+n)/2)}{\Gamma(m/2)\Gamma(n/2)}
    *                (\frac{m}{n})^{m/2} x^{(m/2)-1}
-   *                (1 + \frac{mx}{n})^{-(m+n)/2} 
+   *                (1 + \frac{mx}{n})^{-(m+n)/2}
    * @f]
    *
    * @headerfile random
@@ -3486,7 +3486,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * The formula for the normal probability mass function is:
    * @f[
    *     p(x|n) = \frac{1}{\sqrt(n\pi)} \frac{\Gamma((n+1)/2)}{\Gamma(n/2)}
-   *              (1 + \frac{x^2}{n}) ^{-(n+1)/2} 
+   *              (1 + \frac{x^2}{n}) ^{-(n+1)/2}
    * @f]
    *
    * @headerfile random
@@ -3605,7 +3605,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
         {
 	  typedef typename std::gamma_distribution<result_type>::param_type
 	    param_type;
-	
+
 	  const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2));
 	  return _M_nd(__urng) * std::sqrt(__p.n() / __g);
         }
@@ -5097,7 +5097,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * The formula for the normal probability density function is:
    * @f[
    *     p(x|\alpha,\beta) = \frac{\alpha}{\beta} (\frac{x}{\beta})^{\alpha-1}
-   *                         \exp{(-(\frac{x}{\beta})^\alpha)} 
+   *                         \exp{(-(\frac{x}{\beta})^\alpha)}
    * @f]
    *
    * @headerfile random
@@ -5314,7 +5314,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * The formula for the normal probability mass function is
    * @f[
    *     p(x|a,b) = \frac{1}{b}
-   *                \exp( \frac{a-x}{b} - \exp(\frac{a-x}{b})) 
+   *                \exp( \frac{a-x}{b} - \exp(\frac{a-x}{b}))
    * @f]
    *
    * @headerfile random
@@ -6048,7 +6048,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
 #if __cpp_impl_three_way_comparison < 201907L
   /**
-    * @brief Return true if two piecewise constant distributions have 
+    * @brief Return true if two piecewise constant distributions have
     *        different parameters.
    */
   template<typename _RealType>
diff --git a/libstdc++-v3/include/bits/regex.h b/libstdc++-v3/include/bits/regex.h
index e7e3520..68ff479 100644
--- a/libstdc++-v3/include/bits/regex.h
+++ b/libstdc++-v3/include/bits/regex.h
@@ -923,7 +923,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
     /// @endcond
     {
       typedef iterator_traits<_BiIter>			__iter_traits;
-	
+
     public:
       typedef typename __iter_traits::value_type      	value_type;
       typedef typename __iter_traits::difference_type 	difference_type;
diff --git a/libstdc++-v3/include/bits/slice_array.h b/libstdc++-v3/include/bits/slice_array.h
index 50ed758..a01e174 100644
--- a/libstdc++-v3/include/bits/slice_array.h
+++ b/libstdc++-v3/include/bits/slice_array.h
@@ -94,7 +94,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   // _GLIBCXX_RESOLVE_LIB_DEFECTS
   // 543. valarray slice default constructor
   inline
-  slice::slice() 
+  slice::slice()
   : _M_off(0), _M_sz(0), _M_st(0) {}
 
   inline
diff --git a/libstdc++-v3/include/bits/specfun.h b/libstdc++-v3/include/bits/specfun.h
index 580436e..44fa119 100644
--- a/libstdc++-v3/include/bits/specfun.h
+++ b/libstdc++-v3/include/bits/specfun.h
@@ -157,7 +157,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * @f]
    * is generally found to be within 10<sup>-15</sup> for 64-bit double on
    * linux-x86_64 systems over most of the ranges of validity.
-   * 
+   *
    * @todo Provide accuracy comparisons on a per-function basis for a small
    *       number of targets.
    *
diff --git a/libstdc++-v3/include/bits/stl_algo.h b/libstdc++-v3/include/bits/stl_algo.h
index c10f8aa..04bdaa6 100644
--- a/libstdc++-v3/include/bits/stl_algo.h
+++ b/libstdc++-v3/include/bits/stl_algo.h
@@ -200,7 +200,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  __tailSize -= __remainder;
 	  // __first here is always pointing to one past the last element of
 	  // next possible match.
-	  _RandomAccessIter __backTrack = __first; 
+	  _RandomAccessIter __backTrack = __first;
 	  while (__unary_pred(--__backTrack))
 	    {
 	      if (--__remainder == 0)
@@ -732,7 +732,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
 	    typename iterator_traits<_InputIterator>::value_type>)
       __glibcxx_requires_valid_range(__first, __last);
-      
+
       for (; __first != __last; ++__first)
 	if (__pred(*__first))
 	  {
@@ -1313,7 +1313,7 @@ _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(_V2)
    *  @param  __last    A forward iterator.
    *  @return  first + (last - middle).
    *
-   *  Rotates the elements of the range @p [__first,__last) by 
+   *  Rotates the elements of the range @p [__first,__last) by
    *  @p (__middle - __first) positions so that the element at @p __middle
    *  is moved to @p __first, the element at @p __middle+1 is moved to
    *  @p __first+1 and so on for each element in the range
@@ -1354,13 +1354,13 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
    *  @return   An iterator designating the end of the resulting sequence.
    *
    *  Copies the elements of the range @p [__first,__last) to the
-   *  range beginning at @result, rotating the copied elements by 
+   *  range beginning at @result, rotating the copied elements by
    *  @p (__middle-__first) positions so that the element at @p __middle
    *  is moved to @p __result, the element at @p __middle+1 is moved
    *  to @p __result+1 and so on for each element in the range @p
    *  [__first,__last).
    *
-   *  Performs 
+   *  Performs
    *  @p *(__result+(n+(__last-__middle))%(__last-__first))=*(__first+n)
    *  for each @p n in the range @p [0,__last-__first).
   */
@@ -1605,7 +1605,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
 	  ++__result_real_last;
 	  ++__first;
 	}
-      
+
       std::__make_heap(__result_first, __result_real_last, __comp);
       while (__first != __last)
 	{
@@ -3362,7 +3362,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
    *  @ingroup sorting_algorithms
    *  @param  __first  Start of range.
    *  @param  __last   End of range.
-   *  @return  make_pair(m, M), where m is the first iterator i in 
+   *  @return  make_pair(m, M), where m is the first iterator i in
    *           [__first, __last) such that no other element in the range is
    *           smaller, and where M is the last iterator i in [__first, __last)
    *           such that no other element in the range is larger.
@@ -3390,7 +3390,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
    *  @param  __first  Start of range.
    *  @param  __last   End of range.
    *  @param  __comp   Comparison functor.
-   *  @return  make_pair(m, M), where m is the first iterator i in 
+   *  @return  make_pair(m, M), where m is the first iterator i in
    *           [__first, __last) such that no other element in the range is
    *           smaller, and where M is the last iterator i in [__first, __last)
    *           such that no other element in the range is larger.
@@ -4907,7 +4907,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
 	    typename iterator_traits<_InputIterator2>::value_type>)
       __glibcxx_function_requires(_LessThanOpConcept<
 	    typename iterator_traits<_InputIterator2>::value_type,
-	    typename iterator_traits<_InputIterator1>::value_type>)	
+	    typename iterator_traits<_InputIterator1>::value_type>)
       __glibcxx_requires_sorted_set(__first1, __last1, __first2);
       __glibcxx_requires_sorted_set(__first2, __last2, __first1);
       __glibcxx_requires_irreflexive2(__first1, __last1);
@@ -5390,7 +5390,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
 	    typename iterator_traits<_InputIterator2>::value_type>)
       __glibcxx_function_requires(_LessThanOpConcept<
 	    typename iterator_traits<_InputIterator2>::value_type,
-	    typename iterator_traits<_InputIterator1>::value_type>)	
+	    typename iterator_traits<_InputIterator1>::value_type>)
       __glibcxx_requires_sorted_set(__first1, __last1, __first2);
       __glibcxx_requires_sorted_set(__first2, __last2, __first1);
       __glibcxx_requires_irreflexive2(__first1, __last1);
@@ -5483,7 +5483,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
 	    ++__first1;
 	    ++__first2;
 	  }
-      return std::copy(__first2, __last2, 
+      return std::copy(__first2, __last2,
 		       std::copy(__first1, __last1, __result));
     }
 
@@ -5525,7 +5525,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
 	    typename iterator_traits<_InputIterator2>::value_type>)
       __glibcxx_function_requires(_LessThanOpConcept<
 	    typename iterator_traits<_InputIterator2>::value_type,
-	    typename iterator_traits<_InputIterator1>::value_type>)	
+	    typename iterator_traits<_InputIterator1>::value_type>)
       __glibcxx_requires_sorted_set(__first1, __last1, __first2);
       __glibcxx_requires_sorted_set(__first2, __last2, __first1);
       __glibcxx_requires_irreflexive2(__first1, __last1);
diff --git a/libstdc++-v3/include/bits/stl_function.h b/libstdc++-v3/include/bits/stl_function.h
index c9123cc..8c77471f 100644
--- a/libstdc++-v3/include/bits/stl_function.h
+++ b/libstdc++-v3/include/bits/stl_function.h
@@ -117,10 +117,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     struct unary_function
     {
       /// @c argument_type is the type of the argument
-      typedef _Arg 	argument_type;   
+      typedef _Arg 	argument_type;
 
       /// @c result_type is the return type
-      typedef _Result 	result_type;  
+      typedef _Result 	result_type;
     } _GLIBCXX11_DEPRECATED;
 
   /**
@@ -131,7 +131,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     struct binary_function
     {
       /// @c first_argument_type is the type of the first argument
-      typedef _Arg1 	first_argument_type; 
+      typedef _Arg1 	first_argument_type;
 
       /// @c second_argument_type is the type of the second argument
       typedef _Arg2 	second_argument_type;
diff --git a/libstdc++-v3/include/bits/stl_heap.h b/libstdc++-v3/include/bits/stl_heap.h
index 9c1214a..c4bb7a9 100644
--- a/libstdc++-v3/include/bits/stl_heap.h
+++ b/libstdc++-v3/include/bits/stl_heap.h
@@ -360,7 +360,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  __parent--;
 	}
     }
-  
+
   /**
    *  @brief  Construct a heap over a range.
    *  @param  __first  Start of heap.
@@ -505,7 +505,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       __glibcxx_requires_irreflexive(__first, __last);
 
       __gnu_cxx::__ops::_Iter_less_iter __comp;
-      return __first + 
+      return __first +
 	std::__is_heap_until(__first, std::distance(__first, __last), __comp);
     }
 
diff --git a/libstdc++-v3/include/bits/stl_iterator.h b/libstdc++-v3/include/bits/stl_iterator.h
index 46e0d46..5962ab3 100644
--- a/libstdc++-v3/include/bits/stl_iterator.h
+++ b/libstdc++-v3/include/bits/stl_iterator.h
@@ -1598,10 +1598,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       _GLIBCXX17_CONSTEXPR move_iterator
       operator-(difference_type __n) const
       { return move_iterator(_M_current - __n); }
-    
+
       _GLIBCXX17_CONSTEXPR move_iterator&
       operator-=(difference_type __n)
-      { 
+      {
 	_M_current -= __n;
 	return *this;
       }
diff --git a/libstdc++-v3/include/bits/stl_iterator_base_funcs.h b/libstdc++-v3/include/bits/stl_iterator_base_funcs.h
index 0ee50aa..c0defba 100644
--- a/libstdc++-v3/include/bits/stl_iterator_base_funcs.h
+++ b/libstdc++-v3/include/bits/stl_iterator_base_funcs.h
@@ -244,7 +244,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER
     _GLIBCXX_NODISCARD [[__gnu__::__always_inline__]]
     inline _GLIBCXX17_CONSTEXPR _BidirectionalIterator
     prev(_BidirectionalIterator __x, typename
-	 iterator_traits<_BidirectionalIterator>::difference_type __n = 1) 
+	 iterator_traits<_BidirectionalIterator>::difference_type __n = 1)
     {
       // concept requirements
       __glibcxx_function_requires(_BidirectionalIteratorConcept<
diff --git a/libstdc++-v3/include/bits/stringfwd.h b/libstdc++-v3/include/bits/stringfwd.h
index 8f9a32d..55dd747 100644
--- a/libstdc++-v3/include/bits/stringfwd.h
+++ b/libstdc++-v3/include/bits/stringfwd.h
@@ -76,10 +76,10 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
 _GLIBCXX_END_NAMESPACE_CXX11
 
   /// A string of @c char
-  typedef basic_string<char>    string;   
+  typedef basic_string<char>    string;
 
   /// A string of @c wchar_t
-  typedef basic_string<wchar_t> wstring;   
+  typedef basic_string<wchar_t> wstring;
 
 #ifdef _GLIBCXX_USE_CHAR8_T
   /// A string of @c char8_t
@@ -88,10 +88,10 @@ _GLIBCXX_END_NAMESPACE_CXX11
 
 #if __cplusplus >= 201103L
   /// A string of @c char16_t
-  typedef basic_string<char16_t> u16string; 
+  typedef basic_string<char16_t> u16string;
 
   /// A string of @c char32_t
-  typedef basic_string<char32_t> u32string; 
+  typedef basic_string<char32_t> u32string;
 #endif
 
   /** @}  */
diff --git a/libstdc++-v3/include/bits/unordered_map.h b/libstdc++-v3/include/bits/unordered_map.h
index 01aa31a..8607944 100644
--- a/libstdc++-v3/include/bits/unordered_map.h
+++ b/libstdc++-v3/include/bits/unordered_map.h
@@ -91,7 +91,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
    *  @tparam  _Hash   Hashing function object type, defaults to hash<_Value>.
    *  @tparam  _Pred   Predicate function object type, defaults
    *                   to equal_to<_Value>.
-   *  @tparam  _Alloc  Allocator type, defaults to 
+   *  @tparam  _Alloc  Allocator type, defaults to
    *                   std::allocator<std::pair<const _Key, _Tp>>.
    *
    *  Meets the requirements of a <a href="tables.html#65">container</a>, and
@@ -458,7 +458,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        *
        *  @param __k    Key to use for finding a possibly existing pair in
        *                the unordered_map.
-       *  @param __args  Arguments used to generate the .second for a 
+       *  @param __args  Arguments used to generate the .second for a
        *                new pair instance.
        *
        *  @return  A pair, of which the first element is an iterator that points
@@ -498,7 +498,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        *                should be inserted.
        *  @param __k    Key to use for finding a possibly existing pair in
        *                the unordered_map.
-       *  @param __args  Arguments used to generate the .second for a 
+       *  @param __args  Arguments used to generate the .second for a
        *                new pair instance.
        *  @return An iterator that points to the element with key of the
        *          std::pair built from @a __args (may or may not be that
@@ -544,8 +544,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        *  @param __x Pair to be inserted (see std::make_pair for easy
        *	     creation of pairs).
        *
-       *  @return  A pair, of which the first element is an iterator that 
-       *           points to the possibly inserted pair, and the second is 
+       *  @return  A pair, of which the first element is an iterator that
+       *           points to the possibly inserted pair, and the second is
        *           a bool that is true if the pair was actually inserted.
        *
        *  This function attempts to insert a (key, value) %pair into the
@@ -641,18 +641,18 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        *  @brief Attempts to insert a std::pair into the %unordered_map.
        *  @param __k    Key to use for finding a possibly existing pair in
        *                the map.
-       *  @param __obj  Argument used to generate the .second for a pair 
+       *  @param __obj  Argument used to generate the .second for a pair
        *                instance.
        *
-       *  @return  A pair, of which the first element is an iterator that 
-       *           points to the possibly inserted pair, and the second is 
+       *  @return  A pair, of which the first element is an iterator that
+       *           points to the possibly inserted pair, and the second is
        *           a bool that is true if the pair was actually inserted.
        *
        *  This function attempts to insert a (key, value) %pair into the
        *  %unordered_map. An %unordered_map relies on unique keys and thus a
        *  %pair is only inserted if its first element (the key) is not already
        *  present in the %unordered_map.
-       *  If the %pair was already in the %unordered_map, the .second of 
+       *  If the %pair was already in the %unordered_map, the .second of
        *  the %pair is assigned from __obj.
        *
        *  Insertion requires amortized constant time.
@@ -686,14 +686,14 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        *                  pair should be inserted.
        *  @param __k    Key to use for finding a possibly existing pair in
        *                the unordered_map.
-       *  @param __obj  Argument used to generate the .second for a pair 
+       *  @param __obj  Argument used to generate the .second for a pair
        *                instance.
        *  @return An iterator that points to the element with key of
        *           @a __x (may or may not be the %pair passed in).
        *
        *  This function is not concerned about whether the insertion took place,
        *  and thus does not return a boolean like the single-argument insert()
-       *  does.         
+       *  does.
        *  If the %pair was already in the %unordered map, the .second of
        *  the %pair is assigned from __obj.
        *  Note that the first parameter is only a hint and can
@@ -1038,7 +1038,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
       size_type
       bucket(const key_type& __key) const
       { return _M_h.bucket(__key); }
-      
+
       /**
        *  @brief  Returns a read/write iterator pointing to the first bucket
        *         element.
@@ -1938,7 +1938,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
       size_type
       bucket(const key_type& __key) const
       { return _M_h.bucket(__key); }
-      
+
       /**
        *  @brief  Returns a read/write iterator pointing to the first bucket
        *         element.
diff --git a/libstdc++-v3/include/bits/valarray_after.h b/libstdc++-v3/include/bits/valarray_after.h
index 380839c..ea0e846 100644
--- a/libstdc++-v3/include/bits/valarray_after.h
+++ b/libstdc++-v3/include/bits/valarray_after.h
@@ -50,14 +50,14 @@ namespace __detail
     {
     public:
       typedef typename _Dom::value_type value_type;
-      
+
       _GBase (const _Dom& __e, const valarray<size_t>& __i)
       : _M_expr (__e), _M_index(__i) {}
-      
+
       value_type
       operator[] (size_t __i) const
       { return _M_expr[_M_index[__i]]; }
-      
+
       size_t
       size () const
       { return _M_index.size(); }
@@ -72,14 +72,14 @@ namespace __detail
     {
     public:
       typedef _Tp value_type;
-      
+
       _GBase (_Array<_Tp> __a, const valarray<size_t>& __i)
       : _M_array (__a), _M_index(__i) {}
-      
+
       value_type
       operator[] (size_t __i) const
       { return _M_array._M_data[_M_index[__i]]; }
-      
+
       size_t
       size () const
       { return _M_index.size(); }
@@ -95,7 +95,7 @@ namespace __detail
     {
       typedef _GBase<_Dom> _Base;
       typedef typename _Base::value_type value_type;
-      
+
       _GClos (const _Dom& __e, const valarray<size_t>& __i)
       : _Base (__e, __i) {}
     };
@@ -106,7 +106,7 @@ namespace __detail
     {
       typedef _GBase<_Array<_Tp> > _Base;
       typedef typename _Base::value_type value_type;
-      
+
       _GClos (_Array<_Tp> __a, const valarray<size_t>& __i)
       : _Base (__a, __i) {}
     };
@@ -122,11 +122,11 @@ namespace __detail
 
       _IBase (const _Dom& __e, const valarray<size_t>& __i)
       : _M_expr (__e), _M_index (__i) {}
-      
+
       value_type
       operator[] (size_t __i) const
       { return _M_expr[_M_index[__i]]; }
-      
+
       size_t
       size() const
       { return _M_index.size(); }
@@ -142,7 +142,7 @@ namespace __detail
     {
       typedef _IBase<_Dom> _Base;
       typedef typename _Base::value_type value_type;
-      
+
       _IClos (const _Dom& __e, const valarray<size_t>& __i)
       : _Base (__e, __i) {}
     };
@@ -153,12 +153,12 @@ namespace __detail
     {
       typedef _IBase<valarray<_Tp> > _Base;
       typedef _Tp value_type;
-      
+
       _IClos (const valarray<_Tp>& __a, const valarray<size_t>& __i)
       : _Base (__a, __i) {}
     };
 } // namespace __detail
-  
+
   //
   // class _Expr
   //
diff --git a/libstdc++-v3/include/bits/valarray_array.h b/libstdc++-v3/include/bits/valarray_array.h
index 0c14331..ce21c32 100644
--- a/libstdc++-v3/include/bits/valarray_array.h
+++ b/libstdc++-v3/include/bits/valarray_array.h
@@ -160,13 +160,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       while (__n--)
 	*__a++ = __t;
     }
-  
+
   // fill strided array __a[<__n-1 : __s>] with __t
   template<typename _Tp>
     inline void
     __valarray_fill(_Tp* __restrict__ __a, size_t __n,
 		    size_t __s, const _Tp& __t)
-    { 
+    {
       for (size_t __i = 0; __i < __n; ++__i, __a += __s)
 	*__a = __t;
     }
@@ -180,7 +180,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       for (size_t __j = 0; __j < __n; ++__j, ++__i)
 	__a[*__i] = __t;
     }
-  
+
   // copy plain array __a[<__n>] in __b[<__n>]
   // For non-fundamental types, it is wrong to say 'memcpy()'
   template<typename _Tp, bool>
@@ -339,9 +339,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       explicit _Array(_Tp* const __restrict__);
       explicit _Array(const valarray<_Tp>&);
       _Array(const _Tp* __restrict__, size_t);
-      
+
       _Tp* begin() const;
-      
+
       _Tp* const __restrict__ _M_data;
     };
 
diff --git a/libstdc++-v3/include/bits/valarray_before.h b/libstdc++-v3/include/bits/valarray_before.h
index c6eabd2..2c439f7 100644
--- a/libstdc++-v3/include/bits/valarray_before.h
+++ b/libstdc++-v3/include/bits/valarray_before.h
@@ -504,7 +504,7 @@ namespace __detail
       { return _Oper()(_M_expr[__i]); }
 
       size_t size() const { return _M_expr.size(); }
-      
+
     private:
       typename _ValArrayRef<_Arg>::__type _M_expr;
     };
@@ -692,14 +692,14 @@ namespace __detail
     {
     public:
       typedef typename _Dom::value_type value_type;
-      
+
       _SBase (const _Dom& __e, const slice& __s)
       : _M_expr (__e), _M_slice (__s) {}
-        
+
       value_type
       operator[] (size_t __i) const
       { return _M_expr[_M_slice.start () + __i * _M_slice.stride ()]; }
-        
+
       size_t
       size() const
       { return _M_slice.size (); }
@@ -714,15 +714,15 @@ namespace __detail
     {
     public:
       typedef _Tp value_type;
-      
+
       _SBase (_Array<_Tp> __a, const slice& __s)
       : _M_array (__a._M_data+__s.start()), _M_size (__s.size()),
 	_M_stride (__s.stride()) {}
-        
+
       value_type
       operator[] (size_t __i) const
       { return _M_array._M_data[__i * _M_stride]; }
-      
+
       size_t
       size() const
       { return _M_size; }
@@ -739,7 +739,7 @@ namespace __detail
     {
       typedef _SBase<_Dom> _Base;
       typedef typename _Base::value_type value_type;
-      
+
       _SClos (const _Dom& __e, const slice& __s) : _Base (__e, __s) {}
     };
 
@@ -749,7 +749,7 @@ namespace __detail
     {
       typedef  _SBase<_Array<_Tp> > _Base;
       typedef _Tp value_type;
-      
+
       _SClos (_Array<_Tp> __a, const slice& __s) : _Base (__a, __s) {}
     };
 } // namespace __detail
diff --git a/libstdc++-v3/include/c_compatibility/stdint.h b/libstdc++-v3/include/c_compatibility/stdint.h
index 8923db8..fec6900 100644
--- a/libstdc++-v3/include/c_compatibility/stdint.h
+++ b/libstdc++-v3/include/c_compatibility/stdint.h
@@ -82,7 +82,7 @@ namespace std
 
   using ::intmax_t;
   using ::intptr_t;
-  
+
   using ::uint8_t;
   using ::uint16_t;
   using ::uint32_t;
diff --git a/libstdc++-v3/include/c_compatibility/wchar.h b/libstdc++-v3/include/c_compatibility/wchar.h
index c618b17..d7420dd 100644
--- a/libstdc++-v3/include/c_compatibility/wchar.h
+++ b/libstdc++-v3/include/c_compatibility/wchar.h
@@ -111,6 +111,6 @@ using std::wcstoull;
 
 #endif  //_GLIBCXX_USE_WCHAR_T
 
-#endif 
+#endif
 
 #endif
diff --git a/libstdc++-v3/include/debug/debug.h b/libstdc++-v3/include/debug/debug.h
index 3d1f097..4c88125 100644
--- a/libstdc++-v3/include/debug/debug.h
+++ b/libstdc++-v3/include/debug/debug.h
@@ -46,8 +46,8 @@
  * @brief GNU debug code, replaces standard behavior with debug behavior.
  */
 namespace std
-{ 
-  namespace __debug { } 
+{
+  namespace __debug { }
 }
 
 /** @namespace __gnu_debug
diff --git a/libstdc++-v3/include/ext/atomicity.h b/libstdc++-v3/include/ext/atomicity.h
index 964a634..6242586 100644
--- a/libstdc++-v3/include/ext/atomicity.h
+++ b/libstdc++-v3/include/ext/atomicity.h
@@ -126,4 +126,4 @@ _GLIBCXX_END_NAMESPACE_VERSION
 #define _GLIBCXX_WRITE_MEM_BARRIER __atomic_thread_fence (__ATOMIC_RELEASE)
 #endif
 
-#endif 
+#endif
diff --git a/libstdc++-v3/include/ext/bitmap_allocator.h b/libstdc++-v3/include/ext/bitmap_allocator.h
index 45b2283..c23fe2d 100644
--- a/libstdc++-v3/include/ext/bitmap_allocator.h
+++ b/libstdc++-v3/include/ext/bitmap_allocator.h
@@ -57,7 +57,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
      *
      *  It is to be used only for built-in types or PODs. Notable
      *  differences are:
-     * 
+     *
      *  1. Not all accessor functions are present.
      *  2. Used ONLY for PODs.
      *  3. No Allocator template argument. Uses ::operator new() to get
@@ -225,8 +225,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	typedef std::ptrdiff_t difference_type;
       };
 
-    enum 
-      { 
+    enum
+      {
 	bits_per_byte = 8,
 	bits_per_block = sizeof(std::size_t) * std::size_t(bits_per_byte)
       };
@@ -278,42 +278,42 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
     // _Tp should be a pointer type.
     template<typename _Tp>
-      class _Inclusive_between 
+      class _Inclusive_between
       {
 	typedef _Tp pointer;
 	pointer _M_ptr_value;
 	typedef typename std::pair<_Tp, _Tp> _Block_pair;
-	
+
       public:
-	_Inclusive_between(pointer __ptr) : _M_ptr_value(__ptr) 
+	_Inclusive_between(pointer __ptr) : _M_ptr_value(__ptr)
 	{ }
-	
-	bool 
+
+	bool
 	operator()(_Block_pair __bp) const throw()
 	{
-	  if (std::less_equal<pointer>()(_M_ptr_value, __bp.second) 
+	  if (std::less_equal<pointer>()(_M_ptr_value, __bp.second)
 	      && std::greater_equal<pointer>()(_M_ptr_value, __bp.first))
 	    return true;
 	  else
 	    return false;
 	}
       };
-  
+
     // Used to pass a Functor to functions by reference.
     template<typename _Functor>
-      class _Functor_Ref 
+      class _Functor_Ref
       {
 	_Functor& _M_fref;
-	
+
       public:
 	typedef typename _Functor::argument_type argument_type;
 	typedef typename _Functor::result_type result_type;
 
-	_Functor_Ref(_Functor& __fref) : _M_fref(__fref) 
+	_Functor_Ref(_Functor& __fref) : _M_fref(__fref)
 	{ }
 
-	result_type 
-	operator()(argument_type __arg) 
+	result_type
+	operator()(argument_type __arg)
 	{ return _M_fref(__arg); }
       };
 
@@ -325,7 +325,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     // _Tp should be a pointer type, and _Alloc is the Allocator for
     // the vector.
     template<typename _Tp>
-      class _Ffit_finder 
+      class _Ffit_finder
       {
 	typedef std::pair<_Tp, _Tp> _Block_pair;
 	typedef __detail::__mini_vector<_Block_pair> _BPVector;
@@ -341,7 +341,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	_Ffit_finder() : _M_pbitmap(0), _M_data_offset(0)
 	{ }
 
-	bool 
+	bool
 	operator()(_Block_pair __bp) throw()
 	{
 	  using std::size_t;
@@ -375,7 +375,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	    }
 	  return false;
 	}
-    
+
 	std::size_t*
 	_M_get() const throw()
 	{ return _M_pbitmap; }
@@ -404,15 +404,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	std::size_t* _M_curr_bmap;
 	std::size_t* _M_last_bmap_in_block;
 	_Index_type _M_curr_index;
-    
+
       public:
 	// Use the 2nd parameter with care. Make sure that such an
 	// entry exists in the vector before passing that particular
 	// index to this ctor.
 	_Bitmap_counter(_BPVector& Rvbp, long __index = -1) : _M_vbp(Rvbp)
 	{ this->_M_reset(__index); }
-    
-	void 
+
+	void
 	_M_reset(long __index = -1) throw()
 	{
 	  if (__index == -1)
@@ -425,26 +425,26 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  _M_curr_index = __index;
 	  _M_curr_bmap = reinterpret_cast<std::size_t*>
 	    (_M_vbp[_M_curr_index].first) - 1;
-	  
+
 	  _GLIBCXX_DEBUG_ASSERT(__index <= (long)_M_vbp.size() - 1);
-	
+
 	  _M_last_bmap_in_block = _M_curr_bmap
-	    - ((_M_vbp[_M_curr_index].second 
-		- _M_vbp[_M_curr_index].first + 1) 
+	    - ((_M_vbp[_M_curr_index].second
+		- _M_vbp[_M_curr_index].first + 1)
 	       / std::size_t(bits_per_block) - 1);
 	}
-    
+
 	// Dangerous Function! Use with extreme care. Pass to this
 	// function ONLY those values that are known to be correct,
 	// otherwise this will mess up big time.
 	void
 	_M_set_internal_bitmap(std::size_t* __new_internal_marker) throw()
 	{ _M_curr_bmap = __new_internal_marker; }
-    
+
 	bool
 	_M_finished() const throw()
 	{ return(_M_curr_bmap == 0); }
-    
+
 	_Bitmap_counter&
 	operator++() throw()
 	{
@@ -459,12 +459,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	    --_M_curr_bmap;
 	  return *this;
 	}
-    
+
 	std::size_t*
 	_M_get() const throw()
 	{ return _M_curr_bmap; }
-    
-	pointer 
+
+	pointer
 	_M_base() const throw()
 	{ return _M_vbp[_M_curr_index].first; }
 
@@ -475,7 +475,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	    * ((reinterpret_cast<std::size_t*>(this->_M_base())
 		- _M_curr_bmap) - 1);
 	}
-    
+
 	_Index_type
 	_M_where() const throw()
 	{ return _M_curr_index; }
@@ -484,18 +484,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     /** @brief  Mark a memory address as allocated by re-setting the
      *  corresponding bit in the bit-map.
      */
-    inline void 
+    inline void
     __bit_allocate(std::size_t* __pbmap, std::size_t __pos) throw()
     {
       std::size_t __mask = 1 << __pos;
       __mask = ~__mask;
       *__pbmap &= __mask;
     }
-  
+
     /** @brief  Mark a memory address as free by setting the
      *  corresponding bit in the bit-map.
      */
-    inline void 
+    inline void
     __bit_free(std::size_t* __pbmap, std::size_t __pos) throw()
     {
       std::size_t __mask = 1 << __pos;
@@ -582,10 +582,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	      __free_list.pop_back();
 	    }
 	}
-	  
+
       // Just add the block to the list of free lists unconditionally.
       iterator __temp = __detail::__lower_bound
-	(__free_list.begin(), __free_list.end(), 
+	(__free_list.begin(), __free_list.end(),
 	 *__addr, _LT_pointer_compare());
 
       // We may insert the new free list before _temp;
@@ -603,12 +603,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
      *  @return true if the wastage incurred is acceptable, else returns
      *  false.
      */
-    bool 
+    bool
     _M_should_i_give(std::size_t __block_size,
 		     std::size_t __required_size) throw()
     {
       const std::size_t __max_wastage_percentage = 36;
-      if (__block_size >= __required_size && 
+      if (__block_size >= __required_size &&
 	  (((__block_size - __required_size) * 100 / __block_size)
 	   < __max_wastage_percentage))
 	return true;
@@ -623,7 +623,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
      *  @param  __addr The pointer to the memory block that was given
      *  by a call to the _M_get function.
      */
-    inline void 
+    inline void
     _M_insert(std::size_t* __addr) throw()
     {
 #if defined __GTHREADS
@@ -634,7 +634,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       this->_M_validate(reinterpret_cast<std::size_t*>(__addr) - 1);
       // See discussion as to why this is 1!
     }
-    
+
     /** @brief  This function gets a block of memory of the specified
      *  size from the free list.
      *
@@ -649,13 +649,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     /** @brief  This function just clears the internal Free List, and
      *  gives back all the memory to the OS.
      */
-    void 
+    void
     _M_clear();
   };
 
 
   // Forward declare the class.
-  template<typename _Tp> 
+  template<typename _Tp>
     class bitmap_allocator;
 
   // Specialize for void:
@@ -709,7 +709,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
         struct aligned_size
 	{
 	  enum
-	    { 
+	    {
 	      modulus = _BSize % _AlignSize,
 	      value = _BSize + (modulus ? _AlignSize - (modulus) : 0)
 	    };
@@ -740,7 +740,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #if defined _GLIBCXX_DEBUG
       // Complexity: O(lg(N)). Where, N is the number of block of size
       // sizeof(value_type).
-      void 
+      void
       _S_check_for_free_blocks() throw()
       {
 	typedef typename __detail::_Ffit_finder<_Alloc_block*> _FFF;
@@ -761,7 +761,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        *  is the number of blocks of size sizeof(value_type) within
        *  the newly acquired block. Having a tight bound.
        */
-      void 
+      void
       _S_refill_pool() _GLIBCXX_THROW(std::bad_alloc)
       {
 	using std::size_t;
@@ -771,8 +771,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
 	const size_t __num_bitmaps = (_S_block_size
 				      / size_t(__detail::bits_per_block));
-	const size_t __size_to_allocate = sizeof(size_t) 
-	  + _S_block_size * sizeof(_Alloc_block) 
+	const size_t __size_to_allocate = sizeof(size_t)
+	  + _S_block_size * sizeof(_Alloc_block)
 	  + __num_bitmaps * sizeof(size_t);
 
 	size_t* __temp =
@@ -781,13 +781,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	++__temp;
 
 	// The Header information goes at the Beginning of the Block.
-	_Block_pair __bp = 
+	_Block_pair __bp =
 	  std::make_pair(reinterpret_cast<_Alloc_block*>
-			 (__temp + __num_bitmaps), 
+			 (__temp + __num_bitmaps),
 			 reinterpret_cast<_Alloc_block*>
-			 (__temp + __num_bitmaps) 
+			 (__temp + __num_bitmaps)
 			 + _S_block_size - 1);
-	
+
 	// Fill the Vector with this information.
 	_S_mem_blocks.push_back(__bp);
 
@@ -820,7 +820,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        *  function to have a complexity referred to commonly as:
        *  Amortized Constant time.
        */
-      pointer 
+      pointer
       _M_allocate_single_object() _GLIBCXX_THROW(std::bad_alloc)
       {
 	using std::size_t;
@@ -865,10 +865,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		// Now, get the address of the bit we marked as allocated.
 		pointer __ret = reinterpret_cast<pointer>
 		  (__bpi->first + __fff._M_offset() + __nz_bit);
-		size_t* __puse_count = 
+		size_t* __puse_count =
 		  reinterpret_cast<size_t*>
 		  (__bpi->first) - (__detail::__num_bitmaps(*__bpi) + 1);
-		
+
 		++(*__puse_count);
 		return __ret;
 	      }
@@ -911,7 +911,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        *  close to each other and this case is handled in O(1) time by
        *  the deallocate function.
        */
-      void 
+      void
       _M_deallocate_single_object(pointer __p) throw()
       {
 	using std::size_t;
@@ -952,16 +952,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	// Get the position of the iterator that has been found.
 	const size_t __rotate = (__displacement
 				 % size_t(__detail::bits_per_block));
-	size_t* __bitmapC = 
+	size_t* __bitmapC =
 	  reinterpret_cast<size_t*>
 	  (_S_mem_blocks[__diff].first) - 1;
 	__bitmapC -= (__displacement / size_t(__detail::bits_per_block));
-      
+
 	__detail::__bit_free(__bitmapC, __rotate);
 	size_t* __puse_count = reinterpret_cast<size_t*>
 	  (_S_mem_blocks[__diff].first)
 	  - (__detail::__num_bitmaps(_S_mem_blocks[__diff]) + 1);
-	
+
 	_GLIBCXX_DEBUG_ASSERT(*__puse_count != 0);
 
 	--(*__puse_count);
@@ -969,7 +969,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	if (__builtin_expect(*__puse_count == 0, false))
 	  {
 	    _S_block_size /= 2;
-	  
+
 	    // We can safely remove this block.
 	    // _Block_pair __bp = _S_mem_blocks[__diff];
 	    this->_M_insert(__puse_count);
@@ -982,7 +982,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	    // free list, and hence had been erased from the vector,
 	    // so the size of the vector gets reduced by 1.
 	    if ((_Difference_type)_S_last_request._M_where() >= __diff--)
-	      _S_last_request._M_reset(__diff); 
+	      _S_last_request._M_reset(__diff);
 
 	    // If the Index into the vector of the region of memory
 	    // that might hold the next address that will be passed to
@@ -1011,7 +1011,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       ~bitmap_allocator() _GLIBCXX_USE_NOEXCEPT
       { }
 
-      _GLIBCXX_NODISCARD pointer 
+      _GLIBCXX_NODISCARD pointer
       allocate(size_type __n)
       {
 	if (__n > this->max_size())
@@ -1029,17 +1029,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	if (__builtin_expect(__n == 1, true))
 	  return this->_M_allocate_single_object();
 	else
-	  { 
+	  {
 	    const size_type __b = __n * sizeof(value_type);
 	    return reinterpret_cast<pointer>(::operator new(__b));
 	  }
       }
 
-      _GLIBCXX_NODISCARD pointer 
+      _GLIBCXX_NODISCARD pointer
       allocate(size_type __n, typename bitmap_allocator<void>::const_pointer)
       { return allocate(__n); }
 
-      void 
+      void
       deallocate(pointer __p, size_type __n) throw()
       {
 	if (__builtin_expect(__p != 0, true))
@@ -1060,15 +1060,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  }
       }
 
-      pointer 
+      pointer
       address(reference __r) const _GLIBCXX_NOEXCEPT
       { return std::__addressof(__r); }
 
-      const_pointer 
+      const_pointer
       address(const_reference __r) const _GLIBCXX_NOEXCEPT
       { return std::__addressof(__r); }
 
-      size_type 
+      size_type
       max_size() const _GLIBCXX_USE_NOEXCEPT
       { return size_type(-1) / sizeof(value_type); }
 
@@ -1079,31 +1079,31 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
 
       template<typename _Up>
-        void 
+        void
         destroy(_Up* __p)
         { __p->~_Up(); }
 #else
-      void 
+      void
       construct(pointer __p, const_reference __data)
       { ::new((void *)__p) value_type(__data); }
 
-      void 
+      void
       destroy(pointer __p)
       { __p->~value_type(); }
 #endif
     };
 
   template<typename _Tp1, typename _Tp2>
-    bool 
-    operator==(const bitmap_allocator<_Tp1>&, 
+    bool
+    operator==(const bitmap_allocator<_Tp1>&,
 	       const bitmap_allocator<_Tp2>&) throw()
     { return true; }
-  
+
 #if __cpp_impl_three_way_comparison < 201907L
   template<typename _Tp1, typename _Tp2>
-    bool 
-    operator!=(const bitmap_allocator<_Tp1>&, 
-	       const bitmap_allocator<_Tp2>&) throw() 
+    bool
+    operator!=(const bitmap_allocator<_Tp1>&,
+	       const bitmap_allocator<_Tp2>&) throw()
     { return false; }
 #endif
 
@@ -1117,7 +1117,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       = 2 * std::size_t(__detail::bits_per_block);
 
   template<typename _Tp>
-    typename bitmap_allocator<_Tp>::_BPVector::size_type 
+    typename bitmap_allocator<_Tp>::_BPVector::size_type
     bitmap_allocator<_Tp>::_S_last_dealloc_index = 0;
 
   template<typename _Tp>
@@ -1134,4 +1134,4 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace __gnu_cxx
 
-#endif 
+#endif
diff --git a/libstdc++-v3/include/ext/codecvt_specializations.h b/libstdc++-v3/include/ext/codecvt_specializations.h
index 7306c7d..0da3a89 100644
--- a/libstdc++-v3/include/ext/codecvt_specializations.h
+++ b/libstdc++-v3/include/ext/codecvt_specializations.h
@@ -53,11 +53,11 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
   class encoding_state
   {
   public:
-    // Types: 
+    // Types:
     // NB: A conversion descriptor subsumes and enhances the
     // functionality of a simple state type such as mbstate_t.
     typedef iconv_t	descriptor_type;
-    
+
   protected:
     // Name of internal character set encoding.
     std::string	       	_M_int_enc;
@@ -83,15 +83,15 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
     int 		_M_bytes;
 
   public:
-    explicit 
-    encoding_state() 
+    explicit
+    encoding_state()
     : _M_in_desc(0), _M_out_desc(0), _M_ext_bom(0), _M_int_bom(0), _M_bytes(0)
     { }
 
-    explicit 
-    encoding_state(const char* __int, const char* __ext, 
+    explicit
+    encoding_state(const char* __int, const char* __ext,
 		   int __ibom = 0, int __ebom = 0, int __bytes = 1)
-    : _M_int_enc(__int), _M_ext_enc(__ext), _M_in_desc(0), _M_out_desc(0), 
+    : _M_int_enc(__int), _M_ext_enc(__ext), _M_in_desc(0), _M_out_desc(0),
       _M_ext_bom(__ebom), _M_int_bom(__ibom), _M_bytes(__bytes)
     { init(); }
 
@@ -115,17 +115,17 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
     }
 
     ~encoding_state()
-    { destroy(); } 
+    { destroy(); }
 
     bool
     good() const throw()
-    { 
+    {
       const descriptor_type __err = (iconv_t)(-1);
-      bool __test = _M_in_desc && _M_in_desc != __err; 
+      bool __test = _M_in_desc && _M_in_desc != __err;
       __test &=  _M_out_desc && _M_out_desc != __err;
       return __test;
     }
-    
+
     int
     character_ratio() const
     { return _M_bytes; }
@@ -134,7 +134,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
     internal_encoding() const
     { return _M_int_enc; }
 
-    int 
+    int
     internal_bom() const
     { return _M_int_bom; }
 
@@ -142,7 +142,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
     external_encoding() const
     { return _M_ext_enc; }
 
-    int 
+    int
     external_bom() const
     { return _M_ext_bom; }
 
@@ -192,12 +192,12 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
     destroy() throw()
     {
       const descriptor_type __err = (iconv_t)(-1);
-      if (_M_in_desc && _M_in_desc != __err) 
+      if (_M_in_desc && _M_in_desc != __err)
 	{
 	  iconv_close(_M_in_desc);
 	  _M_in_desc = 0;
 	}
-      if (_M_out_desc && _M_out_desc != __err) 
+      if (_M_out_desc && _M_out_desc != __err)
 	{
 	  iconv_close(_M_out_desc);
 	  _M_out_desc = 0;
@@ -235,7 +235,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     class codecvt<_InternT, _ExternT, encoding_state>
     : public __codecvt_abstract_base<_InternT, _ExternT, encoding_state>
     {
-    public:      
+    public:
       // Types:
       typedef codecvt_base::result			result;
       typedef _InternT 					intern_type;
@@ -246,52 +246,52 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       // Data Members:
       static locale::id 		id;
 
-      explicit 
+      explicit
       codecvt(size_t __refs = 0)
       : __codecvt_abstract_base<intern_type, extern_type, state_type>(__refs)
       { }
 
-      explicit 
+      explicit
       codecvt(state_type& __enc, size_t __refs = 0)
       : __codecvt_abstract_base<intern_type, extern_type, state_type>(__refs)
       { }
 
      protected:
-      virtual 
+      virtual
       ~codecvt() { }
 
       virtual result
-      do_out(state_type& __state, const intern_type* __from, 
+      do_out(state_type& __state, const intern_type* __from,
 	     const intern_type* __from_end, const intern_type*& __from_next,
 	     extern_type* __to, extern_type* __to_end,
 	     extern_type*& __to_next) const;
 
       virtual result
-      do_unshift(state_type& __state, extern_type* __to, 
+      do_unshift(state_type& __state, extern_type* __to,
 		 extern_type* __to_end, extern_type*& __to_next) const;
 
       virtual result
-      do_in(state_type& __state, const extern_type* __from, 
+      do_in(state_type& __state, const extern_type* __from,
 	    const extern_type* __from_end, const extern_type*& __from_next,
-	    intern_type* __to, intern_type* __to_end, 
+	    intern_type* __to, intern_type* __to_end,
 	    intern_type*& __to_next) const;
 
-      virtual int 
+      virtual int
       do_encoding() const throw();
 
-      virtual bool 
+      virtual bool
       do_always_noconv() const throw();
 
-      virtual int 
-      do_length(state_type&, const extern_type* __from, 
+      virtual int
+      do_length(state_type&, const extern_type* __from,
 		const extern_type* __end, size_t __max) const;
 
-      virtual int 
+      virtual int
       do_max_length() const throw();
     };
 
   template<typename _InternT, typename _ExternT>
-    locale::id 
+    locale::id
     codecvt<_InternT, _ExternT, encoding_state>::id;
 
   // This adaptor works around the signature problems of the second
@@ -308,7 +308,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _InternT, typename _ExternT>
     codecvt_base::result
     codecvt<_InternT, _ExternT, encoding_state>::
-    do_out(state_type& __state, const intern_type* __from, 
+    do_out(state_type& __state, const intern_type* __from,
 	   const intern_type* __from_end, const intern_type*& __from_next,
 	   extern_type* __to, extern_type* __to_end,
 	   extern_type*& __to_next) const
@@ -320,8 +320,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  const size_t __fmultiple = sizeof(intern_type);
 	  size_t __fbytes = __fmultiple * (__from_end - __from);
 	  const size_t __tmultiple = sizeof(extern_type);
-	  size_t __tbytes = __tmultiple * (__to_end - __to); 
-	  
+	  size_t __tbytes = __tmultiple * (__to_end - __to);
+
 	  // Argument list for iconv specifies a byte sequence. Thus,
 	  // all to/from arrays must be brutally casted to char*.
 	  char* __cto = reinterpret_cast<char*>(__to);
@@ -335,7 +335,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  // merry way.
 	  int __int_bom = __state.internal_bom();
 	  if (__int_bom)
-	    {	  
+	    {
 	      size_t __size = __from_end - __from;
 	      intern_type* __cfixed = static_cast<intern_type*>
 		(__builtin_alloca(sizeof(intern_type) * (__size + 1)));
@@ -343,14 +343,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	      char_traits<intern_type>::copy(__cfixed + 1, __from, __size);
 	      __cfrom = reinterpret_cast<char*>(__cfixed);
 	      __conv = __iconv_adaptor(iconv, __desc, &__cfrom,
-                                        &__fbytes, &__cto, &__tbytes); 
+                                        &__fbytes, &__cto, &__tbytes);
 	    }
 	  else
 	    {
 	      intern_type* __cfixed = const_cast<intern_type*>(__from);
 	      __cfrom = reinterpret_cast<char*>(__cfixed);
-	      __conv = __iconv_adaptor(iconv, __desc, &__cfrom, &__fbytes, 
-				       &__cto, &__tbytes); 
+	      __conv = __iconv_adaptor(iconv, __desc, &__cfrom, &__fbytes,
+				       &__cto, &__tbytes);
 	    }
 
 	  if (__conv != size_t(-1))
@@ -359,7 +359,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	      __to_next = reinterpret_cast<extern_type*>(__cto);
 	      __ret = codecvt_base::ok;
 	    }
-	  else 
+	  else
 	    {
 	      if (__fbytes < __fmultiple * (__from_end - __from))
 		{
@@ -371,13 +371,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		__ret = codecvt_base::error;
 	    }
 	}
-      return __ret; 
+      return __ret;
     }
 
   template<typename _InternT, typename _ExternT>
     codecvt_base::result
     codecvt<_InternT, _ExternT, encoding_state>::
-    do_unshift(state_type& __state, extern_type* __to, 
+    do_unshift(state_type& __state, extern_type* __to,
 	       extern_type* __to_end, extern_type*& __to_next) const
     {
       result __ret = codecvt_base::error;
@@ -385,14 +385,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	{
 	  const descriptor_type& __desc = __state.in_descriptor();
 	  const size_t __tmultiple = sizeof(intern_type);
-	  size_t __tlen = __tmultiple * (__to_end - __to); 
-	  
+	  size_t __tlen = __tmultiple * (__to_end - __to);
+
 	  // Argument list for iconv specifies a byte sequence. Thus,
 	  // all to/from arrays must be brutally casted to char*.
 	  char* __cto = reinterpret_cast<char*>(__to);
 	  size_t __conv = __iconv_adaptor(iconv,__desc, 0, 0,
-                                          &__cto, &__tlen); 
-	  
+                                          &__cto, &__tlen);
+
 	  if (__conv != size_t(-1))
 	    {
 	      __to_next = reinterpret_cast<extern_type*>(__cto);
@@ -403,20 +403,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	      else
 		__ret = codecvt_base::partial;
 	    }
-	  else 
+	  else
 	    __ret = codecvt_base::error;
 	}
-      return __ret; 
+      return __ret;
     }
-   
+
   template<typename _InternT, typename _ExternT>
     codecvt_base::result
     codecvt<_InternT, _ExternT, encoding_state>::
-    do_in(state_type& __state, const extern_type* __from, 
+    do_in(state_type& __state, const extern_type* __from,
 	  const extern_type* __from_end, const extern_type*& __from_next,
-	  intern_type* __to, intern_type* __to_end, 
+	  intern_type* __to, intern_type* __to_end,
 	  intern_type*& __to_next) const
-    { 
+    {
       result __ret = codecvt_base::error;
       if (__state.good())
 	{
@@ -424,8 +424,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  const size_t __fmultiple = sizeof(extern_type);
 	  size_t __flen = __fmultiple * (__from_end - __from);
 	  const size_t __tmultiple = sizeof(intern_type);
-	  size_t __tlen = __tmultiple * (__to_end - __to); 
-	  
+	  size_t __tlen = __tmultiple * (__to_end - __to);
+
 	  // Argument list for iconv specifies a byte sequence. Thus,
 	  // all to/from arrays must be brutally casted to char*.
 	  char* __cto = reinterpret_cast<char*>(__to);
@@ -439,7 +439,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  // merry way.
 	  int __ext_bom = __state.external_bom();
 	  if (__ext_bom)
-	    {	  
+	    {
 	      size_t __size = __from_end - __from;
 	      extern_type* __cfixed =  static_cast<extern_type*>
 		(__builtin_alloca(sizeof(extern_type) * (__size + 1)));
@@ -447,24 +447,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	      char_traits<extern_type>::copy(__cfixed + 1, __from, __size);
 	      __cfrom = reinterpret_cast<char*>(__cfixed);
 	      __conv = __iconv_adaptor(iconv, __desc, &__cfrom,
-                                       &__flen, &__cto, &__tlen); 
+                                       &__flen, &__cto, &__tlen);
 	    }
 	  else
 	    {
 	      extern_type* __cfixed = const_cast<extern_type*>(__from);
 	      __cfrom = reinterpret_cast<char*>(__cfixed);
 	      __conv = __iconv_adaptor(iconv, __desc, &__cfrom,
-                                       &__flen, &__cto, &__tlen); 
+                                       &__flen, &__cto, &__tlen);
 	    }
 
-	  
+
 	  if (__conv != size_t(-1))
 	    {
 	      __from_next = reinterpret_cast<const extern_type*>(__cfrom);
 	      __to_next = reinterpret_cast<intern_type*>(__cto);
 	      __ret = codecvt_base::ok;
 	    }
-	  else 
+	  else
 	    {
 	      if (__flen < static_cast<size_t>(__from_end - __from))
 		{
@@ -476,37 +476,37 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		__ret = codecvt_base::error;
 	    }
 	}
-      return __ret; 
+      return __ret;
     }
-  
+
   template<typename _InternT, typename _ExternT>
-    int 
+    int
     codecvt<_InternT, _ExternT, encoding_state>::
     do_encoding() const throw()
     {
       int __ret = 0;
       if (sizeof(_ExternT) <= sizeof(_InternT))
 	__ret = sizeof(_InternT) / sizeof(_ExternT);
-      return __ret; 
+      return __ret;
     }
-  
+
   template<typename _InternT, typename _ExternT>
-    bool 
+    bool
     codecvt<_InternT, _ExternT, encoding_state>::
     do_always_noconv() const throw()
     { return false; }
-  
+
   template<typename _InternT, typename _ExternT>
-    int 
+    int
     codecvt<_InternT, _ExternT, encoding_state>::
-    do_length(state_type&, const extern_type* __from, 
+    do_length(state_type&, const extern_type* __from,
 	      const extern_type* __end, size_t __max) const
     { return std::min(__max, static_cast<size_t>(__end - __from)); }
 
   // _GLIBCXX_RESOLVE_LIB_DEFECTS
   // 74.  Garbled text for codecvt::do_max_length
   template<typename _InternT, typename _ExternT>
-    int 
+    int
     codecvt<_InternT, _ExternT, encoding_state>::
     do_max_length() const throw()
     { return 1; }
diff --git a/libstdc++-v3/include/ext/concurrence.h b/libstdc++-v3/include/ext/concurrence.h
index 8191e7a..5f8eccc 100644
--- a/libstdc++-v3/include/ext/concurrence.h
+++ b/libstdc++-v3/include/ext/concurrence.h
@@ -34,7 +34,7 @@
 #endif
 
 #include <exception>
-#include <bits/gthr.h> 
+#include <bits/gthr.h>
 #include <bits/functexcept.h>
 #include <bits/cpp_type_traits.h>
 #include <ext/type_traits.h>
@@ -51,7 +51,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   // _S_mutex     multi-threaded code that requires additional support
   //              from gthr.h or abstraction layers in concurrence.h.
   // _S_atomic    multi-threaded code using atomic operations.
-  enum _Lock_policy { _S_single, _S_mutex, _S_atomic }; 
+  enum _Lock_policy { _S_single, _S_mutex, _S_atomic };
 
   // Compile time constant that indicates prefered locking policy in
   // the current configuration.
@@ -116,8 +116,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   __throw_concurrence_wait_error()
   { _GLIBCXX_THROW_OR_ABORT(__concurrence_wait_error()); }
 #endif
- 
-  class __mutex 
+
+  class __mutex
   {
   private:
 #if __GTHREADS && defined __GTHREAD_MUTEX_INIT
@@ -130,8 +130,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     __mutex& operator=(const __mutex&);
 
   public:
-    __mutex() 
-    { 
+    __mutex()
+    {
 #if __GTHREADS && ! defined __GTHREAD_MUTEX_INIT
       if (__gthread_active_p())
 	__GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex);
@@ -139,12 +139,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     }
 
 #if __GTHREADS && ! defined __GTHREAD_MUTEX_INIT
-    ~__mutex() 
-    { 
+    ~__mutex()
+    {
       if (__gthread_active_p())
-	__gthread_mutex_destroy(&_M_mutex); 
+	__gthread_mutex_destroy(&_M_mutex);
     }
-#endif 
+#endif
 
     void lock()
     {
@@ -156,7 +156,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	}
 #endif
     }
-    
+
     void unlock()
     {
 #if __GTHREADS
@@ -172,7 +172,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       { return &_M_mutex; }
   };
 
-  class __recursive_mutex 
+  class __recursive_mutex
   {
   private:
 #if __GTHREADS && defined __GTHREAD_RECURSIVE_MUTEX_INIT
@@ -185,8 +185,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     __recursive_mutex& operator=(const __recursive_mutex&);
 
   public:
-    __recursive_mutex() 
-    { 
+    __recursive_mutex()
+    {
 #if __GTHREADS && ! defined __GTHREAD_RECURSIVE_MUTEX_INIT
       if (__gthread_active_p())
 	__GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION(&_M_mutex);
@@ -202,7 +202,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #endif
 
     void lock()
-    { 
+    {
 #if __GTHREADS
       if (__gthread_active_p())
 	{
@@ -211,9 +211,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	}
 #endif
     }
-    
+
     void unlock()
-    { 
+    {
 #if __GTHREADS
       if (__gthread_active_p())
 	{
@@ -263,8 +263,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     __cond& operator=(const __cond&);
 
   public:
-    __cond() 
-    { 
+    __cond()
+    {
 #if __GTHREADS && ! defined __GTHREAD_COND_INIT
       if (__gthread_active_p())
 	__GTHREAD_COND_INIT_FUNCTION(&_M_cond);
@@ -272,12 +272,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     }
 
 #if __GTHREADS && ! defined __GTHREAD_COND_INIT
-    ~__cond() 
-    { 
+    ~__cond()
+    {
       if (__gthread_active_p())
-	__gthread_cond_destroy(&_M_cond); 
+	__gthread_cond_destroy(&_M_cond);
     }
-#endif 
+#endif
 
     void broadcast()
     {
diff --git a/libstdc++-v3/include/ext/debug_allocator.h b/libstdc++-v3/include/ext/debug_allocator.h
index 12b8725..15d0fe0 100644
--- a/libstdc++-v3/include/ext/debug_allocator.h
+++ b/libstdc++-v3/include/ext/debug_allocator.h
@@ -87,7 +87,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       // _M_extra is the number of objects that correspond to the
       // extra space where debug information is stored.
       size_type 		_M_extra;
-      
+
       _Alloc			_M_allocator;
 
       template<typename _Alloc2,
@@ -105,7 +105,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       size_type _S_extra()
       {
 	const std::size_t __obj_size = sizeof(value_type);
-	return (sizeof(size_type) + __obj_size - 1) / __obj_size; 
+	return (sizeof(size_type) + __obj_size - 1) / __obj_size;
       }
 
     public:
@@ -122,7 +122,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       _GLIBCXX_NODISCARD pointer
       allocate(size_type __n)
       {
-        pointer __res = _M_allocator.allocate(__n + _M_extra);      
+        pointer __res = _M_allocator.allocate(__n + _M_extra);
 	size_type* __ps = reinterpret_cast<size_type*>(__res);
 	*__ps = __n;
         return __res + _M_extra;
diff --git a/libstdc++-v3/include/ext/extptr_allocator.h b/libstdc++-v3/include/ext/extptr_allocator.h
index dba6091..92d5ca8 100644
--- a/libstdc++-v3/include/ext/extptr_allocator.h
+++ b/libstdc++-v3/include/ext/extptr_allocator.h
@@ -63,7 +63,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       // Note the non-standard pointer types.
       typedef _Pointer_adapter<_Relative_pointer_impl<_Tp> >       pointer;
-      typedef _Pointer_adapter<_Relative_pointer_impl<const _Tp> > 
+      typedef _Pointer_adapter<_Relative_pointer_impl<const _Tp> >
                                                              const_pointer;
 
       typedef _Tp&       reference;
@@ -74,7 +74,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
         struct rebind
         { typedef _ExtPtr_allocator<_Up> other; };
 
-      _ExtPtr_allocator() _GLIBCXX_USE_NOEXCEPT 
+      _ExtPtr_allocator() _GLIBCXX_USE_NOEXCEPT
       : _M_real_alloc() { }
 
       _ExtPtr_allocator(const _ExtPtr_allocator& __rarg) _GLIBCXX_USE_NOEXCEPT
@@ -115,7 +115,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	{ construct(__p.get(), std::forward<_Args>(__args)...); }
 
       template<typename _Up>
-        void 
+        void
         destroy(_Up* __p)
         { __p->~_Up(); }
 
diff --git a/libstdc++-v3/include/ext/malloc_allocator.h b/libstdc++-v3/include/ext/malloc_allocator.h
index 2a58847..03cce39 100644
--- a/libstdc++-v3/include/ext/malloc_allocator.h
+++ b/libstdc++-v3/include/ext/malloc_allocator.h
@@ -48,7 +48,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    *  @brief  An allocator that uses malloc.
    *  @ingroup allocators
    *
-   *  This is precisely the allocator defined in the C++ Standard. 
+   *  This is precisely the allocator defined in the C++ Standard.
    *    - all allocation calls malloc
    *    - all deallocation calls free
    */
@@ -154,7 +154,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
 #if __cplusplus <= 201703L
       size_type
-      max_size() const _GLIBCXX_USE_NOEXCEPT 
+      max_size() const _GLIBCXX_USE_NOEXCEPT
       { return _M_max_size(); }
 
 #if __cplusplus >= 201103L
@@ -165,7 +165,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
 
       template<typename _Up>
-        void 
+        void
         destroy(_Up* __p)
 	noexcept(std::is_nothrow_destructible<_Up>::value)
 	{ __p->~_Up(); }
diff --git a/libstdc++-v3/include/ext/mt_allocator.h b/libstdc++-v3/include/ext/mt_allocator.h
index 77f7dcd..3242118 100644
--- a/libstdc++-v3/include/ext/mt_allocator.h
+++ b/libstdc++-v3/include/ext/mt_allocator.h
@@ -71,13 +71,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       // NB: In any case must be >= sizeof(_Block_record), that
       // is 4 on 32 bit machines and 8 on 64 bit machines.
       size_t	_M_align;
-      
+
       // Allocation requests (after round-up to power of 2) below
       // this value will be handled by the allocator. A raw new/
       // call will be used for requests larger than this value.
       // NB: Must be much smaller than _M_chunk_size and in any
       // case <= 32768.
-      size_t	_M_max_bytes; 
+      size_t	_M_max_bytes;
 
       // Size in bytes of the smallest bin.
       // NB: Must be a power of 2 and >= _M_align (and of course
@@ -89,7 +89,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       // value. Based on previous discussions on the libstdc++
       // mailing list we have chosen the value below.
       // See http://gcc.gnu.org/ml/libstdc++/2001-07/msg00077.html
-      // NB: At least one order of magnitude > _M_max_bytes. 
+      // NB: At least one order of magnitude > _M_max_bytes.
       size_t	_M_chunk_size;
 
       // The maximum number of supported threads. For
@@ -107,40 +107,40 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       // _M_freelist_headroom % of the freelist, we move these
       // records back to the global pool.
       size_t 	_M_freelist_headroom;
-      
+
       // Set to true forces all allocations to use new().
-      bool 	_M_force_new; 
-      
+      bool 	_M_force_new;
+
       explicit
       _Tune()
       : _M_align(_S_align), _M_max_bytes(_S_max_bytes), _M_min_bin(_S_min_bin),
-      _M_chunk_size(_S_chunk_size), _M_max_threads(_S_max_threads), 
-      _M_freelist_headroom(_S_freelist_headroom), 
+      _M_chunk_size(_S_chunk_size), _M_max_threads(_S_max_threads),
+      _M_freelist_headroom(_S_freelist_headroom),
       _M_force_new(std::getenv("GLIBCXX_FORCE_NEW") ? true : false)
       { }
 
       explicit
-      _Tune(size_t __align, size_t __maxb, size_t __minbin, size_t __chunk, 
-	    size_t __maxthreads, size_t __headroom, bool __force) 
+      _Tune(size_t __align, size_t __maxb, size_t __minbin, size_t __chunk,
+	    size_t __maxthreads, size_t __headroom, bool __force)
       : _M_align(__align), _M_max_bytes(__maxb), _M_min_bin(__minbin),
       _M_chunk_size(__chunk), _M_max_threads(__maxthreads),
       _M_freelist_headroom(__headroom), _M_force_new(__force)
       { }
     };
-    
+
     struct _Block_address
     {
       void* 			_M_initial;
       _Block_address* 		_M_next;
     };
-    
+
     const _Tune&
     _M_get_options() const
     { return _M_options; }
 
     void
     _M_set_options(_Tune __t)
-    { 
+    {
       if (!_M_init)
 	_M_options = __t;
     }
@@ -157,16 +157,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     _M_get_align()
     { return _M_options._M_align; }
 
-    explicit 
-    __pool_base() 
+    explicit
+    __pool_base()
     : _M_options(_Tune()), _M_binmap(0), _M_init(false) { }
 
-    explicit 
+    explicit
     __pool_base(const _Tune& __options)
     : _M_options(__options), _M_binmap(0), _M_init(false) { }
 
   private:
-    explicit 
+    explicit
     __pool_base(const __pool_base&);
 
     __pool_base&
@@ -175,7 +175,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   protected:
     // Configuration options.
     _Tune 	       		_M_options;
-    
+
     _Binmap_type* 		_M_binmap;
 
     // Configuration of the pool object via _M_options can happen
@@ -211,7 +211,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	// A list of the initial addresses of all allocated blocks.
 	_Block_address*		     	_M_address;
       };
-      
+
       void
       _M_initialize_once()
       {
@@ -222,27 +222,27 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       void
       _M_destroy() throw();
 
-      char* 
+      char*
       _M_reserve_block(size_t __bytes, const size_t __thread_id);
-    
+
       void
       _M_reclaim_block(char* __p, size_t __bytes) throw ();
-    
-      size_t 
+
+      size_t
       _M_get_thread_id() { return 0; }
-      
+
       const _Bin_record&
       _M_get_bin(size_t __which)
       { return _M_bin[__which]; }
-      
+
       void
       _M_adjust_freelist(const _Bin_record&, _Block_record*, size_t)
       { }
 
-      explicit __pool() 
+      explicit __pool()
       : _M_bin(0), _M_bin_size(1) { }
 
-      explicit __pool(const __pool_base::_Tune& __tune) 
+      explicit __pool(const __pool_base::_Tune& __tune)
       : __pool_base(__tune), _M_bin(0), _M_bin_size(1) { }
 
     private:
@@ -250,14 +250,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       // power of 2 size. Memory to this "array" is allocated in
       // _M_initialize().
       _Bin_record*		 _M_bin;
-      
+
       // Actual value calculated in _M_initialize().
-      size_t 	       	     	_M_bin_size;     
+      size_t 	       	     	_M_bin_size;
 
       void
       _M_initialize();
   };
- 
+
 #ifdef __GTHREADS
   /// Specialization for thread enabled, via gthreads.h.
   template<>
@@ -277,27 +277,27 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       {
 	// Points to next free thread id record. NULL if last record in list.
 	_Thread_record*			_M_next;
-	
+
 	// Thread id ranging from 1 to _S_max_threads.
 	size_t                          _M_id;
       };
-      
+
       union _Block_record
       {
 	// Points to the block_record of the next free block.
 	_Block_record*			_M_next;
-	
+
 	// The thread id of the thread which has requested this block.
 	size_t                          _M_thread_id;
       };
-      
+
       struct _Bin_record
       {
 	// An "array" of pointers to the first free block for each
 	// thread id. Memory to this "array" is allocated in
 	// _S_initialize() for _S_max_threads + global pool 0.
 	_Block_record**			_M_first;
-	
+
 	// A list of the initial addresses of all allocated blocks.
 	_Block_address*		     	_M_address;
 
@@ -312,13 +312,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	//   for _S_max_threads + global pool 0.
 	size_t*				_M_free;
 	size_t*			        _M_used;
-	
+
 	// Each bin has its own mutex which is used to ensure data
 	// integrity while changing "ownership" on a block.  The mutex
 	// is initialized in _S_initialize().
 	__gthread_mutex_t*              _M_mutex;
       };
-      
+
       // XXX GLIBCXX_ABI Deprecated
       void
       _M_initialize(__destroy_handler);
@@ -333,18 +333,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       void
       _M_destroy() throw();
 
-      char* 
+      char*
       _M_reserve_block(size_t __bytes, const size_t __thread_id);
-    
+
       void
       _M_reclaim_block(char* __p, size_t __bytes) throw ();
-    
+
       const _Bin_record&
       _M_get_bin(size_t __which)
       { return _M_bin[__which]; }
-      
+
       void
-      _M_adjust_freelist(const _Bin_record& __bin, _Block_record* __block, 
+      _M_adjust_freelist(const _Bin_record& __bin, _Block_record* __block,
 			 size_t __thread_id)
       {
 	if (__gthread_active_p())
@@ -359,16 +359,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       void
       _M_destroy_thread_key(void*) throw ();
 
-      size_t 
+      size_t
       _M_get_thread_id();
 
-      explicit __pool() 
-      : _M_bin(0), _M_bin_size(1), _M_thread_freelist(0) 
+      explicit __pool()
+      : _M_bin(0), _M_bin_size(1), _M_thread_freelist(0)
       { }
 
-      explicit __pool(const __pool_base::_Tune& __tune) 
-      : __pool_base(__tune), _M_bin(0), _M_bin_size(1), 
-	_M_thread_freelist(0) 
+      explicit __pool(const __pool_base::_Tune& __tune)
+      : __pool_base(__tune), _M_bin(0), _M_bin_size(1),
+	_M_thread_freelist(0)
       { }
 
     private:
@@ -392,10 +392,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     struct __common_pool
     {
       typedef _PoolTp<_Thread> 		pool_type;
-      
+
       static pool_type&
       _S_get_pool()
-      { 
+      {
 	static pool_type _S_pool;
 	return _S_pool;
       }
@@ -405,7 +405,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     struct __common_pool_base;
 
   template<template <bool> class _PoolTp>
-    struct __common_pool_base<_PoolTp, false> 
+    struct __common_pool_base<_PoolTp, false>
     : public __common_pool<_PoolTp, false>
     {
       using  __common_pool<_PoolTp, false>::_S_get_pool;
@@ -416,7 +416,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	static bool __init;
 	if (__builtin_expect(__init == false, false))
 	  {
-	    _S_get_pool()._M_initialize_once(); 
+	    _S_get_pool()._M_initialize_once();
 	    __init = true;
 	  }
       }
@@ -428,14 +428,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     : public __common_pool<_PoolTp, true>
     {
       using  __common_pool<_PoolTp, true>::_S_get_pool;
-      
+
       static void
-      _S_initialize() 
+      _S_initialize()
       { _S_get_pool()._M_initialize_once(); }
 
       static void
       _S_initialize_once()
-      { 
+      {
 	static bool __init;
 	if (__builtin_expect(__init == false, false))
 	  {
@@ -449,7 +449,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	    // Double check initialization. May be necessary on some
 	    // systems for proper construction when not compiling with
 	    // thread flags.
-	    _S_get_pool()._M_initialize_once(); 
+	    _S_get_pool()._M_initialize_once();
 	    __init = true;
 	  }
       }
@@ -460,7 +460,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<template <bool> class _PoolTp, bool _Thread>
     struct __common_pool_policy : public __common_pool_base<_PoolTp, _Thread>
     {
-      template<typename _Tp1, template <bool> class _PoolTp1 = _PoolTp, 
+      template<typename _Tp1, template <bool> class _PoolTp1 = _PoolTp,
 	       bool _Thread1 = _Thread>
         struct _M_rebind
         { typedef __common_pool_policy<_PoolTp1, _Thread1> other; };
@@ -468,14 +468,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       using  __common_pool_base<_PoolTp, _Thread>::_S_get_pool;
       using  __common_pool_base<_PoolTp, _Thread>::_S_initialize_once;
   };
- 
+
 
   template<typename _Tp, template <bool> class _PoolTp, bool _Thread>
     struct __per_type_pool
     {
       typedef _Tp 			value_type;
       typedef _PoolTp<_Thread> 		pool_type;
-      
+
       static pool_type&
       _S_get_pool()
       {
@@ -501,8 +501,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     struct __per_type_pool_base;
 
   template<typename _Tp, template <bool> class _PoolTp>
-    struct __per_type_pool_base<_Tp, _PoolTp, false> 
-    : public __per_type_pool<_Tp, _PoolTp, false> 
+    struct __per_type_pool_base<_Tp, _PoolTp, false>
+    : public __per_type_pool<_Tp, _PoolTp, false>
     {
       using  __per_type_pool<_Tp, _PoolTp, false>::_S_get_pool;
 
@@ -512,7 +512,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	static bool __init;
 	if (__builtin_expect(__init == false, false))
 	  {
-	    _S_get_pool()._M_initialize_once(); 
+	    _S_get_pool()._M_initialize_once();
 	    __init = true;
 	  }
       }
@@ -520,18 +520,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
  #ifdef __GTHREADS
  template<typename _Tp, template <bool> class _PoolTp>
-    struct __per_type_pool_base<_Tp, _PoolTp, true> 
-    : public __per_type_pool<_Tp, _PoolTp, true> 
+    struct __per_type_pool_base<_Tp, _PoolTp, true>
+    : public __per_type_pool<_Tp, _PoolTp, true>
     {
       using  __per_type_pool<_Tp, _PoolTp, true>::_S_get_pool;
 
       static void
-      _S_initialize() 
+      _S_initialize()
       { _S_get_pool()._M_initialize_once(); }
 
       static void
       _S_initialize_once()
-      { 
+      {
 	static bool __init;
 	if (__builtin_expect(__init == false, false))
 	  {
@@ -545,7 +545,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	    // Double check initialization. May be necessary on some
 	    // systems for proper construction when not compiling with
 	    // thread flags.
-	    _S_get_pool()._M_initialize_once(); 
+	    _S_get_pool()._M_initialize_once();
 	    __init = true;
 	  }
       }
@@ -554,10 +554,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   /// Policy for individual __pool objects.
   template<typename _Tp, template <bool> class _PoolTp, bool _Thread>
-    struct __per_type_pool_policy 
+    struct __per_type_pool_policy
     : public __per_type_pool_base<_Tp, _PoolTp, _Thread>
     {
-      template<typename _Tp1, template <bool> class _PoolTp1 = _PoolTp, 
+      template<typename _Tp1, template <bool> class _PoolTp1 = _PoolTp,
 	       bool _Thread1 = _Thread>
         struct _M_rebind
         { typedef __per_type_pool_policy<_Tp1, _PoolTp1, _Thread1> other; };
@@ -569,7 +569,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   /// Base class for _Tp dependent member functions.
   template<typename _Tp>
-    class __mt_alloc_base 
+    class __mt_alloc_base
     {
     public:
       typedef std::size_t               size_type;
@@ -595,7 +595,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       { return std::__addressof(__x); }
 
       size_type
-      max_size() const _GLIBCXX_USE_NOEXCEPT 
+      max_size() const _GLIBCXX_USE_NOEXCEPT
       { return size_type(-1) / sizeof(_Tp); }
 
 #if __cplusplus >= 201103L
@@ -605,16 +605,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
 
       template<typename _Up>
-        void 
+        void
         destroy(_Up* __p) { __p->~_Up(); }
 #else
       // _GLIBCXX_RESOLVE_LIB_DEFECTS
       // 402. wrong new expression in [some_] allocator::construct
-      void 
-      construct(pointer __p, const _Tp& __val) 
+      void
+      construct(pointer __p, const _Tp& __val)
       { ::new((void *)__p) _Tp(__val); }
 
-      void 
+      void
       destroy(pointer __p) { __p->~_Tp(); }
 #endif
     };
@@ -636,7 +636,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    *  Further details:
    *  https://gcc.gnu.org/onlinedocs/libstdc++/manual/mt_allocator.html
    */
-  template<typename _Tp, 
+  template<typename _Tp,
 	   typename _Poolp = __common_pool_policy<__pool, __thread_default> >
     class __mt_alloc : public __mt_alloc_base<_Tp>
     {
@@ -653,7 +653,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       template<typename _Tp1, typename _Poolp1 = _Poolp>
         struct rebind
-        { 
+        {
 	  typedef typename _Poolp1::template _M_rebind<_Tp1>::other pol_type;
 	  typedef __mt_alloc<_Tp1, pol_type> other;
 	};
@@ -675,11 +675,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       const __pool_base::_Tune
       _M_get_options()
-      { 
+      {
 	// Return a copy, not a reference, for external consumption.
 	return __policy_type::_S_get_pool()._M_get_options();
       }
-      
+
       void
       _M_set_options(__pool_base::_Tune __t)
       { __policy_type::_S_get_pool()._M_set_options(__t); }
@@ -713,11 +713,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  void* __ret = ::operator new(__bytes);
 	  return static_cast<_Tp*>(__ret);
 	}
-      
+
       // Round up to power of 2 and figure out which bin to use.
       const size_type __which = __pool._M_get_binmap(__bytes);
       const size_type __thread_id = __pool._M_get_thread_id();
-      
+
       // Find out if we have blocks on our freelist.  If so, go ahead
       // and use them directly without having to lock anything.
       char* __c;
@@ -729,7 +729,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  typedef typename __pool_type::_Block_record _Block_record;
 	  _Block_record* __block = __bin._M_first[__thread_id];
 	  __bin._M_first[__thread_id] = __block->_M_next;
-	  
+
 	  __pool._M_adjust_freelist(__bin, __block, __thread_id);
 	  __c = reinterpret_cast<char*>(__block) + __pool._M_get_align();
 	}
@@ -740,7 +740,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	}
       return static_cast<_Tp*>(static_cast<void*>(__c));
     }
-  
+
   template<typename _Tp, typename _Poolp>
     void
     __mt_alloc<_Tp, _Poolp>::
@@ -767,12 +767,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	    __pool._M_reclaim_block(reinterpret_cast<char*>(__p), __bytes);
 	}
     }
-  
+
   template<typename _Tp, typename _Poolp>
     inline bool
     operator==(const __mt_alloc<_Tp, _Poolp>&, const __mt_alloc<_Tp, _Poolp>&)
     { return true; }
-  
+
 #if __cpp_impl_three_way_comparison < 201907L
   template<typename _Tp, typename _Poolp>
     inline bool
diff --git a/libstdc++-v3/include/ext/pod_char_traits.h b/libstdc++-v3/include/ext/pod_char_traits.h
index 83386c8..05389a2 100644
--- a/libstdc++-v3/include/ext/pod_char_traits.h
+++ b/libstdc++-v3/include/ext/pod_char_traits.h
@@ -147,7 +147,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       static char_type*
       move(char_type* __s1, const char_type* __s2, size_t __n)
-      { 
+      {
 	if (__n == 0)
 	  return __s1;
 	return static_cast<char_type*>
@@ -183,7 +183,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       { return __c1 == __c2; }
 
       static int_type
-      eof() 
+      eof()
       {
 	int_type __r = { static_cast<typename __gnu_cxx::__conditional_type
 			 <std::__is_integer<int_type>::__value,
diff --git a/libstdc++-v3/include/ext/pointer.h b/libstdc++-v3/include/ext/pointer.h
index ae0a9a1..ae45e1f 100644
--- a/libstdc++-v3/include/ext/pointer.h
+++ b/libstdc++-v3/include/ext/pointer.h
@@ -60,10 +60,10 @@ namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
-  /** 
+  /**
    * @brief A storage policy for use with _Pointer_adapter<> which yields a
    *        standard pointer.
-   * 
+   *
    *  A _Storage_policy is required to provide 4 things:
    *    1) A get() API for returning the stored pointer value.
    *    2) An set() API for storing a pointer value.
@@ -71,28 +71,28 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    *    4) An operator<() to support pointer comparison.
    *    5) An operator==() to support pointer comparison.
    */
-  template<typename _Tp> 
-    class _Std_pointer_impl 
+  template<typename _Tp>
+    class _Std_pointer_impl
     {
     public:
       // the type this pointer points to.
       typedef _Tp element_type;
-  
+
       // A method to fetch the pointer value as a standard T* value;
-      inline _Tp* 
-      get() const 
+      inline _Tp*
+      get() const
       { return _M_value; }
-  
+
       // A method to set the pointer value, from a standard T* value;
-      inline void 
-      set(element_type* __arg) 
+      inline void
+      set(element_type* __arg)
       { _M_value = __arg; }
-  
+
       // Comparison of pointers
       inline bool
       operator<(const _Std_pointer_impl& __rarg) const
       { return (_M_value < __rarg._M_value); }
-  
+
       inline bool
       operator==(const _Std_pointer_impl& __rarg) const
       { return (_M_value == __rarg._M_value); }
@@ -105,7 +105,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * @brief A storage policy for use with _Pointer_adapter<> which stores
    *        the pointer's address as an offset value which is relative to
    *        its own address.
-   * 
+   *
    * This is intended for pointers within shared memory regions which
    * might be mapped at different addresses by different processes.
    * For null pointers, a value of 1 is used.  (0 is legitimate
@@ -114,14 +114,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * there is no reason why any normal pointer would point 1 byte into
    * its own pointer address.
    */
-  template<typename _Tp> 
-    class _Relative_pointer_impl 
+  template<typename _Tp>
+    class _Relative_pointer_impl
     {
     public:
       typedef _Tp element_type;
-  
+
       _Tp*
-      get() const 
+      get() const
       {
         if (_M_diff == 1)
           return 0;
@@ -129,17 +129,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
           return reinterpret_cast<_Tp*>(reinterpret_cast<uintptr_t>(this)
 					+ _M_diff);
       }
-  
-      void 
+
+      void
       set(_Tp* __arg)
       {
         if (!__arg)
           _M_diff = 1;
         else
-          _M_diff = reinterpret_cast<uintptr_t>(__arg) 
+          _M_diff = reinterpret_cast<uintptr_t>(__arg)
                     - reinterpret_cast<uintptr_t>(this);
       }
-  
+
       // Comparison of pointers
       inline bool
       operator<(const _Relative_pointer_impl& __rarg) const
@@ -155,17 +155,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef __UINTPTR_TYPE__ uintptr_t;
       uintptr_t _M_diff;
     };
-  
+
   /**
    * Relative_pointer_impl needs a specialization for const T because of
    * the casting done during pointer arithmetic.
    */
-  template<typename _Tp> 
-    class _Relative_pointer_impl<const _Tp> 
+  template<typename _Tp>
+    class _Relative_pointer_impl<const _Tp>
     {
     public:
       typedef const _Tp element_type;
-  
+
       const _Tp*
       get() const
       {
@@ -175,17 +175,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
           return reinterpret_cast<const _Tp*>
 	      (reinterpret_cast<uintptr_t>(this) + _M_diff);
       }
-  
-      void 
+
+      void
       set(const _Tp* __arg)
       {
         if (!__arg)
           _M_diff = 1;
         else
-          _M_diff = reinterpret_cast<uintptr_t>(__arg) 
+          _M_diff = reinterpret_cast<uintptr_t>(__arg)
                     - reinterpret_cast<uintptr_t>(this);
       }
-  
+
       // Comparison of pointers
       inline bool
       operator<(const _Relative_pointer_impl& __rarg) const
@@ -196,7 +196,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       operator==(const _Relative_pointer_impl& __rarg) const
       { return (reinterpret_cast<uintptr_t>(this->get())
 		== reinterpret_cast<uintptr_t>(__rarg.get())); }
-  
+
     private:
       typedef __UINTPTR_TYPE__ uintptr_t;
       uintptr_t _M_diff;
@@ -208,25 +208,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * _Pointer_adapter for cases of void*, const void*, and so on.
    */
   struct _Invalid_type { };
-  
+
   template<typename _Tp>
-    struct _Reference_type 
+    struct _Reference_type
     { typedef _Tp& reference; };
 
-  template<> 
-    struct _Reference_type<void> 
+  template<>
+    struct _Reference_type<void>
     { typedef _Invalid_type& reference; };
 
-  template<> 
-    struct _Reference_type<const void> 
+  template<>
+    struct _Reference_type<const void>
     { typedef const _Invalid_type& reference; };
 
-  template<> 
-    struct _Reference_type<volatile void> 
+  template<>
+    struct _Reference_type<volatile void>
     { typedef volatile _Invalid_type&  reference; };
 
-  template<> 
-    struct _Reference_type<volatile const void> 
+  template<>
+    struct _Reference_type<volatile const void>
     { typedef const volatile _Invalid_type&  reference; };
 
   /**
@@ -234,14 +234,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * std::iterator_traits<> is normally specialized for const T*, so
    * that value_type is still T.
    */
-  template<typename _Tp> 
-    struct _Unqualified_type 
+  template<typename _Tp>
+    struct _Unqualified_type
     { typedef _Tp type; };
-    
-  template<typename _Tp> 
-    struct _Unqualified_type<const _Tp> 
+
+  template<typename _Tp>
+    struct _Unqualified_type<const _Tp>
     { typedef _Tp type; };
-    
+
   /**
    * The following provides an 'alternative pointer' that works with
    * the containers when specified as the pointer typedef of the
@@ -275,7 +275,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * const _Tp* const == const _Pointer_adapter<_Std_pointer_impl<const _Tp> >;
    */
   template<typename _Storage_policy>
-    class _Pointer_adapter : public _Storage_policy 
+    class _Pointer_adapter : public _Storage_policy
     {
     public:
       typedef typename _Storage_policy::element_type element_type;
@@ -287,8 +287,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef _Pointer_adapter                               pointer;
       typedef typename _Reference_type<element_type>::reference  reference;
 
-      // Reminder: 'const' methods mean that the method is valid when the 
-      // pointer is immutable, and has nothing to do with whether the 
+      // Reminder: 'const' methods mean that the method is valid when the
+      // pointer is immutable, and has nothing to do with whether the
       // 'pointee' is const.
 
       // Default Constructor (Convert from element_type*)
@@ -296,7 +296,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       { _Storage_policy::set(__arg); }
 
       // Copy constructor from _Pointer_adapter of same type.
-      _Pointer_adapter(const _Pointer_adapter& __arg) 
+      _Pointer_adapter(const _Pointer_adapter& __arg)
       { _Storage_policy::set(__arg.get()); }
 
       // Convert from _Up* if conversion to element_type* is valid.
@@ -312,39 +312,39 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       // Destructor
       ~_Pointer_adapter() { }
-  
+
       // Assignment operator
       _Pointer_adapter&
-      operator=(const _Pointer_adapter& __arg) 
+      operator=(const _Pointer_adapter& __arg)
       {
-        _Storage_policy::set(__arg.get()); 
-        return *this; 
+        _Storage_policy::set(__arg.get());
+        return *this;
       }
 
       template<typename _Up>
         _Pointer_adapter&
         operator=(const _Pointer_adapter<_Up>& __arg)
         {
-          _Storage_policy::set(__arg.get()); 
-          return *this; 
+          _Storage_policy::set(__arg.get());
+          return *this;
         }
 
       template<typename _Up>
         _Pointer_adapter&
         operator=(_Up* __arg)
         {
-          _Storage_policy::set(__arg); 
-          return *this; 
+          _Storage_policy::set(__arg);
+          return *this;
         }
 
       // Operator*, returns element_type&
-      inline reference 
-      operator*() const 
+      inline reference
+      operator*() const
       { return *(_Storage_policy::get()); }
 
       // Operator->, returns element_type*
-      inline element_type* 
-      operator->() const 
+      inline element_type*
+      operator->() const
       { return _Storage_policy::get(); }
 
       // Operator[], returns a element_type& to the item at that loc.
@@ -362,45 +362,45 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     public:
       operator __unspecified_bool_type() const
       {
-        return _Storage_policy::get() == 0 ? 0 : 
-                         &_Pointer_adapter::operator->; 
+        return _Storage_policy::get() == 0 ? 0 :
+                         &_Pointer_adapter::operator->;
       }
 
       // ! operator (for: if (!ptr)...)
       inline bool
-      operator!() const 
+      operator!() const
       { return (_Storage_policy::get() == 0); }
 #endif
-  
+
       // Pointer differences
-      inline friend std::ptrdiff_t 
-      operator-(const _Pointer_adapter& __lhs, element_type* __rhs) 
+      inline friend std::ptrdiff_t
+      operator-(const _Pointer_adapter& __lhs, element_type* __rhs)
       { return (__lhs.get() - __rhs); }
-  
-      inline friend std::ptrdiff_t 
-      operator-(element_type* __lhs, const _Pointer_adapter& __rhs) 
+
+      inline friend std::ptrdiff_t
+      operator-(element_type* __lhs, const _Pointer_adapter& __rhs)
       { return (__lhs - __rhs.get()); }
-  
+
       template<typename _Up>
-        inline friend std::ptrdiff_t 
-        operator-(const _Pointer_adapter& __lhs, _Up* __rhs) 
+        inline friend std::ptrdiff_t
+        operator-(const _Pointer_adapter& __lhs, _Up* __rhs)
         { return (__lhs.get() - __rhs); }
-    
+
       template<typename _Up>
-        inline friend std::ptrdiff_t 
+        inline friend std::ptrdiff_t
         operator-(_Up* __lhs, const _Pointer_adapter& __rhs)
         { return (__lhs - __rhs.get()); }
 
       template<typename _Up>
-        inline std::ptrdiff_t 
-        operator-(const _Pointer_adapter<_Up>& __rhs) const 
+        inline std::ptrdiff_t
+        operator-(const _Pointer_adapter<_Up>& __rhs) const
         { return (_Storage_policy::get() - __rhs.get()); }
-  
+
       // Pointer math
       // Note: There is a reason for all this overloading based on different
       // integer types.  In some libstdc++-v3 test cases, a templated
       // operator+ is declared which can match any types.  This operator
-      // tends to "steal" the recognition of _Pointer_adapter's own operator+ 
+      // tends to "steal" the recognition of _Pointer_adapter's own operator+
       // unless the integer type matches perfectly.
 
 #define _CXX_POINTER_ARITH_OPERATOR_SET(INT_TYPE) \
@@ -430,7 +430,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
         return *this; \
       } \
 // END of _CXX_POINTER_ARITH_OPERATOR_SET macro
-  
+
       // Expand into the various pointer arithmetic operators needed.
       _CXX_POINTER_ARITH_OPERATOR_SET(short);
       _CXX_POINTER_ARITH_OPERATOR_SET(unsigned short);
@@ -447,30 +447,30 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #endif
 
       // Mathematical Manipulators
-      inline _Pointer_adapter& 
+      inline _Pointer_adapter&
       operator++()
       {
-        _Storage_policy::set(_Storage_policy::get() + 1); 
+        _Storage_policy::set(_Storage_policy::get() + 1);
         return *this;
       }
-  
-      inline _Pointer_adapter 
+
+      inline _Pointer_adapter
       operator++(int)
       {
         _Pointer_adapter __tmp(*this);
         _Storage_policy::set(_Storage_policy::get() + 1);
         return __tmp;
       }
-  
-      inline _Pointer_adapter& 
-      operator--() 
+
+      inline _Pointer_adapter&
+      operator--()
       {
-        _Storage_policy::set(_Storage_policy::get() - 1); 
+        _Storage_policy::set(_Storage_policy::get() - 1);
         return *this;
       }
-  
+
       inline _Pointer_adapter
-      operator--(int) 
+      operator--(int)
       {
         _Pointer_adapter __tmp(*this);
         _Storage_policy::set(_Storage_policy::get() - 1);
@@ -504,7 +504,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     { return __lhs.get() OPERATOR __rhs.get(); } \
 \
 // End GCC_CXX_POINTER_COMPARISON_OPERATION_SET Macro
-  
+
   // Expand into the various comparison operators needed.
   _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(==)
   _GCC_CXX_POINTER_COMPARISON_OPERATION_SET(!=)
@@ -517,22 +517,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _Tp>
     inline bool
     operator==(const _Pointer_adapter<_Tp>& __lhs, int __rhs)
-    { return __lhs.get() == reinterpret_cast<void*>(__rhs); } 
+    { return __lhs.get() == reinterpret_cast<void*>(__rhs); }
 
   template<typename _Tp>
     inline bool
     operator==(int __lhs, const _Pointer_adapter<_Tp>& __rhs)
-    { return __rhs.get() == reinterpret_cast<void*>(__lhs); } 
+    { return __rhs.get() == reinterpret_cast<void*>(__lhs); }
 
   template<typename _Tp>
     inline bool
     operator!=(const _Pointer_adapter<_Tp>& __lhs, int __rhs)
-    { return __lhs.get() != reinterpret_cast<void*>(__rhs); } 
+    { return __lhs.get() != reinterpret_cast<void*>(__rhs); }
 
   template<typename _Tp>
     inline bool
     operator!=(int __lhs, const _Pointer_adapter<_Tp>& __rhs)
-    { return __rhs.get() != reinterpret_cast<void*>(__lhs); } 
+    { return __rhs.get() != reinterpret_cast<void*>(__lhs); }
 
   /**
    * Comparison operators for _Pointer_adapter defer to the base class'
@@ -540,38 +540,38 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    */
   template<typename _Tp>
     inline bool
-    operator==(const _Pointer_adapter<_Tp>& __lhs, 
+    operator==(const _Pointer_adapter<_Tp>& __lhs,
                const _Pointer_adapter<_Tp>& __rhs)
     { return __lhs._Tp::operator==(__rhs); }
 
   template<typename _Tp>
     inline bool
-    operator<=(const _Pointer_adapter<_Tp>& __lhs, 
+    operator<=(const _Pointer_adapter<_Tp>& __lhs,
                const _Pointer_adapter<_Tp>& __rhs)
     { return __lhs._Tp::operator<(__rhs) || __lhs._Tp::operator==(__rhs); }
 
   template<typename _Tp>
     inline bool
-    operator!=(const _Pointer_adapter<_Tp>& __lhs, 
+    operator!=(const _Pointer_adapter<_Tp>& __lhs,
                const _Pointer_adapter<_Tp>& __rhs)
     { return !(__lhs._Tp::operator==(__rhs)); }
 
   template<typename _Tp>
     inline bool
-    operator>(const _Pointer_adapter<_Tp>& __lhs, 
+    operator>(const _Pointer_adapter<_Tp>& __lhs,
               const _Pointer_adapter<_Tp>& __rhs)
     { return !(__lhs._Tp::operator<(__rhs) || __lhs._Tp::operator==(__rhs)); }
 
   template<typename _Tp>
     inline bool
-    operator>=(const _Pointer_adapter<_Tp>& __lhs, 
+    operator>=(const _Pointer_adapter<_Tp>& __lhs,
                const _Pointer_adapter<_Tp>& __rhs)
     { return !(__lhs._Tp::operator<(__rhs)); }
 
 #if _GLIBCXX_HOSTED
   template<typename _CharT, typename _Traits, typename _StoreT>
     inline std::basic_ostream<_CharT, _Traits>&
-    operator<<(std::basic_ostream<_CharT, _Traits>& __os, 
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
                const _Pointer_adapter<_StoreT>& __p)
     { return (__os << __p.get()); }
 #endif // HOSTED
diff --git a/libstdc++-v3/include/ext/pool_allocator.h b/libstdc++-v3/include/ext/pool_allocator.h
index 679b4b3..9b66e8a 100644
--- a/libstdc++-v3/include/ext/pool_allocator.h
+++ b/libstdc++-v3/include/ext/pool_allocator.h
@@ -82,27 +82,27 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       enum { _S_align = 8 };
       enum { _S_max_bytes = 128 };
       enum { _S_free_list_size = (size_t)_S_max_bytes / (size_t)_S_align };
-      
+
       union _Obj
       {
 	union _Obj* _M_free_list_link;
 	char        _M_client_data[1];    // The client sees this.
       };
-      
+
       static _Obj* volatile         _S_free_list[_S_free_list_size];
 
       // Chunk allocation state.
       static char*                  _S_start_free;
       static char*                  _S_end_free;
-      static size_t                 _S_heap_size;     
-      
+      static size_t                 _S_heap_size;
+
       size_t
       _M_round_up(size_t __bytes)
       { return ((__bytes + (size_t)_S_align - 1) & ~((size_t)_S_align - 1)); }
-      
+
       _GLIBCXX_CONST _Obj* volatile*
       _M_get_free_list(size_t __bytes) throw ();
-    
+
       __mutex&
       _M_get_mutex() throw ();
 
@@ -110,7 +110,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       // free list.
       void*
       _M_refill(size_t __n);
-      
+
       // Allocates a chunk for nobjs of size size.  nobjs may be reduced
       // if it is inconvenient to allocate the requested number.
       char*
@@ -165,7 +165,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       { return std::__addressof(__x); }
 
       size_type
-      max_size() const _GLIBCXX_USE_NOEXCEPT 
+      max_size() const _GLIBCXX_USE_NOEXCEPT
       { return std::size_t(-1) / sizeof(_Tp); }
 
 #if __cplusplus >= 201103L
@@ -175,16 +175,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
 
       template<typename _Up>
-        void 
+        void
         destroy(_Up* __p) { __p->~_Up(); }
 #else
       // _GLIBCXX_RESOLVE_LIB_DEFECTS
       // 402. wrong new expression in [some_] allocator::construct
-      void 
-      construct(pointer __p, const _Tp& __val) 
+      void
+      construct(pointer __p, const _Tp& __val)
       { ::new((void *)__p) _Tp(__val); }
 
-      void 
+      void
       destroy(pointer __p) { __p->~_Tp(); }
 #endif
 
@@ -192,7 +192,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       allocate(size_type __n, const void* = 0);
 
       void
-      deallocate(pointer __p, size_type __n);      
+      deallocate(pointer __p, size_type __n);
     };
 
   template<typename _Tp>
@@ -248,7 +248,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  else
 	    {
 	      _Obj* volatile* __free_list = _M_get_free_list(__bytes);
-	      
+
 	      __scoped_lock sentry(_M_get_mutex());
 	      _Obj* __restrict__ __result = *__free_list;
 	      if (__builtin_expect(__result == 0, 0))
diff --git a/libstdc++-v3/include/ext/ropeimpl.h b/libstdc++-v3/include/ext/ropeimpl.h
index 8298a22..82b36f8 100644
--- a/libstdc++-v3/include/ext/ropeimpl.h
+++ b/libstdc++-v3/include/ext/ropeimpl.h
@@ -321,7 +321,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     _S_char_ptr_len(const _CharT* __s)
     {
       const _CharT* __p = __s;
-      
+
       while (!_S_is0(*__p))
 	++__p;
       return (__p - __s);
@@ -351,7 +351,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     {
       if (!_S_is_basic_char_type((_CharT*)0))
 	std::_Destroy(__s, __s + __n, __a);
-      
+
       //  This has to be a static member, so this gets a bit messy
       __a.deallocate(__s,
 		     _Rope_RopeLeaf<_CharT, _Alloc>::_S_rounded_up_size(__n));
@@ -494,7 +494,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 							      __left->
 							      _M_get_allocator());
       size_t __depth = __result->_M_depth;
-      
+
       if (__depth > 20
 	  && (__result->_M_size < 1000
 	      || __depth > size_t(__detail::_S_max_rope_depth)))
@@ -602,7 +602,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       if (__orig_size + __slen <= size_t(_S_copy_max)
 	  && __detail::_S_leaf == __r->_M_tag)
 	{
-	  __result = _S_destr_leaf_concat_char_iter((_RopeLeaf*)__r, __s, 
+	  __result = _S_destr_leaf_concat_char_iter((_RopeLeaf*)__r, __s,
 						    __slen);
 	  return __result;
 	}
@@ -643,7 +643,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       return __result;
     }
 #endif /* !__GC */
-  
+
   template <class _CharT, class _Alloc>
     typename rope<_CharT, _Alloc>::_RopeRep*
     rope<_CharT, _Alloc>::
@@ -719,7 +719,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       size_t __len = __base->_M_size;
       size_t __adj_endp1;
       const size_t __lazy_threshold = 128;
-      
+
       if (__endp1 >= __len)
 	{
 	  if (0 == __start)
@@ -729,7 +729,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	    }
 	  else
 	    __adj_endp1 = __len;
-	  
+
 	}
       else
 	__adj_endp1 = __endp1;
@@ -743,7 +743,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	      _RopeRep* __right = __c->_M_right;
 	      size_t __left_len = __left->_M_size;
 	      _RopeRep* __result;
-	      
+
 	      if (__adj_endp1 <= __left_len)
 		return _S_substring(__left, __start, __endp1);
 	      else if (__start >= __left_len)
@@ -753,7 +753,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 							    __start,
 							    __left_len));
 	      _Self_destruct_ptr __right_result(_S_substring(__right, 0,
-							     __endp1 
+							     __endp1
 							     - __left_len));
 	      __result = _S_concat(__left_result, __right_result);
 	      return __result;
@@ -798,7 +798,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 				       __adj_endp1 - __start,
 				       __base->_M_get_allocator());
 		return __result;
-		
+
 	      } // *** else fall through: ***
 	  }
 	case __detail::_S_function:
@@ -809,7 +809,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	    if (__start >= __adj_endp1)
 	      return 0;
 	    __result_len = __adj_endp1 - __start;
-	    
+
 	    if (__result_len > __lazy_threshold)
 	      goto lazy;
 	    __section = (_CharT*)
@@ -842,12 +842,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     private:
       _CharT* _M_buf_ptr;
     public:
-      
+
       _Rope_flatten_char_consumer(_CharT* __buffer)
       { _M_buf_ptr = __buffer; }
 
       ~_Rope_flatten_char_consumer() {}
-      
+
       bool
       operator()(const _CharT* __leaf, std::size_t __n)
       {
@@ -865,12 +865,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       _CharT _M_pattern;
     public:
       std::size_t _M_count;  // Number of nonmatching characters
-      
+
       _Rope_find_char_char_consumer(_CharT __p)
       : _M_pattern(__p), _M_count(0) {}
-	
+
       ~_Rope_find_char_char_consumer() {}
-      
+
       bool
       operator()(const _CharT* __leaf, std::size_t __n)
       {
@@ -986,7 +986,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     {
       char __f = __o.fill();
       std::size_t __i;
-      
+
       for (__i = 0; __i < __n; __i++)
 	__o.put(__f);
     }
@@ -1017,7 +1017,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       size_t __rope_len = __r.size();
       _Rope_insert_char_consumer<_CharT, _Traits> __c(__o);
       bool __is_simple = _Rope_is_simple((_CharT*)0);
-      
+
       if (__rope_len < __w)
 	__pad_len = __w - __rope_len;
       else
@@ -1125,7 +1125,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  _RopeConcatenation* __c = (_RopeConcatenation*)__r;
 	  _RopeRep* __left = __c->_M_left;
 	  _RopeRep* __right = __c->_M_right;
-	  
+
 #ifdef __GC
 	  printf("Concatenation %p (depth = %d, len = %ld, %s balanced)\n",
 		 __r, __r->_M_depth, __r->_M_size,
@@ -1143,7 +1143,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       else
 	{
 	  const char* __kind;
-	  
+
 	  switch (__r->_M_tag)
 	    {
 	    case __detail::_S_leaf:
@@ -1171,7 +1171,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	      _Self_destruct_ptr __prefix(_S_substring(__r, 0, __max_len));
 	      _CharT __buffer[__max_len + 1];
 	      bool __too_big = __r->_M_size > __prefix->_M_size;
-	      
+
 	      _S_flatten(__prefix, __buffer);
 	      __buffer[__prefix->_M_size] = _S_eos((_CharT*)0);
 	      printf("%s%s\n", (char*)__buffer,
@@ -1212,7 +1212,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       // __forest[__i]._M_size >= _S_min_len[__i]
       // __forest[__i]._M_depth = __i
       // References from forest are included in refcount.
-      
+
       for (__i = 0; __i <= int(__detail::_S_max_rope_depth); ++__i)
 	__forest[__i] = 0;
       __try
@@ -1239,7 +1239,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	    _S_unref(__forest[__i]);
 	  __throw_exception_again;
 	}
-      
+
       if (__result->_M_depth > int(__detail::_S_max_rope_depth))
 	std::__throw_length_error(__N("rope::_S_balance"));
       return(__result);
@@ -1258,7 +1258,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       {
 	_RopeConcatenation* __c = (_RopeConcatenation*)__r;
-	
+
 	_S_add_to_forest(__c->_M_left, __forest);
 	_S_add_to_forest(__c->_M_right, __forest);
       }
@@ -1274,7 +1274,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       _RopeRep* __too_tiny = 0;		// included in refcount
       int __i;				// forest[0..__i-1] is empty
       std::size_t __s = __r->_M_size;
-      
+
       for (__i = 0; __s >= _S_min_len[__i+1]/* not this bucket */; ++__i)
 	{
 	  if (0 != __forest[__i])
@@ -1324,7 +1324,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     _S_fetch(_RopeRep* __r, size_type __i)
     {
       __GC_CONST _CharT* __cstr = __r->_M_c_string;
-      
+
       if (0 != __cstr)
 	return __cstr[__i];
       for(;;)
@@ -1336,12 +1336,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		_RopeConcatenation* __c = (_RopeConcatenation*)__r;
 		_RopeRep* __left = __c->_M_left;
 		std::size_t __left_len = __left->_M_size;
-		
+
 		if (__i >= __left_len)
 		  {
 		    __i -= __left_len;
 		    __r = __c->_M_right;
-		  } 
+		  }
 		else
 		  __r = __left;
 	      }
@@ -1356,14 +1356,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	      {
 		_RopeFunction* __f = (_RopeFunction*)__r;
 		_CharT __result;
-		
+
 		(*(__f->_M_fn))(__i, 1, &__result);
 		return __result;
 	      }
 	    }
 	}
     }
-  
+
 #ifndef __GC
   // Return a uniquely referenced character slot for the given
   // position, or 0 if that's not possible.
@@ -1374,7 +1374,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     {
       _RopeRep* __clrstack[__detail::_S_max_rope_depth];
       std::size_t __csptr = 0;
-      
+
       for(;;)
 	{
 	  if (__r->_M_ref_count > 1)
@@ -1386,14 +1386,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		_RopeConcatenation* __c = (_RopeConcatenation*)__r;
 		_RopeRep* __left = __c->_M_left;
 		std::size_t __left_len = __left->_M_size;
-		
+
 		if (__c->_M_c_string != 0)
 		  __clrstack[__csptr++] = __c;
 		if (__i >= __left_len)
 		  {
 		    __i -= __left_len;
 		    __r = __c->_M_right;
-		  } 
+		  }
 		else
 		  __r = __left;
 	      }
@@ -1431,7 +1431,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     {
       std::size_t __left_len;
       std::size_t __right_len;
-      
+
       if (0 == __right)
 	return 0 != __left;
       if (0 == __left)
@@ -1596,21 +1596,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  else
 	    __result = power(__base_rope, __exponent,
 			     _Rope_Concat_fn<_CharT, _Alloc>());
-	    
+
 	  if (0 != __remainder)
 	    __result += __remainder_rope;
 	}
       else
 	__result = __remainder_rope;
-	  
+
       this->_M_tree_ptr = __result._M_tree_ptr;
       this->_M_tree_ptr->_M_ref_nonnil();
     }
-      
+
   template<class _CharT, class _Alloc>
     _CharT
     rope<_CharT, _Alloc>::_S_empty_c_str[1];
-      
+
   template<class _CharT, class _Alloc>
     const _CharT*
     rope<_CharT, _Alloc>::
@@ -1635,7 +1635,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       __gthread_mutex_unlock (&this->_M_tree_ptr->_M_c_string_lock);
       return(__result);
     }
-  
+
   template<class _CharT, class _Alloc>
     const _CharT* rope<_CharT, _Alloc>::
     replace_with_c_str()
@@ -1660,7 +1660,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     }
 
   // Algorithm specializations.  More should be added.
-  
+
   template<class _Rope_iterator>  // was templated on CharT and Alloc
     void		          // VC++ workaround
     _Rope_rotate(_Rope_iterator __first,
@@ -1669,7 +1669,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     {
       typedef typename _Rope_iterator::value_type _CharT;
       typedef typename _Rope_iterator::_allocator_type _Alloc;
-      
+
       rope<_CharT, _Alloc>& __r(__first.container());
       rope<_CharT, _Alloc> __prefix = __r.substr(0, __first.index());
       rope<_CharT, _Alloc> __suffix =
diff --git a/libstdc++-v3/include/ext/sso_string_base.h b/libstdc++-v3/include/ext/sso_string_base.h
index 07cc54b..69e1eda 100644
--- a/libstdc++-v3/include/ext/sso_string_base.h
+++ b/libstdc++-v3/include/ext/sso_string_base.h
@@ -47,7 +47,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef __vstring_utility<_CharT, _Traits, _Alloc>    _Util_Base;
       typedef typename _Util_Base::_CharT_alloc_type        _CharT_alloc_type;
       typedef typename _CharT_alloc_type::size_type	    size_type;
-      
+
     private:
       // Data Members:
       typename _Util_Base::template _Alloc_hider<_CharT_alloc_type>
@@ -55,7 +55,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       size_type                                             _M_string_length;
 
       enum { _S_local_capacity = 15 };
-      
+
       union
       {
 	_CharT           _M_local_data[_S_local_capacity + 1];
@@ -81,7 +81,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       // Create & Destroy
       _CharT*
       _M_create(size_type&, size_type);
-      
+
       void
       _M_dispose()
       {
@@ -97,7 +97,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       // requires special behaviour if _InIterator is an integral type
       template<typename _InIterator>
         void
-        _M_construct_aux(_InIterator __beg, _InIterator __end, 
+        _M_construct_aux(_InIterator __beg, _InIterator __end,
 			 std::__false_type)
 	{
           typedef typename std::iterator_traits<_InIterator>::iterator_category
@@ -129,7 +129,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
         void
         _M_construct(_InIterator __beg, _InIterator __end,
 		     std::input_iterator_tag);
-      
+
       // For forward_iterators up to random_access_iterators, used for
       // string::iterator, _CharT*, etc.
       template<typename _FwdIterator>
@@ -160,7 +160,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       _M_capacity() const
       {
 	return _M_is_local() ? size_type(_S_local_capacity)
-	                     : _M_allocated_capacity; 
+	                     : _M_allocated_capacity;
       }
 
       bool
@@ -406,7 +406,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	    _M_data()[__len++] = *__beg;
 	    ++__beg;
 	  }
-	
+
 	__try
 	  {
 	    while (__beg != __end)
@@ -546,7 +546,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	      size_type __len2)
     {
       const size_type __how_much = _M_length() - __pos - __len1;
-      
+
       size_type __new_capacity = _M_length() + __len2 - __len1;
       _CharT* __r = _M_create(__new_capacity, _M_capacity());
 
@@ -557,7 +557,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       if (__how_much)
 	this->_S_copy(__r + __pos + __len2,
 		      _M_data() + __pos + __len1, __how_much);
-      
+
       _M_dispose();
       _M_data(__r);
       _M_capacity(__new_capacity);
diff --git a/libstdc++-v3/include/ext/throw_allocator.h b/libstdc++-v3/include/ext/throw_allocator.h
index a113a0f0..79946f4 100644
--- a/libstdc++-v3/include/ext/throw_allocator.h
+++ b/libstdc++-v3/include/ext/throw_allocator.h
@@ -400,7 +400,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       auto beg = __b.map_construct().begin();
       auto end = __b.map_construct().end();
       for (; beg != end; ++beg)
-	__b.log_to_string(error, *beg);      
+	__b.log_to_string(error, *beg);
     }
 #endif
     return os << error;
@@ -868,7 +868,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	}
 
       template<typename _Up>
-        void 
+        void
         destroy(_Up* __p)
         {
 	  erase_construct(__p);
diff --git a/libstdc++-v3/include/ext/type_traits.h b/libstdc++-v3/include/ext/type_traits.h
index 651dfd6..304e539 100644
--- a/libstdc++-v3/include/ext/type_traits.h
+++ b/libstdc++-v3/include/ext/type_traits.h
@@ -47,7 +47,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   // Define a nested type if some predicate holds.
   template<bool, typename>
-    struct __enable_if 
+    struct __enable_if
     { };
 
   template<typename _Tp>
@@ -68,12 +68,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   // Given an integral builtin type, return the corresponding unsigned type.
   template<typename _Tp>
     struct __add_unsigned
-    { 
+    {
     private:
       typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
-      
+
     public:
-      typedef typename __if_type::__type __type; 
+      typedef typename __if_type::__type __type;
     };
 
   template<>
@@ -111,12 +111,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   // Given an integral builtin type, return the corresponding signed type.
   template<typename _Tp>
     struct __remove_unsigned
-    { 
+    {
     private:
       typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
-      
+
     public:
-      typedef typename __if_type::__type __type; 
+      typedef typename __if_type::__type __type;
     };
 
   template<>
@@ -277,4 +277,4 @@ _GLIBCXX_END_NAMESPACE_VERSION
 
 #pragma GCC diagnostic pop
 
-#endif 
+#endif
diff --git a/libstdc++-v3/include/ext/vstring.h b/libstdc++-v3/include/ext/vstring.h
index 22b9a1d..c7b7cc1 100644
--- a/libstdc++-v3/include/ext/vstring.h
+++ b/libstdc++-v3/include/ext/vstring.h
@@ -50,18 +50,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   /**
    *  @class __versa_string vstring.h
-   *  @brief  Template class __versa_string. 
+   *  @brief  Template class __versa_string.
    *  @ingroup extensions
    *
    *  Data structure managing sequences of characters and
-   *  character-like objects. 
+   *  character-like objects.
    */
   template<typename _CharT, typename _Traits, typename _Alloc,
 	   template <typename, typename, typename> class _Base>
     class __versa_string
     : private _Base<_CharT, _Traits, _Alloc>
     {
-      typedef _Base<_CharT, _Traits, _Alloc>                __vstring_base;    
+      typedef _Base<_CharT, _Traits, _Alloc>                __vstring_base;
       typedef typename __vstring_base::_CharT_alloc_type    _CharT_alloc_type;
       typedef __alloc_traits<_CharT_alloc_type> _CharT_alloc_traits;
 
@@ -252,14 +252,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       /**
        *  @brief  Destroy the string instance.
        */
-      ~__versa_string() _GLIBCXX_NOEXCEPT { }	
+      ~__versa_string() _GLIBCXX_NOEXCEPT { }
 
       /**
        *  @brief  Assign the value of @a str to this string.
        *  @param  __str  Source string.
        */
       __versa_string&
-      operator=(const __versa_string& __str) 
+      operator=(const __versa_string& __str)
       { return this->assign(__str); }
 
 #if __cplusplus >= 201103L
@@ -295,7 +295,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        *  @param  __s  Source null-terminated string.
        */
       __versa_string&
-      operator=(const _CharT* __s) 
+      operator=(const _CharT* __s)
       { return this->assign(__s); }
 
       /**
@@ -306,9 +306,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        *  (*this)[0] == @a __c.
        */
       __versa_string&
-      operator=(_CharT __c) 
-      { 
-	this->assign(1, __c); 
+      operator=(_CharT __c)
+      {
+	this->assign(1, __c);
 	return *this;
       }
 
@@ -521,7 +521,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       { this->_M_clear(); }
 
       /**
-       *  Returns true if the %string is empty.  Equivalent to 
+       *  Returns true if the %string is empty.  Equivalent to
        *  <code>*this == ""</code>.
        */
       _GLIBCXX_NODISCARD bool
@@ -673,7 +673,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        */
       __versa_string&
       operator+=(_CharT __c)
-      { 
+      {
 	this->push_back(__c);
 	return *this;
       }
@@ -792,7 +792,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        */
       void
       push_back(_CharT __c)
-      { 
+      {
 	const size_type __size = this->size();
 	if (__size + 1 > this->capacity() || this->_M_is_shared())
 	  this->_M_mutate(__size, size_type(0), 0, size_type(1));
@@ -948,7 +948,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	_GLIBCXX_DEBUG_PEDASSERT(__p >= _M_ibegin() && __p <= _M_iend());
 	const size_type __pos = __p - _M_ibegin();
 	this->replace(__p, __p, __n, __c);
-	return iterator(this->_M_data() + __pos); 
+	return iterator(this->_M_data() + __pos);
       }
 #else
       /**
@@ -1150,7 +1150,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #if __cplusplus >= 201103L
       insert(const_iterator __p, _CharT __c)
 #else
-      insert(iterator __p, _CharT __c)	
+      insert(iterator __p, _CharT __c)
 #endif
       {
 	_GLIBCXX_DEBUG_PEDASSERT(__p >= _M_ibegin() && __p <= _M_iend());
@@ -1177,7 +1177,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       */
       __versa_string&
       erase(size_type __pos = 0, size_type __n = npos)
-      { 
+      {
 	this->_M_erase(_M_check(__pos, "__versa_string::erase"),
 		       _M_limit(__pos, __n));
 	return *this;
@@ -1195,7 +1195,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #if __cplusplus >= 201103L
       erase(const_iterator __position)
 #else
-      erase(iterator __position)	
+      erase(iterator __position)
 #endif
       {
 	_GLIBCXX_DEBUG_PEDASSERT(__position >= _M_ibegin()
@@ -1331,7 +1331,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        *  Removes the characters in the range [pos,pos + n1) from this
        *  string.  In place, the characters of @a __s are inserted.  If
        *  @a pos is beyond end of string, out_of_range is thrown.  If
-       *  the length of result exceeds max_size(), length_error is thrown.  
+       *  the length of result exceeds max_size(), length_error is thrown.
        *  The value of the string doesn't change if an error is thrown.
       */
       __versa_string&
@@ -1429,7 +1429,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #if __cplusplus >= 201103L
       replace(const_iterator __i1, const_iterator __i2, const _CharT* __s)
 #else
-      replace(iterator __i1, iterator __i2, const _CharT* __s)	
+      replace(iterator __i1, iterator __i2, const _CharT* __s)
 #endif
       {
 	__glibcxx_requires_string(__s);
@@ -1569,7 +1569,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
 			     __k1.base(), __k2 - __k1);
       }
-      
+
 #if __cplusplus >= 201103L
       /**
        *  @brief  Replace range of characters with initializer_list.
@@ -2676,7 +2676,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     inline basic_istream<_CharT, _Traits>&
     getline(basic_istream<_CharT, _Traits>& __is,
 	    __gnu_cxx::__versa_string<_CharT, _Traits, _Alloc, _Base>& __str)
-    { return getline(__is, __str, __is.widen('\n')); }      
+    { return getline(__is, __str, __is.widen('\n')); }
 
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace
@@ -2796,12 +2796,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #endif // _GLIBCXX_USE_C99_STDIO
 
 #if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_C99_WCHAR
-  inline int 
+  inline int
   stoi(const __wvstring& __str, std::size_t* __idx = 0, int __base = 10)
   { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
 					__idx, __base); }
 
-  inline long 
+  inline long
   stol(const __wvstring& __str, std::size_t* __idx = 0, int __base = 10)
   { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
 			     __idx, __base); }
diff --git a/libstdc++-v3/include/ext/vstring_fwd.h b/libstdc++-v3/include/ext/vstring_fwd.h
index 8c64604..8cab7f2 100644
--- a/libstdc++-v3/include/ext/vstring_fwd.h
+++ b/libstdc++-v3/include/ext/vstring_fwd.h
@@ -58,7 +58,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   typedef __versa_string<char>                              __vstring;
   typedef __vstring                                         __sso_string;
-  typedef 
+  typedef
   __versa_string<char, std::char_traits<char>,
 		 std::allocator<char>, __rc_string_base>    __rc_string;
 
@@ -71,13 +71,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #if __cplusplus >= 201103L
   typedef __versa_string<char16_t>                          __u16vstring;
   typedef __u16vstring                                      __u16sso_string;
-  typedef 
+  typedef
   __versa_string<char16_t, std::char_traits<char16_t>,
 		 std::allocator<char16_t>, __rc_string_base> __u16rc_string;
 
   typedef __versa_string<char32_t>                          __u32vstring;
   typedef __u32vstring                                      __u32sso_string;
-  typedef 
+  typedef
   __versa_string<char32_t, std::char_traits<char32_t>,
 		 std::allocator<char32_t>, __rc_string_base> __u32rc_string;
 #endif // C++11
diff --git a/libstdc++-v3/include/parallel/algobase.h b/libstdc++-v3/include/parallel/algobase.h
index b46ed61..4c0377b 100644
--- a/libstdc++-v3/include/parallel/algobase.h
+++ b/libstdc++-v3/include/parallel/algobase.h
@@ -75,7 +75,7 @@ namespace __parallel
   template<typename _RAIter1, typename _RAIter2, typename _Predicate>
     pair<_RAIter1, _RAIter2>
     __mismatch_switch(_RAIter1 __begin1, _RAIter1 __end1,
-                      _RAIter2 __begin2, _Predicate __pred, 
+                      _RAIter2 __begin2, _Predicate __pred,
                       random_access_iterator_tag, random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(true))
@@ -153,7 +153,7 @@ namespace __parallel
   template<typename _RAIter1, typename _RAIter2, typename _Predicate>
     pair<_RAIter1, _RAIter2>
     __mismatch_switch(_RAIter1 __begin1, _RAIter1 __end1,
-                      _RAIter2 __begin2, _RAIter2 __end2, _Predicate __pred, 
+                      _RAIter2 __begin2, _RAIter2 __end2, _Predicate __pred,
                       random_access_iterator_tag, random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(true))
@@ -202,14 +202,14 @@ namespace __parallel
   // Sequential fallback
   template<typename _IIter1, typename _IIter2>
     inline bool
-    equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, 
+    equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
           __gnu_parallel::sequential_tag)
     { return _GLIBCXX_STD_A::equal(__begin1, __end1, __begin2); }
 
   // Sequential fallback
   template<typename _IIter1, typename _IIter2, typename _Predicate>
     inline bool
-    equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, 
+    equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
           _Predicate __pred, __gnu_parallel::sequential_tag)
     { return _GLIBCXX_STD_A::equal(__begin1, __end1, __begin2, __pred); }
 
@@ -232,7 +232,7 @@ namespace __parallel
   template<typename _IIter1, typename _IIter2, typename _Predicate>
     _GLIBCXX20_CONSTEXPR
     inline bool
-    equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, 
+    equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
           _Predicate __pred)
     {
 #if __cplusplus > 201703L
@@ -281,7 +281,7 @@ namespace __parallel
   template<typename _RAIter1, typename _RAIter2, typename _Predicate>
     inline bool
     __equal_switch(_RAIter1 __begin1, _RAIter1 __end1,
-		   _RAIter2 __begin2, _RAIter2 __end2, _Predicate __pred, 
+		   _RAIter2 __begin2, _RAIter2 __end2, _Predicate __pred,
 		   random_access_iterator_tag, random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(true))
@@ -338,8 +338,8 @@ namespace __parallel
   // Sequential fallback
   template<typename _IIter1, typename _IIter2>
     inline bool
-    lexicographical_compare(_IIter1 __begin1, _IIter1 __end1, 
-                            _IIter2 __begin2, _IIter2 __end2, 
+    lexicographical_compare(_IIter1 __begin1, _IIter1 __end1,
+                            _IIter2 __begin2, _IIter2 __end2,
                             __gnu_parallel::sequential_tag)
     { return _GLIBCXX_STD_A::lexicographical_compare(__begin1, __end1,
                                                      __begin2, __end2); }
@@ -347,8 +347,8 @@ namespace __parallel
   // Sequential fallback
   template<typename _IIter1, typename _IIter2, typename _Predicate>
     inline bool
-    lexicographical_compare(_IIter1 __begin1, _IIter1 __end1, 
-                            _IIter2 __begin2, _IIter2 __end2, 
+    lexicographical_compare(_IIter1 __begin1, _IIter1 __end1,
+                            _IIter2 __begin2, _IIter2 __end2,
                             _Predicate __pred, __gnu_parallel::sequential_tag)
     { return _GLIBCXX_STD_A::lexicographical_compare(
                __begin1, __end1, __begin2, __end2, __pred); }
@@ -358,7 +358,7 @@ namespace __parallel
            typename _Predicate, typename _IteratorTag1, typename _IteratorTag2>
     inline bool
     __lexicographical_compare_switch(_IIter1 __begin1, _IIter1 __end1,
-                                     _IIter2 __begin2, _IIter2 __end2, 
+                                     _IIter2 __begin2, _IIter2 __end2,
                                      _Predicate __pred,
                                      _IteratorTag1, _IteratorTag2)
     { return _GLIBCXX_STD_A::lexicographical_compare(
@@ -371,7 +371,7 @@ namespace __parallel
     __lexicographical_compare_switch(_RAIter1 __begin1, _RAIter1 __end1,
                                      _RAIter2 __begin2, _RAIter2 __end2,
                                      _Predicate __pred,
-                                     random_access_iterator_tag, 
+                                     random_access_iterator_tag,
                                      random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(true))
@@ -390,9 +390,9 @@ namespace __parallel
           if ((__end1 - __begin1) < (__end2 - __begin2))
             {
               typedef pair<_RAIter1, _RAIter2> _SpotType;
-              _SpotType __mm = __mismatch_switch(__begin1, __end1, __begin2, 
-                                             _EqualFromLessCompare(__pred), 
-                                             random_access_iterator_tag(), 
+              _SpotType __mm = __mismatch_switch(__begin1, __end1, __begin2,
+                                             _EqualFromLessCompare(__pred),
+                                             random_access_iterator_tag(),
                                              random_access_iterator_tag());
 
               return (__mm.first == __end1)
@@ -401,9 +401,9 @@ namespace __parallel
           else
             {
               typedef pair<_RAIter2, _RAIter1> _SpotType;
-              _SpotType __mm = __mismatch_switch(__begin2, __end2, __begin1, 
-                                             _EqualFromLessCompare(__pred), 
-                                             random_access_iterator_tag(), 
+              _SpotType __mm = __mismatch_switch(__begin2, __end2, __begin1,
+                                             _EqualFromLessCompare(__pred),
+                                             random_access_iterator_tag(),
                                              random_access_iterator_tag());
 
               return (__mm.first != __end2)
diff --git a/libstdc++-v3/include/parallel/algorithmfwd.h b/libstdc++-v3/include/parallel/algorithmfwd.h
index 7c9843a..066be68 100644
--- a/libstdc++-v3/include/parallel/algorithmfwd.h
+++ b/libstdc++-v3/include/parallel/algorithmfwd.h
@@ -72,7 +72,7 @@ namespace __parallel
 
   template<typename _RAIter, typename _BiPredicate>
     _RAIter
-    __adjacent_find_switch(_RAIter, _RAIter, _BiPredicate, 
+    __adjacent_find_switch(_RAIter, _RAIter, _BiPredicate,
                          random_access_iterator_tag);
 
 
@@ -388,7 +388,7 @@ namespace __parallel
     _FIter
     search_n(_FIter, _FIter, _Integer, const _Tp&, _BiPredicate,
              __gnu_parallel::sequential_tag);
-    
+
   template<typename _FIter, typename _Integer, typename _Tp>
     _FIter
     search_n(_FIter, _FIter, _Integer, const _Tp&);
@@ -417,25 +417,25 @@ namespace __parallel
 
   template<typename _IIter, typename _OIter, typename _UnaryOperation>
     _OIter
-    transform(_IIter, _IIter, _OIter, _UnaryOperation, 
+    transform(_IIter, _IIter, _OIter, _UnaryOperation,
               __gnu_parallel::sequential_tag);
 
   template<typename _IIter, typename _OIter, typename _UnaryOperation>
     _OIter
-    transform(_IIter, _IIter, _OIter, _UnaryOperation, 
+    transform(_IIter, _IIter, _OIter, _UnaryOperation,
               __gnu_parallel::_Parallelism);
 
   template<typename _IIter, typename _OIter, typename _UnaryOperation,
            typename _IterTag1, typename _IterTag2>
     _OIter
-    __transform1_switch(_IIter, _IIter, _OIter, _UnaryOperation, 
+    __transform1_switch(_IIter, _IIter, _OIter, _UnaryOperation,
                       _IterTag1, _IterTag2);
-    
+
 
   template<typename _RAIIter, typename _RAOIter, typename _UnaryOperation>
     _RAOIter
-    __transform1_switch(_RAIIter, _RAIIter, _RAOIter, _UnaryOperation, 
-                      random_access_iterator_tag, random_access_iterator_tag, 
+    __transform1_switch(_RAIIter, _RAIIter, _RAOIter, _UnaryOperation,
+                      random_access_iterator_tag, random_access_iterator_tag,
                       __gnu_parallel::_Parallelism __parallelism
                       = __gnu_parallel::parallel_balanced);
 
@@ -448,20 +448,20 @@ namespace __parallel
   template<typename _IIter1, typename _IIter2, typename _OIter,
            typename _BiOperation>
     _OIter
-    transform(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation, 
+    transform(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation,
               __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2, typename _OIter,
            typename _BiOperation>
     _OIter
-    transform(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation, 
+    transform(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation,
               __gnu_parallel::_Parallelism);
 
   template<typename _RAIter1, typename _RAIter2, typename _RAIter3,
            typename _BiOperation>
     _RAIter3
-    __transform2_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter3, _BiOperation, 
-                      random_access_iterator_tag, random_access_iterator_tag, 
+    __transform2_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter3, _BiOperation,
+                      random_access_iterator_tag, random_access_iterator_tag,
                       random_access_iterator_tag,
                       __gnu_parallel::_Parallelism __parallelism
                       = __gnu_parallel::parallel_balanced);
@@ -470,7 +470,7 @@ namespace __parallel
            typename _BiOperation, typename _Tag1,
            typename _Tag2, typename _Tag3>
     _OIter
-    __transform2_switch(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation, 
+    __transform2_switch(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation,
                       _Tag1, _Tag2, _Tag3);
 
 
@@ -480,7 +480,7 @@ namespace __parallel
 
   template<typename _FIter, typename _Tp>
     void
-    replace(_FIter, _FIter, const _Tp&, const _Tp&, 
+    replace(_FIter, _FIter, const _Tp&, const _Tp&,
             __gnu_parallel::sequential_tag);
 
   template<typename _FIter, typename _Tp>
@@ -494,7 +494,7 @@ namespace __parallel
 
   template<typename _RAIter, typename _Tp>
     void
-    __replace_switch(_RAIter, _RAIter, const _Tp&, const _Tp&, 
+    __replace_switch(_RAIter, _RAIter, const _Tp&, const _Tp&,
                    random_access_iterator_tag, __gnu_parallel::_Parallelism);
 
 
@@ -516,7 +516,7 @@ namespace __parallel
            typename _IterTag>
     void
     __replace_if_switch(_FIter, _FIter, _Predicate, const _Tp&, _IterTag);
- 
+
   template<typename _RAIter, typename _Predicate, typename _Tp>
     void
     __replace_if_switch(_RAIter, _RAIter, _Predicate, const _Tp&,
@@ -562,13 +562,13 @@ namespace __parallel
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _OIter
-    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, 
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
           __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2, typename _OIter,
            typename _Compare>
     _OIter
-    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, 
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare,
           __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2, typename _OIter,
@@ -584,14 +584,14 @@ namespace __parallel
            typename _Compare, typename _IterTag1, typename _IterTag2,
            typename _IterTag3>
     _OIter
-    __merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, 
+    __merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare,
                  _IterTag1, _IterTag2, _IterTag3);
 
   template<typename _IIter1, typename _IIter2, typename _OIter,
            typename _Compare>
     _OIter
-    __merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, 
-                 random_access_iterator_tag, random_access_iterator_tag, 
+    __merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare,
+                 random_access_iterator_tag, random_access_iterator_tag,
                  random_access_iterator_tag);
 
 
@@ -668,7 +668,7 @@ namespace __parallel
   template<typename _FIter, typename _Predicate>
     _FIter
     partition(_FIter, _FIter, _Predicate, __gnu_parallel::sequential_tag);
-    
+
   template<typename _FIter, typename _Predicate>
     _FIter
     partition(_FIter, _FIter, _Predicate);
@@ -676,7 +676,7 @@ namespace __parallel
   template<typename _FIter, typename _Predicate, typename _IterTag>
     _FIter
     __partition_switch(_FIter, _FIter, _Predicate, _IterTag);
-    
+
   template<typename _RAIter, typename _Predicate>
     _RAIter
     __partition_switch(
@@ -721,7 +721,7 @@ namespace __parallel
 
   template<typename _IIter1, typename _IIter2, typename _OIter,
            typename _Predicate>
-    _OIter 
+    _OIter
     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate);
 
   template<typename _IIter1, typename _IIter2, typename _Predicate,
@@ -755,7 +755,7 @@ namespace __parallel
 
   template<typename _IIter1, typename _IIter2, typename _OIter,
            typename _Predicate>
-    _OIter 
+    _OIter
     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate);
 
   template<typename _IIter1, typename _IIter2, typename _Predicate,
@@ -786,12 +786,12 @@ namespace __parallel
                              _Predicate, __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
-    _OIter 
+    _OIter
     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
   template<typename _IIter1, typename _IIter2, typename _OIter,
            typename _Predicate>
-    _OIter 
+    _OIter
     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
                              _Predicate);
 
diff --git a/libstdc++-v3/include/parallel/base.h b/libstdc++-v3/include/parallel/base.h
index 4341e26..e0f720e 100644
--- a/libstdc++-v3/include/parallel/base.h
+++ b/libstdc++-v3/include/parallel/base.h
@@ -45,9 +45,9 @@
  * @namespace std::__parallel
  * @brief GNU parallel code, replaces standard behavior with parallel behavior.
  */
-namespace std _GLIBCXX_VISIBILITY(default) 
-{ 
-  namespace __parallel { } 
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+  namespace __parallel { }
 }
 
 /**
@@ -64,14 +64,14 @@ namespace __gnu_parallel
  * @namespace __gnu_sequential
  * @brief GNU sequential classes for public use.
  */
-namespace __gnu_sequential 
-{ 
+namespace __gnu_sequential
+{
   // Import whatever is the serial version.
 #ifdef _GLIBCXX_PARALLEL
   using namespace std::_GLIBCXX_STD_A;
 #else
   using namespace std;
-#endif   
+#endif
 }
 
 
@@ -82,14 +82,14 @@ namespace __gnu_parallel
   // and active, which imples that the OpenMP runtime is actually
   // going to be linked in.
   inline _ThreadIndex
-  __get_max_threads() 
-  { 
+  __get_max_threads()
+  {
     _ThreadIndex __i = omp_get_max_threads();
-    return __i > 1 ? __i : 1; 
+    return __i > 1 ? __i : 1;
   }
 
 
-  inline bool 
+  inline bool
   __is_parallel(const _Parallelism __p) { return __p != sequential; }
 
 
diff --git a/libstdc++-v3/include/parallel/find_selectors.h b/libstdc++-v3/include/parallel/find_selectors.h
index 681579f..4c808da 100644
--- a/libstdc++-v3/include/parallel/find_selectors.h
+++ b/libstdc++-v3/include/parallel/find_selectors.h
@@ -43,7 +43,7 @@ namespace __gnu_parallel
   struct __generic_find_selector
   { };
 
-  /** 
+  /**
    *  @brief Test predicate on a single element, used for std::find()
    *  and std::find_if ().
    */
@@ -56,7 +56,7 @@ namespace __gnu_parallel
      */
     template<typename _RAIter1, typename _RAIter2,
              typename _Pred>
-      bool 
+      bool
       operator()(_RAIter1 __i1, _RAIter2 __i2, _Pred __pred)
       { return __pred(*__i1); }
 
@@ -68,7 +68,7 @@ namespace __gnu_parallel
      */
     template<typename _RAIter1, typename _RAIter2,
              typename _Pred>
-      std::pair<_RAIter1, _RAIter2> 
+      std::pair<_RAIter1, _RAIter2>
       _M_sequential_algorithm(_RAIter1 __begin1,
                            _RAIter1 __end1,
                            _RAIter2 __begin2, _Pred __pred)
@@ -86,7 +86,7 @@ namespace __gnu_parallel
      */
     template<typename _RAIter1, typename _RAIter2,
              typename _Pred>
-      bool 
+      bool
       operator()(_RAIter1 __i1, _RAIter2 __i2, _Pred __pred)
       {
         // Passed end iterator is one short.
@@ -118,24 +118,24 @@ namespace __gnu_parallel
   /** @brief Test inverted predicate on a single element. */
   struct __mismatch_selector : public __generic_find_selector
   {
-    /** 
+    /**
      *  @brief Test on one position.
      *  @param __i1 _Iterator on first sequence.
      *  @param __i2 _Iterator on second sequence (unused).
-     *  @param __pred Find predicate. 
+     *  @param __pred Find predicate.
      */
     template<typename _RAIter1, typename _RAIter2,
              typename _Pred>
-      bool 
+      bool
       operator()(_RAIter1 __i1, _RAIter2 __i2, _Pred __pred)
       { return !__pred(*__i1, *__i2); }
 
-    /** 
+    /**
      *  @brief Corresponding sequential algorithm on a sequence.
      *  @param __begin1 Begin iterator of first sequence.
      *  @param __end1 End iterator of first sequence.
      *  @param __begin2 Begin iterator of second sequence.
-     *  @param __pred Find predicate. 
+     *  @param __pred Find predicate.
      */
     template<typename _RAIter1, typename _RAIter2,
              typename _Pred>
diff --git a/libstdc++-v3/include/parallel/list_partition.h b/libstdc++-v3/include/parallel/list_partition.h
index 78404bb..9295cbf 100644
--- a/libstdc++-v3/include/parallel/list_partition.h
+++ b/libstdc++-v3/include/parallel/list_partition.h
@@ -89,8 +89,8 @@ namespace __gnu_parallel
    *  @param __num_parts Number of parts to split the sequence into.
    *  @param __f Functor to be applied to each element by traversing __it
    *  @param __oversampling Oversampling factor. If 0, then the
-   *  partitions will differ in at most 
-   *  \f$\sqrt{\mathrm{end} - \mathrm{begin}}\f$ 
+   *  partitions will differ in at most
+   *  \f$\sqrt{\mathrm{end} - \mathrm{begin}}\f$
    *  elements. Otherwise, the ratio between the
    *  longest and the shortest part is bounded by
    *  \f$1/(\mathrm{oversampling} \cdot \mathrm{num\_parts})\f$
diff --git a/libstdc++-v3/include/parallel/losertree.h b/libstdc++-v3/include/parallel/losertree.h
index e356375..1546ab4 100644
--- a/libstdc++-v3/include/parallel/losertree.h
+++ b/libstdc++-v3/include/parallel/losertree.h
@@ -561,7 +561,7 @@ namespace __gnu_parallel
     };
 
   /** @brief Base class for unguarded _LoserTree implementation.
-   * 
+   *
    * The whole element is copied into the tree structure.
    *
    * No guarding is done, therefore not a single input sequence must
diff --git a/libstdc++-v3/include/parallel/multiseq_selection.h b/libstdc++-v3/include/parallel/multiseq_selection.h
index 53264fd..af9257c 100644
--- a/libstdc++-v3/include/parallel/multiseq_selection.h
+++ b/libstdc++-v3/include/parallel/multiseq_selection.h
@@ -27,7 +27,7 @@
  *  multiple sorted sequences.  Also serves for splitting such
  *  sequence sets.
  *
- *  The algorithm description can be found in 
+ *  The algorithm description can be found in
  *
  *  P. J. Varman, S. D. Scheufler, B. R. Iyer, and G. R. Ricard.
  *  Merging Multiple Lists on Hierarchical-Memory Multiprocessors.
@@ -106,7 +106,7 @@ namespace __gnu_parallel
 
 #pragma GCC diagnostic pop // -Wdeprecated-declarations
 
-  /** 
+  /**
    *  @brief Splits several sorted sequences at a certain global __rank,
    *  resulting in a splitting point for each sequence.
    *  The sequences are passed via a sequence of random-access
@@ -120,7 +120,7 @@ namespace __gnu_parallel
    *  __result will be stored in. Each element of the sequence is an
    *  iterator that points to the first element on the greater part of
    *  the respective __sequence.
-   *  @param __comp The ordering functor, defaults to std::less<_Tp>. 
+   *  @param __comp The ordering functor, defaults to std::less<_Tp>.
    */
   template<typename _RanSeqs, typename _RankType, typename _RankIterator,
             typename _Compare>
@@ -230,7 +230,7 @@ namespace __gnu_parallel
         __a[__sample[__j].second] += __n + 1;
       for (; __j < __m; __j++)
         __b[__sample[__j].second] -= __n + 1;
-      
+
       // Further refinement.
       while (__n > 0)
         {
@@ -284,7 +284,7 @@ namespace __gnu_parallel
                 std::vector<std::pair<_ValueType, _SeqNumber> >,
                 _LexicographicReverse<_ValueType, _SeqNumber, _Compare> >
                 __pq(__lrcomp);
-              
+
               for (_SeqNumber __i = 0; __i < __m; __i++)
                 if (__b[__i] < __ns[__i])
                   __pq.push(std::make_pair(__S(__i)[__b[__i]], __i));
@@ -377,7 +377,7 @@ namespace __gnu_parallel
     }
 
 
-  /** 
+  /**
    *  @brief Selects the element at a certain global __rank from several
    *  sorted sequences.
    *
@@ -389,7 +389,7 @@ namespace __gnu_parallel
    *  @param __offset The rank of the selected element in the global
    *  subsequence of elements equal to the selected element. If the
    *  selected element is unique, this number is 0.
-   *  @param __comp The ordering functor, defaults to std::less. 
+   *  @param __comp The ordering functor, defaults to std::less.
    */
   template<typename _Tp, typename _RanSeqs, typename _RankType,
            typename _Compare>
diff --git a/libstdc++-v3/include/parallel/multiway_merge.h b/libstdc++-v3/include/parallel/multiway_merge.h
index d894e63..642d625 100644
--- a/libstdc++-v3/include/parallel/multiway_merge.h
+++ b/libstdc++-v3/include/parallel/multiway_merge.h
@@ -140,7 +140,7 @@ namespace __gnu_parallel
 	if (__bi1._M_current == __bi1._M_end)       // __bi2 is sup
 	  return false;
 	return !(__bi1.__comp)(*__bi2, *__bi1);     // normal compare
-      } 
+      }
     };
 
   template<typename _RAIter, typename _Compare>
@@ -1139,7 +1139,7 @@ namespace __gnu_parallel
 
       // (Settings::multiway_merge_splitting
       //  == __gnu_parallel::_Settings::EXACT).
-      std::vector<_RAIter1>* __offsets = 
+      std::vector<_RAIter1>* __offsets =
 	new std::vector<_RAIter1>[__num_threads];
       std::vector<std::pair<_RAIter1, _RAIter1> > __se(__k);
 
diff --git a/libstdc++-v3/include/parallel/multiway_mergesort.h b/libstdc++-v3/include/parallel/multiway_mergesort.h
index d3cbb62..553d6c4 100644
--- a/libstdc++-v3/include/parallel/multiway_mergesort.h
+++ b/libstdc++-v3/include/parallel/multiway_mergesort.h
@@ -105,7 +105,7 @@ namespace __gnu_parallel
 
       _DifferenceType* __es = new _DifferenceType[__num_samples + 2];
 
-      __equally_split(__sd->_M_starts[__iam + 1] - __sd->_M_starts[__iam], 
+      __equally_split(__sd->_M_starts[__iam + 1] - __sd->_M_starts[__iam],
 		      __num_samples + 1, __es);
 
       for (_DifferenceType __i = 0; __i < __num_samples; ++__i)
@@ -181,7 +181,7 @@ namespace __gnu_parallel
       }
   };
 
-  /** @brief Split by sampling. */ 
+  /** @brief Split by sampling. */
   template<typename _RAIter, typename _Compare,
 	   typename _SortingPlacesIterator>
     struct _SplitConsistently<false, _RAIter, _Compare, _SortingPlacesIterator>
@@ -243,7 +243,7 @@ namespace __gnu_parallel
 	  }
       }
   };
-  
+
   template<bool __stable, typename _RAIter, typename _Compare>
     struct __possibly_stable_sort
     { };
@@ -424,7 +424,7 @@ namespace __gnu_parallel
 	{
 	  __sd._M_num_threads = __num_threads;
 	  __sd._M_source = __begin;
-	  
+
 	  __sd._M_temporary = new _ValueType*[__num_threads];
 
 	  if (!__exact)
diff --git a/libstdc++-v3/include/parallel/numericfwd.h b/libstdc++-v3/include/parallel/numericfwd.h
index 7f26486..19f298d 100644
--- a/libstdc++-v3/include/parallel/numericfwd.h
+++ b/libstdc++-v3/include/parallel/numericfwd.h
@@ -97,7 +97,7 @@ namespace __parallel
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
     _OIter
-    adjacent_difference(_IIter, _IIter, _OIter, _BinaryOper, 
+    adjacent_difference(_IIter, _IIter, _OIter, _BinaryOper,
                         __gnu_parallel::sequential_tag);
 
   template<typename _IIter, typename _OIter>
@@ -107,7 +107,7 @@ namespace __parallel
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
     _OIter
-    adjacent_difference(_IIter, _IIter, _OIter, _BinaryOper, 
+    adjacent_difference(_IIter, _IIter, _OIter, _BinaryOper,
                         __gnu_parallel::_Parallelism);
 
   template<typename _IIter, typename _OIter, typename _BinaryOper,
@@ -118,9 +118,9 @@ namespace __parallel
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
     _OIter
-    __adjacent_difference_switch(_IIter, _IIter, _OIter, _BinaryOper, 
-                               random_access_iterator_tag, 
-                               random_access_iterator_tag, 
+    __adjacent_difference_switch(_IIter, _IIter, _OIter, _BinaryOper,
+                               random_access_iterator_tag,
+                               random_access_iterator_tag,
                                __gnu_parallel::_Parallelism __parallelism
                                = __gnu_parallel::parallel_unbalanced);
 
@@ -169,7 +169,7 @@ namespace __parallel
            typename _BinaryFunction1, typename _BinaryFunction2,
            typename _Tag1, typename _Tag2>
     _Tp
-    __inner_product_switch(_IIter1, _IIter1, _IIter2, _Tp, _BinaryFunction1, 
+    __inner_product_switch(_IIter1, _IIter1, _IIter2, _Tp, _BinaryFunction1,
                          _BinaryFunction2, _Tag1, _Tag2);
 
 
diff --git a/libstdc++-v3/include/parallel/partial_sum.h b/libstdc++-v3/include/parallel/partial_sum.h
index 294600f..5c8d068 100644
--- a/libstdc++-v3/include/parallel/partial_sum.h
+++ b/libstdc++-v3/include/parallel/partial_sum.h
@@ -119,7 +119,7 @@ namespace __gnu_parallel
 #       pragma omp single
 	{
 	  __num_threads = omp_get_num_threads();
-	    
+
 	  __borders = new _DifferenceType[__num_threads + 2];
 
 	  if (__s.partial_sum_dilation == 1.0f)
diff --git a/libstdc++-v3/include/parallel/partition.h b/libstdc++-v3/include/parallel/partition.h
index 631b3dd..6d6b9a9 100644
--- a/libstdc++-v3/include/parallel/partition.h
+++ b/libstdc++-v3/include/parallel/partition.h
@@ -89,7 +89,7 @@ namespace __gnu_parallel
 
 	    if (__s.partition_chunk_share > 0.0)
 	      __chunk_size = std::max<_DifferenceType>
-		(__s.partition_chunk_size, (double)__n 
+		(__s.partition_chunk_size, (double)__n
 		 * __s.partition_chunk_share / (double)__num_threads);
 	    else
 	      __chunk_size = __s.partition_chunk_size;
@@ -328,8 +328,8 @@ namespace __gnu_parallel
     *  @param __comp Comparator.
     */
   template<typename _RAIter, typename _Compare>
-    void 
-    __parallel_nth_element(_RAIter __begin, _RAIter __nth, 
+    void
+    __parallel_nth_element(_RAIter __begin, _RAIter __nth,
 			   _RAIter __end, _Compare __comp)
     {
       typedef std::iterator_traits<_RAIter> _TraitsType;
diff --git a/libstdc++-v3/include/parallel/random_number.h b/libstdc++-v3/include/parallel/random_number.h
index 0357fab..cece046 100644
--- a/libstdc++-v3/include/parallel/random_number.h
+++ b/libstdc++-v3/include/parallel/random_number.h
@@ -56,7 +56,7 @@ namespace __gnu_parallel
 
     // Bit results.
     int __bits_left;
-    
+
     static uint32_t
     __scale_down(uint64_t __x,
 #if _GLIBCXX_SCALE_DOWN_FPU
diff --git a/libstdc++-v3/include/parallel/random_shuffle.h b/libstdc++-v3/include/parallel/random_shuffle.h
index 42688bc..4cf170f 100644
--- a/libstdc++-v3/include/parallel/random_shuffle.h
+++ b/libstdc++-v3/include/parallel/random_shuffle.h
@@ -118,7 +118,7 @@ namespace __gnu_parallel
   /** @brief Random shuffle code executed by each thread.
     *  @param __pus Array of thread-local data records. */
   template<typename _RAIter, typename _RandomNumberGenerator>
-    void 
+    void
     __parallel_random_shuffle_drs_pu(_DRSSorterPU<_RAIter,
 				     _RandomNumberGenerator>* __pus)
     {
@@ -244,7 +244,7 @@ namespace __gnu_parallel
   /** @brief Round up to the next greater power of 2.
     *  @param __x _Integer to round up */
   template<typename _Tp>
-    _Tp 
+    _Tp
     __round_up_to_pow2(_Tp __x)
     {
       if (__x <= 1)
@@ -345,7 +345,7 @@ namespace __gnu_parallel
 #       pragma omp single
 	{
 	  __pus = new _DRSSorterPU<_RAIter, _RandomNumber>[__num_threads];
-	  
+
 	  __sd._M_temporaries = new _ValueType*[__num_threads];
 	  __sd._M_dist = new _DifferenceType*[__num_bins + 1];
 	  __sd._M_bin_proc = new _ThreadIndex[__num_bins];
@@ -490,7 +490,7 @@ namespace __gnu_parallel
 
           // Distribute according to oracles.
           for (_DifferenceType __i = 0; __i < __n; ++__i)
-            ::new(&(__target[(__dist0[__oracles[__i]])++])) 
+            ::new(&(__target[(__dist0[__oracles[__i]])++]))
 		_ValueType(*(__begin + __i));
 
           for (int __b = 0; __b < __num_bins; ++__b)
@@ -503,7 +503,7 @@ namespace __gnu_parallel
           delete[] __dist0;
           delete[] __dist1;
           delete[] __oracles;
-	  
+
 	  for (_DifferenceType __i = 0; __i < __n; ++__i)
 	    __target[__i].~_ValueType();
           ::operator delete(__target);
diff --git a/libstdc++-v3/include/parallel/search.h b/libstdc++-v3/include/parallel/search.h
index f14f07a..eee4e71 100644
--- a/libstdc++-v3/include/parallel/search.h
+++ b/libstdc++-v3/include/parallel/search.h
@@ -44,11 +44,11 @@ namespace __gnu_parallel
    *  @brief Precalculate __advances for Knuth-Morris-Pratt algorithm.
    *  @param __elements Begin iterator of sequence to search for.
    *  @param __length Length of sequence to search for.
-   *  @param __off Returned __offsets. 
+   *  @param __off Returned __offsets.
    */
   template<typename _RAIter, typename _DifferenceTp>
     void
-    __calc_borders(_RAIter __elements, _DifferenceTp __length, 
+    __calc_borders(_RAIter __elements, _DifferenceTp __length,
 		   _DifferenceTp* __off)
     {
       typedef _DifferenceTp _DifferenceType;
@@ -163,7 +163,7 @@ namespace __gnu_parallel
       omp_destroy_lock(&__result_lock);
 
       delete[] __splitters;
-      
+
       // Return iterator on found element.
       return (__begin1 + __result);
     }
diff --git a/libstdc++-v3/include/parallel/settings.h b/libstdc++-v3/include/parallel/settings.h
index aac4164..ebd4ab6 100644
--- a/libstdc++-v3/include/parallel/settings.h
+++ b/libstdc++-v3/include/parallel/settings.h
@@ -87,7 +87,7 @@
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wlong-long" // LL literal
 
-/** 
+/**
   * @brief Determine at compile(?)-time if the parallel variant of an
   * algorithm should be called.
   * @param __c A condition that is convertible to bool that is overruled by
@@ -125,7 +125,7 @@ namespace __gnu_parallel
   struct _Settings
   {
     _AlgorithmStrategy          algorithm_strategy;
-    
+
     _SortAlgorithm              sort_algorithm;
     _PartialSumAlgorithm        partial_sum_algorithm;
     _MultiwayMergeAlgorithm     multiway_merge_algorithm;
@@ -245,7 +245,7 @@ namespace __gnu_parallel
     /// Minimal input size for parallel std::transform.
     _SequenceIndex              transform_minimal_n;
 
-    /// Minimal input size for unique_copy. 
+    /// Minimal input size for unique_copy.
     _SequenceIndex              unique_copy_minimal_n;
 
     _SequenceIndex              workstealing_chunk_size;
@@ -285,7 +285,7 @@ namespace __gnu_parallel
     static void
     set(_Settings&) throw();
 
-    explicit 
+    explicit
     _Settings() :
             algorithm_strategy(heuristic),
             sort_algorithm(MWMS),
diff --git a/libstdc++-v3/include/parallel/sort.h b/libstdc++-v3/include/parallel/sort.h
index 5a3a6cb..4d7586c 100644
--- a/libstdc++-v3/include/parallel/sort.h
+++ b/libstdc++-v3/include/parallel/sort.h
@@ -60,15 +60,15 @@ namespace __gnu_parallel
     void
     __parallel_sort(_RAIter __begin, _RAIter __end,
 		    _Compare __comp, _Parallelism __parallelism);
-        
-  /** 
+
+  /**
    *  @brief Choose multiway mergesort, splitting variant at run-time,
    *  for parallel sorting.
    *  @param __begin Begin iterator of input sequence.
    *  @param __end End iterator of input sequence.
    *  @param __comp Comparator.
    *  @tparam __stable Sort stable.
-   *  @callgraph 
+   *  @callgraph
    */
   template<bool __stable, typename _RAIter, typename _Compare>
     inline void
@@ -85,14 +85,14 @@ namespace __gnu_parallel
 	  (__begin, __end, __comp, __parallelism.__get_num_threads());
     }
 
-  /** 
+  /**
    *  @brief Choose multiway mergesort with exact splitting,
    *  for parallel sorting.
    *  @param __begin Begin iterator of input sequence.
    *  @param __end End iterator of input sequence.
    *  @param __comp Comparator.
    *  @tparam __stable Sort stable.
-   *  @callgraph 
+   *  @callgraph
    */
   template<bool __stable, typename _RAIter, typename _Compare>
     inline void
@@ -106,14 +106,14 @@ namespace __gnu_parallel
         (__begin, __end, __comp, __parallelism.__get_num_threads());
     }
 
-  /** 
+  /**
    *  @brief Choose multiway mergesort with splitting by sampling,
    *  for parallel sorting.
    *  @param __begin Begin iterator of input sequence.
    *  @param __end End iterator of input sequence.
    *  @param __comp Comparator.
    *  @tparam __stable Sort stable.
-   *  @callgraph 
+   *  @callgraph
    */
   template<bool __stable, typename _RAIter, typename _Compare>
     inline void
@@ -133,7 +133,7 @@ namespace __gnu_parallel
    *  @param __end End iterator of input sequence.
    *  @param __comp Comparator.
    *  @tparam __stable Sort stable.
-   *  @callgraph 
+   *  @callgraph
    */
   template<bool __stable, typename _RAIter, typename _Compare>
     inline void
@@ -154,7 +154,7 @@ namespace __gnu_parallel
    *  @param __end End iterator of input sequence.
    *  @param __comp Comparator.
    *  @tparam __stable Sort stable.
-   *  @callgraph 
+   *  @callgraph
    */
    template<bool __stable, typename _RAIter, typename _Compare>
      inline void
@@ -169,14 +169,14 @@ namespace __gnu_parallel
 			   __parallelism.__get_num_threads());
      }
 
-  /** 
+  /**
    *  @brief Choose multiway mergesort with exact splitting,
    *  for parallel sorting.
    *  @param __begin Begin iterator of input sequence.
    *  @param __end End iterator of input sequence.
    *  @param __comp Comparator.
    *  @tparam __stable Sort stable.
-   *  @callgraph 
+   *  @callgraph
    */
   template<bool __stable, typename _RAIter, typename _Compare>
     inline void
@@ -196,7 +196,7 @@ namespace __gnu_parallel
    *  @param __end End iterator of input sequence.
    *  @param __comp Comparator.
    *  @tparam __stable Sort stable.
-   *  @callgraph 
+   *  @callgraph
    */
   template<bool __stable, typename _RAIter, typename _Compare>
     inline void
diff --git a/libstdc++-v3/include/parallel/types.h b/libstdc++-v3/include/parallel/types.h
index 020723d..59f1ba2 100644
--- a/libstdc++-v3/include/parallel/types.h
+++ b/libstdc++-v3/include/parallel/types.h
@@ -62,7 +62,7 @@ namespace __gnu_parallel
       parallel_taskqueue
     };
 
-  /// Strategies for run-time algorithm selection: 
+  /// Strategies for run-time algorithm selection:
   // force_sequential, force_parallel, heuristic.
   enum _AlgorithmStrategy
     {
@@ -71,16 +71,16 @@ namespace __gnu_parallel
       force_parallel
     };
 
-  /// Sorting algorithms: 
+  /// Sorting algorithms:
   // multi-way mergesort, quicksort, load-balanced quicksort.
-  enum _SortAlgorithm 
-    { 
-      MWMS, 
-      QS, 
-      QS_BALANCED 
+  enum _SortAlgorithm
+    {
+      MWMS,
+      QS,
+      QS_BALANCED
     };
 
-  /// Merging algorithms: 
+  /// Merging algorithms:
   // bubblesort-alike, loser-tree variants, enum __sentinel.
   enum _MultiwayMergeAlgorithm
     {
@@ -88,26 +88,26 @@ namespace __gnu_parallel
     };
 
   /// Partial sum algorithms: recursive, linear.
-  enum _PartialSumAlgorithm 
-    { 
-      RECURSIVE, 
-      LINEAR 
+  enum _PartialSumAlgorithm
+    {
+      RECURSIVE,
+      LINEAR
     };
 
   /// Sorting/merging algorithms: sampling, __exact.
-  enum _SplittingAlgorithm 
-    { 
-      SAMPLING, 
-      EXACT 
+  enum _SplittingAlgorithm
+    {
+      SAMPLING,
+      EXACT
     };
 
   /// Find algorithms:
   // growing blocks, equal-sized blocks, equal splitting.
-  enum _FindAlgorithm 
-    { 
-      GROWING_BLOCKS, 
-      CONSTANT_SIZE_BLOCKS, 
-      EQUAL_SPLIT 
+  enum _FindAlgorithm
+    {
+      GROWING_BLOCKS,
+      CONSTANT_SIZE_BLOCKS,
+      EQUAL_SPLIT
     };
 
   /**
diff --git a/libstdc++-v3/include/tr1/complex.h b/libstdc++-v3/include/tr1/complex.h
index 047c0cf..bae4d0e 100644
--- a/libstdc++-v3/include/tr1/complex.h
+++ b/libstdc++-v3/include/tr1/complex.h
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file tr1/complex.h
- *  This is a TR1 C++ Library header. 
+ *  This is a TR1 C++ Library header.
  */
 
 #ifndef _GLIBCXX_TR1_COMPLEX_H
diff --git a/libstdc++-v3/include/tr1/ctype.h b/libstdc++-v3/include/tr1/ctype.h
index 551c643..16ff774 100644
--- a/libstdc++-v3/include/tr1/ctype.h
+++ b/libstdc++-v3/include/tr1/ctype.h
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file tr1/ctype.h
- *  This is a TR1 C++ Library header. 
+ *  This is a TR1 C++ Library header.
  */
 
 #ifndef _TR1_CTYPE_H
diff --git a/libstdc++-v3/include/tr1/fenv.h b/libstdc++-v3/include/tr1/fenv.h
index 8c16d3c..fa87c9d 100644
--- a/libstdc++-v3/include/tr1/fenv.h
+++ b/libstdc++-v3/include/tr1/fenv.h
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file tr1/fenv.h
- *  This is a TR1 C++ Library header. 
+ *  This is a TR1 C++ Library header.
  */
 
 #ifndef _TR1_FENV_H
diff --git a/libstdc++-v3/include/tr1/float.h b/libstdc++-v3/include/tr1/float.h
index b955308..d84a169 100644
--- a/libstdc++-v3/include/tr1/float.h
+++ b/libstdc++-v3/include/tr1/float.h
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file tr1/float.h
- *  This is a TR1 C++ Library header. 
+ *  This is a TR1 C++ Library header.
  */
 
 #ifndef _TR1_FLOAT_H
diff --git a/libstdc++-v3/include/tr1/functional_hash.h b/libstdc++-v3/include/tr1/functional_hash.h
index 707d35f..1da5e69 100644
--- a/libstdc++-v3/include/tr1/functional_hash.h
+++ b/libstdc++-v3/include/tr1/functional_hash.h
@@ -130,7 +130,7 @@ namespace tr1
 	  return __result;
 	}
     };
-  
+
   template<>
     struct _Fnv_hash_base<8>
     {
diff --git a/libstdc++-v3/include/tr1/hashtable_policy.h b/libstdc++-v3/include/tr1/hashtable_policy.h
index cc18ce9..55bfb77 100644
--- a/libstdc++-v3/include/tr1/hashtable_policy.h
+++ b/libstdc++-v3/include/tr1/hashtable_policy.h
@@ -24,12 +24,12 @@
 
 /** @file tr1/hashtable_policy.h
  *  This is an internal header file, included by other library headers.
- *  Do not attempt to use it directly. 
+ *  Do not attempt to use it directly.
  *  @headername{tr1/unordered_map, tr1/unordered_set}
  */
 
 namespace std _GLIBCXX_VISIBILITY(default)
-{ 
+{
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
 namespace tr1
@@ -60,7 +60,7 @@ namespace __detail
 
   // Auxiliary types used for all instantiations of _Hashtable: nodes
   // and iterators.
-  
+
   // Nodes, used to wrap elements stored in the hash table.  A policy
   // template parameter of class template _Hashtable controls whether
   // nodes also store a hash code. In some cases (e.g. strings) this
@@ -90,7 +90,7 @@ namespace __detail
     {
       _Node_iterator_base(_Hash_node<_Value, __cache>* __p)
       : _M_cur(__p) { }
-      
+
       void
       _M_incr()
       { _M_cur = _M_cur->_M_next; }
@@ -136,21 +136,21 @@ namespace __detail
       reference
       operator*() const
       { return this->_M_cur->_M_v; }
-  
+
       pointer
       operator->() const
       { return std::__addressof(this->_M_cur->_M_v); }
 
       _Node_iterator&
       operator++()
-      { 
+      {
 	this->_M_incr();
-	return *this; 
+	return *this;
       }
-  
+
       _Node_iterator
       operator++(int)
-      { 
+      {
 	_Node_iterator __tmp(*this);
 	this->_M_incr();
 	return __tmp;
@@ -181,21 +181,21 @@ namespace __detail
       reference
       operator*() const
       { return this->_M_cur->_M_v; }
-  
+
       pointer
       operator->() const
       { return std::__addressof(this->_M_cur->_M_v); }
 
       _Node_const_iterator&
       operator++()
-      { 
+      {
 	this->_M_incr();
-	return *this; 
+	return *this;
       }
-  
+
       _Node_const_iterator
       operator++(int)
-      { 
+      {
 	_Node_const_iterator __tmp(*this);
 	this->_M_incr();
 	return __tmp;
@@ -281,21 +281,21 @@ namespace __detail
       reference
       operator*() const
       { return this->_M_cur_node->_M_v; }
-  
+
       pointer
       operator->() const
       { return std::__addressof(this->_M_cur_node->_M_v); }
 
       _Hashtable_iterator&
       operator++()
-      { 
+      {
 	this->_M_incr();
 	return *this;
       }
-  
+
       _Hashtable_iterator
       operator++(int)
-      { 
+      {
 	_Hashtable_iterator __tmp(*this);
 	this->_M_incr();
 	return __tmp;
@@ -331,21 +331,21 @@ namespace __detail
       reference
       operator*() const
       { return this->_M_cur_node->_M_v; }
-  
+
       pointer
       operator->() const
       { return std::__addressof(this->_M_cur_node->_M_v); }
 
       _Hashtable_const_iterator&
       operator++()
-      { 
+      {
 	this->_M_incr();
 	return *this;
       }
-  
+
       _Hashtable_const_iterator
       operator++(int)
-      { 
+      {
 	_Hashtable_const_iterator __tmp(*this);
 	this->_M_incr();
 	return __tmp;
@@ -385,16 +385,16 @@ namespace __detail
 
     float
     max_load_factor() const
-    { return _M_max_load_factor; }      
+    { return _M_max_load_factor; }
 
     // Return a bucket size no smaller than n.
     std::size_t
     _M_next_bkt(std::size_t __n) const;
-    
+
     // Return a bucket count appropriate for n elements
     std::size_t
     _M_bkt_for_elements(std::size_t __n) const;
-    
+
     // __n_bkt is current bucket count, __n_elt is current element count,
     // and __n_ins is number of elements to be inserted.  Do we need to
     // increase bucket count?  If so, return make_pair(true, n), where n
@@ -413,7 +413,7 @@ namespace __detail
   extern const unsigned long __prime_list[];
 
   // XXX This is a hack.  There's no good reason for any of
-  // _Prime_rehash_policy's member functions to be inline.  
+  // _Prime_rehash_policy's member functions to be inline.
 
   // Return a prime no smaller than n.
   inline std::size_t
@@ -425,7 +425,7 @@ namespace __detail
     // iterator that can be dereferenced to get the last prime.
     const unsigned long* __p
       = std::lower_bound(__prime_list, __prime_list + _S_n_primes - 1, __n);
-    _M_next_resize = 
+    _M_next_resize =
       static_cast<std::size_t>(__builtin_ceil(*__p * _M_max_load_factor));
     return *__p;
   }
@@ -442,7 +442,7 @@ namespace __detail
 
   // Finds the smallest prime p such that alpha p > __n_elt + __n_ins.
   // If p > __n_bkt, return make_pair(true, p); otherwise return
-  // make_pair(false, 0).  In principle this isn't very different from 
+  // make_pair(false, 0).  In principle this isn't very different from
   // _M_bkt_for_elements.
 
   // The only tricky part is that we're caching the element count at
@@ -464,7 +464,7 @@ namespace __detail
 	    return std::make_pair(true,
 				  _M_next_bkt(__builtin_ceil(__min_bkts)));
 	  }
-	else 
+	else
 	  {
 	    _M_next_resize = static_cast<std::size_t>
 	      (__builtin_ceil(__n_bkt * _M_max_load_factor));
@@ -488,11 +488,11 @@ namespace __detail
   // form pair<T1, T2> and a key extraction policy that returns the
   // first part of the pair, the hashtable gets a mapped_type typedef.
   // If it satisfies those criteria and also has unique keys, then it
-  // also gets an operator[].  
+  // also gets an operator[].
   template<typename _Key, typename _Value, typename _Ex, bool __unique,
 	   typename _Hashtable>
     struct _Map_base { };
-	  
+
   template<typename _Key, typename _Pair, typename _Hashtable>
     struct _Map_base<_Key, _Pair, std::_Select1st<_Pair>, false, _Hashtable>
     {
@@ -503,7 +503,7 @@ namespace __detail
     struct _Map_base<_Key, _Pair, std::_Select1st<_Pair>, true, _Hashtable>
     {
       typedef typename _Pair::second_type mapped_type;
-      
+
       mapped_type&
       operator[](const _Key& __k);
     };
@@ -558,10 +558,10 @@ namespace __detail
   //       we have a dummy type as placeholder.
   //   (2) Whether or not we cache hash codes.  Caching hash codes is
   //       meaningless if we have a ranged hash function.
-  // We also put the key extraction and equality comparison function 
+  // We also put the key extraction and equality comparison function
   // objects here, for convenience.
-  
-  // Primary template: unused except as a hook for specializations.  
+
+  // Primary template: unused except as a hook for specializations.
   template<typename _Key, typename _Value,
 	   typename _ExtractKey, typename _Equal,
 	   typename _H1, typename _H2, typename _Hash,
@@ -582,11 +582,11 @@ namespace __detail
       : _M_extract(__ex), _M_eq(__eq), _M_ranged_hash(__h) { }
 
       typedef void* _Hash_code_type;
-  
+
       _Hash_code_type
       _M_hash_code(const _Key& __key) const
       { return 0; }
-  
+
       std::size_t
       _M_bucket_index(const _Key& __k, _Hash_code_type,
 		      std::size_t __n) const
@@ -596,7 +596,7 @@ namespace __detail
       _M_bucket_index(const _Hash_node<_Value, false>* __p,
 		      std::size_t __n) const
       { return _M_ranged_hash(_M_extract(__p->_M_v), __n); }
-  
+
       bool
       _M_compare(const _Key& __k, _Hash_code_type,
 		 _Hash_node<_Value, false>* __n) const
@@ -610,7 +610,7 @@ namespace __detail
       _M_copy_code(_Hash_node<_Value, false>*,
 		   const _Hash_node<_Value, false>*) const
       { }
-      
+
       void
       _M_swap(_Hash_code_base& __x)
       {
@@ -628,11 +628,11 @@ namespace __detail
 
   // No specialization for ranged hash function while caching hash codes.
   // That combination is meaningless, and trying to do it is an error.
-  
-  
+
+
   // Specialization: ranged hash function, cache hash codes.  This
   // combination is meaningless, so we provide only a declaration
-  // and no definition.  
+  // and no definition.
   template<typename _Key, typename _Value,
 	   typename _ExtractKey, typename _Equal,
 	   typename _H1, typename _H2, typename _Hash>
@@ -641,7 +641,7 @@ namespace __detail
 
   // Specialization: hash function and range-hashing function, no
   // caching of hash codes.  H is provided but ignored.  Provides
-  // typedef and accessor required by TR1.  
+  // typedef and accessor required by TR1.
   template<typename _Key, typename _Value,
 	   typename _ExtractKey, typename _Equal,
 	   typename _H1, typename _H2>
@@ -665,7 +665,7 @@ namespace __detail
       _Hash_code_type
       _M_hash_code(const _Key& __k) const
       { return _M_h1(__k); }
-      
+
       std::size_t
       _M_bucket_index(const _Key&, _Hash_code_type __c,
 		      std::size_t __n) const
@@ -706,7 +706,7 @@ namespace __detail
       _H2          _M_h2;
     };
 
-  // Specialization: hash function and range-hashing function, 
+  // Specialization: hash function and range-hashing function,
   // caching hash codes.  H is provided but ignored.  Provides
   // typedef and accessor required by TR1.
   template<typename _Key, typename _Value,
@@ -716,7 +716,7 @@ namespace __detail
 			   _Default_ranged_hash, true>
     {
       typedef _H1 hasher;
-      
+
       hasher
       hash_function() const
       { return _M_h1; }
@@ -728,11 +728,11 @@ namespace __detail
       : _M_extract(__ex), _M_eq(__eq), _M_h1(__h1), _M_h2(__h2) { }
 
       typedef std::size_t _Hash_code_type;
-  
+
       _Hash_code_type
       _M_hash_code(const _Key& __k) const
       { return _M_h1(__k); }
-  
+
       std::size_t
       _M_bucket_index(const _Key&, _Hash_code_type __c,
 		      std::size_t __n) const
@@ -765,7 +765,7 @@ namespace __detail
 	std::swap(_M_h1, __x._M_h1);
 	std::swap(_M_h2, __x._M_h2);
       }
-      
+
     protected:
       _ExtractKey  _M_extract;
       _Equal       _M_eq;
diff --git a/libstdc++-v3/include/tr1/inttypes.h b/libstdc++-v3/include/tr1/inttypes.h
index 1032f78..9e77855 100644
--- a/libstdc++-v3/include/tr1/inttypes.h
+++ b/libstdc++-v3/include/tr1/inttypes.h
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file tr1/inttypes.h
- *  This is a TR1 C++ Library header. 
+ *  This is a TR1 C++ Library header.
  */
 
 #ifndef _GLIBCXX_TR1_INTTYPES_H
diff --git a/libstdc++-v3/include/tr1/limits.h b/libstdc++-v3/include/tr1/limits.h
index 2093886..d64955e 100644
--- a/libstdc++-v3/include/tr1/limits.h
+++ b/libstdc++-v3/include/tr1/limits.h
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file tr1/limits.h
- *  This is a TR1 C++ Library header. 
+ *  This is a TR1 C++ Library header.
  */
 
 #ifndef _TR1_LIMITS_H
diff --git a/libstdc++-v3/include/tr1/math.h b/libstdc++-v3/include/tr1/math.h
index 5f904f6..7ff87cc 100644
--- a/libstdc++-v3/include/tr1/math.h
+++ b/libstdc++-v3/include/tr1/math.h
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file tr1/math.h
- *  This is a TR1 C++ Library header. 
+ *  This is a TR1 C++ Library header.
  */
 
 #ifndef _GLIBCXX_TR1_MATH_H
diff --git a/libstdc++-v3/include/tr1/random.h b/libstdc++-v3/include/tr1/random.h
index 74950c9..e291cca 100644
--- a/libstdc++-v3/include/tr1/random.h
+++ b/libstdc++-v3/include/tr1/random.h
@@ -54,7 +54,7 @@ namespace tr1
    */
   namespace __detail
   {
-    template<typename _UIntType, int __w, 
+    template<typename _UIntType, int __w,
 	     bool = __w < std::numeric_limits<_UIntType>::digits>
       struct _Shift
       { static const _UIntType __value = 0; };
@@ -82,7 +82,7 @@ namespace tr1
      */
     template<typename _Engine, typename _Distribution>
       struct _Adaptor
-      { 
+      {
 	typedef typename _Engine::result_type           _Engine_result_type;
 	typedef typename _Distribution::input_type      result_type;
 
@@ -141,7 +141,7 @@ namespace tr1
 	    __return_value = result_type(_M_g() - _M_g.min())
 	      / result_type(_M_g.max() - _M_g.min() + result_type(1));
 	  else
-	    __return_value = (((_M_g() - _M_g.min()) 
+	    __return_value = (((_M_g() - _M_g.min())
 			       / (_M_g.max() - _M_g.min()))
 			      * std::numeric_limits<result_type>::max());
 	  return __return_value;
@@ -295,7 +295,7 @@ namespace tr1
    * requirements.  <table border=1 cellpadding=10 cellspacing=0>
    * <caption align=top>Random Number Generator Requirements</caption>
    * <tr><td>To be documented.</td></tr> </table>
-   * 
+   *
    * @{
    */
 
@@ -396,7 +396,7 @@ namespace tr1
       /**
        * Compares two linear congruential random number generator
        * objects of the same type for equality.
-       *  
+       *
        * @param __lhs A linear congruential random number generator object.
        * @param __rhs Another linear congruential random number generator obj.
        *
@@ -664,7 +664,7 @@ namespace tr1
 
   /**
    * @brief The Marsaglia-Zaman generator.
-   * 
+   *
    * This is a model of a Generalized Fibonacci discrete random number
    * generator, sometimes referred to as the SWC generator.
    *
@@ -690,7 +690,7 @@ namespace tr1
     public:
       /** The type of the generated random value. */
       typedef _IntType result_type;
-      
+
       // parameter values
       static const _IntType modulus   = __m;
       static const int      long_lag  = __r;
@@ -853,7 +853,7 @@ namespace tr1
    * @var _M_x     The state of the generator.  This is a ring buffer.
    * @var _M_carry The carry.
    * @var _M_p     Current index of x(i - r).
-   * @var _M_npows Precomputed negative powers of 2.   
+   * @var _M_npows Precomputed negative powers of 2.
    */
   template<typename _RealType, int __w, int __s, int __r>
     class subtract_with_carry_01
@@ -861,7 +861,7 @@ namespace tr1
     public:
       /** The type of the generated random value. */
       typedef _RealType result_type;
-      
+
       // parameter values
       static const int      word_size = __w;
       static const int      long_lag  = __r;
@@ -898,7 +898,7 @@ namespace tr1
         subtract_with_carry_01(_Gen& __g)
         {
 	  this->seed(__g);
-	  _M_initialize_npows();	  
+	  _M_initialize_npows();
 	}
 
       /**
@@ -1036,7 +1036,7 @@ namespace tr1
 
   // _GLIBCXX_RESOLVE_LIB_DEFECTS
   // 508. Bad parameters for ranlux64_base_01.
-  typedef subtract_with_carry_01<double, 48, 5, 12> ranlux64_base_01;  
+  typedef subtract_with_carry_01<double, 48, 5, 12> ranlux64_base_01;
 
 
   /**
@@ -1281,7 +1281,7 @@ namespace tr1
 
       // constructors and member function
       xor_combine()
-      : _M_b1(), _M_b2()	
+      : _M_b1(), _M_b2()
       { _M_initialize_max(); }
 
       xor_combine(const base1_type& __rng1, const base2_type& __rng2)
@@ -1531,7 +1531,7 @@ namespace tr1
     class uniform_int
     {
       __glibcxx_class_requires(_IntType, _IntegerConcept)
- 
+
     public:
       /** The type of the parameters of the distribution. */
       typedef _IntType input_type;
@@ -1672,7 +1672,7 @@ namespace tr1
     explicit
     bernoulli_distribution(double __p = 0.5)
     : _M_p(__p)
-    { 
+    {
       _GLIBCXX_DEBUG_ASSERT((_M_p >= 0.0) && (_M_p <= 1.0));
     }
 
@@ -1741,7 +1741,7 @@ namespace tr1
   /**
    * @brief A discrete geometric random number distribution.
    *
-   * The formula for the geometric probability mass function is 
+   * The formula for the geometric probability mass function is
    * @f$ p(i) = (1 - p)p^{i-1} @f$ where @f$ p @f$ is the parameter of the
    * distribution.
    */
@@ -1914,7 +1914,7 @@ namespace tr1
   /**
    * @brief A discrete binomial random number distribution.
    *
-   * The formula for the binomial probability mass function is 
+   * The formula for the binomial probability mass function is
    * @f$ p(i) = \binom{n}{i} p^i (1 - p)^{t - i} @f$ where @f$ t @f$
    * and @f$ p @f$ are the parameters of the distribution.
    */
@@ -1942,7 +1942,7 @@ namespace tr1
       _IntType
       t() const
       { return _M_t; }
-      
+
       /**
        * Gets the distribution @p p parameter.
        */
@@ -2103,7 +2103,7 @@ namespace tr1
   /**
    * @brief An exponential continuous distribution for random numbers.
    *
-   * The formula for the exponential probability mass function is 
+   * The formula for the exponential probability mass function is
    * @f$ p(x) = \lambda e^{-\lambda x} @f$.
    *
    * <table border=1 cellpadding=10 cellspacing=0>
@@ -2131,7 +2131,7 @@ namespace tr1
       explicit
       exponential_distribution(const result_type& __lambda = result_type(1))
       : _M_lambda(__lambda)
-      { 
+      {
 	_GLIBCXX_DEBUG_ASSERT(_M_lambda > 0);
       }
 
@@ -2194,8 +2194,8 @@ namespace tr1
   /**
    * @brief A normal continuous distribution for random numbers.
    *
-   * The formula for the normal probability mass function is 
-   * @f$ p(x) = \frac{1}{\sigma \sqrt{2 \pi}} 
+   * The formula for the normal probability mass function is
+   * @f$ p(x) = \frac{1}{\sigma \sqrt{2 \pi}}
    *            e^{- \frac{{x - mean}^ {2}}{2 \sigma ^ {2}} } @f$.
    */
   template<typename _RealType = double>
@@ -2215,7 +2215,7 @@ namespace tr1
       normal_distribution(const result_type& __mean = result_type(0),
 			  const result_type& __sigma = result_type(1))
       : _M_mean(__mean), _M_sigma(__sigma), _M_saved_available(false)
-      { 
+      {
 	_GLIBCXX_DEBUG_ASSERT(_M_sigma > 0);
       }
 
@@ -2277,14 +2277,14 @@ namespace tr1
       result_type _M_mean;
       result_type _M_sigma;
       result_type _M_saved;
-      bool        _M_saved_available;     
+      bool        _M_saved_available;
     };
 
 
   /**
    * @brief A gamma continuous distribution for random numbers.
    *
-   * The formula for the gamma probability mass function is 
+   * The formula for the gamma probability mass function is
    * @f$ p(x) = \frac{1}{\Gamma(\alpha)} x^{\alpha - 1} e^{-x} @f$.
    */
   template<typename _RealType = double>
@@ -2302,7 +2302,7 @@ namespace tr1
       explicit
       gamma_distribution(const result_type& __alpha_val = result_type(1))
       : _M_alpha(__alpha_val)
-      { 
+      {
 	_GLIBCXX_DEBUG_ASSERT(_M_alpha > 0);
 	_M_initialize();
       }
diff --git a/libstdc++-v3/include/tr1/shared_ptr.h b/libstdc++-v3/include/tr1/shared_ptr.h
index 926dea8..bf93b9a 100644
--- a/libstdc++-v3/include/tr1/shared_ptr.h
+++ b/libstdc++-v3/include/tr1/shared_ptr.h
@@ -102,34 +102,34 @@ namespace tr1
     class _Sp_counted_base
     : public _Mutex_base<_Lp>
     {
-    public:  
+    public:
       _Sp_counted_base()
       : _M_use_count(1), _M_weak_count(1) { }
-      
+
       virtual
-      ~_Sp_counted_base() // nothrow 
+      ~_Sp_counted_base() // nothrow
       { }
-  
+
       // Called when _M_use_count drops to zero, to release the resources
       // managed by *this.
       virtual void
       _M_dispose() = 0; // nothrow
-      
+
       // Called when _M_weak_count drops to zero.
       virtual void
       _M_destroy() // nothrow
       { delete this; }
-      
+
       virtual void*
       _M_get_deleter(const std::type_info&) = 0;
 
       void
       _M_add_ref_copy()
       { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }
-  
+
       void
       _M_add_ref_lock();
-      
+
       void
       _M_release() // nothrow
       {
@@ -158,7 +158,7 @@ namespace tr1
               }
 	  }
       }
-  
+
       void
       _M_weak_add_ref() // nothrow
       { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }
@@ -180,7 +180,7 @@ namespace tr1
 	    _M_destroy();
 	  }
       }
-  
+
       long
       _M_get_use_count() const // nothrow
       {
@@ -189,7 +189,7 @@ namespace tr1
         return const_cast<const volatile _Atomic_word&>(_M_use_count);
       }
 
-    private:  
+    private:
       _Sp_counted_base(_Sp_counted_base const&);
       _Sp_counted_base& operator=(_Sp_counted_base const&);
 
@@ -222,7 +222,7 @@ namespace tr1
 	}
     }
 
-  template<> 
+  template<>
     inline void
     _Sp_counted_base<_S_atomic>::
     _M_add_ref_lock()
@@ -234,10 +234,10 @@ namespace tr1
 	  if (__count == 0)
 	    __throw_bad_weak_ptr();
 	  // Replace the current counter value with the old value + 1, as
-	  // long as it's not changed meanwhile. 
+	  // long as it's not changed meanwhile.
 	}
       while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
-					  true, __ATOMIC_ACQ_REL, 
+					  true, __ATOMIC_ACQ_REL,
 					  __ATOMIC_RELAXED));
      }
 
@@ -249,11 +249,11 @@ namespace tr1
       // Precondition: __d(__p) must not throw.
       _Sp_counted_base_impl(_Ptr __p, _Deleter __d)
       : _M_ptr(__p), _M_del(__d) { }
-    
+
       virtual void
       _M_dispose() // nothrow
       { _M_del(_M_ptr); }
-      
+
       virtual void*
       _M_get_deleter(const std::type_info& __ti)
       {
@@ -263,11 +263,11 @@ namespace tr1
         return 0;
 #endif
       }
-      
+
     private:
       _Sp_counted_base_impl(const _Sp_counted_base_impl&);
       _Sp_counted_base_impl& operator=(const _Sp_counted_base_impl&);
-      
+
       _Ptr      _M_ptr;  // copy constructor must not throw
       _Deleter  _M_del;  // copy constructor must not throw
     };
@@ -286,11 +286,11 @@ namespace tr1
   template<_Lock_policy _Lp = __default_lock_policy>
     class __shared_count
     {
-    public: 
+    public:
       __shared_count()
       : _M_pi(0) // nothrow
       { }
-  
+
       template<typename _Ptr>
         __shared_count(_Ptr __p) : _M_pi(0)
         {
@@ -337,20 +337,20 @@ namespace tr1
       // Throw bad_weak_ptr when __r._M_get_use_count() == 0.
       explicit
       __shared_count(const __weak_count<_Lp>& __r);
-  
+
       ~__shared_count() // nothrow
       {
 	if (_M_pi != 0)
 	  _M_pi->_M_release();
       }
-      
+
       __shared_count(const __shared_count& __r)
       : _M_pi(__r._M_pi) // nothrow
       {
 	if (_M_pi != 0)
 	  _M_pi->_M_add_ref_copy();
       }
-  
+
       __shared_count&
       operator=(const __shared_count& __r) // nothrow
       {
@@ -365,7 +365,7 @@ namespace tr1
 	  }
 	return *this;
       }
-  
+
       void
       _M_swap(__shared_count& __r) // nothrow
       {
@@ -373,7 +373,7 @@ namespace tr1
 	__r._M_pi = _M_pi;
 	_M_pi = __tmp;
       }
-  
+
       long
       _M_get_use_count() const // nothrow
       { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
@@ -381,15 +381,15 @@ namespace tr1
       bool
       _M_unique() const // nothrow
       { return this->_M_get_use_count() == 1; }
-      
+
       friend inline bool
       operator==(const __shared_count& __a, const __shared_count& __b)
       { return __a._M_pi == __b._M_pi; }
-  
+
       friend inline bool
       operator<(const __shared_count& __a, const __shared_count& __b)
       { return std::less<_Sp_counted_base<_Lp>*>()(__a._M_pi, __b._M_pi); }
-  
+
       void*
       _M_get_deleter(const std::type_info& __ti) const
       { return _M_pi ? _M_pi->_M_get_deleter(__ti) : 0; }
@@ -408,27 +408,27 @@ namespace tr1
       __weak_count()
       : _M_pi(0) // nothrow
       { }
-  
+
       __weak_count(const __shared_count<_Lp>& __r)
       : _M_pi(__r._M_pi) // nothrow
       {
 	if (_M_pi != 0)
 	  _M_pi->_M_weak_add_ref();
       }
-      
+
       __weak_count(const __weak_count<_Lp>& __r)
       : _M_pi(__r._M_pi) // nothrow
       {
 	if (_M_pi != 0)
 	  _M_pi->_M_weak_add_ref();
       }
-      
+
       ~__weak_count() // nothrow
       {
 	if (_M_pi != 0)
 	  _M_pi->_M_weak_release();
       }
-      
+
       __weak_count<_Lp>&
       operator=(const __shared_count<_Lp>& __r) // nothrow
       {
@@ -437,10 +437,10 @@ namespace tr1
 	  __tmp->_M_weak_add_ref();
 	if (_M_pi != 0)
 	  _M_pi->_M_weak_release();
-	_M_pi = __tmp;  
+	_M_pi = __tmp;
 	return *this;
       }
-      
+
       __weak_count<_Lp>&
       operator=(const __weak_count<_Lp>& __r) // nothrow
       {
@@ -460,7 +460,7 @@ namespace tr1
 	__r._M_pi = _M_pi;
 	_M_pi = __tmp;
       }
-  
+
       long
       _M_get_use_count() const // nothrow
       { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
@@ -468,7 +468,7 @@ namespace tr1
       friend inline bool
       operator==(const __weak_count<_Lp>& __a, const __weak_count<_Lp>& __b)
       { return __a._M_pi == __b._M_pi; }
-      
+
       friend inline bool
       operator<(const __weak_count<_Lp>& __a, const __weak_count<_Lp>& __b)
       { return std::less<_Sp_counted_base<_Lp>*>()(__a._M_pi, __b._M_pi); }
@@ -495,7 +495,7 @@ namespace tr1
   // Forward declarations.
   template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
     class __shared_ptr;
-  
+
   template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
     class __weak_ptr;
 
@@ -504,7 +504,7 @@ namespace tr1
 
   template<typename _Tp>
     class shared_ptr;
-  
+
   template<typename _Tp>
     class weak_ptr;
 
@@ -545,7 +545,7 @@ namespace tr1
     {
     public:
       typedef _Tp   element_type;
-      
+
       __shared_ptr()
       : _M_ptr(0), _M_refcount() // never throws
       { }
@@ -568,9 +568,9 @@ namespace tr1
 	  // TODO requires _Deleter CopyConstructible and __d(__p) well-formed
 	  __enable_shared_from_this_helper(_M_refcount, __p, __p);
 	}
-      
+
       //  generated copy constructor, assignment, destructor are fine.
-      
+
       template<typename _Tp1>
         __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r)
 	: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
@@ -657,7 +657,7 @@ namespace tr1
         reset(_Tp1* __p) // _Tp1 must be complete.
         {
 	  // Catch self-reset errors.
-	  _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != _M_ptr); 
+	  _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != _M_ptr);
 	  __shared_ptr(__p).swap(*this);
 	}
 
@@ -680,7 +680,7 @@ namespace tr1
 	_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
 	return _M_ptr;
       }
-    
+
       _Tp*
       get() const // never throws
       { return _M_ptr; }
@@ -784,7 +784,7 @@ namespace tr1
   // 2.2.3.7 shared_ptr I/O
   template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
     std::basic_ostream<_Ch, _Tr>&
-    operator<<(std::basic_ostream<_Ch, _Tr>& __os, 
+    operator<<(std::basic_ostream<_Ch, _Tr>& __os,
 	       const __shared_ptr<_Tp, _Lp>& __p)
     {
       __os << __p.get();
@@ -809,13 +809,13 @@ namespace tr1
     {
     public:
       typedef _Tp element_type;
-      
+
       __weak_ptr()
       : _M_ptr(0), _M_refcount() // never throws
       { }
 
       // Generated copy constructor, assignment, destructor are fine.
-      
+
       // The "obvious" converting constructor implementation:
       //
       //  template<typename _Tp1>
@@ -851,7 +851,7 @@ namespace tr1
 	  _M_refcount = __r._M_refcount;
 	  return *this;
 	}
-      
+
       template<typename _Tp1>
         __weak_ptr&
         operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws
@@ -880,7 +880,7 @@ namespace tr1
 	    //    use_count test above.
 	    return __shared_ptr<element_type, _Lp>();
 	  }
-	
+
 #else
 	// Optimization: avoid try/catch overhead when single threaded.
 	return expired() ? __shared_ptr<element_type, _Lp>()
@@ -896,7 +896,7 @@ namespace tr1
       bool
       expired() const // never throws
       { return _M_refcount._M_get_use_count() == 0; }
-      
+
       void
       reset() // never throws
       { __weak_ptr().swap(*this); }
@@ -949,15 +949,15 @@ namespace tr1
     {
     protected:
       __enable_shared_from_this() { }
-      
+
       __enable_shared_from_this(const __enable_shared_from_this&) { }
-      
+
       __enable_shared_from_this&
       operator=(const __enable_shared_from_this&)
       { return *this; }
 
       ~__enable_shared_from_this() { }
-      
+
     public:
       __shared_ptr<_Tp, _Lp>
       shared_from_this()
@@ -1090,7 +1090,7 @@ namespace tr1
     public:
       weak_ptr()
       : __weak_ptr<_Tp>() { }
-      
+
       template<typename _Tp1>
         weak_ptr(const weak_ptr<_Tp1>& __r)
 	: __weak_ptr<_Tp>(__r) { }
@@ -1142,7 +1142,7 @@ namespace tr1
     {
     protected:
       enable_shared_from_this() { }
-      
+
       enable_shared_from_this(const enable_shared_from_this&) { }
 
       enable_shared_from_this&
diff --git a/libstdc++-v3/include/tr1/stdarg.h b/libstdc++-v3/include/tr1/stdarg.h
index b81da14..63430ea 100644
--- a/libstdc++-v3/include/tr1/stdarg.h
+++ b/libstdc++-v3/include/tr1/stdarg.h
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file tr1/stdarg.h
- *  This is a TR1 C++ Library header. 
+ *  This is a TR1 C++ Library header.
  */
 
 #ifndef _TR1_STDARG_H
diff --git a/libstdc++-v3/include/tr1/stdbool.h b/libstdc++-v3/include/tr1/stdbool.h
index a9412d8..6990d5d 100644
--- a/libstdc++-v3/include/tr1/stdbool.h
+++ b/libstdc++-v3/include/tr1/stdbool.h
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file tr1/stdbool.h
- *  This is a TR1 C++ Library header. 
+ *  This is a TR1 C++ Library header.
  */
 
 #ifndef _TR1_STDBOOL_H
diff --git a/libstdc++-v3/include/tr1/stdint.h b/libstdc++-v3/include/tr1/stdint.h
index 4c02b84..82c6316 100644
--- a/libstdc++-v3/include/tr1/stdint.h
+++ b/libstdc++-v3/include/tr1/stdint.h
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file tr1/stdint.h
- *  This is a TR1 C++ Library header. 
+ *  This is a TR1 C++ Library header.
  */
 
 #ifndef _TR1_STDINT_H
diff --git a/libstdc++-v3/include/tr1/stdio.h b/libstdc++-v3/include/tr1/stdio.h
index 036abfb..a88e2cf 100644
--- a/libstdc++-v3/include/tr1/stdio.h
+++ b/libstdc++-v3/include/tr1/stdio.h
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file tr1/stdio.h
- *  This is a TR1 C++ Library header. 
+ *  This is a TR1 C++ Library header.
  */
 
 #ifndef _TR1_STDIO_H
diff --git a/libstdc++-v3/include/tr1/stdlib.h b/libstdc++-v3/include/tr1/stdlib.h
index 81cad11..d435dc4 100644
--- a/libstdc++-v3/include/tr1/stdlib.h
+++ b/libstdc++-v3/include/tr1/stdlib.h
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file tr1/stdlib.h
- *  This is a TR1 C++ Library header. 
+ *  This is a TR1 C++ Library header.
  */
 
 #ifndef _GLIBCXX_TR1_STDLIB_H
diff --git a/libstdc++-v3/include/tr1/tgmath.h b/libstdc++-v3/include/tr1/tgmath.h
index 77104a9..4637a9a 100644
--- a/libstdc++-v3/include/tr1/tgmath.h
+++ b/libstdc++-v3/include/tr1/tgmath.h
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file tr1/tgmath.h
- *  This is a TR1 C++ Library header. 
+ *  This is a TR1 C++ Library header.
  */
 
 #ifndef _GLIBCXX_TR1_TGMATH_H
diff --git a/libstdc++-v3/include/tr1/wchar.h b/libstdc++-v3/include/tr1/wchar.h
index 573af9a..c4a2628 100644
--- a/libstdc++-v3/include/tr1/wchar.h
+++ b/libstdc++-v3/include/tr1/wchar.h
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file tr1/wchar.h
- *  This is a TR1 C++ Library header. 
+ *  This is a TR1 C++ Library header.
  */
 
 #ifndef _GLIBCXX_TR1_WCHAR_H
diff --git a/libstdc++-v3/include/tr1/wctype.h b/libstdc++-v3/include/tr1/wctype.h
index 5027e32..79ffb03 100644
--- a/libstdc++-v3/include/tr1/wctype.h
+++ b/libstdc++-v3/include/tr1/wctype.h
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file tr1/wctype.h
- *  This is a TR1 C++ Library header. 
+ *  This is a TR1 C++ Library header.
  */
 
 #ifndef _GLIBCXX_TR1_WCTYPE_H
diff --git a/libstdc++-v3/libsupc++/atexit_arm.cc b/libstdc++-v3/libsupc++/atexit_arm.cc
index a832cd4..1c58e09 100644
--- a/libstdc++-v3/libsupc++/atexit_arm.cc
+++ b/libstdc++-v3/libsupc++/atexit_arm.cc
@@ -1,5 +1,5 @@
 // Copyright (C) 2007-2024 Free Software Foundation, Inc.
-//  
+//
 // This file is part of GCC.
 //
 // GCC is free software; you can redistribute it and/or modify
@@ -28,7 +28,7 @@
 namespace __aeabiv1
 {
   extern "C" int
-  __aeabi_atexit (void *object, 
+  __aeabi_atexit (void *object,
 		  void (*destructor) (void *),
 		  void *dso_handle) throw ()
   {
diff --git a/libstdc++-v3/libsupc++/bad_alloc.cc b/libstdc++-v3/libsupc++/bad_alloc.cc
index 9203adb..d53908a 100644
--- a/libstdc++-v3/libsupc++/bad_alloc.cc
+++ b/libstdc++-v3/libsupc++/bad_alloc.cc
@@ -27,7 +27,7 @@
 
 std::bad_alloc::~bad_alloc() _GLIBCXX_USE_NOEXCEPT { }
 
-const char* 
+const char*
 std::bad_alloc::what() const _GLIBCXX_USE_NOEXCEPT
 {
   return "std::bad_alloc";
diff --git a/libstdc++-v3/libsupc++/bad_array_length.cc b/libstdc++-v3/libsupc++/bad_array_length.cc
index e380564..38b52be 100644
--- a/libstdc++-v3/libsupc++/bad_array_length.cc
+++ b/libstdc++-v3/libsupc++/bad_array_length.cc
@@ -23,7 +23,7 @@
 
 #include <new>
 
-namespace std 
+namespace std
 {
 // From N3639.  This was voted in and then back out of C++14, and is now
 // just here for backward link compatibility with code built with 4.9.
diff --git a/libstdc++-v3/libsupc++/bad_array_new.cc b/libstdc++-v3/libsupc++/bad_array_new.cc
index da39452..b6ec9d8 100644
--- a/libstdc++-v3/libsupc++/bad_array_new.cc
+++ b/libstdc++-v3/libsupc++/bad_array_new.cc
@@ -23,7 +23,7 @@
 
 #include <new>
 
-namespace std 
+namespace std
 {
 
 bad_array_new_length::~bad_array_new_length() _GLIBCXX_USE_NOEXCEPT { }
diff --git a/libstdc++-v3/libsupc++/bad_cast.cc b/libstdc++-v3/libsupc++/bad_cast.cc
index 081292e..17bff71 100644
--- a/libstdc++-v3/libsupc++/bad_cast.cc
+++ b/libstdc++-v3/libsupc++/bad_cast.cc
@@ -27,7 +27,7 @@ namespace std {
 
 bad_cast::~bad_cast() _GLIBCXX_USE_NOEXCEPT { }
 
-const char* 
+const char*
 bad_cast::what() const _GLIBCXX_USE_NOEXCEPT
 {
   return "std::bad_cast";
diff --git a/libstdc++-v3/libsupc++/bad_typeid.cc b/libstdc++-v3/libsupc++/bad_typeid.cc
index f332814..3714035 100644
--- a/libstdc++-v3/libsupc++/bad_typeid.cc
+++ b/libstdc++-v3/libsupc++/bad_typeid.cc
@@ -27,7 +27,7 @@ namespace std {
 
 bad_typeid::~bad_typeid() _GLIBCXX_USE_NOEXCEPT { }
 
-const char* 
+const char*
 bad_typeid::what() const _GLIBCXX_USE_NOEXCEPT
 {
   return "std::bad_typeid";
diff --git a/libstdc++-v3/libsupc++/class_type_info.cc b/libstdc++-v3/libsupc++/class_type_info.cc
index 7b51a82..65d84b9 100644
--- a/libstdc++-v3/libsupc++/class_type_info.cc
+++ b/libstdc++-v3/libsupc++/class_type_info.cc
@@ -47,7 +47,7 @@ __do_upcast (const __class_type_info *dst_type,
              void **obj_ptr) const
 {
   __upcast_result result (__vmi_class_type_info::__flags_unknown_mask);
-  
+
   __do_upcast (dst_type, *obj_ptr, result);
   if (!contained_public_p (result.part2dst))
     return false;
diff --git a/libstdc++-v3/libsupc++/cxxabi.h b/libstdc++-v3/libsupc++/cxxabi.h
index f10cb91..b9640ef 100644
--- a/libstdc++-v3/libsupc++/cxxabi.h
+++ b/libstdc++-v3/libsupc++/cxxabi.h
@@ -152,10 +152,10 @@ namespace __cxxabiv1
   __cxa_deleted_virtual(void) __attribute__ ((__noreturn__));
 
   // Exception handling auxiliary.
-  void 
+  void
   __cxa_bad_cast() __attribute__((__noreturn__));
 
-  void 
+  void
   __cxa_bad_typeid() __attribute__((__noreturn__));
 
   void
@@ -618,7 +618,7 @@ namespace __cxxabiv1
   __cxa_get_globals_fast() _GLIBCXX_NOTHROW __attribute__ ((__const__));
 
   // Free the space allocated for the primary exception.
-  void 
+  void
   __cxa_free_exception(void*) _GLIBCXX_NOTHROW;
 
   // Throw the exception.
@@ -633,10 +633,10 @@ namespace __cxxabiv1
   void*
   __cxa_begin_catch(void*) _GLIBCXX_NOTHROW;
 
-  void 
+  void
   __cxa_end_catch();
 
-  void 
+  void
   __cxa_rethrow() __attribute__((__noreturn__));
 
   // Returns the type_info for the currently handled exception [15.3/8], or
diff --git a/libstdc++-v3/libsupc++/cxxabi_forced.h b/libstdc++-v3/libsupc++/cxxabi_forced.h
index 9609001..8ba1f48 100644
--- a/libstdc++-v3/libsupc++/cxxabi_forced.h
+++ b/libstdc++-v3/libsupc++/cxxabi_forced.h
@@ -1,5 +1,5 @@
 // cxxabi.h subset for cancellation -*- C++ -*-
-  
+
 // Copyright (C) 2007-2024 Free Software Foundation, Inc.
 //
 // This file is part of GCC.
@@ -8,12 +8,12 @@
 // it under the terms of the GNU General Public License as published by
 // the Free Software Foundation; either version 3, or (at your option)
 // any later version.
-// 
+//
 // GCC is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
-// 
+//
 // Under Section 7 of GPL version 3, you are granted additional
 // permissions described in the GCC Runtime Library Exception, version
 // 3.1, as published by the Free Software Foundation.
@@ -39,8 +39,8 @@
 
 #ifdef __cplusplus
 namespace __cxxabiv1
-{  
-  /** 
+{
+  /**
    *  @brief Thrown as part of forced unwinding.
    *  @ingroup exceptions
    *
@@ -52,11 +52,11 @@ namespace __cxxabiv1
     virtual ~__forced_unwind() throw();
 
     // Prevent catch by value.
-    virtual void __pure_dummy() = 0; 
+    virtual void __pure_dummy() = 0;
   };
 }
 #endif // __cplusplus
 
 #pragma GCC visibility pop
 
-#endif // __CXXABI_FORCED_H 
+#endif // __CXXABI_FORCED_H
diff --git a/libstdc++-v3/libsupc++/eh_arm.cc b/libstdc++-v3/libsupc++/eh_arm.cc
index 50f50bb..3a071d5 100644
--- a/libstdc++-v3/libsupc++/eh_arm.cc
+++ b/libstdc++-v3/libsupc++/eh_arm.cc
@@ -69,7 +69,7 @@ __cxa_type_match(_Unwind_Exception* ue_header,
       // here, so there's no backwards compatibility problem.
       thrown_ptr = __get_object_from_ue (ue_header);
     }
-  
+
   __cxa_type_match_result result = ctm_succeeded;
 
   // Pointer types need to adjust the actual pointer, not
diff --git a/libstdc++-v3/libsupc++/eh_catch.cc b/libstdc++-v3/libsupc++/eh_catch.cc
index ec5d5c6..9e052f7 100644
--- a/libstdc++-v3/libsupc++/eh_catch.cc
+++ b/libstdc++-v3/libsupc++/eh_catch.cc
@@ -58,7 +58,7 @@ __cxxabiv1::__cxa_begin_catch (void *exc_obj_in) _GLIBCXX_NOTHROW
       // Remember for end_catch and rethrow.
       globals->caughtExceptions = header;
 
-      // ??? No sensible value to return; we don't know what the 
+      // ??? No sensible value to return; we don't know what the
       // object is, much less where it is in relation to the header.
       return 0;
     }
diff --git a/libstdc++-v3/libsupc++/eh_exception.cc b/libstdc++-v3/libsupc++/eh_exception.cc
index 4c31981..0ebc996 100644
--- a/libstdc++-v3/libsupc++/eh_exception.cc
+++ b/libstdc++-v3/libsupc++/eh_exception.cc
@@ -36,7 +36,7 @@ abi::__forced_unwind::~__forced_unwind() throw() { }
 
 abi::__foreign_exception::~__foreign_exception() throw() { }
 
-const char* 
+const char*
 std::exception::what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT
 {
   // NB: Another elegant option would be returning typeid(*this).name()
@@ -45,7 +45,7 @@ std::exception::what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT
   return "std::exception";
 }
 
-const char* 
+const char*
 std::bad_exception::what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT
 {
   return "std::bad_exception";
diff --git a/libstdc++-v3/libsupc++/eh_personality.cc b/libstdc++-v3/libsupc++/eh_personality.cc
index be8fb7b..a62917e 100644
--- a/libstdc++-v3/libsupc++/eh_personality.cc
+++ b/libstdc++-v3/libsupc++/eh_personality.cc
@@ -130,7 +130,7 @@ check_exception_spec(lsda_header_info* info, _throw_typet* throw_type,
       _uleb128_t tmp;
 
       tmp = *e;
-      
+
       // Zero signals the end of the list.  If we've not found
       // a match by now, then we've failed the specification.
       if (tmp == 0)
@@ -666,7 +666,7 @@ PERSONALITY_FUNCTION (int version,
     }
 
  install_context:
-  
+
   // We can't use any of the cxa routines with foreign exceptions,
   // because they all expect ue_header to be a struct __cxa_exception.
   // So in that case, call terminate or unexpected directly.
@@ -702,7 +702,7 @@ PERSONALITY_FUNCTION (int version,
 #ifdef __ARM_EABI_UNWINDER__
 	  const _Unwind_Word* e;
 	  _Unwind_Word n;
-	  
+
 	  e = ((const _Unwind_Word*) info.TType) - handler_switch_value - 1;
 	  // Count the number of rtti objects.
 	  n = 0;
@@ -771,9 +771,9 @@ __cxa_call_unexpected (void *exc_obj_in)
   xh_terminate_handler = xh->terminateHandler;
   info.ttype_base = (_Unwind_Ptr) xh->catchTemp;
 
-  __try 
-    { __unexpected (xh->unexpectedHandler); } 
-  __catch(...) 
+  __try
+    { __unexpected (xh->unexpectedHandler); }
+  __catch(...)
     {
       // Get the exception thrown from unexpected.
 
@@ -797,7 +797,7 @@ __cxa_call_unexpected (void *exc_obj_in)
       const std::type_info &bad_exc = typeid (std::bad_exception);
       if (check_exception_spec (&info, &bad_exc, 0, xh_switch_value))
 	throw std::bad_exception();
-#endif   
+#endif
 
       // Otherwise, die.
       __terminate (xh_terminate_handler);
diff --git a/libstdc++-v3/libsupc++/eh_terminate.cc b/libstdc++-v3/libsupc++/eh_terminate.cc
index f21e206..5c03839 100644
--- a/libstdc++-v3/libsupc++/eh_terminate.cc
+++ b/libstdc++-v3/libsupc++/eh_terminate.cc
@@ -43,12 +43,12 @@ using namespace __cxxabiv1;
 void
 __cxxabiv1::__terminate (std::terminate_handler handler) throw ()
 {
-  __try 
+  __try
     {
       handler ();
       std::abort ();
-    } 
-  __catch(...) 
+    }
+  __catch(...)
     { std::abort (); }
 }
 
diff --git a/libstdc++-v3/libsupc++/eh_throw.cc b/libstdc++-v3/libsupc++/eh_throw.cc
index b547bdd..c78f179 100644
--- a/libstdc++-v3/libsupc++/eh_throw.cc
+++ b/libstdc++-v3/libsupc++/eh_throw.cc
@@ -129,7 +129,7 @@ __cxxabiv1::__cxa_rethrow ()
       _Unwind_Resume_or_Rethrow (&header->unwindHeader);
 #endif
 #endif
-  
+
       // Some sort of unwinding error.  Note that terminate is a handler.
       __cxa_begin_catch (&header->unwindHeader);
     }
diff --git a/libstdc++-v3/libsupc++/exception_ptr.h b/libstdc++-v3/libsupc++/exception_ptr.h
index ee977a8..ad2bb5d 100644
--- a/libstdc++-v3/libsupc++/exception_ptr.h
+++ b/libstdc++-v3/libsupc++/exception_ptr.h
@@ -8,12 +8,12 @@
 // it under the terms of the GNU General Public License as published by
 // the Free Software Foundation; either version 3, or (at your option)
 // any later version.
-// 
+//
 // GCC is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
-// 
+//
 // Under Section 7 of GPL version 3, you are granted additional
 // permissions described in the GCC Runtime Library Exception, version
 // 3.1, as published by the Free Software Foundation.
@@ -132,11 +132,11 @@ namespace std _GLIBCXX_VISIBILITY(default)
       exception_ptr(__safe_bool) _GLIBCXX_USE_NOEXCEPT;
 #endif
 
-      exception_ptr& 
+      exception_ptr&
       operator=(const exception_ptr&) _GLIBCXX_USE_NOEXCEPT;
 
 #if __cplusplus >= 201103L
-      exception_ptr& 
+      exception_ptr&
       operator=(exception_ptr&& __o) noexcept
       {
         exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this);
@@ -146,7 +146,7 @@ namespace std _GLIBCXX_VISIBILITY(default)
 
       ~exception_ptr() _GLIBCXX_USE_NOEXCEPT;
 
-      void 
+      void
       swap(exception_ptr&) _GLIBCXX_USE_NOEXCEPT;
 
 #ifdef _GLIBCXX_EH_PTR_COMPAT
diff --git a/libstdc++-v3/libsupc++/guard.cc b/libstdc++-v3/libsupc++/guard.cc
index 707083e..d3999e3 100644
--- a/libstdc++-v3/libsupc++/guard.cc
+++ b/libstdc++-v3/libsupc++/guard.cc
@@ -1,5 +1,5 @@
 // Copyright (C) 2002-2024 Free Software Foundation, Inc.
-//  
+//
 // This file is part of GCC.
 //
 // GCC is free software; you can redistribute it and/or modify
@@ -79,7 +79,7 @@ __cxa_guard_abort (__guard* g) _GLIBCXX_NOTHROW
 namespace
 {
   // A single mutex controlling all static initializations.
-  static __gnu_cxx::__recursive_mutex* static_mutex;  
+  static __gnu_cxx::__recursive_mutex* static_mutex;
 
   typedef char fake_recursive_mutex[sizeof(__gnu_cxx::__recursive_mutex)]
   __attribute__ ((aligned(__alignof__(__gnu_cxx::__recursive_mutex))));
@@ -116,7 +116,7 @@ namespace
 namespace
 {
   // A single condition variable controlling all static initializations.
-  static __gnu_cxx::__cond* static_cond;  
+  static __gnu_cxx::__cond* static_cond;
 
   // using a fake type to avoid initializing a static class.
   typedef char fake_cond_t[sizeof(__gnu_cxx::__cond)]
@@ -219,7 +219,7 @@ __set_and_release (__cxxabiv1::__guard *g)
 //  | _GLIBCXX_GUARD_WAITING_BIT) and some other threads are waiting until
 //				  it is initialized.
 
-namespace __cxxabiv1 
+namespace __cxxabiv1
 {
 #ifdef _GLIBCXX_USE_FUTEX
   namespace
@@ -269,7 +269,7 @@ namespace __cxxabiv1
   }
 
   extern "C"
-  int __cxa_guard_acquire (__guard *g) 
+  int __cxa_guard_acquire (__guard *g)
   {
 #ifdef __GTHREADS
     // If the target can reorder loads, we need to insert a read memory
@@ -315,11 +315,11 @@ namespace __cxxabiv1
 		// This thread should do the initialization.
 		return 1;
 	      }
-	      
+
 	    if (expected == guard_bit)
 	      {
 		// Already initialized.
-		return 0;	
+		return 0;
 	      }
 
 	     if (expected == pending_bit)
@@ -327,7 +327,7 @@ namespace __cxxabiv1
 		 // Use acquire here.
 		 int newv = expected | waiting_bit;
 		 if (!__atomic_compare_exchange_n(gi, &expected, newv, false,
-						  __ATOMIC_ACQ_REL, 
+						  __ATOMIC_ACQ_REL,
 						  __ATOMIC_ACQUIRE))
 		   {
 		     if (expected == guard_bit)
@@ -341,7 +341,7 @@ namespace __cxxabiv1
 		     if (expected == 0)
 		       continue;
 		   }
-		 
+
 		 expected = newv;
 	       }
 
@@ -417,7 +417,7 @@ namespace __cxxabiv1
       }
 #elif defined(__GTHREAD_HAS_COND)
     if (__gthread_active_p())
-      {	
+      {
 	mutex_wrapper mw;
 
 	set_init_in_progress_flag(g, 0);
@@ -426,7 +426,7 @@ namespace __cxxabiv1
 	// the condition variable.
         get_static_cond().broadcast();
 	return;
-      }	
+      }
 #endif
 
     set_init_in_progress_flag(g, 0);
@@ -473,7 +473,7 @@ namespace __cxxabiv1
 
         get_static_cond().broadcast();
 	return;
-      }	
+      }
 #endif
 
     set_init_in_progress_flag(g, 0);
diff --git a/libstdc++-v3/libsupc++/guard_error.cc b/libstdc++-v3/libsupc++/guard_error.cc
index 7e8b2ee..03c9236 100644
--- a/libstdc++-v3/libsupc++/guard_error.cc
+++ b/libstdc++-v3/libsupc++/guard_error.cc
@@ -1,5 +1,5 @@
 // Copyright (C) 2011-2024 Free Software Foundation, Inc.
-//  
+//
 // This file is part of GCC.
 //
 // GCC is free software; you can redistribute it and/or modify
diff --git a/libstdc++-v3/libsupc++/nested_exception.cc b/libstdc++-v3/libsupc++/nested_exception.cc
index 1c5fc9a..341c145 100644
--- a/libstdc++-v3/libsupc++/nested_exception.cc
+++ b/libstdc++-v3/libsupc++/nested_exception.cc
@@ -23,7 +23,7 @@
 
 #include <exception>
 
-namespace std 
+namespace std
 {
   nested_exception::~nested_exception() noexcept = default;
 } // namespace std
diff --git a/libstdc++-v3/libsupc++/pbase_type_info.cc b/libstdc++-v3/libsupc++/pbase_type_info.cc
index 57ae2a3..ff08986 100644
--- a/libstdc++-v3/libsupc++/pbase_type_info.cc
+++ b/libstdc++-v3/libsupc++/pbase_type_info.cc
@@ -68,7 +68,7 @@ __do_catch (const type_info *thr_type,
   if (typeid (*this) != typeid (*thr_type))
     return false;     // not both same kind of pointers
 #endif
-  
+
   if (!(outer & 1))
     // We're not the same and our outer pointers are not all const qualified
     // Therefore there must at least be a qualification conversion involved
@@ -94,14 +94,14 @@ __do_catch (const type_info *thr_type,
   if (catch_fqual & ~throw_fqual)
     /* But not the reverse.  */
     return false;
-  
+
   if (tflags & ~__flags)
     // We're less qualified.
     return false;
-  
+
   if (!(__flags & __const_mask))
     outer &= ~1;
-  
+
   return __pointer_catch (thrown_type, thr_obj, outer);
 }
 
diff --git a/libstdc++-v3/libsupc++/pmem_type_info.cc b/libstdc++-v3/libsupc++/pmem_type_info.cc
index 4e39ac0..274af0b 100644
--- a/libstdc++-v3/libsupc++/pmem_type_info.cc
+++ b/libstdc++-v3/libsupc++/pmem_type_info.cc
@@ -38,10 +38,10 @@ __pointer_catch (const __pbase_type_info *thr_type,
   // thr_type is really a __pointer_to_member_type_info.
   const __pointer_to_member_type_info *thrown_type =
     static_cast <const __pointer_to_member_type_info *> (thr_type);
-  
+
   if (*__context != *thrown_type->__context)
     return false;     // not pointers to member of same class
-  
+
   return __pbase_type_info::__pointer_catch (thrown_type, thr_obj, outer);
 }
 
diff --git a/libstdc++-v3/libsupc++/pointer_type_info.cc b/libstdc++-v3/libsupc++/pointer_type_info.cc
index a1c9969..f45b62e 100644
--- a/libstdc++-v3/libsupc++/pointer_type_info.cc
+++ b/libstdc++-v3/libsupc++/pointer_type_info.cc
@@ -47,7 +47,7 @@ __pointer_catch (const __pbase_type_info *thrown_type,
       return !thrown_type->__pointee->__is_function_p ();
     }
 #endif
-  
+
   return __pbase_type_info::__pointer_catch (thrown_type, thr_obj, outer);
 }
 
diff --git a/libstdc++-v3/libsupc++/pure.cc b/libstdc++-v3/libsupc++/pure.cc
index fe7079e..a14c7f8 100644
--- a/libstdc++-v3/libsupc++/pure.cc
+++ b/libstdc++-v3/libsupc++/pure.cc
@@ -1,4 +1,4 @@
-// -*- C++ -*- 
+// -*- C++ -*-
 // Copyright (C) 2000-2024 Free Software Foundation, Inc.
 //
 // This file is part of GCC.
diff --git a/libstdc++-v3/libsupc++/si_class_type_info.cc b/libstdc++-v3/libsupc++/si_class_type_info.cc
index 9bd907f..adb5082 100644
--- a/libstdc++-v3/libsupc++/si_class_type_info.cc
+++ b/libstdc++-v3/libsupc++/si_class_type_info.cc
@@ -77,7 +77,7 @@ __do_upcast (const __class_type_info *dst, const void *obj_ptr,
 {
   if (__class_type_info::__do_upcast (dst, obj_ptr, result))
     return true;
-  
+
   return __base_type->__do_upcast (dst, obj_ptr, result);
 }
 
diff --git a/libstdc++-v3/libsupc++/tinfo.h b/libstdc++-v3/libsupc++/tinfo.h
index e6135e6..5f3b25e 100644
--- a/libstdc++-v3/libsupc++/tinfo.h
+++ b/libstdc++-v3/libsupc++/tinfo.h
@@ -38,26 +38,26 @@ using namespace abi;
 
 // Initial part of a vtable, this structure is used with offsetof, so we don't
 // have to keep alignments consistent manually.
-struct vtable_prefix 
+struct vtable_prefix
 {
   // Offset to most derived object.
   ptrdiff_t whole_object;
 
   // Additional padding if necessary.
 #ifdef _GLIBCXX_VTABLE_PADDING
-  ptrdiff_t padding1;               
+  ptrdiff_t padding1;
 #endif
 
   // Pointer to most derived type_info.
-  const __class_type_info *whole_type;  
+  const __class_type_info *whole_type;
 
   // Additional padding if necessary.
 #ifdef _GLIBCXX_VTABLE_PADDING
-  ptrdiff_t padding2;               
+  ptrdiff_t padding2;
 #endif
 
   // What a class's vptr points to.
-  const void *origin;               
+  const void *origin;
 };
 
 template <typename T>
@@ -76,7 +76,7 @@ convert_to_base (void const *addr, bool is_virtual, ptrdiff_t offset)
   if (is_virtual)
     {
       const void *vtable = *static_cast <const void *const *> (addr);
-      
+
       offset = *adjust_pointer<ptrdiff_t> (vtable, offset);
     }
 
@@ -143,7 +143,7 @@ struct __class_type_info::__dyncast_result
   __sub_kind whole2src;       // path from most derived object to sub object
   __sub_kind dst2src;         // path from target to sub object
   int whole_details;          // details of the whole class hierarchy
-  
+
   __dyncast_result (int details_ = __vmi_class_type_info::__flags_unknown_mask)
     :dst_ptr (NULL), whole2dst (__unknown),
      whole2src (__unknown), dst2src (__unknown),
@@ -152,7 +152,7 @@ struct __class_type_info::__dyncast_result
 
 protected:
   __dyncast_result(const __dyncast_result&);
-  
+
   __dyncast_result&
   operator=(const __dyncast_result&);
 };
diff --git a/libstdc++-v3/libsupc++/unwind-cxx.h b/libstdc++-v3/libsupc++/unwind-cxx.h
index abc8b80..4afb6f51 100644
--- a/libstdc++-v3/libsupc++/unwind-cxx.h
+++ b/libstdc++-v3/libsupc++/unwind-cxx.h
@@ -189,7 +189,7 @@ extern "C" void __cxa_tm_cleanup (void *, void *, unsigned int) throw();
 
 // Invokes given handler, dying appropriately if the user handler was
 // so inconsiderate as to return.
-extern void __terminate(std::terminate_handler) throw () 
+extern void __terminate(std::terminate_handler) throw ()
   __attribute__((__noreturn__));
 extern void __unexpected(std::terminate_handler)
   __attribute__((__noreturn__));
@@ -318,7 +318,7 @@ __gxx_caught_object(_Unwind_Exception* eo)
 #else // !__ARM_EABI_UNWINDER__
 // This is the primary exception class we report -- "GNUCC++\0".
 const _Unwind_Exception_Class __gxx_primary_exception_class
-= ((((((((_Unwind_Exception_Class) 'G' 
+= ((((((((_Unwind_Exception_Class) 'G'
 	 << 8 | (_Unwind_Exception_Class) 'N')
 	<< 8 | (_Unwind_Exception_Class) 'U')
        << 8 | (_Unwind_Exception_Class) 'C')
@@ -330,7 +330,7 @@ const _Unwind_Exception_Class __gxx_primary_exception_class
 // This is the dependent (from std::rethrow_exception) exception class we report
 // "GNUCC++\x01"
 const _Unwind_Exception_Class __gxx_dependent_exception_class
-= ((((((((_Unwind_Exception_Class) 'G' 
+= ((((((((_Unwind_Exception_Class) 'G'
 	 << 8 | (_Unwind_Exception_Class) 'N')
 	<< 8 | (_Unwind_Exception_Class) 'U')
        << 8 | (_Unwind_Exception_Class) 'C')
diff --git a/libstdc++-v3/libsupc++/vec.cc b/libstdc++-v3/libsupc++/vec.cc
index f35eb7f..036df21 100644
--- a/libstdc++-v3/libsupc++/vec.cc
+++ b/libstdc++-v3/libsupc++/vec.cc
@@ -1,7 +1,7 @@
 // New abi Support -*- C++ -*-
 
 // Copyright (C) 2000-2024 Free Software Foundation, Inc.
-//  
+//
 // This file is part of GCC.
 //
 // GCC is free software; you can redistribute it and/or modify
@@ -33,13 +33,13 @@
 
 namespace __cxxabiv1
 {
-  namespace 
+  namespace
   {
-    struct uncatch_exception 
+    struct uncatch_exception
     {
       uncatch_exception();
       ~uncatch_exception () { __cxa_begin_catch (&p->unwindHeader); }
-      
+
       __cxa_exception* p;
 
     private:
@@ -127,7 +127,7 @@ namespace __cxxabiv1
       }
     return base;
   }
-  
+
   extern "C" void *
   __cxa_vec_new3(std::size_t element_count,
 		 std::size_t element_size,
@@ -142,7 +142,7 @@ namespace __cxxabiv1
     char *base = static_cast<char *>(alloc (size));
     if (!base)
       return base;
-    
+
     if (padding_size)
       {
 	base += padding_size;
@@ -167,7 +167,7 @@ namespace __cxxabiv1
       }
     return base;
   }
-  
+
   // Construct array.
   extern "C" __cxa_vec_ctor_return_type
   __cxa_vec_ctor(void *array_address,
@@ -178,7 +178,7 @@ namespace __cxxabiv1
   {
     std::size_t ix = 0;
     char *ptr = static_cast<char *>(array_address);
-    
+
     __try
       {
 	if (constructor)
@@ -195,7 +195,7 @@ namespace __cxxabiv1
       }
     _GLIBCXX_CXA_VEC_CTOR_RETURN (array_address);
   }
-  
+
   // Construct an array by copying.
   extern "C" __cxa_vec_ctor_return_type
   __cxa_vec_cctor(void *dest_array,
@@ -208,11 +208,11 @@ namespace __cxxabiv1
     std::size_t ix = 0;
     char *dest_ptr = static_cast<char *>(dest_array);
     char *src_ptr = static_cast<char *>(src_array);
-    
+
     __try
       {
 	if (constructor)
-	  for (; ix != element_count; 
+	  for (; ix != element_count;
 	       ix++, src_ptr += element_size, dest_ptr += element_size)
 	    constructor(dest_ptr, src_ptr);
       }
@@ -226,7 +226,7 @@ namespace __cxxabiv1
       }
     _GLIBCXX_CXA_VEC_CTOR_RETURN (dest_array);
   }
-  
+
   // Destruct array.
   extern "C" void
   __cxa_vec_dtor(void *array_address,
@@ -314,7 +314,7 @@ namespace __cxxabiv1
       return;
 
     char* base = static_cast<char *>(array_address);
-  
+
     if (padding_size)
       {
 	std::size_t element_count = reinterpret_cast<std::size_t *>(base)[-1];
@@ -404,14 +404,14 @@ namespace __aeabiv1
     reinterpret_cast<std::size_t *>(array_address)[-2] = element_size;
     reinterpret_cast<std::size_t *>(array_address)[-1] = element_count;
     return abi::__cxa_vec_ctor (array_address,
-				element_count, element_size, 
+				element_count, element_size,
 				constructor, /*destructor=*/NULL);
   }
-  
+
   extern "C" void *
   __aeabi_vec_cctor_nocookie_nodtor (void *dest_array,
-				     void *src_array, 
-				     std::size_t element_size, 
+				     void *src_array,
+				     std::size_t element_size,
 				     std::size_t element_count,
 				     void *(*constructor) (void *, void *))
   {
@@ -421,73 +421,73 @@ namespace __aeabiv1
   }
 
   extern "C" void *
-  __aeabi_vec_new_cookie_noctor (std::size_t element_size, 
+  __aeabi_vec_new_cookie_noctor (std::size_t element_size,
 				 std::size_t element_count)
   {
-    return abi::__cxa_vec_new(element_count, element_size, 
+    return abi::__cxa_vec_new(element_count, element_size,
 			      2 * sizeof (std::size_t),
 			      /*constructor=*/NULL, /*destructor=*/NULL);
   }
 
   extern "C" void *
-  __aeabi_vec_new_nocookie (std::size_t element_size, 
+  __aeabi_vec_new_nocookie (std::size_t element_size,
 			    std::size_t element_count,
 			    abi::__cxa_cdtor_type constructor)
   {
-    return abi::__cxa_vec_new (element_count, element_size, 0, constructor, 
+    return abi::__cxa_vec_new (element_count, element_size, 0, constructor,
 			       NULL);
   }
 
   extern "C" void *
-  __aeabi_vec_new_cookie_nodtor (std::size_t element_size, 
+  __aeabi_vec_new_cookie_nodtor (std::size_t element_size,
 				 std::size_t element_count,
 				 abi::__cxa_cdtor_type constructor)
   {
-    return abi::__cxa_vec_new(element_count, element_size, 
+    return abi::__cxa_vec_new(element_count, element_size,
 			      2 * sizeof (std::size_t),
 			      constructor, NULL);
   }
 
   extern "C" void *
-  __aeabi_vec_new_cookie(std::size_t element_size, 
+  __aeabi_vec_new_cookie(std::size_t element_size,
 			 std::size_t element_count,
 			 abi::__cxa_cdtor_type constructor,
 			 abi::__cxa_cdtor_type destructor)
   {
-    return abi::__cxa_vec_new (element_count, element_size, 
+    return abi::__cxa_vec_new (element_count, element_size,
 			       2 * sizeof (std::size_t),
 			       constructor, destructor);
   }
 
-  
+
   extern "C" void *
-  __aeabi_vec_dtor (void *array_address, 
+  __aeabi_vec_dtor (void *array_address,
 		    abi::__cxa_cdtor_type destructor,
-		    std::size_t element_size, 
+		    std::size_t element_size,
 		    std::size_t element_count)
   {
-    abi::__cxa_vec_dtor (array_address, element_count, element_size, 
+    abi::__cxa_vec_dtor (array_address, element_count, element_size,
 			 destructor);
     return reinterpret_cast<std::size_t*> (array_address) - 2;
   }
 
   extern "C" void *
-  __aeabi_vec_dtor_cookie (void *array_address, 
+  __aeabi_vec_dtor_cookie (void *array_address,
 			   abi::__cxa_cdtor_type destructor)
   {
     if (!array_address)
       return NULL;
 
-    abi::__cxa_vec_dtor (array_address, 
+    abi::__cxa_vec_dtor (array_address,
 			 reinterpret_cast<std::size_t *>(array_address)[-1],
 			 reinterpret_cast<std::size_t *>(array_address)[-2],
 			 destructor);
     return reinterpret_cast<std::size_t*> (array_address) - 2;
   }
-  
-  
+
+
   extern "C" void
-  __aeabi_vec_delete (void *array_address, 
+  __aeabi_vec_delete (void *array_address,
 		      abi::__cxa_cdtor_type destructor)
   {
     if (!array_address)
@@ -500,7 +500,7 @@ namespace __aeabiv1
   }
 
   extern "C" void
-  __aeabi_vec_delete3 (void *array_address, 
+  __aeabi_vec_delete3 (void *array_address,
 		       abi::__cxa_cdtor_type destructor,
 		       void (*dealloc) (void *, std::size_t))
   {
diff --git a/libstdc++-v3/libsupc++/vmi_class_type_info.cc b/libstdc++-v3/libsupc++/vmi_class_type_info.cc
index fb6e94f..066ba20 100644
--- a/libstdc++-v3/libsupc++/vmi_class_type_info.cc
+++ b/libstdc++-v3/libsupc++/vmi_class_type_info.cc
@@ -37,23 +37,23 @@ __do_find_public_src (ptrdiff_t src2dst,
 {
   if (obj_ptr == src_ptr && *this == *src_type)
     return __contained_public;
-  
+
   for (std::size_t i = __base_count; i--;)
     {
       if (!__base_info[i].__is_public_p ())
         continue; // Not public, can't be here.
-      
+
       const void *base = obj_ptr;
       ptrdiff_t offset = __base_info[i].__offset ();
       bool is_virtual = __base_info[i].__is_virtual_p ();
-      
+
       if (is_virtual)
         {
           if (src2dst == -3)
             continue; // Not a virtual base, so can't be here.
         }
       base = convert_to_base (base, is_virtual, offset);
-      
+
       __sub_kind base_kind = __base_info[i].__base_type->__do_find_public_src
                               (src2dst, base, src_type, src_ptr);
       if (contained_p (base_kind))
@@ -63,7 +63,7 @@ __do_find_public_src (ptrdiff_t src2dst,
           return base_kind;
         }
     }
-  
+
   return __not_contained;
 }
 
@@ -87,7 +87,7 @@ __do_dyncast (ptrdiff_t src2dst,
 {
   if (result.whole_details & __flags_unknown_mask)
     result.whole_details = __flags;
-  
+
   if (obj_ptr == src_ptr && *this == *src_type)
     {
       // The src object we started from. Indicate how we are accessible from
@@ -125,7 +125,7 @@ __do_dyncast (ptrdiff_t src2dst,
       __sub_kind base_access = access_path;
       ptrdiff_t offset = __base_info[i].__offset ();
       bool is_virtual = __base_info[i].__is_virtual_p ();
-      
+
       if (is_virtual)
         base_access = __sub_kind (base_access | __contained_virtual_mask);
       base = convert_to_base (base, is_virtual, offset);
@@ -156,7 +156,7 @@ __do_dyncast (ptrdiff_t src2dst,
             continue;
           base_access = __sub_kind (base_access & ~__contained_public_mask);
         }
-      
+
       bool result2_ambig
           = __base_info[i].__base_type->__do_dyncast (src2dst, base_access,
                                              dst_type, base,
@@ -172,7 +172,7 @@ __do_dyncast (ptrdiff_t src2dst,
           // which can't be disambiguated
           return result2_ambig;
         }
-      
+
       if (!result_ambig && !result.dst_ptr)
         {
           // Not found anything yet.
@@ -202,10 +202,10 @@ __do_dyncast (ptrdiff_t src2dst,
           // we're ambiguous and fail. If it is in neither, we're ambiguous,
           // but don't yet fail as we might later find a third base which does
           // contain SRC_PTR.
-        
+
           __sub_kind new_sub_kind = result2.dst2src;
           __sub_kind old_sub_kind = result.dst2src;
-          
+
           if (contained_p (result.whole2src)
               && (!virtual_p (result.whole2src)
                   || !(result.whole_details & __diamond_shaped_mask)))
@@ -232,7 +232,7 @@ __do_dyncast (ptrdiff_t src2dst,
               else
                 old_sub_kind = dst_type->__find_public_src
                                 (src2dst, result.dst_ptr, src_type, src_ptr);
-          
+
               if (new_sub_kind >= __not_contained)
                 ;// already calculated
               else if (contained_p (old_sub_kind)
@@ -245,7 +245,7 @@ __do_dyncast (ptrdiff_t src2dst,
                 new_sub_kind = dst_type->__find_public_src
                                 (src2dst, result2.dst_ptr, src_type, src_ptr);
             }
-          
+
           // Neither sub_kind can be contained_ambig -- we bail out early
           // when we find those.
           if (contained_p (__sub_kind (new_sub_kind ^ old_sub_kind)))
@@ -282,7 +282,7 @@ __do_dyncast (ptrdiff_t src2dst,
               result_ambig = true;
             }
         }
-      
+
       if (result.whole2src == __contained_private)
         // We found SRC_PTR as a private non-virtual base, therefore all
         // cross casts will fail. We have already found a down cast, if
@@ -307,11 +307,11 @@ __do_upcast (const __class_type_info *dst, const void *obj_ptr,
 {
   if (__class_type_info::__do_upcast (dst, obj_ptr, result))
     return true;
-  
+
   int src_details = result.src_details;
   if (src_details & __flags_unknown_mask)
     src_details = __flags;
-  
+
   for (std::size_t i = __base_count; i--;)
     {
       __upcast_result result2 (src_details);
@@ -319,27 +319,27 @@ __do_upcast (const __class_type_info *dst, const void *obj_ptr,
       ptrdiff_t offset = __base_info[i].__offset ();
       bool is_virtual = __base_info[i].__is_virtual_p ();
       bool is_public = __base_info[i].__is_public_p ();
-      
+
       if (!is_public && !(src_details & __non_diamond_repeat_mask))
         // original cannot have an ambiguous base, so skip private bases
         continue;
 
       if (base)
         base = convert_to_base (base, is_virtual, offset);
-      
+
       if (__base_info[i].__base_type->__do_upcast (dst, base, result2))
         {
           if (result2.base_type == nonvirtual_base_type && is_virtual)
             result2.base_type = __base_info[i].__base_type;
           if (contained_p (result2.part2dst) && !is_public)
             result2.part2dst = __sub_kind (result2.part2dst & ~__contained_public_mask);
-          
+
           if (!result.base_type)
             {
               result = result2;
               if (!contained_p (result.part2dst))
                 return true; // found ambiguously
-              
+
               if (result.part2dst & __contained_public_mask)
                 {
                   if (!(__flags & __non_diamond_repeat_mask))
diff --git a/libstdc++-v3/libsupc++/vterminate.cc b/libstdc++-v3/libsupc++/vterminate.cc
index 23deeef..44a678c 100644
--- a/libstdc++-v3/libsupc++/vterminate.cc
+++ b/libstdc++-v3/libsupc++/vterminate.cc
@@ -61,7 +61,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	{
 	  int status = -1;
 	  char *dem = 0;
-	  
+
 	  dem = __cxa_demangle(name, 0, 0, &status);
 
 	  fputs("terminate called after throwing an instance of '", stderr);
@@ -91,7 +91,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       }
     else
       fputs("terminate called without an active exception\n", stderr);
-    
+
     abort();
   }
author	Jakub Jelinek <jakub@redhat.com>	2024-10-25 09:44:10 +0200
committer	Jakub Jelinek <jakub@gcc.gnu.org>	2024-10-25 10:03:17 +0200
commit	45ab93d9afaead934a6501f070d6ac60a6bf9dd2 (patch)
tree	16dad9bf8b15968fac3956c2a664274af3e3678f /libstdc++-v3
parent	50332a4fdd3243899c395712c43daaef82c8180b (diff)
download	gcc-45ab93d9afaead934a6501f070d6ac60a6bf9dd2.zip gcc-45ab93d9afaead934a6501f070d6ac60a6bf9dd2.tar.gz gcc-45ab93d9afaead934a6501f070d6ac60a6bf9dd2.tar.bz2