[committed] libstdc++: Move C++14 components to new header

[Jonathan Wakely via Gcc-patches]

This moves the "classic" contents of <chrono> to a new header, so that
<future>, <thread> etc. can get use durations and clocks without
calendar types, time zones, and chrono I/O.

libstdc++-v3/ChangeLog:

        * include/Makefile.am: Add new header.
        * include/Makefile.in: Regenerate.
        * include/std/chrono (duration, time_point, system_clock)
        (steady_clock, high_resolution_clock, chrono_literals, sys_time)
        (file_clock, file_time): Move to ...
        * include/bits/chrono.h: New file.
        * include/bits/atomic_futex.h: Include new header instead of
        <chrono>.
        * include/bits/atomic_timed_wait.h: Likewise.
        * include/bits/fs_fwd.h: Likewise.
        * include/bits/semaphore_base.h: Likewise.
        * include/bits/this_thread_sleep.h: Likewise.
        * include/bits/unique_lock.h: Likewise.
        * include/experimental/bits/fs_fwd.h: Likewise.
        * include/experimental/chrono: Likewise.
        * include/experimental/io_context: Likewise.
        * include/experimental/netfwd: Likewise.
        * include/experimental/timer: Likewise.
        * include/std/condition_variable: Likewise.
        * include/std/mutex: Likewise.
        * include/std/shared_mutex: Likewise.

Tested powerpc64le-linux. Committed to trunk.

Nothing in the rest of the library needs the calendar types, so this
saves them from parsing 2000 lines of <chrono> just to use durations
and clocks. The saving is going to get bigger soon as I add time zones
and I/O to <chrono> (which means it needs to include <sstream> and
other headers).


commit 7f78718b7958f603d50d5c30fd8735d73900bd1f
Author: Jonathan Wakely <jwak...@redhat.com>
Date:   Thu Oct 7 14:51:18 2021

    libstdc++: Move C++14 <chrono> components to new <bits/chrono.h> header
    
    This moves the "classic" contents of <chrono> to a new header, so that
    <future>, <thread> etc. can get use durations and clocks without
    calendar types, time zones, and chrono I/O.
    
    libstdc++-v3/ChangeLog:
    
            * include/Makefile.am: Add new header.
            * include/Makefile.in: Regenerate.
            * include/std/chrono (duration, time_point, system_clock)
            (steady_clock, high_resolution_clock, chrono_literals, sys_time)
            (file_clock, file_time): Move to ...
            * include/bits/chrono.h: New file.
            * include/bits/atomic_futex.h: Include new header instead of
            <chrono>.
            * include/bits/atomic_timed_wait.h: Likewise.
            * include/bits/fs_fwd.h: Likewise.
            * include/bits/semaphore_base.h: Likewise.
            * include/bits/this_thread_sleep.h: Likewise.
            * include/bits/unique_lock.h: Likewise.
            * include/experimental/bits/fs_fwd.h: Likewise.
            * include/experimental/chrono: Likewise.
            * include/experimental/io_context: Likewise.
            * include/experimental/netfwd: Likewise.
            * include/experimental/timer: Likewise.
            * include/std/condition_variable: Likewise.
            * include/std/mutex: Likewise.
            * include/std/shared_mutex: Likewise.

diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am
index 27b548607b9..0e43f147591 100644
--- a/libstdc++-v3/include/Makefile.am
+++ b/libstdc++-v3/include/Makefile.am
@@ -117,6 +117,7 @@ bits_headers = \
        ${bits_srcdir}/c++0x_warning.h \
        ${bits_srcdir}/char_traits.h \
        ${bits_srcdir}/charconv.h \
+       ${bits_srcdir}/chrono.h \
        ${bits_srcdir}/codecvt.h \
        ${bits_srcdir}/concept_check.h \
        ${bits_srcdir}/cow_string.h \
diff --git a/libstdc++-v3/include/bits/atomic_futex.h 
b/libstdc++-v3/include/bits/atomic_futex.h
index d4bb32c26de..41c59c4c64d 100644
--- a/libstdc++-v3/include/bits/atomic_futex.h
+++ b/libstdc++-v3/include/bits/atomic_futex.h
@@ -32,13 +32,12 @@
 
 #pragma GCC system_header
 
-#include <bits/c++config.h>
 #include <atomic>
-#include <chrono>
 #if ! (defined(_GLIBCXX_HAVE_LINUX_FUTEX) && ATOMIC_INT_LOCK_FREE > 1)
 #include <mutex>
 #include <condition_variable>
 #endif
+#include <bits/chrono.h>
 
 #ifndef _GLIBCXX_ALWAYS_INLINE
 #define _GLIBCXX_ALWAYS_INLINE inline __attribute__((__always_inline__))
diff --git a/libstdc++-v3/include/bits/atomic_timed_wait.h 
b/libstdc++-v3/include/bits/atomic_timed_wait.h
index d423a7af7c3..64c1ba62a3e 100644
--- a/libstdc++-v3/include/bits/atomic_timed_wait.h
+++ b/libstdc++-v3/include/bits/atomic_timed_wait.h
@@ -37,8 +37,7 @@
 #if __cpp_lib_atomic_wait
 #include <bits/functional_hash.h>
 #include <bits/this_thread_sleep.h>
-
-#include <chrono>
+#include <bits/chrono.h>
 
 #ifdef _GLIBCXX_HAVE_LINUX_FUTEX
 #include <exception> // std::terminate
diff --git a/libstdc++-v3/include/bits/chrono.h 
b/libstdc++-v3/include/bits/chrono.h
new file mode 100644
index 00000000000..956af059ad3
--- /dev/null
+++ b/libstdc++-v3/include/bits/chrono.h
@@ -0,0 +1,1392 @@
+// chrono::duration and chrono::time_point -*- C++ -*-
+
+// Copyright (C) 2008-2021 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/bits/chrono.h
+ *  This is an internal header file, included by other library headers.
+ *  Do not attempt to use it directly. @headername{chrono}
+ */
+
+#ifndef _GLIBCXX_CHRONO_H
+#define _GLIBCXX_CHRONO_H 1
+
+#pragma GCC system_header
+
+#if __cplusplus >= 201103L
+
+#include <ratio>
+#include <type_traits>
+#include <limits>
+#include <ctime>
+#include <bits/parse_numbers.h> // for literals support.
+#if __cplusplus >= 202002L
+# include <concepts>
+# include <compare>
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+#if __cplusplus >= 201703L
+  namespace filesystem { struct __file_clock; };
+#endif
+
+  namespace chrono
+  {
+    /// @addtogroup chrono
+    /// @{
+
+    /// `chrono::duration` represents a distance between two points in time
+    template<typename _Rep, typename _Period = ratio<1>>
+      struct duration;
+
+    /// `chrono::time_point` represents a point in time as measured by a clock
+    template<typename _Clock, typename _Dur = typename _Clock::duration>
+      struct time_point;
+    /// @}
+  }
+
+  /// @addtogroup chrono
+  /// @{
+
+  // 20.11.4.3 specialization of common_type (for duration, sfinae-friendly)
+
+  /// @cond undocumented
+
+  template<typename _CT, typename _Period1, typename _Period2, typename = void>
+    struct __duration_common_type
+    { };
+
+  template<typename _CT, typename _Period1, typename _Period2>
+    struct __duration_common_type<_CT, _Period1, _Period2,
+                                 __void_t<typename _CT::type>>
+    {
+    private:
+      using __gcd_num = __static_gcd<_Period1::num, _Period2::num>;
+      using __gcd_den = __static_gcd<_Period1::den, _Period2::den>;
+      using __cr = typename _CT::type;
+      using __r = ratio<__gcd_num::value,
+                       (_Period1::den / __gcd_den::value) * _Period2::den>;
+
+    public:
+      using type = chrono::duration<__cr, typename __r::type>;
+    };
+
+  /// @endcond
+
+  /// @{
+  /// @relates chrono::duration
+
+  /// Specialization of common_type for chrono::duration types.
+  template<typename _Rep1, typename _Period1, typename _Rep2, typename 
_Period2>
+    struct common_type<chrono::duration<_Rep1, _Period1>,
+                      chrono::duration<_Rep2, _Period2>>
+    : __duration_common_type<common_type<_Rep1, _Rep2>,
+                            typename _Period1::type,
+                            typename _Period2::type>
+    { };
+
+  /// Specialization of common_type for two identical chrono::duration types.
+  template<typename _Rep, typename _Period>
+    struct common_type<chrono::duration<_Rep, _Period>,
+                      chrono::duration<_Rep, _Period>>
+    {
+      using type = chrono::duration<typename common_type<_Rep>::type,
+                                   typename _Period::type>;
+    };
+
+  /// Specialization of common_type for one chrono::duration type.
+  template<typename _Rep, typename _Period>
+    struct common_type<chrono::duration<_Rep, _Period>>
+    {
+      using type = chrono::duration<typename common_type<_Rep>::type,
+                                   typename _Period::type>;
+    };
+  /// @}
+
+  // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly)
+
+  /// @cond undocumented
+
+  template<typename _CT, typename _Clock, typename = void>
+    struct __timepoint_common_type
+    { };
+
+  template<typename _CT, typename _Clock>
+    struct __timepoint_common_type<_CT, _Clock, __void_t<typename _CT::type>>
+    {
+      using type = chrono::time_point<_Clock, typename _CT::type>;
+    };
+
+  /// @endcond
+
+  /// @{
+  /// @relates chrono::time_point
+
+  /// Specialization of common_type for chrono::time_point types.
+  template<typename _Clock, typename _Duration1, typename _Duration2>
+    struct common_type<chrono::time_point<_Clock, _Duration1>,
+                      chrono::time_point<_Clock, _Duration2>>
+    : __timepoint_common_type<common_type<_Duration1, _Duration2>, _Clock>
+    { };
+
+  /// Specialization of common_type for two identical chrono::time_point types.
+  template<typename _Clock, typename _Duration>
+    struct common_type<chrono::time_point<_Clock, _Duration>,
+                      chrono::time_point<_Clock, _Duration>>
+    { using type = chrono::time_point<_Clock, _Duration>; };
+
+  /// Specialization of common_type for one chrono::time_point type.
+  template<typename _Clock, typename _Duration>
+    struct common_type<chrono::time_point<_Clock, _Duration>>
+    { using type = chrono::time_point<_Clock, _Duration>; };
+  /// @}
+
+  /// @} group chrono
+
+  namespace chrono
+  {
+    /// @addtogroup chrono
+    /// @{
+
+    /// @cond undocumented
+
+    // Primary template for duration_cast impl.
+    template<typename _ToDur, typename _CF, typename _CR,
+            bool _NumIsOne = false, bool _DenIsOne = false>
+      struct __duration_cast_impl
+      {
+       template<typename _Rep, typename _Period>
+         static constexpr _ToDur
+         __cast(const duration<_Rep, _Period>& __d)
+         {
+           typedef typename _ToDur::rep                        __to_rep;
+           return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count())
+             * static_cast<_CR>(_CF::num)
+             / static_cast<_CR>(_CF::den)));
+         }
+      };
+
+    template<typename _ToDur, typename _CF, typename _CR>
+      struct __duration_cast_impl<_ToDur, _CF, _CR, true, true>
+      {
+       template<typename _Rep, typename _Period>
+         static constexpr _ToDur
+         __cast(const duration<_Rep, _Period>& __d)
+         {
+           typedef typename _ToDur::rep                        __to_rep;
+           return _ToDur(static_cast<__to_rep>(__d.count()));
+         }
+      };
+
+    template<typename _ToDur, typename _CF, typename _CR>
+      struct __duration_cast_impl<_ToDur, _CF, _CR, true, false>
+      {
+       template<typename _Rep, typename _Period>
+         static constexpr _ToDur
+         __cast(const duration<_Rep, _Period>& __d)
+         {
+           typedef typename _ToDur::rep                        __to_rep;
+           return _ToDur(static_cast<__to_rep>(
+             static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den)));
+         }
+      };
+
+    template<typename _ToDur, typename _CF, typename _CR>
+      struct __duration_cast_impl<_ToDur, _CF, _CR, false, true>
+      {
+       template<typename _Rep, typename _Period>
+         static constexpr _ToDur
+         __cast(const duration<_Rep, _Period>& __d)
+         {
+           typedef typename _ToDur::rep                        __to_rep;
+           return _ToDur(static_cast<__to_rep>(
+             static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num)));
+         }
+      };
+
+    template<typename _Tp>
+      struct __is_duration
+      : std::false_type
+      { };
+
+    template<typename _Rep, typename _Period>
+      struct __is_duration<duration<_Rep, _Period>>
+      : std::true_type
+      { };
+
+    template<typename _Tp>
+      using __enable_if_is_duration
+       = typename enable_if<__is_duration<_Tp>::value, _Tp>::type;
+
+    template<typename _Tp>
+      using __disable_if_is_duration
+       = typename enable_if<!__is_duration<_Tp>::value, _Tp>::type;
+
+    /// @endcond
+
+    /// duration_cast
+    template<typename _ToDur, typename _Rep, typename _Period>
+      constexpr __enable_if_is_duration<_ToDur>
+      duration_cast(const duration<_Rep, _Period>& __d)
+      {
+       typedef typename _ToDur::period                         __to_period;
+       typedef typename _ToDur::rep                            __to_rep;
+       typedef ratio_divide<_Period, __to_period>              __cf;
+       typedef typename common_type<__to_rep, _Rep, intmax_t>::type __cr;
+       typedef  __duration_cast_impl<_ToDur, __cf, __cr,
+                                     __cf::num == 1, __cf::den == 1> __dc;
+       return __dc::__cast(__d);
+      }
+
+    /// treat_as_floating_point
+    template<typename _Rep>
+      struct treat_as_floating_point
+      : is_floating_point<_Rep>
+      { };
+
+#if __cplusplus > 201402L
+    template <typename _Rep>
+      inline constexpr bool treat_as_floating_point_v =
+       treat_as_floating_point<_Rep>::value;
+#endif // C++17
+
+#if __cplusplus > 201703L
+    template<typename _Tp>
+      struct is_clock;
+
+    template<typename _Tp>
+      inline constexpr bool is_clock_v = is_clock<_Tp>::value;
+
+#if __cpp_lib_concepts
+    template<typename _Tp>
+      struct is_clock : false_type
+      { };
+
+    template<typename _Tp>
+      requires requires {
+       typename _Tp::rep;
+       typename _Tp::period;
+       typename _Tp::duration;
+       typename _Tp::time_point::clock;
+       typename _Tp::time_point::duration;
+       { &_Tp::is_steady } -> same_as<const bool*>;
+       { _Tp::now() } -> same_as<typename _Tp::time_point>;
+       requires same_as<typename _Tp::duration,
+                        duration<typename _Tp::rep, typename _Tp::period>>;
+       requires same_as<typename _Tp::time_point::duration,
+                        typename _Tp::duration>;
+      }
+      struct is_clock<_Tp> : true_type
+      { };
+#else
+    template<typename _Tp, typename = void>
+      struct __is_clock_impl : false_type
+      { };
+
+    template<typename _Tp>
+      struct __is_clock_impl<_Tp,
+                            void_t<typename _Tp::rep, typename _Tp::period,
+                                   typename _Tp::duration,
+                                   typename _Tp::time_point::duration,
+                                   decltype(_Tp::is_steady),
+                                   decltype(_Tp::now())>>
+      : __and_<is_same<typename _Tp::duration,
+                      duration<typename _Tp::rep, typename _Tp::period>>,
+              is_same<typename _Tp::time_point::duration,
+                      typename _Tp::duration>,
+              is_same<decltype(&_Tp::is_steady), const bool*>,
+              is_same<decltype(_Tp::now()), typename _Tp::time_point>>::type
+      { };
+
+    template<typename _Tp>
+      struct is_clock : __is_clock_impl<_Tp>::type
+      { };
+#endif
+#endif // C++20
+
+#if __cplusplus >= 201703L
+# define __cpp_lib_chrono 201611
+
+    template<typename _ToDur, typename _Rep, typename _Period>
+      constexpr __enable_if_is_duration<_ToDur>
+      floor(const duration<_Rep, _Period>& __d)
+      {
+       auto __to = chrono::duration_cast<_ToDur>(__d);
+       if (__to > __d)
+         return __to - _ToDur{1};
+       return __to;
+      }
+
+    template<typename _ToDur, typename _Rep, typename _Period>
+      constexpr __enable_if_is_duration<_ToDur>
+      ceil(const duration<_Rep, _Period>& __d)
+      {
+       auto __to = chrono::duration_cast<_ToDur>(__d);
+       if (__to < __d)
+         return __to + _ToDur{1};
+       return __to;
+      }
+
+    template <typename _ToDur, typename _Rep, typename _Period>
+      constexpr enable_if_t<
+       __and_<__is_duration<_ToDur>,
+              __not_<treat_as_floating_point<typename _ToDur::rep>>>::value,
+       _ToDur>
+      round(const duration<_Rep, _Period>& __d)
+      {
+       _ToDur __t0 = chrono::floor<_ToDur>(__d);
+       _ToDur __t1 = __t0 + _ToDur{1};
+       auto __diff0 = __d - __t0;
+       auto __diff1 = __t1 - __d;
+       if (__diff0 == __diff1)
+       {
+           if (__t0.count() & 1)
+               return __t1;
+           return __t0;
+       }
+       else if (__diff0 < __diff1)
+           return __t0;
+       return __t1;
+      }
+
+    template<typename _Rep, typename _Period>
+      constexpr
+      enable_if_t<numeric_limits<_Rep>::is_signed, duration<_Rep, _Period>>
+      abs(duration<_Rep, _Period> __d)
+      {
+       if (__d >= __d.zero())
+         return __d;
+       return -__d;
+      }
+
+    // Make chrono::ceil<D> also usable as chrono::__detail::ceil<D>.
+    namespace __detail { using chrono::ceil; }
+
+#else // ! C++17
+
+    // We want to use ceil even when compiling for earlier standards versions.
+    // C++11 only allows a single statement in a constexpr function, so we
+    // need to move the comparison into a separate function, __ceil_impl.
+    namespace __detail
+    {
+      template<typename _Tp, typename _Up>
+       constexpr _Tp
+       __ceil_impl(const _Tp& __t, const _Up& __u)
+       {
+         return (__t < __u) ? (__t + _Tp{1}) : __t;
+       }
+
+      // C++11-friendly version of std::chrono::ceil<D> for internal use.
+      template<typename _ToDur, typename _Rep, typename _Period>
+       constexpr _ToDur
+       ceil(const duration<_Rep, _Period>& __d)
+       {
+         return __detail::__ceil_impl(chrono::duration_cast<_ToDur>(__d), __d);
+       }
+    }
+#endif // C++17
+
+    /// duration_values
+    template<typename _Rep>
+      struct duration_values
+      {
+       static constexpr _Rep
+       zero() noexcept
+       { return _Rep(0); }
+
+       static constexpr _Rep
+       max() noexcept
+       { return numeric_limits<_Rep>::max(); }
+
+       static constexpr _Rep
+       min() noexcept
+       { return numeric_limits<_Rep>::lowest(); }
+      };
+
+    /// @cond undocumented
+
+    template<typename _Tp>
+      struct __is_ratio
+      : std::false_type
+      { };
+
+    template<intmax_t _Num, intmax_t _Den>
+      struct __is_ratio<ratio<_Num, _Den>>
+      : std::true_type
+      { };
+
+    /// @endcond
+
+    template<typename _Rep, typename _Period>
+      struct duration
+      {
+      private:
+       template<typename _Rep2>
+         using __is_float = treat_as_floating_point<_Rep2>;
+
+       static constexpr intmax_t
+       _S_gcd(intmax_t __m, intmax_t __n) noexcept
+       {
+         // Duration only allows positive periods so we don't need to
+         // handle negative values here (unlike __static_gcd and std::gcd).
+#if __cplusplus >= 201402L
+         do
+           {
+             intmax_t __rem = __m % __n;
+             __m = __n;
+             __n = __rem;
+           }
+         while (__n != 0);
+         return __m;
+#else
+         // C++11 doesn't allow loops in constexpr functions, but this
+         // recursive version can be more expensive to evaluate.
+         return (__n == 0) ? __m : _S_gcd(__n, __m % __n);
+#endif
+       }
+
+       // _GLIBCXX_RESOLVE_LIB_DEFECTS
+       // 2094. overflow shouldn't participate in overload resolution
+       // 3090. What is [2094] intended to mean?
+       // This only produces a valid type if no overflow occurs.
+       template<typename _R1, typename _R2,
+                intmax_t __gcd1 = _S_gcd(_R1::num, _R2::num),
+                intmax_t __gcd2 = _S_gcd(_R1::den, _R2::den)>
+         using __divide = ratio<(_R1::num / __gcd1) * (_R2::den / __gcd2),
+                                (_R1::den / __gcd2) * (_R2::num / __gcd1)>;
+
+       // _Period2 is an exact multiple of _Period
+       template<typename _Period2>
+         using __is_harmonic
+           = __bool_constant<__divide<_Period2, _Period>::den == 1>;
+
+      public:
+
+       using rep = _Rep;
+       using period = typename _Period::type;
+
+       static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
+       static_assert(__is_ratio<_Period>::value,
+                     "period must be a specialization of ratio");
+       static_assert(_Period::num > 0, "period must be positive");
+
+       // 20.11.5.1 construction / copy / destroy
+       constexpr duration() = default;
+
+       duration(const duration&) = default;
+
+       // _GLIBCXX_RESOLVE_LIB_DEFECTS
+       // 3050. Conversion specification problem in chrono::duration
+       template<typename _Rep2, typename = _Require<
+                is_convertible<const _Rep2&, rep>,
+                __or_<__is_float<rep>, __not_<__is_float<_Rep2>>>>>
+         constexpr explicit duration(const _Rep2& __rep)
+         : __r(static_cast<rep>(__rep)) { }
+
+       template<typename _Rep2, typename _Period2, typename = _Require<
+                is_convertible<const _Rep2&, rep>,
+                __or_<__is_float<rep>,
+                      __and_<__is_harmonic<_Period2>,
+                             __not_<__is_float<_Rep2>>>>>>
+         constexpr duration(const duration<_Rep2, _Period2>& __d)
+         : __r(duration_cast<duration>(__d).count()) { }
+
+       ~duration() = default;
+       duration& operator=(const duration&) = default;
+
+       // 20.11.5.2 observer
+       constexpr rep
+       count() const
+       { return __r; }
+
+       // 20.11.5.3 arithmetic
+
+       constexpr duration<typename common_type<rep>::type, period>
+       operator+() const
+       { return duration<typename common_type<rep>::type, period>(__r); }
+
+       constexpr duration<typename common_type<rep>::type, period>
+       operator-() const
+       { return duration<typename common_type<rep>::type, period>(-__r); }
+
+       _GLIBCXX17_CONSTEXPR duration&
+       operator++()
+       {
+         ++__r;
+         return *this;
+       }
+
+       _GLIBCXX17_CONSTEXPR duration
+       operator++(int)
+       { return duration(__r++); }
+
+       _GLIBCXX17_CONSTEXPR duration&
+       operator--()
+       {
+         --__r;
+         return *this;
+       }
+
+       _GLIBCXX17_CONSTEXPR duration
+       operator--(int)
+       { return duration(__r--); }
+
+       _GLIBCXX17_CONSTEXPR duration&
+       operator+=(const duration& __d)
+       {
+         __r += __d.count();
+         return *this;
+       }
+
+       _GLIBCXX17_CONSTEXPR duration&
+       operator-=(const duration& __d)
+       {
+         __r -= __d.count();
+         return *this;
+       }
+
+       _GLIBCXX17_CONSTEXPR duration&
+       operator*=(const rep& __rhs)
+       {
+         __r *= __rhs;
+         return *this;
+       }
+
+       _GLIBCXX17_CONSTEXPR duration&
+       operator/=(const rep& __rhs)
+       {
+         __r /= __rhs;
+         return *this;
+       }
+
+       // DR 934.
+       template<typename _Rep2 = rep>
+         _GLIBCXX17_CONSTEXPR
+         typename enable_if<!treat_as_floating_point<_Rep2>::value,
+                            duration&>::type
+         operator%=(const rep& __rhs)
+         {
+           __r %= __rhs;
+           return *this;
+         }
+
+       template<typename _Rep2 = rep>
+         _GLIBCXX17_CONSTEXPR
+         typename enable_if<!treat_as_floating_point<_Rep2>::value,
+                            duration&>::type
+         operator%=(const duration& __d)
+         {
+           __r %= __d.count();
+           return *this;
+         }
+
+       // 20.11.5.4 special values
+       static constexpr duration
+       zero() noexcept
+       { return duration(duration_values<rep>::zero()); }
+
+       static constexpr duration
+       min() noexcept
+       { return duration(duration_values<rep>::min()); }
+
+       static constexpr duration
+       max() noexcept
+       { return duration(duration_values<rep>::max()); }
+
+      private:
+       rep __r;
+      };
+
+    /// @{
+    /// @relates std::chrono::duration
+
+    /// The sum of two durations.
+    template<typename _Rep1, typename _Period1,
+            typename _Rep2, typename _Period2>
+      constexpr typename common_type<duration<_Rep1, _Period1>,
+                                    duration<_Rep2, _Period2>>::type
+      operator+(const duration<_Rep1, _Period1>& __lhs,
+               const duration<_Rep2, _Period2>& __rhs)
+      {
+       typedef duration<_Rep1, _Period1>                       __dur1;
+       typedef duration<_Rep2, _Period2>                       __dur2;
+       typedef typename common_type<__dur1,__dur2>::type       __cd;
+       return __cd(__cd(__lhs).count() + __cd(__rhs).count());
+      }
+
+    /// The difference between two durations.
+    template<typename _Rep1, typename _Period1,
+            typename _Rep2, typename _Period2>
+      constexpr typename common_type<duration<_Rep1, _Period1>,
+                                    duration<_Rep2, _Period2>>::type
+      operator-(const duration<_Rep1, _Period1>& __lhs,
+               const duration<_Rep2, _Period2>& __rhs)
+      {
+       typedef duration<_Rep1, _Period1>                       __dur1;
+       typedef duration<_Rep2, _Period2>                       __dur2;
+       typedef typename common_type<__dur1,__dur2>::type       __cd;
+       return __cd(__cd(__lhs).count() - __cd(__rhs).count());
+      }
+
+    /// @}
+
+    /// @cond undocumented
+
+    // SFINAE helper to obtain common_type<_Rep1, _Rep2> only if _Rep2
+    // is implicitly convertible to it.
+    // _GLIBCXX_RESOLVE_LIB_DEFECTS
+    // 3050. Conversion specification problem in chrono::duration constructor
+    template<typename _Rep1, typename _Rep2,
+            typename _CRep = typename common_type<_Rep1, _Rep2>::type>
+      using __common_rep_t = typename
+       enable_if<is_convertible<const _Rep2&, _CRep>::value, _CRep>::type;
+
+    /// @endcond
+
+    /** @{
+     * Arithmetic operators for chrono::duration
+     * @relates std::chrono::duration
+     */
+
+    template<typename _Rep1, typename _Period, typename _Rep2>
+      constexpr duration<__common_rep_t<_Rep1, _Rep2>, _Period>
+      operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
+      {
+       typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
+         __cd;
+       return __cd(__cd(__d).count() * __s);
+      }
+
+    template<typename _Rep1, typename _Rep2, typename _Period>
+      constexpr duration<__common_rep_t<_Rep2, _Rep1>, _Period>
+      operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
+      { return __d * __s; }
+
+    template<typename _Rep1, typename _Period, typename _Rep2>
+      constexpr
+      duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period>
+      operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
+      {
+       typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
+         __cd;
+       return __cd(__cd(__d).count() / __s);
+      }
+
+    template<typename _Rep1, typename _Period1,
+            typename _Rep2, typename _Period2>
+      constexpr typename common_type<_Rep1, _Rep2>::type
+      operator/(const duration<_Rep1, _Period1>& __lhs,
+               const duration<_Rep2, _Period2>& __rhs)
+      {
+       typedef duration<_Rep1, _Period1>                       __dur1;
+       typedef duration<_Rep2, _Period2>                       __dur2;
+       typedef typename common_type<__dur1,__dur2>::type       __cd;
+       return __cd(__lhs).count() / __cd(__rhs).count();
+      }
+
+    // DR 934.
+    template<typename _Rep1, typename _Period, typename _Rep2>
+      constexpr
+      duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period>
+      operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
+      {
+       typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
+         __cd;
+       return __cd(__cd(__d).count() % __s);
+      }
+
+    template<typename _Rep1, typename _Period1,
+            typename _Rep2, typename _Period2>
+      constexpr typename common_type<duration<_Rep1, _Period1>,
+                                    duration<_Rep2, _Period2>>::type
+      operator%(const duration<_Rep1, _Period1>& __lhs,
+               const duration<_Rep2, _Period2>& __rhs)
+      {
+       typedef duration<_Rep1, _Period1>                       __dur1;
+       typedef duration<_Rep2, _Period2>                       __dur2;
+       typedef typename common_type<__dur1,__dur2>::type       __cd;
+       return __cd(__cd(__lhs).count() % __cd(__rhs).count());
+      }
+    /// @}
+
+    // comparisons
+
+    /** @{
+     * Comparisons for chrono::duration
+     * @relates std::chrono::duration
+     */
+
+    template<typename _Rep1, typename _Period1,
+            typename _Rep2, typename _Period2>
+      constexpr bool
+      operator==(const duration<_Rep1, _Period1>& __lhs,
+                const duration<_Rep2, _Period2>& __rhs)
+      {
+       typedef duration<_Rep1, _Period1>                       __dur1;
+       typedef duration<_Rep2, _Period2>                       __dur2;
+       typedef typename common_type<__dur1,__dur2>::type       __ct;
+       return __ct(__lhs).count() == __ct(__rhs).count();
+      }
+
+    template<typename _Rep1, typename _Period1,
+            typename _Rep2, typename _Period2>
+      constexpr bool
+      operator<(const duration<_Rep1, _Period1>& __lhs,
+               const duration<_Rep2, _Period2>& __rhs)
+      {
+       typedef duration<_Rep1, _Period1>                       __dur1;
+       typedef duration<_Rep2, _Period2>                       __dur2;
+       typedef typename common_type<__dur1,__dur2>::type       __ct;
+       return __ct(__lhs).count() < __ct(__rhs).count();
+      }
+
+#if __cpp_lib_three_way_comparison
+    template<typename _Rep1, typename _Period1,
+            typename _Rep2, typename _Period2>
+      requires three_way_comparable<common_type_t<_Rep1, _Rep2>>
+      constexpr auto
+      operator<=>(const duration<_Rep1, _Period1>& __lhs,
+                 const duration<_Rep2, _Period2>& __rhs)
+      {
+       using __ct = common_type_t<duration<_Rep1, _Period1>,
+                                  duration<_Rep2, _Period2>>;
+       return __ct(__lhs).count() <=> __ct(__rhs).count();
+      }
+#else
+    template<typename _Rep1, typename _Period1,
+            typename _Rep2, typename _Period2>
+      constexpr bool
+      operator!=(const duration<_Rep1, _Period1>& __lhs,
+                const duration<_Rep2, _Period2>& __rhs)
+      { return !(__lhs == __rhs); }
+#endif
+
+    template<typename _Rep1, typename _Period1,
+            typename _Rep2, typename _Period2>
+      constexpr bool
+      operator<=(const duration<_Rep1, _Period1>& __lhs,
+                const duration<_Rep2, _Period2>& __rhs)
+      { return !(__rhs < __lhs); }
+
+    template<typename _Rep1, typename _Period1,
+            typename _Rep2, typename _Period2>
+      constexpr bool
+      operator>(const duration<_Rep1, _Period1>& __lhs,
+               const duration<_Rep2, _Period2>& __rhs)
+      { return __rhs < __lhs; }
+
+    template<typename _Rep1, typename _Period1,
+            typename _Rep2, typename _Period2>
+      constexpr bool
+      operator>=(const duration<_Rep1, _Period1>& __lhs,
+                const duration<_Rep2, _Period2>& __rhs)
+      { return !(__lhs < __rhs); }
+
+    /// @}
+
+    /// @cond undocumented
+#ifdef _GLIBCXX_USE_C99_STDINT_TR1
+# define _GLIBCXX_CHRONO_INT64_T int64_t
+#elif defined __INT64_TYPE__
+# define _GLIBCXX_CHRONO_INT64_T __INT64_TYPE__
+#else
+    static_assert(std::numeric_limits<unsigned long long>::digits >= 64,
+       "Representation type for nanoseconds must have at least 64 bits");
+# define _GLIBCXX_CHRONO_INT64_T long long
+#endif
+    /// @endcond
+
+    /// nanoseconds
+    using nanoseconds  = duration<_GLIBCXX_CHRONO_INT64_T, nano>;
+
+    /// microseconds
+    using microseconds = duration<_GLIBCXX_CHRONO_INT64_T, micro>;
+
+    /// milliseconds
+    using milliseconds = duration<_GLIBCXX_CHRONO_INT64_T, milli>;
+
+    /// seconds
+    using seconds      = duration<_GLIBCXX_CHRONO_INT64_T>;
+
+    /// minutes
+    using minutes      = duration<_GLIBCXX_CHRONO_INT64_T, ratio< 60>>;
+
+    /// hours
+    using hours                = duration<_GLIBCXX_CHRONO_INT64_T, 
ratio<3600>>;
+
+#if __cplusplus > 201703L
+    /// days
+    using days         = duration<_GLIBCXX_CHRONO_INT64_T, ratio<86400>>;
+
+    /// weeks
+    using weeks                = duration<_GLIBCXX_CHRONO_INT64_T, 
ratio<604800>>;
+
+    /// years
+    using years                = duration<_GLIBCXX_CHRONO_INT64_T, 
ratio<31556952>>;
+
+    /// months
+    using months       = duration<_GLIBCXX_CHRONO_INT64_T, ratio<2629746>>;
+#endif // C++20
+
+#undef _GLIBCXX_CHRONO_INT64_T
+
+    template<typename _Clock, typename _Dur>
+      struct time_point
+      {
+       static_assert(__is_duration<_Dur>::value,
+           "duration must be a specialization of std::chrono::duration");
+
+       typedef _Clock                                          clock;
+       typedef _Dur                                            duration;
+       typedef typename duration::rep                          rep;
+       typedef typename duration::period                       period;
+
+       constexpr time_point() : __d(duration::zero())
+       { }
+
+       constexpr explicit time_point(const duration& __dur)
+       : __d(__dur)
+       { }
+
+       // conversions
+       template<typename _Dur2,
+                typename = _Require<is_convertible<_Dur2, _Dur>>>
+         constexpr time_point(const time_point<clock, _Dur2>& __t)
+         : __d(__t.time_since_epoch())
+         { }
+
+       // observer
+       constexpr duration
+       time_since_epoch() const
+       { return __d; }
+
+#if __cplusplus > 201703L
+       constexpr time_point&
+       operator++()
+       {
+         ++__d;
+         return *this;
+       }
+
+       constexpr time_point
+       operator++(int)
+       { return time_point{__d++}; }
+
+       constexpr time_point&
+       operator--()
+       {
+         --__d;
+         return *this;
+       }
+
+       constexpr time_point
+       operator--(int)
+       { return time_point{__d--}; }
+#endif
+
+       // arithmetic
+       _GLIBCXX17_CONSTEXPR time_point&
+       operator+=(const duration& __dur)
+       {
+         __d += __dur;
+         return *this;
+       }
+
+       _GLIBCXX17_CONSTEXPR time_point&
+       operator-=(const duration& __dur)
+       {
+         __d -= __dur;
+         return *this;
+       }
+
+       // special values
+       static constexpr time_point
+       min() noexcept
+       { return time_point(duration::min()); }
+
+       static constexpr time_point
+       max() noexcept
+       { return time_point(duration::max()); }
+
+      private:
+       duration __d;
+      };
+
+    /// time_point_cast
+    template<typename _ToDur, typename _Clock, typename _Dur>
+      constexpr typename enable_if<__is_duration<_ToDur>::value,
+                                  time_point<_Clock, _ToDur>>::type
+      time_point_cast(const time_point<_Clock, _Dur>& __t)
+      {
+       typedef time_point<_Clock, _ToDur>                      __time_point;
+       return __time_point(duration_cast<_ToDur>(__t.time_since_epoch()));
+      }
+
+#if __cplusplus > 201402L
+    template<typename _ToDur, typename _Clock, typename _Dur>
+      constexpr
+      enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>>
+      floor(const time_point<_Clock, _Dur>& __tp)
+      {
+       return time_point<_Clock, _ToDur>{
+           chrono::floor<_ToDur>(__tp.time_since_epoch())};
+      }
+
+    template<typename _ToDur, typename _Clock, typename _Dur>
+      constexpr
+      enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>>
+      ceil(const time_point<_Clock, _Dur>& __tp)
+      {
+       return time_point<_Clock, _ToDur>{
+           chrono::ceil<_ToDur>(__tp.time_since_epoch())};
+      }
+
+    template<typename _ToDur, typename _Clock, typename _Dur>
+      constexpr enable_if_t<
+       __and_<__is_duration<_ToDur>,
+              __not_<treat_as_floating_point<typename _ToDur::rep>>>::value,
+       time_point<_Clock, _ToDur>>
+      round(const time_point<_Clock, _Dur>& __tp)
+      {
+       return time_point<_Clock, _ToDur>{
+           chrono::round<_ToDur>(__tp.time_since_epoch())};
+      }
+#endif // C++17
+
+    /// @{
+    /// @relates time_point
+
+    /// Adjust a time point forwards by the given duration.
+    template<typename _Clock, typename _Dur1,
+            typename _Rep2, typename _Period2>
+      constexpr time_point<_Clock,
+       typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
+      operator+(const time_point<_Clock, _Dur1>& __lhs,
+               const duration<_Rep2, _Period2>& __rhs)
+      {
+       typedef duration<_Rep2, _Period2>                       __dur2;
+       typedef typename common_type<_Dur1,__dur2>::type        __ct;
+       typedef time_point<_Clock, __ct>                        __time_point;
+       return __time_point(__lhs.time_since_epoch() + __rhs);
+      }
+
+    /// Adjust a time point forwards by the given duration.
+    template<typename _Rep1, typename _Period1,
+            typename _Clock, typename _Dur2>
+      constexpr time_point<_Clock,
+       typename common_type<duration<_Rep1, _Period1>, _Dur2>::type>
+      operator+(const duration<_Rep1, _Period1>& __lhs,
+               const time_point<_Clock, _Dur2>& __rhs)
+      {
+       typedef duration<_Rep1, _Period1>                       __dur1;
+       typedef typename common_type<__dur1,_Dur2>::type        __ct;
+       typedef time_point<_Clock, __ct>                        __time_point;
+       return __time_point(__rhs.time_since_epoch() + __lhs);
+      }
+
+    /// Adjust a time point backwards by the given duration.
+    template<typename _Clock, typename _Dur1,
+            typename _Rep2, typename _Period2>
+      constexpr time_point<_Clock,
+       typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
+      operator-(const time_point<_Clock, _Dur1>& __lhs,
+               const duration<_Rep2, _Period2>& __rhs)
+      {
+       typedef duration<_Rep2, _Period2>                       __dur2;
+       typedef typename common_type<_Dur1,__dur2>::type        __ct;
+       typedef time_point<_Clock, __ct>                        __time_point;
+       return __time_point(__lhs.time_since_epoch() -__rhs);
+      }
+
+    /// The difference between two time points (as a duration)
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr typename common_type<_Dur1, _Dur2>::type
+      operator-(const time_point<_Clock, _Dur1>& __lhs,
+               const time_point<_Clock, _Dur2>& __rhs)
+      { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }
+    /// @}
+
+    /** @{
+     * Comparisons for time_point
+     * @relates chrono::time_point
+     */
+
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr bool
+      operator==(const time_point<_Clock, _Dur1>& __lhs,
+                const time_point<_Clock, _Dur2>& __rhs)
+      { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }
+
+#if __cpp_lib_three_way_comparison
+    template<typename _Clock, typename _Dur1,
+            three_way_comparable_with<_Dur1> _Dur2>
+      constexpr auto
+      operator<=>(const time_point<_Clock, _Dur1>& __lhs,
+                 const time_point<_Clock, _Dur2>& __rhs)
+      { return __lhs.time_since_epoch() <=> __rhs.time_since_epoch(); }
+#else
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr bool
+      operator!=(const time_point<_Clock, _Dur1>& __lhs,
+                const time_point<_Clock, _Dur2>& __rhs)
+      { return !(__lhs == __rhs); }
+#endif
+
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr bool
+      operator<(const time_point<_Clock, _Dur1>& __lhs,
+               const time_point<_Clock, _Dur2>& __rhs)
+      { return  __lhs.time_since_epoch() < __rhs.time_since_epoch(); }
+
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr bool
+      operator<=(const time_point<_Clock, _Dur1>& __lhs,
+                const time_point<_Clock, _Dur2>& __rhs)
+      { return !(__rhs < __lhs); }
+
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr bool
+      operator>(const time_point<_Clock, _Dur1>& __lhs,
+               const time_point<_Clock, _Dur2>& __rhs)
+      { return __rhs < __lhs; }
+
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr bool
+      operator>=(const time_point<_Clock, _Dur1>& __lhs,
+                const time_point<_Clock, _Dur2>& __rhs)
+      { return !(__lhs < __rhs); }
+
+    /// @}
+    /// @} group chrono
+
+    // Clocks.
+
+    // Why nanosecond resolution as the default?
+    // Why have std::system_clock always count in the highest
+    // resolution (ie nanoseconds), even if on some OSes the low 3
+    // or 9 decimal digits will be always zero? This allows later
+    // implementations to change the system_clock::now()
+    // implementation any time to provide better resolution without
+    // changing function signature or units.
+
+    // To support the (forward) evolution of the library's defined
+    // clocks, wrap inside inline namespace so that the current
+    // defintions of system_clock, steady_clock, and
+    // high_resolution_clock types are uniquely mangled. This way, new
+    // code can use the latests clocks, while the library can contain
+    // compatibility definitions for previous versions.  At some
+    // point, when these clocks settle down, the inlined namespaces
+    // can be removed.  XXX GLIBCXX_ABI Deprecated
+    inline namespace _V2 {
+
+    /**
+     *  @brief System clock.
+     *
+     *  Time returned represents wall time from the system-wide clock.
+     *  @ingroup chrono
+    */
+    struct system_clock
+    {
+      typedef chrono::nanoseconds                              duration;
+      typedef duration::rep                                    rep;
+      typedef duration::period                                 period;
+      typedef chrono::time_point<system_clock, duration>       time_point;
+
+      static_assert(system_clock::duration::min()
+                   < system_clock::duration::zero(),
+                   "a clock's minimum duration cannot be less than its epoch");
+
+      static constexpr bool is_steady = false;
+
+      static time_point
+      now() noexcept;
+
+      // Map to C API
+      static std::time_t
+      to_time_t(const time_point& __t) noexcept
+      {
+       return std::time_t(duration_cast<chrono::seconds>
+                          (__t.time_since_epoch()).count());
+      }
+
+      static time_point
+      from_time_t(std::time_t __t) noexcept
+      {
+       typedef chrono::time_point<system_clock, seconds>       __from;
+       return time_point_cast<system_clock::duration>
+              (__from(chrono::seconds(__t)));
+      }
+    };
+
+
+    /**
+     *  @brief Monotonic clock
+     *
+     *  Time returned has the property of only increasing at a uniform rate.
+     *  @ingroup chrono
+    */
+    struct steady_clock
+    {
+      typedef chrono::nanoseconds                              duration;
+      typedef duration::rep                                    rep;
+      typedef duration::period                                 period;
+      typedef chrono::time_point<steady_clock, duration>       time_point;
+
+      static constexpr bool is_steady = true;
+
+      static time_point
+      now() noexcept;
+    };
+
+
+    /**
+     *  @brief Highest-resolution clock
+     *
+     *  This is the clock "with the shortest tick period." Alias to
+     *  std::system_clock until higher-than-nanosecond definitions
+     *  become feasible.
+     *  @ingroup chrono
+    */
+    using high_resolution_clock = system_clock;
+
+    } // end inline namespace _V2
+
+#if __cplusplus >= 202002L
+    /// @addtogroup chrono
+    /// @{
+    template<typename _Duration>
+      using sys_time = time_point<system_clock, _Duration>;
+    using sys_seconds = sys_time<seconds>;
+    using sys_days = sys_time<days>;
+
+    using file_clock = ::std::filesystem::__file_clock;
+
+    template<typename _Duration>
+      using file_time = time_point<file_clock, _Duration>;
+
+    template<> struct is_clock<system_clock> : true_type { };
+    template<> struct is_clock<steady_clock> : true_type { };
+    template<> struct is_clock<file_clock> : true_type { };
+
+    template<> inline constexpr bool is_clock_v<system_clock> = true;
+    template<> inline constexpr bool is_clock_v<steady_clock> = true;
+    template<> inline constexpr bool is_clock_v<file_clock> = true;
+    /// @}
+#endif // C++20
+  } // namespace chrono
+
+#if __cplusplus >= 201402L
+    #define __cpp_lib_chrono_udls 201304
+
+  inline namespace literals
+  {
+  /** ISO C++ 2014  namespace for suffixes for duration literals.
+   *
+   * These suffixes can be used to create `chrono::duration` values with
+   * tick periods of hours, minutes, seconds, milliseconds, microseconds
+   * or nanoseconds. For example, `std::chrono::seconds(5)` can be written
+   * as `5s` after making the suffix visible in the current scope.
+   * The suffixes can be made visible by a using-directive or
+   * using-declaration such as:
+   *  - `using namespace std::chrono_literals;`
+   *  - `using namespace std::literals;`
+   *  - `using namespace std::chrono;`
+   *  - `using namespace std;`
+   *  - `using std::chrono_literals::operator""s;`
+   *
+   * The result of these suffixes on an integer literal is one of the
+   * standard typedefs such as `std::chrono::hours`.
+   * The result on a floating-point literal is a duration type with the
+   * specified tick period and an unspecified floating-point representation,
+   * for example `1.5e2ms` might be equivalent to
+   * `chrono::duration<long double, chrono::milli>(1.5e2)`.
+   *
+   * @since C+14
+   * @ingroup chrono
+   */
+  inline namespace chrono_literals
+  {
+    /// @addtogroup chrono
+    /// @{
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wliteral-suffix"
+    /// @cond undocumented
+    template<typename _Dur, char... _Digits>
+      constexpr _Dur __check_overflow()
+      {
+       using _Val = __parse_int::_Parse_int<_Digits...>;
+       constexpr typename _Dur::rep __repval = _Val::value;
+       static_assert(__repval >= 0 && __repval == _Val::value,
+                     "literal value cannot be represented by duration type");
+       return _Dur(__repval);
+      }
+    /// @endcond
+
+    /// Literal suffix for durations representing non-integer hours
+    constexpr chrono::duration<long double, ratio<3600,1>>
+    operator""h(long double __hours)
+    { return chrono::duration<long double, ratio<3600,1>>{__hours}; }
+
+    /// Literal suffix for durations of type `std::chrono::hours`
+    template <char... _Digits>
+      constexpr chrono::hours
+      operator""h()
+      { return __check_overflow<chrono::hours, _Digits...>(); }
+
+    /// Literal suffix for durations representing non-integer minutes
+    constexpr chrono::duration<long double, ratio<60,1>>
+    operator""min(long double __mins)
+    { return chrono::duration<long double, ratio<60,1>>{__mins}; }
+
+    /// Literal suffix for durations of type `std::chrono::minutes`
+    template <char... _Digits>
+      constexpr chrono::minutes
+      operator""min()
+      { return __check_overflow<chrono::minutes, _Digits...>(); }
+
+    /// Literal suffix for durations representing non-integer seconds
+    constexpr chrono::duration<long double>
+    operator""s(long double __secs)
+    { return chrono::duration<long double>{__secs}; }
+
+    /// Literal suffix for durations of type `std::chrono::seconds`
+    template <char... _Digits>
+      constexpr chrono::seconds
+      operator""s()
+      { return __check_overflow<chrono::seconds, _Digits...>(); }
+
+    /// Literal suffix for durations representing non-integer milliseconds
+    constexpr chrono::duration<long double, milli>
+    operator""ms(long double __msecs)
+    { return chrono::duration<long double, milli>{__msecs}; }
+
+    /// Literal suffix for durations of type `std::chrono::milliseconds`
+    template <char... _Digits>
+      constexpr chrono::milliseconds
+      operator""ms()
+      { return __check_overflow<chrono::milliseconds, _Digits...>(); }
+
+    /// Literal suffix for durations representing non-integer microseconds
+    constexpr chrono::duration<long double, micro>
+    operator""us(long double __usecs)
+    { return chrono::duration<long double, micro>{__usecs}; }
+
+    /// Literal suffix for durations of type `std::chrono::microseconds`
+    template <char... _Digits>
+      constexpr chrono::microseconds
+      operator""us()
+      { return __check_overflow<chrono::microseconds, _Digits...>(); }
+
+    /// Literal suffix for durations representing non-integer nanoseconds
+    constexpr chrono::duration<long double, nano>
+    operator""ns(long double __nsecs)
+    { return chrono::duration<long double, nano>{__nsecs}; }
+
+    /// Literal suffix for durations of type `std::chrono::nanoseconds`
+    template <char... _Digits>
+      constexpr chrono::nanoseconds
+      operator""ns()
+      { return __check_overflow<chrono::nanoseconds, _Digits...>(); }
+
+#pragma GCC diagnostic pop
+    /// @}
+  } // inline namespace chrono_literals
+  } // inline namespace literals
+
+  namespace chrono
+  {
+    using namespace literals::chrono_literals;
+  } // namespace chrono
+#endif // C++14
+
+#if __cplusplus >= 201703L
+  namespace filesystem
+  {
+    struct __file_clock
+    {
+      using duration                  = chrono::nanoseconds;
+      using rep                       = duration::rep;
+      using period                    = duration::period;
+      using time_point                = chrono::time_point<__file_clock>;
+      static constexpr bool is_steady = false;
+
+      static time_point
+      now() noexcept
+      { return _S_from_sys(chrono::system_clock::now()); }
+
+#if __cplusplus > 201703L
+      template<typename _Dur>
+       static
+       chrono::file_time<_Dur>
+       from_sys(const chrono::sys_time<_Dur>& __t) noexcept
+       { return _S_from_sys(__t); }
+
+      // For internal use only
+      template<typename _Dur>
+       static
+       chrono::sys_time<_Dur>
+       to_sys(const chrono::file_time<_Dur>& __t) noexcept
+       { return _S_to_sys(__t); }
+#endif // C++20
+
+    private:
+      using __sys_clock = chrono::system_clock;
+
+      // This clock's (unspecified) epoch is 2174-01-01 00:00:00 UTC.
+      // A signed 64-bit duration with nanosecond resolution gives roughly
+      // +/- 292 years, which covers the 1901-2446 date range for ext4.
+      static constexpr chrono::seconds _S_epoch_diff{6437664000};
+
+    protected:
+      // For internal use only
+      template<typename _Dur>
+       static
+       chrono::time_point<__file_clock, _Dur>
+       _S_from_sys(const chrono::time_point<__sys_clock, _Dur>& __t) noexcept
+       {
+         using __file_time = chrono::time_point<__file_clock, _Dur>;
+         return __file_time{__t.time_since_epoch()} - _S_epoch_diff;
+       }
+
+      // For internal use only
+      template<typename _Dur>
+       static
+       chrono::time_point<__sys_clock, _Dur>
+       _S_to_sys(const chrono::time_point<__file_clock, _Dur>& __t) noexcept
+       {
+         using __sys_time = chrono::time_point<__sys_clock, _Dur>;
+         return __sys_time{__t.time_since_epoch()} + _S_epoch_diff;
+       }
+    };
+  } // namespace filesystem
+#endif // C++17
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif // C++11
+
+#endif //_GLIBCXX_CHRONO_H
diff --git a/libstdc++-v3/include/bits/fs_fwd.h 
b/libstdc++-v3/include/bits/fs_fwd.h
index a7f5a37709c..51f351e94d4 100644
--- a/libstdc++-v3/include/bits/fs_fwd.h
+++ b/libstdc++-v3/include/bits/fs_fwd.h
@@ -34,7 +34,7 @@
 
 #include <system_error>
 #include <cstdint>
-#include <chrono>
+#include <bits/chrono.h>
 
 namespace std _GLIBCXX_VISIBILITY(default)
 {
diff --git a/libstdc++-v3/include/bits/semaphore_base.h 
b/libstdc++-v3/include/bits/semaphore_base.h
index c4565d7e560..2c8d7576894 100644
--- a/libstdc++-v3/include/bits/semaphore_base.h
+++ b/libstdc++-v3/include/bits/semaphore_base.h
@@ -33,6 +33,7 @@
 #pragma GCC system_header
 
 #include <bits/atomic_base.h>
+#include <bits/chrono.h>
 #if __cpp_lib_atomic_wait
 #include <bits/atomic_timed_wait.h>
 #include <ext/numeric_traits.h>
@@ -45,9 +46,6 @@
 # include <semaphore.h>        // sem_t, sem_init, sem_wait, sem_post etc.
 #endif
 
-#include <chrono>
-#include <type_traits>
-
 namespace std _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
diff --git a/libstdc++-v3/include/bits/this_thread_sleep.h 
b/libstdc++-v3/include/bits/this_thread_sleep.h
index bdcd0cdeb77..0b95f51a109 100644
--- a/libstdc++-v3/include/bits/this_thread_sleep.h
+++ b/libstdc++-v3/include/bits/this_thread_sleep.h
@@ -33,9 +33,7 @@
 #pragma GCC system_header
 
 #if __cplusplus >= 201103L
-#include <bits/c++config.h>
-
-#include <chrono> // std::chrono::*
+#include <bits/chrono.h> // std::chrono::*
 
 #ifdef _GLIBCXX_USE_NANOSLEEP
 # include <cerrno>  // errno, EINTR
diff --git a/libstdc++-v3/include/bits/unique_lock.h 
b/libstdc++-v3/include/bits/unique_lock.h
index 07edfbbccb1..048bc273d98 100644
--- a/libstdc++-v3/include/bits/unique_lock.h
+++ b/libstdc++-v3/include/bits/unique_lock.h
@@ -36,7 +36,7 @@
 # include <bits/c++0x_warning.h>
 #else
 
-#include <chrono>
+#include <bits/chrono.h>
 #include <bits/move.h> // for std::swap
 #include <bits/std_mutex.h> // for std::defer_lock_t
 
diff --git a/libstdc++-v3/include/experimental/bits/fs_fwd.h 
b/libstdc++-v3/include/experimental/bits/fs_fwd.h
index 8d63e095be5..243e571a52a 100644
--- a/libstdc++-v3/include/experimental/bits/fs_fwd.h
+++ b/libstdc++-v3/include/experimental/bits/fs_fwd.h
@@ -36,7 +36,7 @@
 
 #include <system_error>
 #include <cstdint>
-#include <chrono>
+#include <bits/chrono.h>
 
 namespace std _GLIBCXX_VISIBILITY(default)
 {
diff --git a/libstdc++-v3/include/experimental/chrono 
b/libstdc++-v3/include/experimental/chrono
index a38cb521678..8d66174bf6d 100644
--- a/libstdc++-v3/include/experimental/chrono
+++ b/libstdc++-v3/include/experimental/chrono
@@ -38,7 +38,7 @@
 
 #if __cplusplus >= 201402L
 
-#include <chrono>
+#include <bits/chrono.h> // Only the C++14 parts of <chrono>
 #include <experimental/bits/lfts_config.h>
 
 namespace std _GLIBCXX_VISIBILITY(default)
diff --git a/libstdc++-v3/include/experimental/io_context 
b/libstdc++-v3/include/experimental/io_context
index 63d7db5b2d0..f0e2e326885 100644
--- a/libstdc++-v3/include/experimental/io_context
+++ b/libstdc++-v3/include/experimental/io_context
@@ -35,7 +35,6 @@
 #if __cplusplus >= 201402L
 
 #include <atomic>
-#include <chrono>
 #include <forward_list>
 #include <functional>
 #include <system_error>
@@ -43,6 +42,7 @@
 #include <vector>
 #include <experimental/netfwd>
 #include <experimental/executor>
+#include <bits/chrono.h>
 #if _GLIBCXX_HAVE_UNISTD_H
 # include <unistd.h>
 #endif
diff --git a/libstdc++-v3/include/experimental/netfwd 
b/libstdc++-v3/include/experimental/netfwd
index b3315985067..31b938c2118 100644
--- a/libstdc++-v3/include/experimental/netfwd
+++ b/libstdc++-v3/include/experimental/netfwd
@@ -37,7 +37,7 @@
 // #define __cpp_lib_experimental_net 201803
 // #define __cpp_lib_experimental_net_extensible 201803
 
-#include <chrono>
+#include <bits/chrono.h>
 
 namespace std _GLIBCXX_VISIBILITY(default)
 {
diff --git a/libstdc++-v3/include/experimental/timer 
b/libstdc++-v3/include/experimental/timer
index e28efa3f3f3..d947a586a0a 100644
--- a/libstdc++-v3/include/experimental/timer
+++ b/libstdc++-v3/include/experimental/timer
@@ -34,7 +34,7 @@
 
 #if __cplusplus >= 201402L
 
-#include <chrono>
+#include <bits/chrono.h>
 #include <system_error>
 #include <thread>
 #include <experimental/netfwd>
diff --git a/libstdc++-v3/include/std/chrono b/libstdc++-v3/include/std/chrono
index a3290546f16..c8060d7a67e 100644
--- a/libstdc++-v3/include/std/chrono
+++ b/libstdc++-v3/include/std/chrono
@@ -36,24 +36,12 @@
 # include <bits/c++0x_warning.h>
 #else
 
-#include <ratio>
-#include <type_traits>
-#include <limits>
-#include <ctime>
-#include <bits/parse_numbers.h> // for literals support.
-#if __cplusplus > 201703L
-# include <concepts>
-# include <compare>
-#endif
+#include <bits/chrono.h>
 
 namespace std _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
-#if __cplusplus >= 201703L
-  namespace filesystem { struct __file_clock; };
-#endif
-
   /**
    * @defgroup chrono Time
    * @ingroup utilities
@@ -69,1144 +57,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    */
   namespace chrono
   {
+#if __cplusplus >= 202002L
     /// @addtogroup chrono
     /// @{
-
-    /// `chrono::duration` represents a distance between two points in time
-    template<typename _Rep, typename _Period = ratio<1>>
-      struct duration;
-
-    /// `chrono::time_point` represents a point in time as measured by a clock
-    template<typename _Clock, typename _Dur = typename _Clock::duration>
-      struct time_point;
-    /// @}
-  }
-
-  /// @addtogroup chrono
-  /// @{
-
-  // 20.11.4.3 specialization of common_type (for duration, sfinae-friendly)
-
-  /// @cond undocumented
-
-  template<typename _CT, typename _Period1, typename _Period2, typename = void>
-    struct __duration_common_type
-    { };
-
-  template<typename _CT, typename _Period1, typename _Period2>
-    struct __duration_common_type<_CT, _Period1, _Period2,
-                                 __void_t<typename _CT::type>>
-    {
-    private:
-      using __gcd_num = __static_gcd<_Period1::num, _Period2::num>;
-      using __gcd_den = __static_gcd<_Period1::den, _Period2::den>;
-      using __cr = typename _CT::type;
-      using __r = ratio<__gcd_num::value,
-                       (_Period1::den / __gcd_den::value) * _Period2::den>;
-
-    public:
-      using type = chrono::duration<__cr, typename __r::type>;
-    };
-
-  /// @endcond
-
-  /// @{
-  /// @relates chrono::duration
-
-  /// Specialization of common_type for chrono::duration types.
-  template<typename _Rep1, typename _Period1, typename _Rep2, typename 
_Period2>
-    struct common_type<chrono::duration<_Rep1, _Period1>,
-                      chrono::duration<_Rep2, _Period2>>
-    : __duration_common_type<common_type<_Rep1, _Rep2>,
-                            typename _Period1::type,
-                            typename _Period2::type>
-    { };
-
-  /// Specialization of common_type for two identical chrono::duration types.
-  template<typename _Rep, typename _Period>
-    struct common_type<chrono::duration<_Rep, _Period>,
-                      chrono::duration<_Rep, _Period>>
-    {
-      using type = chrono::duration<typename common_type<_Rep>::type,
-                                   typename _Period::type>;
-    };
-
-  /// Specialization of common_type for one chrono::duration type.
-  template<typename _Rep, typename _Period>
-    struct common_type<chrono::duration<_Rep, _Period>>
-    {
-      using type = chrono::duration<typename common_type<_Rep>::type,
-                                   typename _Period::type>;
-    };
-  /// @}
-
-  // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly)
-
-  /// @cond undocumented
-
-  template<typename _CT, typename _Clock, typename = void>
-    struct __timepoint_common_type
-    { };
-
-  template<typename _CT, typename _Clock>
-    struct __timepoint_common_type<_CT, _Clock, __void_t<typename _CT::type>>
-    {
-      using type = chrono::time_point<_Clock, typename _CT::type>;
-    };
-
-  /// @endcond
-
-  /// @{
-  /// @relates chrono::time_point
-
-  /// Specialization of common_type for chrono::time_point types.
-  template<typename _Clock, typename _Duration1, typename _Duration2>
-    struct common_type<chrono::time_point<_Clock, _Duration1>,
-                      chrono::time_point<_Clock, _Duration2>>
-    : __timepoint_common_type<common_type<_Duration1, _Duration2>, _Clock>
-    { };
-
-  /// Specialization of common_type for two identical chrono::time_point types.
-  template<typename _Clock, typename _Duration>
-    struct common_type<chrono::time_point<_Clock, _Duration>,
-                      chrono::time_point<_Clock, _Duration>>
-    { using type = chrono::time_point<_Clock, _Duration>; };
-
-  /// Specialization of common_type for one chrono::time_point type.
-  template<typename _Clock, typename _Duration>
-    struct common_type<chrono::time_point<_Clock, _Duration>>
-    { using type = chrono::time_point<_Clock, _Duration>; };
-  /// @}
-
-  /// @} group chrono
-
-  namespace chrono
-  {
-    /// @addtogroup chrono
-    /// @{
-
-    /// @cond undocumented
-
-    // Primary template for duration_cast impl.
-    template<typename _ToDur, typename _CF, typename _CR,
-            bool _NumIsOne = false, bool _DenIsOne = false>
-      struct __duration_cast_impl
-      {
-       template<typename _Rep, typename _Period>
-         static constexpr _ToDur
-         __cast(const duration<_Rep, _Period>& __d)
-         {
-           typedef typename _ToDur::rep                        __to_rep;
-           return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count())
-             * static_cast<_CR>(_CF::num)
-             / static_cast<_CR>(_CF::den)));
-         }
-      };
-
-    template<typename _ToDur, typename _CF, typename _CR>
-      struct __duration_cast_impl<_ToDur, _CF, _CR, true, true>
-      {
-       template<typename _Rep, typename _Period>
-         static constexpr _ToDur
-         __cast(const duration<_Rep, _Period>& __d)
-         {
-           typedef typename _ToDur::rep                        __to_rep;
-           return _ToDur(static_cast<__to_rep>(__d.count()));
-         }
-      };
-
-    template<typename _ToDur, typename _CF, typename _CR>
-      struct __duration_cast_impl<_ToDur, _CF, _CR, true, false>
-      {
-       template<typename _Rep, typename _Period>
-         static constexpr _ToDur
-         __cast(const duration<_Rep, _Period>& __d)
-         {
-           typedef typename _ToDur::rep                        __to_rep;
-           return _ToDur(static_cast<__to_rep>(
-             static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den)));
-         }
-      };
-
-    template<typename _ToDur, typename _CF, typename _CR>
-      struct __duration_cast_impl<_ToDur, _CF, _CR, false, true>
-      {
-       template<typename _Rep, typename _Period>
-         static constexpr _ToDur
-         __cast(const duration<_Rep, _Period>& __d)
-         {
-           typedef typename _ToDur::rep                        __to_rep;
-           return _ToDur(static_cast<__to_rep>(
-             static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num)));
-         }
-      };
-
-    template<typename _Tp>
-      struct __is_duration
-      : std::false_type
-      { };
-
-    template<typename _Rep, typename _Period>
-      struct __is_duration<duration<_Rep, _Period>>
-      : std::true_type
-      { };
-
-    template<typename _Tp>
-      using __enable_if_is_duration
-       = typename enable_if<__is_duration<_Tp>::value, _Tp>::type;
-
-    template<typename _Tp>
-      using __disable_if_is_duration
-       = typename enable_if<!__is_duration<_Tp>::value, _Tp>::type;
-
-    /// @endcond
-
-    /// duration_cast
-    template<typename _ToDur, typename _Rep, typename _Period>
-      constexpr __enable_if_is_duration<_ToDur>
-      duration_cast(const duration<_Rep, _Period>& __d)
-      {
-       typedef typename _ToDur::period                         __to_period;
-       typedef typename _ToDur::rep                            __to_rep;
-       typedef ratio_divide<_Period, __to_period>              __cf;
-       typedef typename common_type<__to_rep, _Rep, intmax_t>::type
-                                                               __cr;
-       typedef  __duration_cast_impl<_ToDur, __cf, __cr,
-                                     __cf::num == 1, __cf::den == 1> __dc;
-       return __dc::__cast(__d);
-      }
-
-    /// treat_as_floating_point
-    template<typename _Rep>
-      struct treat_as_floating_point
-      : is_floating_point<_Rep>
-      { };
-
-#if __cplusplus > 201402L
-    template <typename _Rep>
-      inline constexpr bool treat_as_floating_point_v =
-        treat_as_floating_point<_Rep>::value;
-#endif // C++17
-
-#if __cplusplus > 201703L
-    template<typename _Tp>
-      struct is_clock;
-
-    template<typename _Tp>
-      inline constexpr bool is_clock_v = is_clock<_Tp>::value;
-
-#if __cpp_lib_concepts
-    template<typename _Tp>
-      struct is_clock : false_type
-      { };
-
-    template<typename _Tp>
-      requires requires {
-       typename _Tp::rep;
-       typename _Tp::period;
-       typename _Tp::duration;
-       typename _Tp::time_point::clock;
-       typename _Tp::time_point::duration;
-       { &_Tp::is_steady } -> same_as<const bool*>;
-       { _Tp::now() } -> same_as<typename _Tp::time_point>;
-       requires same_as<typename _Tp::duration,
-                        duration<typename _Tp::rep, typename _Tp::period>>;
-       requires same_as<typename _Tp::time_point::duration,
-                        typename _Tp::duration>;
-      }
-      struct is_clock<_Tp> : true_type
-      { };
-#else
-    template<typename _Tp, typename = void>
-      struct __is_clock_impl : false_type
-      { };
-
-    template<typename _Tp>
-      struct __is_clock_impl<_Tp,
-                            void_t<typename _Tp::rep, typename _Tp::period,
-                                   typename _Tp::duration,
-                                   typename _Tp::time_point::duration,
-                                   decltype(_Tp::is_steady),
-                                   decltype(_Tp::now())>>
-      : __and_<is_same<typename _Tp::duration,
-                      duration<typename _Tp::rep, typename _Tp::period>>,
-              is_same<typename _Tp::time_point::duration,
-                      typename _Tp::duration>,
-              is_same<decltype(&_Tp::is_steady), const bool*>,
-              is_same<decltype(_Tp::now()), typename _Tp::time_point>>::type
-      { };
-
-    template<typename _Tp>
-      struct is_clock : __is_clock_impl<_Tp>::type
-      { };
-#endif
-#endif // C++20
-
-#if __cplusplus >= 201703L
-# define __cpp_lib_chrono 201611
-
-    template<typename _ToDur, typename _Rep, typename _Period>
-      constexpr __enable_if_is_duration<_ToDur>
-      floor(const duration<_Rep, _Period>& __d)
-      {
-       auto __to = chrono::duration_cast<_ToDur>(__d);
-       if (__to > __d)
-         return __to - _ToDur{1};
-       return __to;
-      }
-
-    template<typename _ToDur, typename _Rep, typename _Period>
-      constexpr __enable_if_is_duration<_ToDur>
-      ceil(const duration<_Rep, _Period>& __d)
-      {
-       auto __to = chrono::duration_cast<_ToDur>(__d);
-       if (__to < __d)
-         return __to + _ToDur{1};
-       return __to;
-      }
-
-    template <typename _ToDur, typename _Rep, typename _Period>
-      constexpr enable_if_t<
-       __and_<__is_duration<_ToDur>,
-              __not_<treat_as_floating_point<typename _ToDur::rep>>>::value,
-       _ToDur>
-      round(const duration<_Rep, _Period>& __d)
-      {
-       _ToDur __t0 = chrono::floor<_ToDur>(__d);
-       _ToDur __t1 = __t0 + _ToDur{1};
-       auto __diff0 = __d - __t0;
-       auto __diff1 = __t1 - __d;
-       if (__diff0 == __diff1)
-       {
-           if (__t0.count() & 1)
-               return __t1;
-           return __t0;
-       }
-       else if (__diff0 < __diff1)
-           return __t0;
-       return __t1;
-      }
-
-    template<typename _Rep, typename _Period>
-      constexpr
-      enable_if_t<numeric_limits<_Rep>::is_signed, duration<_Rep, _Period>>
-      abs(duration<_Rep, _Period> __d)
-      {
-       if (__d >= __d.zero())
-         return __d;
-       return -__d;
-      }
-
-    // Make chrono::ceil<D> also usable as chrono::__detail::ceil<D>.
-    namespace __detail { using chrono::ceil; }
-
-#else // ! C++17
-
-    // We want to use ceil even when compiling for earlier standards versions.
-    // C++11 only allows a single statement in a constexpr function, so we
-    // need to move the comparison into a separate function, __ceil_impl.
-    namespace __detail
-    {
-      template<typename _Tp, typename _Up>
-       constexpr _Tp
-       __ceil_impl(const _Tp& __t, const _Up& __u)
-       {
-         return (__t < __u) ? (__t + _Tp{1}) : __t;
-       }
-
-      // C++11-friendly version of std::chrono::ceil<D> for internal use.
-      template<typename _ToDur, typename _Rep, typename _Period>
-       constexpr _ToDur
-       ceil(const duration<_Rep, _Period>& __d)
-       {
-         return __detail::__ceil_impl(chrono::duration_cast<_ToDur>(__d), __d);
-       }
-    }
-#endif // C++17
-
-    /// duration_values
-    template<typename _Rep>
-      struct duration_values
-      {
-       static constexpr _Rep
-       zero() noexcept
-       { return _Rep(0); }
-
-       static constexpr _Rep
-       max() noexcept
-       { return numeric_limits<_Rep>::max(); }
-
-       static constexpr _Rep
-       min() noexcept
-       { return numeric_limits<_Rep>::lowest(); }
-      };
-
-    /// @cond undocumented
-
-    template<typename _Tp>
-      struct __is_ratio
-      : std::false_type
-      { };
-
-    template<intmax_t _Num, intmax_t _Den>
-      struct __is_ratio<ratio<_Num, _Den>>
-      : std::true_type
-      { };
-
-    /// @endcond
-
-    template<typename _Rep, typename _Period>
-      struct duration
-      {
-      private:
-       template<typename _Rep2>
-         using __is_float = treat_as_floating_point<_Rep2>;
-
-       static constexpr intmax_t
-       _S_gcd(intmax_t __m, intmax_t __n) noexcept
-       {
-         // Duration only allows positive periods so we don't need to
-         // handle negative values here (unlike __static_gcd and std::gcd).
-#if __cplusplus >= 201402L
-         do
-           {
-             intmax_t __rem = __m % __n;
-             __m = __n;
-             __n = __rem;
-           }
-         while (__n != 0);
-         return __m;
-#else
-         // C++11 doesn't allow loops in constexpr functions, but this
-         // recursive version can be more expensive to evaluate.
-         return (__n == 0) ? __m : _S_gcd(__n, __m % __n);
-#endif
-       }
-
-       // _GLIBCXX_RESOLVE_LIB_DEFECTS
-       // 2094. overflow shouldn't participate in overload resolution
-       // 3090. What is [2094] intended to mean?
-       // This only produces a valid type if no overflow occurs.
-       template<typename _R1, typename _R2,
-                intmax_t __gcd1 = _S_gcd(_R1::num, _R2::num),
-                intmax_t __gcd2 = _S_gcd(_R1::den, _R2::den)>
-         using __divide = ratio<(_R1::num / __gcd1) * (_R2::den / __gcd2),
-                                (_R1::den / __gcd2) * (_R2::num / __gcd1)>;
-
-       // _Period2 is an exact multiple of _Period
-       template<typename _Period2>
-         using __is_harmonic
-           = __bool_constant<__divide<_Period2, _Period>::den == 1>;
-
-      public:
-
-       using rep = _Rep;
-       using period = typename _Period::type;
-
-       static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
-       static_assert(__is_ratio<_Period>::value,
-                     "period must be a specialization of ratio");
-       static_assert(_Period::num > 0, "period must be positive");
-
-       // 20.11.5.1 construction / copy / destroy
-       constexpr duration() = default;
-
-       duration(const duration&) = default;
-
-       // _GLIBCXX_RESOLVE_LIB_DEFECTS
-       // 3050. Conversion specification problem in chrono::duration
-       template<typename _Rep2, typename = _Require<
-                is_convertible<const _Rep2&, rep>,
-                __or_<__is_float<rep>, __not_<__is_float<_Rep2>>>>>
-         constexpr explicit duration(const _Rep2& __rep)
-         : __r(static_cast<rep>(__rep)) { }
-
-       template<typename _Rep2, typename _Period2, typename = _Require<
-                is_convertible<const _Rep2&, rep>,
-                __or_<__is_float<rep>,
-                      __and_<__is_harmonic<_Period2>,
-                             __not_<__is_float<_Rep2>>>>>>
-         constexpr duration(const duration<_Rep2, _Period2>& __d)
-         : __r(duration_cast<duration>(__d).count()) { }
-
-       ~duration() = default;
-       duration& operator=(const duration&) = default;
-
-       // 20.11.5.2 observer
-       constexpr rep
-       count() const
-       { return __r; }
-
-       // 20.11.5.3 arithmetic
-
-       constexpr duration<typename common_type<rep>::type, period>
-       operator+() const
-       { return duration<typename common_type<rep>::type, period>(__r); }
-
-       constexpr duration<typename common_type<rep>::type, period>
-       operator-() const
-       { return duration<typename common_type<rep>::type, period>(-__r); }
-
-       _GLIBCXX17_CONSTEXPR duration&
-       operator++()
-       {
-         ++__r;
-         return *this;
-       }
-
-       _GLIBCXX17_CONSTEXPR duration
-       operator++(int)
-       { return duration(__r++); }
-
-       _GLIBCXX17_CONSTEXPR duration&
-       operator--()
-       {
-         --__r;
-         return *this;
-       }
-
-       _GLIBCXX17_CONSTEXPR duration
-       operator--(int)
-       { return duration(__r--); }
-
-       _GLIBCXX17_CONSTEXPR duration&
-       operator+=(const duration& __d)
-       {
-         __r += __d.count();
-         return *this;
-       }
-
-       _GLIBCXX17_CONSTEXPR duration&
-       operator-=(const duration& __d)
-       {
-         __r -= __d.count();
-         return *this;
-       }
-
-       _GLIBCXX17_CONSTEXPR duration&
-       operator*=(const rep& __rhs)
-       {
-         __r *= __rhs;
-         return *this;
-       }
-
-       _GLIBCXX17_CONSTEXPR duration&
-       operator/=(const rep& __rhs)
-       {
-         __r /= __rhs;
-         return *this;
-       }
-
-       // DR 934.
-       template<typename _Rep2 = rep>
-         _GLIBCXX17_CONSTEXPR
-         typename enable_if<!treat_as_floating_point<_Rep2>::value,
-                            duration&>::type
-         operator%=(const rep& __rhs)
-         {
-           __r %= __rhs;
-           return *this;
-         }
-
-       template<typename _Rep2 = rep>
-         _GLIBCXX17_CONSTEXPR
-         typename enable_if<!treat_as_floating_point<_Rep2>::value,
-                            duration&>::type
-         operator%=(const duration& __d)
-         {
-           __r %= __d.count();
-           return *this;
-         }
-
-       // 20.11.5.4 special values
-       static constexpr duration
-       zero() noexcept
-       { return duration(duration_values<rep>::zero()); }
-
-       static constexpr duration
-       min() noexcept
-       { return duration(duration_values<rep>::min()); }
-
-       static constexpr duration
-       max() noexcept
-       { return duration(duration_values<rep>::max()); }
-
-      private:
-       rep __r;
-      };
-
-    /// @{
-    /// @relates std::chrono::duration
-
-    /// The sum of two durations.
-    template<typename _Rep1, typename _Period1,
-            typename _Rep2, typename _Period2>
-      constexpr typename common_type<duration<_Rep1, _Period1>,
-                                    duration<_Rep2, _Period2>>::type
-      operator+(const duration<_Rep1, _Period1>& __lhs,
-               const duration<_Rep2, _Period2>& __rhs)
-      {
-       typedef duration<_Rep1, _Period1>                       __dur1;
-       typedef duration<_Rep2, _Period2>                       __dur2;
-       typedef typename common_type<__dur1,__dur2>::type       __cd;
-       return __cd(__cd(__lhs).count() + __cd(__rhs).count());
-      }
-
-    /// The difference between two durations.
-    template<typename _Rep1, typename _Period1,
-            typename _Rep2, typename _Period2>
-      constexpr typename common_type<duration<_Rep1, _Period1>,
-                                    duration<_Rep2, _Period2>>::type
-      operator-(const duration<_Rep1, _Period1>& __lhs,
-               const duration<_Rep2, _Period2>& __rhs)
-      {
-       typedef duration<_Rep1, _Period1>                       __dur1;
-       typedef duration<_Rep2, _Period2>                       __dur2;
-       typedef typename common_type<__dur1,__dur2>::type       __cd;
-       return __cd(__cd(__lhs).count() - __cd(__rhs).count());
-      }
-
-    /// @}
-
-    /// @cond undocumented
-
-    // SFINAE helper to obtain common_type<_Rep1, _Rep2> only if _Rep2
-    // is implicitly convertible to it.
-    // _GLIBCXX_RESOLVE_LIB_DEFECTS
-    // 3050. Conversion specification problem in chrono::duration constructor
-    template<typename _Rep1, typename _Rep2,
-            typename _CRep = typename common_type<_Rep1, _Rep2>::type>
-      using __common_rep_t = typename
-       enable_if<is_convertible<const _Rep2&, _CRep>::value, _CRep>::type;
-
-    /// @endcond
-
-    /** @{
-     * Arithmetic operators for chrono::duration
-     * @relates std::chrono::duration
-     */
-
-    template<typename _Rep1, typename _Period, typename _Rep2>
-      constexpr duration<__common_rep_t<_Rep1, _Rep2>, _Period>
-      operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
-      {
-       typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
-         __cd;
-       return __cd(__cd(__d).count() * __s);
-      }
-
-    template<typename _Rep1, typename _Rep2, typename _Period>
-      constexpr duration<__common_rep_t<_Rep2, _Rep1>, _Period>
-      operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
-      { return __d * __s; }
-
-    template<typename _Rep1, typename _Period, typename _Rep2>
-      constexpr
-      duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period>
-      operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
-      {
-       typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
-         __cd;
-       return __cd(__cd(__d).count() / __s);
-      }
-
-    template<typename _Rep1, typename _Period1,
-            typename _Rep2, typename _Period2>
-      constexpr typename common_type<_Rep1, _Rep2>::type
-      operator/(const duration<_Rep1, _Period1>& __lhs,
-               const duration<_Rep2, _Period2>& __rhs)
-      {
-       typedef duration<_Rep1, _Period1>                       __dur1;
-       typedef duration<_Rep2, _Period2>                       __dur2;
-       typedef typename common_type<__dur1,__dur2>::type       __cd;
-       return __cd(__lhs).count() / __cd(__rhs).count();
-      }
-
-    // DR 934.
-    template<typename _Rep1, typename _Period, typename _Rep2>
-      constexpr
-      duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period>
-      operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
-      {
-       typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
-         __cd;
-       return __cd(__cd(__d).count() % __s);
-      }
-
-    template<typename _Rep1, typename _Period1,
-            typename _Rep2, typename _Period2>
-      constexpr typename common_type<duration<_Rep1, _Period1>,
-                                    duration<_Rep2, _Period2>>::type
-      operator%(const duration<_Rep1, _Period1>& __lhs,
-               const duration<_Rep2, _Period2>& __rhs)
-      {
-       typedef duration<_Rep1, _Period1>                       __dur1;
-       typedef duration<_Rep2, _Period2>                       __dur2;
-       typedef typename common_type<__dur1,__dur2>::type       __cd;
-       return __cd(__cd(__lhs).count() % __cd(__rhs).count());
-      }
-    /// @}
-
-    // comparisons
-
-    /** @{
-     * Comparisons for chrono::duration
-     * @relates std::chrono::duration
-     */
-
-    template<typename _Rep1, typename _Period1,
-            typename _Rep2, typename _Period2>
-      constexpr bool
-      operator==(const duration<_Rep1, _Period1>& __lhs,
-                const duration<_Rep2, _Period2>& __rhs)
-      {
-       typedef duration<_Rep1, _Period1>                       __dur1;
-       typedef duration<_Rep2, _Period2>                       __dur2;
-       typedef typename common_type<__dur1,__dur2>::type       __ct;
-       return __ct(__lhs).count() == __ct(__rhs).count();
-      }
-
-    template<typename _Rep1, typename _Period1,
-            typename _Rep2, typename _Period2>
-      constexpr bool
-      operator<(const duration<_Rep1, _Period1>& __lhs,
-               const duration<_Rep2, _Period2>& __rhs)
-      {
-       typedef duration<_Rep1, _Period1>                       __dur1;
-       typedef duration<_Rep2, _Period2>                       __dur2;
-       typedef typename common_type<__dur1,__dur2>::type       __ct;
-       return __ct(__lhs).count() < __ct(__rhs).count();
-      }
-
-#if __cpp_lib_three_way_comparison
-    template<typename _Rep1, typename _Period1,
-            typename _Rep2, typename _Period2>
-      requires three_way_comparable<common_type_t<_Rep1, _Rep2>>
-      constexpr auto
-      operator<=>(const duration<_Rep1, _Period1>& __lhs,
-                 const duration<_Rep2, _Period2>& __rhs)
-      {
-       using __ct = common_type_t<duration<_Rep1, _Period1>,
-                                  duration<_Rep2, _Period2>>;
-       return __ct(__lhs).count() <=> __ct(__rhs).count();
-      }
-#else
-    template<typename _Rep1, typename _Period1,
-            typename _Rep2, typename _Period2>
-      constexpr bool
-      operator!=(const duration<_Rep1, _Period1>& __lhs,
-                const duration<_Rep2, _Period2>& __rhs)
-      { return !(__lhs == __rhs); }
-#endif
-
-    template<typename _Rep1, typename _Period1,
-            typename _Rep2, typename _Period2>
-      constexpr bool
-      operator<=(const duration<_Rep1, _Period1>& __lhs,
-                const duration<_Rep2, _Period2>& __rhs)
-      { return !(__rhs < __lhs); }
-
-    template<typename _Rep1, typename _Period1,
-            typename _Rep2, typename _Period2>
-      constexpr bool
-      operator>(const duration<_Rep1, _Period1>& __lhs,
-               const duration<_Rep2, _Period2>& __rhs)
-      { return __rhs < __lhs; }
-
-    template<typename _Rep1, typename _Period1,
-            typename _Rep2, typename _Period2>
-      constexpr bool
-      operator>=(const duration<_Rep1, _Period1>& __lhs,
-                const duration<_Rep2, _Period2>& __rhs)
-      { return !(__lhs < __rhs); }
-
-    /// @}
-
-    /// @cond undocumented
-#ifdef _GLIBCXX_USE_C99_STDINT_TR1
-# define _GLIBCXX_CHRONO_INT64_T int64_t
-#elif defined __INT64_TYPE__
-# define _GLIBCXX_CHRONO_INT64_T __INT64_TYPE__
-#else
-    static_assert(std::numeric_limits<unsigned long long>::digits >= 64,
-       "Representation type for nanoseconds must have at least 64 bits");
-# define _GLIBCXX_CHRONO_INT64_T long long
-#endif
-    /// @endcond
-
-    /// nanoseconds
-    using nanoseconds  = duration<_GLIBCXX_CHRONO_INT64_T, nano>;
-
-    /// microseconds
-    using microseconds = duration<_GLIBCXX_CHRONO_INT64_T, micro>;
-
-    /// milliseconds
-    using milliseconds = duration<_GLIBCXX_CHRONO_INT64_T, milli>;
-
-    /// seconds
-    using seconds      = duration<_GLIBCXX_CHRONO_INT64_T>;
-
-    /// minutes
-    using minutes      = duration<_GLIBCXX_CHRONO_INT64_T, ratio< 60>>;
-
-    /// hours
-    using hours                = duration<_GLIBCXX_CHRONO_INT64_T, 
ratio<3600>>;
-
-#if __cplusplus > 201703L
-    /// days
-    using days         = duration<_GLIBCXX_CHRONO_INT64_T, ratio<86400>>;
-
-    /// weeks
-    using weeks                = duration<_GLIBCXX_CHRONO_INT64_T, 
ratio<604800>>;
-
-    /// years
-    using years                = duration<_GLIBCXX_CHRONO_INT64_T, 
ratio<31556952>>;
-
-    /// months
-    using months       = duration<_GLIBCXX_CHRONO_INT64_T, ratio<2629746>>;
-#endif // C++20
-
-#undef _GLIBCXX_CHRONO_INT64_T
-
-    template<typename _Clock, typename _Dur>
-      struct time_point
-      {
-       static_assert(__is_duration<_Dur>::value,
-           "duration must be a specialization of std::chrono::duration");
-
-       typedef _Clock                                          clock;
-       typedef _Dur                                            duration;
-       typedef typename duration::rep                          rep;
-       typedef typename duration::period                       period;
-
-       constexpr time_point() : __d(duration::zero())
-       { }
-
-       constexpr explicit time_point(const duration& __dur)
-       : __d(__dur)
-       { }
-
-       // conversions
-       template<typename _Dur2,
-                typename = _Require<is_convertible<_Dur2, _Dur>>>
-         constexpr time_point(const time_point<clock, _Dur2>& __t)
-         : __d(__t.time_since_epoch())
-         { }
-
-       // observer
-       constexpr duration
-       time_since_epoch() const
-       { return __d; }
-
-#if __cplusplus > 201703L
-       constexpr time_point&
-       operator++()
-       {
-         ++__d;
-         return *this;
-       }
-
-       constexpr time_point
-       operator++(int)
-       { return time_point{__d++}; }
-
-       constexpr time_point&
-       operator--()
-       {
-         --__d;
-         return *this;
-       }
-
-       constexpr time_point
-       operator--(int)
-       { return time_point{__d--}; }
-#endif
-
-       // arithmetic
-       _GLIBCXX17_CONSTEXPR time_point&
-       operator+=(const duration& __dur)
-       {
-         __d += __dur;
-         return *this;
-       }
-
-       _GLIBCXX17_CONSTEXPR time_point&
-       operator-=(const duration& __dur)
-       {
-         __d -= __dur;
-         return *this;
-       }
-
-       // special values
-       static constexpr time_point
-       min() noexcept
-       { return time_point(duration::min()); }
-
-       static constexpr time_point
-       max() noexcept
-       { return time_point(duration::max()); }
-
-      private:
-       duration __d;
-      };
-
-    /// time_point_cast
-    template<typename _ToDur, typename _Clock, typename _Dur>
-      constexpr typename enable_if<__is_duration<_ToDur>::value,
-                                  time_point<_Clock, _ToDur>>::type
-      time_point_cast(const time_point<_Clock, _Dur>& __t)
-      {
-       typedef time_point<_Clock, _ToDur>                      __time_point;
-       return __time_point(duration_cast<_ToDur>(__t.time_since_epoch()));
-      }
-
-#if __cplusplus > 201402L
-    template<typename _ToDur, typename _Clock, typename _Dur>
-      constexpr
-      enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>>
-      floor(const time_point<_Clock, _Dur>& __tp)
-      {
-       return time_point<_Clock, _ToDur>{
-           chrono::floor<_ToDur>(__tp.time_since_epoch())};
-      }
-
-    template<typename _ToDur, typename _Clock, typename _Dur>
-      constexpr
-      enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>>
-      ceil(const time_point<_Clock, _Dur>& __tp)
-      {
-       return time_point<_Clock, _ToDur>{
-           chrono::ceil<_ToDur>(__tp.time_since_epoch())};
-      }
-
-    template<typename _ToDur, typename _Clock, typename _Dur>
-      constexpr enable_if_t<
-       __and_<__is_duration<_ToDur>,
-              __not_<treat_as_floating_point<typename _ToDur::rep>>>::value,
-       time_point<_Clock, _ToDur>>
-      round(const time_point<_Clock, _Dur>& __tp)
-      {
-       return time_point<_Clock, _ToDur>{
-           chrono::round<_ToDur>(__tp.time_since_epoch())};
-      }
-#endif // C++17
-
-    /// @{
-    /// @relates time_point
-
-    /// Adjust a time point forwards by the given duration.
-    template<typename _Clock, typename _Dur1,
-            typename _Rep2, typename _Period2>
-      constexpr time_point<_Clock,
-       typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
-      operator+(const time_point<_Clock, _Dur1>& __lhs,
-               const duration<_Rep2, _Period2>& __rhs)
-      {
-       typedef duration<_Rep2, _Period2>                       __dur2;
-       typedef typename common_type<_Dur1,__dur2>::type        __ct;
-       typedef time_point<_Clock, __ct>                        __time_point;
-       return __time_point(__lhs.time_since_epoch() + __rhs);
-      }
-
-    /// Adjust a time point forwards by the given duration.
-    template<typename _Rep1, typename _Period1,
-            typename _Clock, typename _Dur2>
-      constexpr time_point<_Clock,
-       typename common_type<duration<_Rep1, _Period1>, _Dur2>::type>
-      operator+(const duration<_Rep1, _Period1>& __lhs,
-               const time_point<_Clock, _Dur2>& __rhs)
-      {
-       typedef duration<_Rep1, _Period1>                       __dur1;
-       typedef typename common_type<__dur1,_Dur2>::type        __ct;
-       typedef time_point<_Clock, __ct>                        __time_point;
-       return __time_point(__rhs.time_since_epoch() + __lhs);
-      }
-
-    /// Adjust a time point backwards by the given duration.
-    template<typename _Clock, typename _Dur1,
-            typename _Rep2, typename _Period2>
-      constexpr time_point<_Clock,
-       typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
-      operator-(const time_point<_Clock, _Dur1>& __lhs,
-               const duration<_Rep2, _Period2>& __rhs)
-      {
-       typedef duration<_Rep2, _Period2>                       __dur2;
-       typedef typename common_type<_Dur1,__dur2>::type        __ct;
-       typedef time_point<_Clock, __ct>                        __time_point;
-       return __time_point(__lhs.time_since_epoch() -__rhs);
-      }
-
-    /// The difference between two time points (as a duration)
-    template<typename _Clock, typename _Dur1, typename _Dur2>
-      constexpr typename common_type<_Dur1, _Dur2>::type
-      operator-(const time_point<_Clock, _Dur1>& __lhs,
-               const time_point<_Clock, _Dur2>& __rhs)
-      { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }
-    /// @}
-
-    /** @{
-     * Comparisons for time_point
-     * @relates chrono::time_point
-     */
-
-    template<typename _Clock, typename _Dur1, typename _Dur2>
-      constexpr bool
-      operator==(const time_point<_Clock, _Dur1>& __lhs,
-                const time_point<_Clock, _Dur2>& __rhs)
-      { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }
-
-#if __cpp_lib_three_way_comparison
-    template<typename _Clock, typename _Dur1,
-            three_way_comparable_with<_Dur1> _Dur2>
-      constexpr auto
-      operator<=>(const time_point<_Clock, _Dur1>& __lhs,
-                 const time_point<_Clock, _Dur2>& __rhs)
-      { return __lhs.time_since_epoch() <=> __rhs.time_since_epoch(); }
-#else
-    template<typename _Clock, typename _Dur1, typename _Dur2>
-      constexpr bool
-      operator!=(const time_point<_Clock, _Dur1>& __lhs,
-                const time_point<_Clock, _Dur2>& __rhs)
-      { return !(__lhs == __rhs); }
-#endif
-
-    template<typename _Clock, typename _Dur1, typename _Dur2>
-      constexpr bool
-      operator<(const time_point<_Clock, _Dur1>& __lhs,
-               const time_point<_Clock, _Dur2>& __rhs)
-      { return  __lhs.time_since_epoch() < __rhs.time_since_epoch(); }
-
-    template<typename _Clock, typename _Dur1, typename _Dur2>
-      constexpr bool
-      operator<=(const time_point<_Clock, _Dur1>& __lhs,
-                const time_point<_Clock, _Dur2>& __rhs)
-      { return !(__rhs < __lhs); }
-
-    template<typename _Clock, typename _Dur1, typename _Dur2>
-      constexpr bool
-      operator>(const time_point<_Clock, _Dur1>& __lhs,
-               const time_point<_Clock, _Dur2>& __rhs)
-      { return __rhs < __lhs; }
-
-    template<typename _Clock, typename _Dur1, typename _Dur2>
-      constexpr bool
-      operator>=(const time_point<_Clock, _Dur1>& __lhs,
-                const time_point<_Clock, _Dur2>& __rhs)
-      { return !(__lhs < __rhs); }
-
-    /// @}
-
-    // Clocks.
-
-    // Why nanosecond resolution as the default?
-    // Why have std::system_clock always count in the highest
-    // resolution (ie nanoseconds), even if on some OSes the low 3
-    // or 9 decimal digits will be always zero? This allows later
-    // implementations to change the system_clock::now()
-    // implementation any time to provide better resolution without
-    // changing function signature or units.
-
-    // To support the (forward) evolution of the library's defined
-    // clocks, wrap inside inline namespace so that the current
-    // defintions of system_clock, steady_clock, and
-    // high_resolution_clock types are uniquely mangled. This way, new
-    // code can use the latests clocks, while the library can contain
-    // compatibility definitions for previous versions.  At some
-    // point, when these clocks settle down, the inlined namespaces
-    // can be removed.  XXX GLIBCXX_ABI Deprecated
-    inline namespace _V2 {
-
-    /**
-     *  @brief System clock.
-     *
-     *  Time returned represents wall time from the system-wide clock.
-     *  @ingroup chrono
-    */
-    struct system_clock
-    {
-      typedef chrono::nanoseconds                              duration;
-      typedef duration::rep                                    rep;
-      typedef duration::period                                 period;
-      typedef chrono::time_point<system_clock, duration>       time_point;
-
-      static_assert(system_clock::duration::min()
-                   < system_clock::duration::zero(),
-                   "a clock's minimum duration cannot be less than its epoch");
-
-      static constexpr bool is_steady = false;
-
-      static time_point
-      now() noexcept;
-
-      // Map to C API
-      static std::time_t
-      to_time_t(const time_point& __t) noexcept
-      {
-       return std::time_t(duration_cast<chrono::seconds>
-                          (__t.time_since_epoch()).count());
-      }
-
-      static time_point
-      from_time_t(std::time_t __t) noexcept
-      {
-       typedef chrono::time_point<system_clock, seconds>       __from;
-       return time_point_cast<system_clock::duration>
-              (__from(chrono::seconds(__t)));
-      }
-    };
-
-
-    /**
-     *  @brief Monotonic clock
-     *
-     *  Time returned has the property of only increasing at a uniform rate.
-     *  @ingroup chrono
-    */
-    struct steady_clock
-    {
-      typedef chrono::nanoseconds                              duration;
-      typedef duration::rep                                    rep;
-      typedef duration::period                                 period;
-      typedef chrono::time_point<steady_clock, duration>       time_point;
-
-      static constexpr bool is_steady = true;
-
-      static time_point
-      now() noexcept;
-    };
-
-
-    /**
-     *  @brief Highest-resolution clock
-     *
-     *  This is the clock "with the shortest tick period." Alias to
-     *  std::system_clock until higher-than-nanosecond definitions
-     *  become feasible.
-     *  @ingroup chrono
-    */
-    using high_resolution_clock = system_clock;
-
-    } // end inline namespace _V2
-
-#if __cplusplus > 201703L
-    template<typename _Duration>
-      using sys_time = time_point<system_clock, _Duration>;
-    using sys_seconds = sys_time<seconds>;
-    using sys_days = sys_time<days>;
-
-    using file_clock = ::std::filesystem::__file_clock;
-
-    template<typename _Duration>
-      using file_time = time_point<file_clock, _Duration>;
-
-    template<> struct is_clock<system_clock> : true_type { };
-    template<> struct is_clock<steady_clock> : true_type { };
-    template<> struct is_clock<file_clock> : true_type { };
-
-    template<> inline constexpr bool is_clock_v<system_clock> = true;
-    template<> inline constexpr bool is_clock_v<steady_clock> = true;
-    template<> inline constexpr bool is_clock_v<file_clock> = true;
-
     struct local_t { };
     template<typename _Duration>
       using local_time = time_point<local_t, _Duration>;
@@ -3157,150 +2010,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        chrono::seconds _M_s;
        precision _M_ss;
       };
-#endif // C++20
-
-    /// @} group chrono
-  } // namespace chrono
-
-#if __cplusplus > 201103L
-
-#define __cpp_lib_chrono_udls 201304
-
-  inline namespace literals
-  {
-  /** ISO C++ 2014  namespace for suffixes for duration literals.
-   *
-   * These suffixes can be used to create `chrono::duration` values with
-   * tick periods of hours, minutes, seconds, milliseconds, microseconds
-   * or nanoseconds. For example, `std::chrono::seconds(5)` can be written
-   * as `5s` after making the suffix visible in the current scope.
-   * The suffixes can be made visible by a using-directive or
-   * using-declaration such as:
-   *  - `using namespace std::chrono_literals;`
-   *  - `using namespace std::literals;`
-   *  - `using namespace std::chrono;`
-   *  - `using namespace std;`
-   *  - `using std::chrono_literals::operator""s;`
-   *
-   * The result of these suffixes on an integer literal is one of the
-   * standard typedefs such as `std::chrono::hours`.
-   * The result on a floating-point literal is a duration type with the
-   * specified tick period and an unspecified floating-point representation,
-   * for example `1.5e2ms` might be equivalent to
-   * `chrono::duration<long double, chrono::milli>(1.5e2)`.
-   *
-   * @ingroup chrono
-   */
-  inline namespace chrono_literals
-  {
-    /// @addtogroup chrono
-    /// @{
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wliteral-suffix"
-    /// @cond undocumented
-    template<typename _Dur, char... _Digits>
-      constexpr _Dur __check_overflow()
-      {
-       using _Val = __parse_int::_Parse_int<_Digits...>;
-       constexpr typename _Dur::rep __repval = _Val::value;
-       static_assert(__repval >= 0 && __repval == _Val::value,
-                     "literal value cannot be represented by duration type");
-       return _Dur(__repval);
-      }
-    /// @endcond
-
-    /// Literal suffix for durations representing non-integer hours
-    constexpr chrono::duration<long double, ratio<3600,1>>
-    operator""h(long double __hours)
-    { return chrono::duration<long double, ratio<3600,1>>{__hours}; }
-
-    /// Literal suffix for durations of type `std::chrono::hours`
-    template <char... _Digits>
-      constexpr chrono::hours
-      operator""h()
-      { return __check_overflow<chrono::hours, _Digits...>(); }
-
-    /// Literal suffix for durations representing non-integer minutes
-    constexpr chrono::duration<long double, ratio<60,1>>
-    operator""min(long double __mins)
-    { return chrono::duration<long double, ratio<60,1>>{__mins}; }
-
-    /// Literal suffix for durations of type `std::chrono::minutes`
-    template <char... _Digits>
-      constexpr chrono::minutes
-      operator""min()
-      { return __check_overflow<chrono::minutes, _Digits...>(); }
-
-    /// Literal suffix for durations representing non-integer seconds
-    constexpr chrono::duration<long double>
-    operator""s(long double __secs)
-    { return chrono::duration<long double>{__secs}; }
-
-    /// Literal suffix for durations of type `std::chrono::seconds`
-    template <char... _Digits>
-      constexpr chrono::seconds
-      operator""s()
-      { return __check_overflow<chrono::seconds, _Digits...>(); }
-
-    /// Literal suffix for durations representing non-integer milliseconds
-    constexpr chrono::duration<long double, milli>
-    operator""ms(long double __msecs)
-    { return chrono::duration<long double, milli>{__msecs}; }
-
-    /// Literal suffix for durations of type `std::chrono::milliseconds`
-    template <char... _Digits>
-      constexpr chrono::milliseconds
-      operator""ms()
-      { return __check_overflow<chrono::milliseconds, _Digits...>(); }
-
-    /// Literal suffix for durations representing non-integer microseconds
-    constexpr chrono::duration<long double, micro>
-    operator""us(long double __usecs)
-    { return chrono::duration<long double, micro>{__usecs}; }
-
-    /// Literal suffix for durations of type `std::chrono::microseconds`
-    template <char... _Digits>
-      constexpr chrono::microseconds
-      operator""us()
-      { return __check_overflow<chrono::microseconds, _Digits...>(); }
-
-    /// Literal suffix for durations representing non-integer nanoseconds
-    constexpr chrono::duration<long double, nano>
-    operator""ns(long double __nsecs)
-    { return chrono::duration<long double, nano>{__nsecs}; }
-
-    /// Literal suffix for durations of type `std::chrono::nanoseconds`
-    template <char... _Digits>
-      constexpr chrono::nanoseconds
-      operator""ns()
-      { return __check_overflow<chrono::nanoseconds, _Digits...>(); }
-
-#if __cplusplus > 201703L
-    constexpr chrono::day
-    operator""d(unsigned long long __d) noexcept
-    { return chrono::day{static_cast<unsigned>(__d)}; }
-
-    constexpr chrono::year
-    operator""y(unsigned long long __y) noexcept
-    { return chrono::year{static_cast<int>(__y)}; }
-#endif // C++20
-
-#pragma GCC diagnostic pop
-    /// @}
-  } // inline namespace chrono_literals
-  } // inline namespace literals
-
-  namespace chrono
-  {
-    using namespace literals::chrono_literals;
-  } // namespace chrono
-
-#if __cplusplus > 201703L
-  namespace chrono
-  {
-    /// @addtogroup chrono
-    /// @{
 
     // 12/24 HOURS FUNCTIONS
 
@@ -3341,71 +2050,34 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        }
     }
     /// @} group chrono
-  } // namespace chrono
-#endif
-
-#if __cplusplus >= 201703L
-  namespace filesystem
-  {
-    struct __file_clock
-    {
-      using duration                  = chrono::nanoseconds;
-      using rep                       = duration::rep;
-      using period                    = duration::period;
-      using time_point                = chrono::time_point<__file_clock>;
-      static constexpr bool is_steady = false;
-
-      static time_point
-      now() noexcept
-      { return _S_from_sys(chrono::system_clock::now()); }
-
-#if __cplusplus > 201703L
-      template<typename _Dur>
-       static
-       chrono::file_time<_Dur>
-       from_sys(const chrono::sys_time<_Dur>& __t) noexcept
-       { return _S_from_sys(__t); }
-
-      // For internal use only
-      template<typename _Dur>
-       static
-       chrono::sys_time<_Dur>
-       to_sys(const chrono::file_time<_Dur>& __t) noexcept
-       { return _S_to_sys(__t); }
 #endif // C++20
+  } // namespace chrono
 
-    private:
-      using __sys_clock = chrono::system_clock;
+#if __cplusplus >= 202002L
+  inline namespace literals
+  {
+  inline namespace chrono_literals
+  {
+    /// @addtogroup chrono
+    /// @{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wliteral-suffix"
+    /// Literal suffix for creating chrono::day objects.
+    /// @since C++20
+    constexpr chrono::day
+    operator""d(unsigned long long __d) noexcept
+    { return chrono::day{static_cast<unsigned>(__d)}; }
 
-      // This clock's (unspecified) epoch is 2174-01-01 00:00:00 UTC.
-      // A signed 64-bit duration with nanosecond resolution gives roughly
-      // +/- 292 years, which covers the 1901-2446 date range for ext4.
-      static constexpr chrono::seconds _S_epoch_diff{6437664000};
-
-    protected:
-      // For internal use only
-      template<typename _Dur>
-       static
-       chrono::time_point<__file_clock, _Dur>
-       _S_from_sys(const chrono::time_point<__sys_clock, _Dur>& __t) noexcept
-       {
-         using __file_time = chrono::time_point<__file_clock, _Dur>;
-         return __file_time{__t.time_since_epoch()} - _S_epoch_diff;
-       }
-
-      // For internal use only
-      template<typename _Dur>
-       static
-       chrono::time_point<__sys_clock, _Dur>
-       _S_to_sys(const chrono::time_point<__file_clock, _Dur>& __t) noexcept
-       {
-         using __sys_time = chrono::time_point<__sys_clock, _Dur>;
-         return __sys_time{__t.time_since_epoch()} + _S_epoch_diff;
-       }
-    };
-  } // namespace filesystem
-#endif // C++17
-#endif // C++14
+    /// Literal suffix for creating chrono::year objects.
+    /// @since C++20
+    constexpr chrono::year
+    operator""y(unsigned long long __y) noexcept
+    { return chrono::year{static_cast<int>(__y)}; }
+#pragma GCC diagnostic pop
+    /// @}
+  } // inline namespace chrono_literals
+  } // inline namespace literals
+#endif // C++20
 
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace std
diff --git a/libstdc++-v3/include/std/condition_variable 
b/libstdc++-v3/include/std/condition_variable
index fb9b7d3f027..4fcec6aa73d 100644
--- a/libstdc++-v3/include/std/condition_variable
+++ b/libstdc++-v3/include/std/condition_variable
@@ -35,8 +35,7 @@
 # include <bits/c++0x_warning.h>
 #else
 
-#include <chrono>
-
+#include <bits/chrono.h>
 #include <bits/std_mutex.h>
 #include <bits/unique_lock.h>
 #include <bits/alloc_traits.h>
diff --git a/libstdc++-v3/include/std/mutex b/libstdc++-v3/include/std/mutex
index 7ab4ee12690..12918fd19e7 100644
--- a/libstdc++-v3/include/std/mutex
+++ b/libstdc++-v3/include/std/mutex
@@ -36,10 +36,10 @@
 #else
 
 #include <tuple>
-#include <chrono>
 #include <exception>
 #include <type_traits>
 #include <system_error>
+#include <bits/chrono.h>
 #include <bits/std_mutex.h>
 #include <bits/unique_lock.h>
 #if ! _GTHREAD_USE_MUTEX_TIMEDLOCK
diff --git a/libstdc++-v3/include/std/shared_mutex 
b/libstdc++-v3/include/std/shared_mutex
index edf6dcd0a3e..4611a108203 100644
--- a/libstdc++-v3/include/std/shared_mutex
+++ b/libstdc++-v3/include/std/shared_mutex
@@ -33,7 +33,7 @@
 
 #if __cplusplus >= 201402L
 
-#include <chrono>
+#include <bits/chrono.h>
 #include <bits/functexcept.h>
 #include <bits/move.h>        // move, __exchange
 #include <bits/std_mutex.h>   // defer_lock_t