chrono_io.h

Go to the documentation of this file.

// <chrono> Formatting -*- C++ -*-
 
// Copyright The GNU Toolchain Authors.
//
// 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_io.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{chrono}
 */
 
#ifndef _GLIBCXX_CHRONO_IO_H
#define _GLIBCXX_CHRONO_IO_H 1
 
#ifdef _GLIBCXX_SYSHDR
#pragma GCC system_header
#endif
 
#if __cplusplus >= 202002L
 
#include <sstream> // ostringstream
#include <format>
#include <charconv> // from_chars
#include <stdexcept> // __sso_string
 
#include <bits/streambuf_iterator.h>
#include <bits/unique_ptr.h>
 
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
 
namespace chrono
{
/// @addtogroup chrono
/// @{
 
/// @cond undocumented
namespace __detail
{
#define _GLIBCXX_WIDEN_(C, S) ::std::__format::_Widen<C>(S, L##S)
#define _GLIBCXX_WIDEN(S) _GLIBCXX_WIDEN_(_CharT, S)
 
  template<typename _Period, typename _CharT>
    constexpr basic_string_view<_CharT>
    __units_suffix() noexcept
    {
      // The standard say these are all narrow strings, which would need to
      // be widened at run-time when inserted into a wide stream. We use
      // STATICALLY-WIDEN to widen at compile-time.
#define _GLIBCXX_UNITS_SUFFIX(period, suffix) \
    if constexpr (is_same_v<_Period, period>) \
      return _GLIBCXX_WIDEN(suffix);          \
    else
 
      _GLIBCXX_UNITS_SUFFIX(atto,  "as")
      _GLIBCXX_UNITS_SUFFIX(femto, "fs")
      _GLIBCXX_UNITS_SUFFIX(pico,  "ps")
      _GLIBCXX_UNITS_SUFFIX(nano,  "ns")
      _GLIBCXX_UNITS_SUFFIX(milli, "ms")
#if _GLIBCXX_USE_ALT_MICROSECONDS_SUFFIX
      // Deciding this at compile-time is wrong, maybe use nl_langinfo(CODESET)
      // to check runtime environment and return u8"\u00b5s", "\xb5s", or "us".
      _GLIBCXX_UNITS_SUFFIX(micro, "\u00b5s")
#else
      _GLIBCXX_UNITS_SUFFIX(micro, "us")
#endif
      _GLIBCXX_UNITS_SUFFIX(centi, "cs")
      _GLIBCXX_UNITS_SUFFIX(deci,  "ds")
      _GLIBCXX_UNITS_SUFFIX(ratio<1>, "s")
      _GLIBCXX_UNITS_SUFFIX(deca,  "das")
      _GLIBCXX_UNITS_SUFFIX(hecto, "hs")
      _GLIBCXX_UNITS_SUFFIX(kilo,  "ks")
      _GLIBCXX_UNITS_SUFFIX(mega,  "Ms")
      _GLIBCXX_UNITS_SUFFIX(giga,  "Gs")
      _GLIBCXX_UNITS_SUFFIX(tera,  "Ts")
      _GLIBCXX_UNITS_SUFFIX(tera,  "Ts")
      _GLIBCXX_UNITS_SUFFIX(peta,  "Ps")
      _GLIBCXX_UNITS_SUFFIX(exa,   "Es")
      _GLIBCXX_UNITS_SUFFIX(ratio<60>,    "min")
      _GLIBCXX_UNITS_SUFFIX(ratio<3600>,  "h")
      _GLIBCXX_UNITS_SUFFIX(ratio<86400>, "d")
#undef _GLIBCXX_UNITS_SUFFIX
        return {};
    }
 
  template<typename _Period, typename _CharT, typename _Out>
    inline _Out
    __fmt_units_suffix(_Out __out) noexcept
    {
      if (auto __s = __detail::__units_suffix<_Period, _CharT>(); __s.size())
        return __format::__write(std::move(__out), __s);
      else if constexpr (_Period::den == 1)
        return std::format_to(std::move(__out), _GLIBCXX_WIDEN("[{}]s"),
                              (uintmax_t)_Period::num);
      else
        return std::format_to(std::move(__out), _GLIBCXX_WIDEN("[{}/{}]s"),
                              (uintmax_t)_Period::num,
                              (uintmax_t)_Period::den);
    }
} // namespace __detail
/// @endcond
 
  /** Write a `chrono::duration` to an ostream.
   *
   * @since C++20
   */
  template<typename _CharT, typename _Traits,
           typename _Rep, typename _Period>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
               const duration<_Rep, _Period>& __d)
    {
      using _Out = ostreambuf_iterator<_CharT, _Traits>;
      using period = typename _Period::type;
      std::basic_ostringstream<_CharT, _Traits> __s;
      __s.flags(__os.flags());
      __s.imbue(__os.getloc());
      __s.precision(__os.precision());
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 4118. How should duration formatters format custom rep types?
      __s << +__d.count();
      __detail::__fmt_units_suffix<period, _CharT>(_Out(__s));
      __os << std::move(__s).str();
      return __os;
    }
 
/// @cond undocumented
namespace __detail
{
  // An unspecified type returned by `chrono::local_time_format`.
  // This is called `local-time-format-t` in the standard.
  template<typename _Duration>
    struct __local_time_fmt
    {
      local_time<_Duration> _M_time;
      const string* _M_abbrev;
      const seconds* _M_offset_sec;
    };
 
  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 4124. Cannot format zoned_time with resolution coarser than seconds
  template<typename _Duration>
    using __local_time_fmt_for
      = __local_time_fmt<common_type_t<_Duration, seconds>>;
}
/// @endcond
 
  /** Return an object that asssociates timezone info with a local time.
   *
   * A `chrono::local_time` object has no timezone associated with it. This
   * function creates an object that allows formatting a `local_time` as
   * though it refers to a timezone with the given abbreviated name and
   * offset from UTC.
   *
   * @since C++20
   */
  template<typename _Duration>
    inline __detail::__local_time_fmt<_Duration>
    local_time_format(local_time<_Duration> __time,
                      const string* __abbrev = nullptr,
                      const seconds* __offset_sec = nullptr)
    { return {__time, __abbrev, __offset_sec}; }
 
  /// @}
} // namespace chrono
 
/// @cond undocumented
namespace __format
{
  [[noreturn,__gnu__::__always_inline__]]
  inline void
  __not_valid_for_duration()
  { __throw_format_error("format error: chrono-format-spec not valid for "
                         "chrono::duration"); }
 
  [[noreturn,__gnu__::__always_inline__]]
  inline void
  __invalid_chrono_spec()
  { __throw_format_error("format error: chrono-format-spec not valid for "
                         "argument type"); }
 
  // Represents the information provided by a chrono type.
  // e.g. month_weekday has month and weekday but no year or time of day,
  // hh_mm_ss has time of day but no date, sys_time is time_point+timezone.
  enum class _ChronoParts : unsigned short {
    _None = 0, _TotalSeconds = 1u, _Subseconds = 1u << 2,
 
    // time since epoch
    _EpochUnits = 1u << 3, _UnitSuffix = 1u << 4,
    _EpochSeconds = _EpochUnits | _TotalSeconds,
 
    // local (wall) time
    _LocalDays = 1u << 5,
    _LocalSeconds = _LocalDays | _TotalSeconds,
 
    _Year = 1u << 6, _Month = 1u << 7, _Day = 1u << 8,
    _Weekday = 1u << 9, _WeekdayIndex = 1u << 10,  _DayOfYear = 1u << 11,
    _IndexedWeekday = _Weekday | _WeekdayIndex,
    _YearMonthDay = _Year | _Month | _Day,
    _Date = _LocalDays | _YearMonthDay | _IndexedWeekday | _DayOfYear,
 
    _HoursMinutesSeconds = 1u << 12,
    _TimeOfDay = _HoursMinutesSeconds | _Subseconds,
    _Time = _TimeOfDay | _TotalSeconds,
    _EpochTime = _Time | _EpochUnits | _UnitSuffix,
    _DateTime = _Date | _Time,
 
    _ZoneAbbrev = 1u << 13, _ZoneOffset = 1u << 14,
    _TimeZone = _ZoneAbbrev | _ZoneOffset,
    _ZonedDateTime = _DateTime | _TimeZone,
  };
 
  [[__gnu__::__always_inline__]]
  constexpr _ChronoParts
  operator&(_ChronoParts __x, _ChronoParts __y) noexcept
  { return static_cast<_ChronoParts>((unsigned)__x & (unsigned)__y); }
 
  [[__gnu__::__always_inline__]]
  constexpr _ChronoParts&
  operator&=(_ChronoParts& __x, _ChronoParts __y) noexcept
  { return __x = __x & __y; }
 
  [[__gnu__::__always_inline__]]
  constexpr _ChronoParts
  operator|(_ChronoParts __x, _ChronoParts __y) noexcept
  { return static_cast<_ChronoParts>((unsigned short)__x | (unsigned short)__y); }
 
  [[__gnu__::__always_inline__]]
  constexpr _ChronoParts&
  operator|=(_ChronoParts& __x, _ChronoParts __y) noexcept
  { return __x = __x | __y; }
 
  // returns copy of x with all bits from y unset.
  [[__gnu__::__always_inline__]]
  constexpr _ChronoParts
  operator-(_ChronoParts __x, _ChronoParts __y) noexcept
  { return static_cast<_ChronoParts>((unsigned short)__x & ~(unsigned short)__y); }
 
  // unsets all bits of x that are set in y
  [[__gnu__::__always_inline__]]
  constexpr _ChronoParts&
  operator-=(_ChronoParts& __x, _ChronoParts __y) noexcept
  { return __x = __x - __y; }
 
  [[__gnu__::__always_inline__]]
  constexpr bool
  operator==(_ChronoParts __x, decltype(nullptr)) noexcept
  { return (unsigned short)__x == 0; }
 
  template<typename _CharT>
    struct _ChronoSpec : _Spec<_CharT>
    {
      // When _M_prec_kind is _WP_none, the _M_prec contains the default
      // value of fraction digits to be used for time '%S'.
 
      // Placed in tail-padding of __format::_Spec<C>.
      // This indicates that a locale-dependent conversion specifier such as
      // %a is used in the chrono-specs. This is not the same as the
      // _Spec<C>::_M_localized member which indicates that "L" was present
      // in the format-spec, e.g. "{:L%a}" is localized and locale-specific,
      // but "{:L}" is only localized and "{:%a}" is only locale-specific.
      unsigned _M_locale_specific : 1;
      // Indicates if parts that are checked for ok come directly from the
      // input, instead of being computed.
      unsigned _M_needs_ok_check : 1;
      // Indicates that duration should be treated as floating point.
      unsigned _M_floating_point_rep : 1;
      // Indicate that duration uses user-defined representation.
      unsigned _M_custom_rep : 1;
      unsigned _M_unused : 4;
 
      // Chrono parts required by format specs
      _ChronoParts _M_needed;
      basic_string_view<_CharT> _M_chrono_specs;
 
      [[__gnu__::__always_inline__]]
      constexpr bool
      _M_needs(_ChronoParts __parts) const
      { return (_M_needed & __parts) != 0; }
    };
 
  template<typename _CharT>
  struct _ChronoFormats
  {
    using _String_view = basic_string_view<_CharT>;
 
    static consteval
    _String_view
    _S_ftz() noexcept
    { return _GLIBCXX_WIDEN("%F %T %Z"); }
 
    static consteval
    _String_view
    _S_ft() noexcept
    { return _S_ftz().substr(0, 5); }
 
    static consteval
    _String_view
    _S_f() noexcept
    { return _S_ftz().substr(0, 2); }
 
    static consteval
    _String_view
    _S_t() noexcept
    { return _S_ftz().substr(3, 2); }
 
    static consteval
    _String_view
    _S_ymd() noexcept
    { return _GLIBCXX_WIDEN("%Y/%b/%d"); }
 
    static consteval
    _String_view
    _S_ym() noexcept
    { return _S_ymd().substr(0, 5); }
 
    static consteval
    _String_view
    _S_md() noexcept
    { return _S_ymd().substr(3); }
 
    static consteval
    _String_view
    _S_y() noexcept
    { return _S_ymd().substr(0, 2); }
 
    static consteval
    _String_view
    _S_m() noexcept
    { return _S_ymd().substr(3, 2); }
 
    static consteval
    _String_view
    _S_d() noexcept
    { return _S_ymd().substr(6, 2); }
 
    static consteval
    _String_view
    _S_ymwi() noexcept
    // %\0 is extension for handling weekday index
    { return _String_view(_GLIBCXX_WIDEN("%Y/%b/%a[%\0]"), 12); }
 
    static consteval
    _String_view
    _S_mwi() noexcept
    { return _S_ymwi().substr(3); }
 
    static consteval
    _String_view
    _S_wi() noexcept
    { return _S_ymwi().substr(6); }
 
    static consteval
    _String_view
    _S_w() noexcept
    { return _S_ymwi().substr(6, 2); }
 
    static consteval
    _String_view
    _S_ymwl() noexcept
    { return _GLIBCXX_WIDEN("%Y/%b/%a[last]"); }
 
    static consteval
    _String_view
    _S_mwl() noexcept
    { return _S_ymwl().substr(3); }
 
    static consteval
    _String_view
    _S_wl() noexcept
    { return _S_ymwl().substr(6); }
 
    static consteval
    _String_view
    _S_yml() noexcept
    { return _GLIBCXX_WIDEN("%Y/%b/last"); }
 
    static consteval
    _String_view
    _S_ml() noexcept
    { return _S_yml().substr(3); }
  };
 
  template<typename _CharT>
    struct _ChronoData
    {
      static constexpr unsigned _S_max_prec = 18;
      using _Attoseconds = chrono::duration<__UINT_LEAST64_TYPE__, atto>;
 
      using _FormatContext
        = basic_format_context<_Sink_iter<_CharT>, _CharT>;
      using _FormatArgs = basic_format_args<_FormatContext>;
      static inline auto _S_args = std::make_format_args<_FormatContext>();
 
      _ChronoData() = default;
      _ChronoData(_ChronoData&&) = delete;
 
      // time since epoch
      chrono::seconds           _M_eseconds;
      // n.b. due offset being seconds or coarser, local and epoch subseconds
      // has the same value
      _Attoseconds              _M_subseconds;
      // _M_ereps.get(0) stores duration units
      // _M_ereps.get(1) stores subseconds units
      // _M_ereps.get(2) stores precision
      _FormatArgs               _M_ereps = _S_args;
      basic_string_view<_CharT> _M_unit_suffix;
 
      // local (wall) time
      chrono::local_seconds _M_lseconds;
      chrono::local_days    _M_ldays;
 
      chrono::year    _M_year;
      chrono::month   _M_month;
      chrono::day     _M_day;
      chrono::weekday _M_weekday;
      unsigned char   _M_weekday_index;
      chrono::days    _M_day_of_year;
 
      bool            _M_is_neg;
      chrono::hours   _M_hours;
      chrono::minutes _M_minutes;
      chrono::seconds _M_seconds;
 
      chrono::seconds           _M_zone_offset;
      basic_string_view<_CharT> _M_zone_abbrev;
      const char*               _M_zone_cstr = "";
 
      template<typename _YearMonth>
        [[__gnu__::__always_inline__]]
        _ChronoParts
        _M_fill_year_month(const _YearMonth& __ym, _ChronoParts __parts)
        {
          _M_year = __ym.year();
          __parts -= _ChronoParts::_Year;
          _M_month = __ym.month();
          __parts -= _ChronoParts::_Month;
          return __parts;
        }
 
      [[__gnu__::__always_inline__]]
      _ChronoParts
      _M_fill_day(chrono::day __d, _ChronoParts __parts)
      {
        _M_day = __d;
        __parts -= _ChronoParts::_Day;
        _M_weekday_index = ((unsigned)__d + 6u) / 7u;
        __parts -= _ChronoParts::_WeekdayIndex;
        return __parts;
      }
 
      [[__gnu__::__always_inline__]]
      _ChronoParts
      _M_fill_weekday(chrono::weekday_indexed __wi, _ChronoParts __parts)
      {
        _M_weekday = __wi.weekday();
        __parts -= _ChronoParts::_Weekday;
        _M_weekday_index = __wi.index();
        __parts -= _ChronoParts::_WeekdayIndex;
        return __parts;
      }
 
      // pre: _M_year is set
      [[__gnu__::__always_inline__]]
      _ChronoParts
      _M_fill_aux(chrono::local_days __ld, _ChronoParts __parts)
      {
        using namespace chrono;
        if ((__parts & _ChronoParts::_Weekday) != 0)
          _M_weekday = weekday(__ld);
        __parts -= _ChronoParts::_Weekday;
        if ((__parts & _ChronoParts::_DayOfYear) != 0)
          // See "Calculating Ordinal Dates" at
          // https://github.com/HowardHinnant/date/wiki/Examples-and-Recipes
          _M_day_of_year = __ld - local_days(_M_year/January/0);
        __parts -= _ChronoParts::_DayOfYear;
        return __parts;
      }
 
      // pre: _M_year is set
      [[__gnu__::__always_inline__]]
      _ChronoParts
      _M_fill_ldays(chrono::local_days __ld, _ChronoParts __parts)
      {
        _M_ldays = __ld;
        __parts -= _ChronoParts::_LocalDays;
        return _M_fill_aux(__ld, __parts);
      }
 
      void
      _M_fill_time(chrono::seconds __d)
      {
        chrono::hh_mm_ss<chrono::seconds> __hms(__d);
        _M_hours = __hms.hours();
        _M_minutes = __hms.minutes();
        _M_seconds = __hms.seconds();
      }
 
      void
      _M_fill_date_time(chrono::local_seconds __ls, _ChronoParts __parts)
      {
        _M_ldays = chrono::floor<chrono::days>(__ls);
        __parts -= _ChronoParts::_LocalDays;
        if ((__parts & _ChronoParts::_HoursMinutesSeconds) != 0)
          _M_fill_time(_M_lseconds - _M_ldays);
 
        if ((__parts & _ChronoParts::_Date) != 0)
          {
            const chrono::year_month_day __ymd(_M_ldays);
            _M_fill_year_month(__ymd, __parts);
            _M_fill_day(__ymd.day(), __parts);
            _M_fill_aux(_M_ldays, __parts);
          }
      }
 
      void
      _M_fill_zone(const char* __abbrev, const wchar_t* __wabbrev)
      {
        if constexpr (is_same_v<_CharT, char>)
          _M_zone_abbrev = __abbrev;
        else
          _M_zone_abbrev = __wabbrev;
        _M_zone_cstr = __abbrev;
      }
 
      [[__gnu__::__always_inline__]]
      void
      _M_fill_utc_zone()
      { _M_fill_zone("UTC", L"UTC"); }
    };
 
  // TODO rename this to chrono::__formatter? or chrono::__detail::__formatter?
  template<typename _CharT>
    struct __formatter_chrono
    {
      using __string_view = basic_string_view<_CharT>;
      using __string = basic_string<_CharT>;
 
      __formatter_chrono() = default;
 
      constexpr explicit
      __formatter_chrono(_ChronoSpec<_CharT> __spec) noexcept
      : _M_spec(__spec)
      { }
 
      constexpr typename basic_format_parse_context<_CharT>::iterator
      _M_parse(basic_format_parse_context<_CharT>& __pc, _ChronoParts __parts,
               const _ChronoSpec<_CharT>& __def)
      {
        auto __first = __pc.begin();
        auto __last = __pc.end();
 
        _ChronoSpec<_CharT> __spec = __def;
 
        auto __finalize = [this, &__spec, &__def] {
          using enum _ChronoParts;
          _ChronoParts __checked
            = __spec._M_debug ? _YearMonthDay|_IndexedWeekday
                              : _Month|_Weekday;
          // n.b. for calendar types __def._M_needed contains only parts
          // copied from the input, remaining ones are computed, and thus ok
          __spec._M_needs_ok_check
             = __spec._M_needs(__def._M_needed & __checked);
          _M_spec = __spec;
        };
 
        auto __finished = [&] {
          if (__first == __last || *__first == '}')
            {
              __finalize();
              return true;
            }
          return false;
        };
 
        if (__finished())
          return __first;
 
        __first = __spec._M_parse_fill_and_align(__first, __last);
        if (__finished())
          return __first;
 
        __first = __spec._M_parse_width(__first, __last, __pc);
        if (__finished())
          return __first;
 
        if (*__first == '.')
          {
            if ((__parts & _ChronoParts::_EpochUnits) == 0
                  || !__spec._M_floating_point_rep)
              __throw_format_error("format error: invalid precision for duration");
 
            // Precision is allowed, but value is ignored.
            __first = _Spec<_CharT>()._M_parse_precision(__first, __last, __pc);
            // Still inditate that there was user supplied precision.
            __spec._M_prec_kind = _WP_value;
            if (__finished())
              return __first;
          }
 
        __spec._M_localized = false;
        __first = __spec._M_parse_locale(__first, __last);
        if (__finished())
          return __first;
 
        // Everything up to the end of the string or the first '}' is a
        // chrono-specs string. Check it is valid.
        {
          __string_view __str(__first, __last - __first);
          auto __end = __str.find('}');
          if (__end != __str.npos)
            {
              __str.remove_suffix(__str.length() - __end);
              __last = __first + __end;
            }
          if (__str.find('{') != __str.npos)
            __throw_format_error("chrono format error: '{' in chrono-specs");
        }
 
        // Parse chrono-specs in [first,last), checking each conversion-spec
        // against __parts (so fail for %Y if no year in parts).
        // Save range in __spec._M_chrono_specs.
        __spec._M_debug = false;
        __spec._M_locale_specific = false;
        __spec._M_needed = _ChronoParts::_None;
        __spec._M_chrono_specs = __string_view();
 
        const auto __chrono_specs = __first++; // Skip leading '%'
        if (*__chrono_specs != '%')
          __throw_format_error("chrono format error: no '%' at start of "
                               "chrono-specs");
 
        _CharT __mod{};
        bool __conv = true;
        while (__first != __last)
          {
            enum _Mods { _Mod_none, _Mod_E, _Mod_O, _Mod_E_O };
            _Mods __allowed_mods = _Mod_none;
 
            _ChronoParts __needed = _ChronoParts::_None;
            bool __locale_specific = false;
 
            _CharT __c = *__first++;
            switch (__c)
              {
              using enum _ChronoParts;
              case 'a':
              case 'A':
                __needed = _Weekday;
                __locale_specific = true;
                break;
              case 'b':
              case 'h':
              case 'B':
                __needed = _Month;
                __locale_specific = true;
                break;
              case 'c':
                __needed = _Date|_HoursMinutesSeconds;
                __allowed_mods = _Mod_E;
                __locale_specific = true;
                break;
              case 'C':
                __needed = _Year;
                __allowed_mods = _Mod_E;
                break;
              case 'd':
              case 'e':
                __needed = _Day;
                __allowed_mods = _Mod_O;
                break;
              case 'D':
              case 'F':
                __needed = _YearMonthDay;
                break;
              case 'g':
              case 'G':
              case 'V':
                __needed = _LocalDays|_Year|_DayOfYear|_Weekday;
                break;
              case 'H':
              case 'I':
                __needed = _HoursMinutesSeconds;
                __allowed_mods = _Mod_O;
                break;
              case 'j':
                __needed = __parts & _DayOfYear;
                // If we do not know day-of-year then we must have a duration,
                // which is to be formatted as decimal number of days.
                if (__needed == _None)
                  __needed = _HoursMinutesSeconds;
                break;
              case 'm':
                __needed = _Month;
                __allowed_mods = _Mod_O;
                break;
              case 'M':
                __needed = _HoursMinutesSeconds;
                __allowed_mods = _Mod_O;
                break;
              case 'p':
              case 'r':
                __locale_specific = true;
                [[fallthrough]];
              case 'R':
                __needed = _HoursMinutesSeconds;
                break;
              case 'T':
                __needed = _TimeOfDay;
                break;
              case 'q':
                __needed = _UnitSuffix;
                break;
              case 'Q':
                __needed = _EpochUnits;
                break;
              case 'S':
                __needed = _TimeOfDay;
                __allowed_mods = _Mod_O;
                break;
              case 'u':
              case 'w':
                __needed = _Weekday;
                __allowed_mods = _Mod_O;
                break;
              case 'U':
              case 'W':
                __needed = _DayOfYear|_Weekday;
                __allowed_mods = _Mod_O;
                break;
              case 'x':
                __needed = _Date;
                __locale_specific = true;
                __allowed_mods = _Mod_E;
                break;
              case 'X':
                __needed = _HoursMinutesSeconds;
                __locale_specific = true;
                __allowed_mods = _Mod_E;
                break;
              case 'y':
                __needed = _Year;
                __allowed_mods = _Mod_E_O;
                break;
              case 'Y':
                __needed = _Year;
                __allowed_mods = _Mod_E;
                break;
              case 'z':
                __needed = _ZoneOffset;
                __allowed_mods = _Mod_E_O;
                break;
              case 'Z':
                __needed = _ZoneAbbrev;
                break;
              case 'n':
              case 't':
              case '%':
                break;
              case 'O':
              case 'E':
                if (__mod) [[unlikely]]
                  {
                    __allowed_mods = _Mod_none;
                    break;
                  }
                __mod = __c;
                continue;
              default:
                __throw_format_error("chrono format error: invalid specifier "
                                     "in chrono-specs");
            }
 
            if ((__mod == 'E' && !(__allowed_mods & _Mod_E))
                   || (__mod == 'O' && !(__allowed_mods & _Mod_O)))
              __throw_format_error("chrono format error: invalid  modifier "
                                   "in chrono-specs");
            if (__mod && __c != 'z')
              __locale_specific = true;
            __mod = _CharT();
 
            // localized formats do not include subseconds
            if (__locale_specific)
              __needed -= _ChronoParts::_Subseconds;
 
            if ((__parts & __needed) != __needed)
              __throw_format_error("chrono format error: format argument does "
                                   "not contain the information required by the "
                                   "chrono-specs");
            __spec._M_needed |= __needed;
            __spec._M_locale_specific |= __locale_specific;
 
            // Scan for next '%', ignoring literal-chars before it.
            size_t __pos = __string_view(__first, __last - __first).find('%');
            if (__pos == 0)
              ++__first;
            else
              {
                if (__pos == __string_view::npos)
                  {
                    __first = __last;
                    __conv = false;
                  }
                else
                  __first += __pos + 1;
              }
          }
 
        // Check for a '%' conversion-spec without a type.
        if (__conv || __mod != _CharT())
          __throw_format_error("chrono format error: unescaped '%' in "
                               "chrono-specs");
 
        __spec._M_chrono_specs
          = __string_view(__chrono_specs, __first - __chrono_specs);
 
        __finalize();
        return __first;
      }
 
      // pre: !_M_spec._M_chrono_specs.empty()
      template<typename _FormatContext>
        typename _FormatContext::iterator
        _M_format(const _ChronoData<_CharT>& __t, _FormatContext& __fc) const
        {
#if defined _GLIBCXX_USE_NL_LANGINFO_L && __CHAR_BIT__ == 8
          // _GLIBCXX_RESOLVE_LIB_DEFECTS
          // 3565. Handling of encodings in localized formatting
          //       of chrono types is underspecified
          if constexpr (is_same_v<_CharT, char>)
            if constexpr (__unicode::__literal_encoding_is_utf8())
              if (_M_spec._M_localized && _M_spec._M_locale_specific)
                {
                  extern locale __with_encoding_conversion(const locale&);
 
                  // Allocate and cache the necessary state to convert strings
                  // in the locale's encoding to UTF-8.
                  locale __loc = __fc.locale();
                  if (__loc != locale::classic())
                    __fc._M_loc = __with_encoding_conversion(__loc);
                }
#endif
 
          const size_t __padwidth = _M_spec._M_get_width(__fc);
          if (__padwidth == 0)
            return _M_format_to(__t, __fc.out(), __fc);
 
          using _Out = typename _FormatContext::iterator;
          _Padding_sink<_Out, _CharT> __sink(__fc.out(), __padwidth);
          _M_format_to(__t, __sink.out(), __fc);
          return __sink._M_finish(_M_spec._M_align, _M_spec._M_fill);
        }
 
      _ChronoSpec<_CharT> _M_spec;
 
    protected:
      static constexpr const _CharT* _S_chars
        = _GLIBCXX_WIDEN("0123456789.Lf:/ +-{}");
      static constexpr _CharT _S_dot = _S_chars[10];
      static constexpr _CharT _S_colon = _S_chars[13];
      static constexpr _CharT _S_slash = _S_chars[14];
      static constexpr _CharT _S_space = _S_chars[15];
      static constexpr const _CharT* _S_fp_fmt = _S_chars + 11;
      static constexpr const _CharT* _S_plus_minus = _S_chars + 16;
      static constexpr const _CharT* _S_minus_empty_spec = _S_chars + 17;
      static constexpr const _CharT* _S_empty_spec = _S_chars + 18;
 
      [[__gnu__::__always_inline__]]
      static _Dynamic_format_string<_CharT>
      _S_empty_fs()
      { return _Dynamic_format_string<_CharT>(_S_empty_spec); }
 
      static constexpr const _CharT* _S_weekdays[]
      {
        _GLIBCXX_WIDEN("Sunday"),
        _GLIBCXX_WIDEN("Monday"),
        _GLIBCXX_WIDEN("Tuesday"),
        _GLIBCXX_WIDEN("Wednesday"),
        _GLIBCXX_WIDEN("Thursday"),
        _GLIBCXX_WIDEN("Friday"),
        _GLIBCXX_WIDEN("Saturday"),
      };
 
      static constexpr const _CharT* _S_months[]
      {
        _GLIBCXX_WIDEN("January"),
        _GLIBCXX_WIDEN("February"),
        _GLIBCXX_WIDEN("March"),
        _GLIBCXX_WIDEN("April"),
        _GLIBCXX_WIDEN("May"),
        _GLIBCXX_WIDEN("June"),
        _GLIBCXX_WIDEN("July"),
        _GLIBCXX_WIDEN("August"),
        _GLIBCXX_WIDEN("September"),
        _GLIBCXX_WIDEN("October"),
        _GLIBCXX_WIDEN("November"),
        _GLIBCXX_WIDEN("December"),
      };
 
    private:
      template<typename _OutIter>
        _OutIter
        _M_write(_OutIter __out, [[maybe_unused]] const locale& __loc,
                 __string_view __s) const
        {
#if defined _GLIBCXX_USE_NL_LANGINFO_L && __CHAR_BIT__ == 8
          __sso_string __buf;
          // _GLIBCXX_RESOLVE_LIB_DEFECTS
          // 3565. Handling of encodings in localized formatting
          //       of chrono types is underspecified
          if constexpr (is_same_v<_CharT, char>)
            if constexpr (__unicode::__literal_encoding_is_utf8())
              if (_M_spec._M_localized && _M_spec._M_locale_specific
                    && __loc != locale::classic())
                {
                  extern string_view
                  __locale_encoding_to_utf8(const locale&, string_view, void*);
 
                  __s = __locale_encoding_to_utf8(__loc, __s, &__buf);
                }
#endif
          return __format::__write(std::move(__out), __s);
        }
 
      [[__gnu__::__always_inline__]]
      static bool
      _S_localized_spec(_CharT __conv, _CharT __mod)
      {
        switch (__conv)
          {
          case 'a':
          case 'A':
          case 'b':
          case 'B':
          case 'c':
          case 'h':
          case 'p':
          case 'r':
          case 'x':
          case 'X':
            return true;
          case 'z':
            return false;
          default:
            return (bool)__mod;
          };
      }
 
      // Use the formatting locale's std::time_put facet to produce
      // a locale-specific representation.
      template<typename _Iter>
        _Iter
        _M_locale_fmt(_Iter __out, const locale& __loc, const struct tm& __tm,
                      char __fmt, char __mod) const
        {
          basic_ostringstream<_CharT> __os;
          __os.imbue(__loc);
          const auto& __tp = use_facet<time_put<_CharT>>(__loc);
          __tp.put(__os, __os, _S_space, &__tm, __fmt, __mod);
          if (__os)
            __out = _M_write(std::move(__out), __loc, __os.view());
          return __out;
        }
 
      __string_view
      _M_check_ok(const _ChronoData<_CharT>& __t, _CharT& __conv) const
      {
        if (!_M_spec._M_debug)
          {
            switch (__conv)
            {
            case 'a':
            case 'A':
              if (!__t._M_weekday.ok()) [[unlikely]]
                __throw_format_error("format error: invalid weekday");
              break;
            case 'b':
            case 'h':
            case 'B':
              if (!__t._M_month.ok()) [[unlikely]]
                __throw_format_error("format error: invalid month");
              break;
            default:
              break;
            }
            return __string_view();
          }
 
        switch (__conv)
        {
        // %\0 is extension for handling weekday index
        case '\0':
          if (__t._M_weekday_index < 1 || __t._M_weekday_index > 5) [[unlikely]]
            return _GLIBCXX_WIDEN("index");
          break;
        case 'a':
        case 'A':
          if (!__t._M_weekday.ok()) [[unlikely]]
            {
              __conv = 'w'; // print as decimal number
              return _GLIBCXX_WIDEN("weekday");
            }
          break;
        case 'b':
        case 'h':
        case 'B':
          if (!__t._M_month.ok()) [[unlikely]]
            {
              __conv = 'm'; // print as decimal number
              return _GLIBCXX_WIDEN("month");
            }
          break;
        case 'd':
        case 'e':
          if (!__t._M_day.ok()) [[unlikely]]
            return _GLIBCXX_WIDEN("day");
          break;
        case 'F':
          if (!(__t._M_year/__t._M_month/__t._M_day).ok()) [[unlikely]]
            return _GLIBCXX_WIDEN("date");
          break;
        case 'Y':
          if (!__t._M_year.ok()) [[unlikely]]
            return _GLIBCXX_WIDEN("year");
          break;
        default:
          break;
        }
        return __string_view();
      }
 
      template<typename _OutIter, typename _FormatContext>
        _OutIter
        _M_format_to(const _ChronoData<_CharT>& __t, _OutIter __out,
                     _FormatContext& __fc) const
        {
          auto __first = _M_spec._M_chrono_specs.begin();
          const auto __last = _M_spec._M_chrono_specs.end();
 
          auto __print_sign = [__is_neg = __t._M_is_neg, &__out] () mutable {
            if (__is_neg)
                {
                  *__out++ = _S_plus_minus[1];
                  __is_neg = false;
                }
            return std::move(__out);
          };
 
          struct tm __tm{};
          bool __use_locale_fmt = false;
          if (_M_spec._M_localized && _M_spec._M_locale_specific)
            if (__fc.locale() != locale::classic())
              {
                __use_locale_fmt = true;
 
                __tm.tm_year = (int)__t._M_year - 1900;
                __tm.tm_yday = __t._M_day_of_year.count();
                __tm.tm_mon = (unsigned)__t._M_month - 1;
                __tm.tm_mday = (unsigned)__t._M_day;
                __tm.tm_wday = __t._M_weekday.c_encoding();
                __tm.tm_hour = __t._M_hours.count();
                __tm.tm_min = __t._M_minutes.count();
                __tm.tm_sec = __t._M_seconds.count();
 
                // Some locales use %Z in their %c format but we don't want strftime
                // to use the system's local time zone (from /etc/localtime or $TZ)
                // as the output for %Z. Setting tm_isdst to -1 says there is no
                // time zone info available for the time in __tm.
                __tm.tm_isdst = -1;
 
#ifdef _GLIBCXX_USE_STRUCT_TM_TM_ZONE
                // POSIX.1-2024 adds tm.tm_zone which will be used for %Z.
                // BSD has had tm_zone since 1987 but as char* so cast away const.
                if (__t._M_zone_cstr)
                  __tm.tm_zone = const_cast<char*>(__t._M_zone_cstr);
#endif
              }
 
          // Characters to output for "%n", "%t" and "%%" specifiers.
          constexpr const _CharT* __literals = _GLIBCXX_WIDEN("\n\t%");
 
          ++__first; // Skip leading '%' at start of chrono-specs.
 
          _CharT __mod{};
          do
            {
              _CharT __c = *__first++;
              __string_view __invalid;
              if (_M_spec._M_needs_ok_check)
                __invalid = _M_check_ok(__t, __c);
 
              if (__invalid.empty() &&__use_locale_fmt
                    && _S_localized_spec(__c, __mod)) [[unlikely]]
                __out = _M_locale_fmt(std::move(__out), __fc.locale(),
                                      __tm, __c, __mod);
              else switch (__c)
                {
                // %\0 is extension for handling weekday index
                case '\0':
                  __out = _M_wi(__t._M_weekday_index, std::move(__out));
                  break;
                case 'a':
                case 'A':
                  __out = _M_a_A(__t._M_weekday, std::move(__out), __c == 'A');
                  break;
                case 'b':
                case 'h':
                case 'B':
                  __out = _M_b_B(__t._M_month, std::move(__out), __c == 'B');
                  break;
                case 'c':
                  __out = _M_c(__t, std::move(__out));
                  break;
                case 'C':
                case 'y':
                case 'Y':
                  __out = _M_C_y_Y(__t._M_year, std::move(__out), __c);
                  break;
                case 'd':
                case 'e':
                  __out = _M_d_e(__t._M_day, std::move(__out), __c);
                  break;
                case 'D':
                case 'x':
                  __out = _M_D_x(__t, std::move(__out));
                  break;
                case 'F':
                  __out = _M_F(__t, std::move(__out));
                  break;
                case 'g':
                case 'G':
                case 'V':
                  __out = _M_g_G_V(__t, std::move(__out), __c);
                  break;
                case 'H':
                case 'I':
                  __out = _M_H_I(__t._M_hours, __print_sign(), __c);
                  break;
                case 'j':
                  __out = _M_j(__t, __print_sign());
                  break;
                case 'm':
                  __out = _M_m(__t._M_month, std::move(__out));
                  break;
                case 'M':
                  __out = _M_M(__t._M_minutes, __print_sign());
                  break;
                case 'p':
                  __out = _M_p(__t._M_hours, std::move(__out));
                  break;
                case 'q':
                  __out = _M_q(__t._M_unit_suffix, std::move(__out));
                  break;
                case 'Q':
                  __out = _M_Q(__t, __print_sign(), __fc);
                  break;
                case 'r':
                  __out = _M_r(__t, __print_sign());
                  break;
                case 'R':
                case 'X':
                  __out = _M_R_X(__t, __print_sign(), __c != 'R');
                  break;
                case 'T':
                  __out = _M_T(__t, __print_sign(), __fc);
                  break;
                case 'S':
                  __out = _M_S(__t, __print_sign(), __fc, __mod != 'O');
                  break;
                case 'u':
                case 'w':
                  __out = _M_u_w(__t._M_weekday, std::move(__out), __c);
                  break;
                case 'U':
                case 'W':
                  __out = _M_U_W(__t, std::move(__out), __c);
                  break;
                case 'z':
                  __out = _M_z(__t._M_zone_offset, std::move(__out), (bool)__mod);
                  break;
                case 'Z':
                  __out = _M_Z(__t._M_zone_abbrev, std::move(__out));
                  break;
                case 'n':
                  *__out++ = __literals[0];
                  break;
                case 't':
                  *__out++ = __literals[1];
                  break;
                case '%':
                  *__out++ = __literals[2];
                  break;
                case 'O':
                case 'E':
                  __mod = __c;
                  continue;
                case '}':
                  __first = __last;
                  break;
                }
 
              if (!__invalid.empty())
                {
                  constexpr __string_view __pref = _GLIBCXX_WIDEN(" is not a valid ");
                  __out = __format::__write(std::move(__out), __pref);
                  __out = __format::__write(std::move(__out), __invalid);
                }
 
              __mod = _CharT();
              // Scan for next '%' and write out everything before it.
              __string_view __str(__first, __last - __first);
              size_t __pos = __str.find('%');
              if (__pos == 0)
                ++__first;
              else
                {
                  if (__pos == __str.npos)
                    __first = __last;
                  else
                    {
                      __str.remove_suffix(__str.length() - __pos);
                      __first += __pos + 1;
                    }
                  __out = __format::__write(std::move(__out), __str);
                }
            }
          while (__first != __last);
          return std::move(__out);
        }
 
      template<typename _OutIter>
        _OutIter
        _M_wi(unsigned __wi, _OutIter __out) const
        {
          // %\0 Extension to format weekday index, used only by empty format spec
          _CharT __buf[3];
          __out = __format::__write(std::move(__out), _S_str_d1(__buf, __wi));
          return std::move(__out);
        }
 
      template<typename _OutIter>
        _OutIter
        _M_a_A(chrono::weekday __wd, _OutIter __out, bool __full) const
        {
          // %a Locale's abbreviated weekday name.
          // %A Locale's full weekday name.
          __string_view __str = _S_weekdays[__wd.c_encoding()];
          if (!__full)
            __str = __str.substr(0, 3);
          return __format::__write(std::move(__out), __str);
        }
 
      template<typename _OutIter>
        _OutIter
        _M_b_B(chrono::month __m, _OutIter __out, bool __full) const
        {
          // %b Locale's abbreviated month name.
          // %B Locale's full month name.
          __string_view __str = _S_months[(unsigned)__m - 1];
          if (!__full)
            __str = __str.substr(0, 3);
          return __format::__write(std::move(__out), __str);
        }
 
      template<typename _OutIter>
        _OutIter
        _M_c(const _ChronoData<_CharT>& __t, _OutIter __out) const
        {
          // %c  Locale's date and time representation, for C-locale: %a %b %e %T %Y
          // %Ec Locale's alternate date and time representation, for C-locale same as above
 
          __out = _M_a_A(__t._M_weekday, std::move(__out), false);
          *__out = _S_space;
          __out = _M_b_B(__t._M_month, std::move(++__out), false);
          *__out = _S_space;
          __out = _M_d_e(__t._M_day, std::move(++__out), 'e');
          *__out = _S_space;
          __out = _M_R_X(__t, std::move(++__out), true);
          *__out = _S_space;
          return _M_C_y_Y(__t._M_year, std::move(++__out), 'Y');
        }
 
      template<typename _OutIter>
        _OutIter
        _M_C_y_Y(chrono::year __y, _OutIter __out, _CharT __conv) const
        {
          // %C  Year divided by 100 using floored division.
          // %EC Locale's alternative preresentation of the century (era name).
          // %y  Last two decimal digits of the year.
          // %Oy Locale's alternative representation.
          // %Ey Locale's alternative representation of offset from %EC.
          // %Y  Year as a decimal number.
          // %EY Locale's alternative full year representation.
 
          int __yi = (int)__y;
          const bool __is_neg = __yi < 0;
          // _GLIBCXX_RESOLVE_LIB_DEFECTS
          // 3831. Two-digit formatting of negative year is ambiguous
          __yi = __builtin_abs(__yi);
          int __ci = __yi / 100;
          // For floored division -123//100 is -2 and -100//100 is -1
          if (__conv == 'C' && __is_neg && (__ci * 100) != __yi) [[unlikely]]
            ++__ci;
 
          if (__conv != 'y' && __ci >= 100) [[unlikely]]
            {
              using _FmtStr = _Dynamic_format_string<_CharT>;
              __string_view __fs = _S_minus_empty_spec + !__is_neg;
              __out = std::format_to(std::move(__out), _FmtStr(__fs),
                                     __conv == 'C' ? __ci : __yi);
            }
          else
            {
              _CharT __buf[5];
              __buf[0] = _S_plus_minus[1];
              __string_view __sv(__buf + 3, __buf + 3);
              if (__conv != 'y')
                {
                  _S_fill_two_digits(__buf + 1, __ci);
                  __sv = __string_view(__buf + !__is_neg, __buf + 3);
                }
              if (__conv != 'C')
                {
                  _S_fill_two_digits(__buf + 3, __yi % 100);
                  __sv = __string_view(__sv.data(), __buf + 5);
                }
              __out = __format::__write(std::move(__out), __sv);
            }
          return __out;
        }
 
      template<typename _OutIter>
        _OutIter
        _M_D_x(const _ChronoData<_CharT>& __t, _OutIter __out) const
        {
          // %D  Equivalent to %m/%d/%y
          // %x  Locale's date rep, for C-locale: %m/%d/%y
          // %Ex Locale's alternative date representation, for C-locale same as above
 
          auto __di = (unsigned)__t._M_day;
          auto __mi = (unsigned)__t._M_month;
          auto __yi = __builtin_abs((int)__t._M_year) % 100;
 
          if (__mi >= 100 || __di >= 100) [[unlikely]]
            {
              using _FmtStr = _Dynamic_format_string<_CharT>;
              __string_view __fs = _GLIBCXX_WIDEN("{:02d}/{:02d}/{:02d}");
              __out = std::format_to(std::move(__out), _FmtStr(__fs),
                                     __mi, __di, __yi);
            }
          else
            {
              _CharT __buf[8];
              __buf[2] = _S_slash;
              __buf[5] = _S_slash;
              __string_view __sv(__buf, __buf + 8);
 
              _S_fill_two_digits(__buf, __mi);
              _S_fill_two_digits(__buf + 3, __di);
              _S_fill_two_digits(__buf + 6, __yi);
              __out = __format::__write(std::move(__out), __sv);
            }
          return std::move(__out);
        }
 
      template<typename _OutIter>
        _OutIter
        _M_d_e(chrono::day __d, _OutIter __out, _CharT __conv) const
        {
          // %d  The day of month as a decimal number.
          // %Od Locale's alternative representation.
          // %e  Day of month as decimal number, padded with space.
          // %Oe Locale's alternative digits.
 
          unsigned __i = (unsigned)__d;
 
          _CharT __buf[3];
          auto __sv = _S_str_d2(__buf, __i);
          if (__conv == _CharT('e') && __i < 10)
            {
              __buf[1] = __sv[1];
              __buf[0] = _S_space;
              __sv = {__buf, 2};
            }
 
          __out = __format::__write(std::move(__out), __sv);
          return std::move(__out);
        }
 
      template<typename _OutIter>
        _OutIter
        _M_F(const _ChronoData<_CharT>& __t, _OutIter __out) const
        {
          auto __di = (unsigned)__t._M_day;
          auto __mi = (unsigned)__t._M_month;
          auto __yi = (int)__t._M_year;
          const bool __is_neg = __yi < 0;
          __yi = __builtin_abs(__yi);
 
          if (__yi >= 10000 || __mi >= 100 || __di >= 100) [[unlikely]]
            {
              using _FmtStr = _Dynamic_format_string<_CharT>;
              __string_view __fs
                = _GLIBCXX_WIDEN("-{:04d}-{:02d}-{:02d}") + !__is_neg;
              __out = std::format_to(std::move(__out), _FmtStr(__fs),
                                     __yi, __mi, __di);
            }
          else
            {
              _CharT __buf[11];
              __buf[0] = _S_plus_minus[1];
              __buf[5] = _S_plus_minus[1];
              __buf[8] = _S_plus_minus[1];
              __string_view __sv(__buf + !__is_neg, __buf + 11);
 
              _S_fill_two_digits(__buf + 1, __yi / 100);
              _S_fill_two_digits(__buf + 3, __yi % 100);
              _S_fill_two_digits(__buf + 6, __mi);
              _S_fill_two_digits(__buf + 9, __di);
              __out = __format::__write(std::move(__out), __sv);
            }
 
          return std::move(__out);
        }
 
      template<typename _OutIter>
        _OutIter
        _M_g_G_V(const _ChronoData<_CharT>& __t, _OutIter __out,
                _CharT __conv) const
        {
          // %g  last two decimal digits of the ISO week-based year.
          // %G  ISO week-based year.
          // %V  ISO week-based week number as a decimal number.
          // %OV Locale's alternative numeric rep.
 
          // ISO week-based year of __t is the year that contains the nearest
          // Thursday. The ISO week of __t is the number of weeks since
          // January 1 of that year.
 
          using namespace chrono;
          // Offset of the nearest Thursday:
          const days __offset = (__t._M_weekday - Monday) - days(3);
          // Nearest Thursday as local days:
          const local_days __ild = __t._M_ldays - __offset;
          // Day of year of nearest Thursday:
          days __idoy = __t._M_day_of_year - __offset;
 
          // Year of nearest Thursday:
          year __iyear;
          if (__idoy <= days(0))
            __iyear = __t._M_year - years(1);
          else if (__idoy <= days(365))
            __iyear = __t._M_year;
          else if (__idoy == days(366) && __t._M_year.is_leap())
            __iyear = __t._M_year;
          else if (__idoy <= days(730))
            __iyear = __t._M_year + years(1);
          else [[unlikely]]
            __iyear = year_month_day(__ild).year();
 
          if (__conv != 'V')
            return _M_C_y_Y(__iyear, std::move(__out), "yY"[__conv == 'G']);
 
          if (__iyear != __t._M_year)
            __idoy = __ild - local_days(__iyear/January/0);
 
          const auto __wi = chrono::floor<weeks>(__idoy - days(1)).count() + 1;
          return __format::__write(std::move(__out), _S_two_digits(__wi));
        }
 
      template<typename _OutIter>
        _OutIter
        _M_H_I(chrono::hours __h, _OutIter __out, _CharT __conv) const
        {
          // %H  The hour (24-hour clock) as a decimal number.
          // %OH Locale's alternative representation.
          // %I  The hour (12-hour clock) as a decimal number.
          // %OI Locale's alternative representation.
 
          int __i = __h.count();
 
          if (__conv == _CharT('I'))
            {
              __i %= 12;
              if (__i == 0)
                __i = 12;
            }
          else if (__i >= 100) [[unlikely]]
            return std::format_to(std::move(__out), _S_empty_fs(), __i);
 
          return __format::__write(std::move(__out), _S_two_digits(__i));
        }
 
      template<typename _OutIter>
        _OutIter
        _M_j(const _ChronoData<_CharT>& __t, _OutIter __out) const
        {
          if (!_M_spec._M_needs(_ChronoParts::_DayOfYear))
          {
            // Decimal number of days, without padding.
            auto __d = chrono::floor<chrono::days>(__t._M_hours).count();
            return std::format_to(std::move(__out), _S_empty_fs(), __d);
          }
 
          auto __d = __t._M_day_of_year.count();
          if (__d >= 1000) [[unlikely]]
            return std::format_to(std::move(__out), _S_empty_fs(), __d);
 
          _CharT __buf[3];
          return __format::__write(std::move(__out), _S_str_d3(__buf, __d));
        }
 
      template<typename _OutIter>
        _OutIter
        _M_m(chrono::month __m, _OutIter __out) const
        {
          // %m  month as a decimal number.
          // %Om Locale's alternative representation.
          auto __i = (unsigned)__m;
          if (__i == 0 && _M_spec._M_debug) [[unlikely]]
            // 0 should not be padded to two digits
            return __format::__write(std::move(__out), _S_digit(0));
 
          _CharT __buf[3];
          return __format::__write(std::move(__out), _S_str_d2(__buf, __i));
        }
 
      template<typename _OutIter>
        _OutIter
        _M_M(chrono::minutes __m, _OutIter __out) const
        {
          // %M  The minute as a decimal number.
          // %OM Locale's alternative representation.
 
          auto __i = __m.count();
          return __format::__write(std::move(__out), _S_two_digits(__i));
        }
 
      template<typename _OutIter>
        _OutIter
        _M_p(chrono::hours __h, _OutIter __out) const
        {
          // %p The locale's equivalent of the AM/PM designations.
 
          _CharT __buf[2];
          _S_fill_ampm(__buf, __h);
          return __format::__write(std::move(__out), __string_view(__buf, 2));
        }
 
      template<typename _OutIter>
        _OutIter
        _M_q(__string_view __us, _OutIter __out) const
        {
          // %q The duration's unit suffix
          return __format::__write(std::move(__out), __us);
        }
 
      template<typename _OutIter, typename _FormatContext>
        _OutIter
        _M_Q(const _ChronoData<_CharT>& __t, _OutIter __out,
             _FormatContext&) const
        {
          // %Q The duration's numeric value.
          return std::vformat_to(std::move(__out), _S_empty_spec, __t._M_ereps);
        }
 
      template<typename _OutIter>
        _OutIter
        _M_r(const _ChronoData<_CharT>& __t, _OutIter __out) const
        {
          // %r Locale's 12-hour clock time, for C-locale: %I:%M:%S %p
          auto __hi = __t._M_hours.count() % 12;
          if (__hi == 0)
            __hi = 12;
 
          _CharT __buf[11];
          __buf[2] = _S_colon;
          __buf[5] = _S_colon;
          __buf[8] = _S_space;
          _S_fill_two_digits(__buf, __hi);
          _S_fill_two_digits(__buf + 3, __t._M_minutes.count());
          _S_fill_two_digits(__buf + 6, __t._M_seconds.count());
          _S_fill_ampm(__buf + 9, __t._M_hours);
 
          return __format::__write(std::move(__out), __string_view(__buf, 11));
        }
 
      template<typename _OutIter>
        _OutIter
        _M_R_X(const _ChronoData<_CharT>& __t, _OutIter __out,
               bool __secs) const
        {
          // %R  Equivalent to %H:%M
          // %X  Locale's time rep, for C-locale: %H:%M:%S (without subseconds)
          // %EX Locale's alternative time representation, for C-locale same as above
 
          auto __hi = __t._M_hours.count();
 
          _CharT __buf[8];
          __buf[2] = _S_colon;
          __buf[5] = _S_colon;
          __string_view __sv(__buf, 8);
 
          if (__hi >= 100) [[unlikely]]
            {
              __out = std::format_to(std::move(__out), _S_empty_fs(), __hi);
              __sv.remove_prefix(2);
            }
          else
            _S_fill_two_digits(__buf, __hi);
 
          _S_fill_two_digits(__buf + 3, __t._M_minutes.count());
          if (__secs)
            _S_fill_two_digits(__buf + 6, __t._M_seconds.count());
          else
            __sv.remove_suffix(3);
 
          return __format::__write(std::move(__out), __sv);
        }
 
      template<typename _OutIter, typename _FormatContext>
        _OutIter
        _M_S(const _ChronoData<_CharT>& __t, _OutIter __out,
             _FormatContext& __ctx, bool __subs = true) const
        {
          // %S  Seconds as a decimal number.
          // %OS The locale's alternative representation.
          auto __s = __t._M_seconds;
 
          __out = __format::__write(std::move(__out),
                                    _S_two_digits(__s.count()));
          if (__subs)
            __out = _M_subsecs(__t, std::move(__out), __ctx);
          return __out;
        }
 
      template<typename _OutIter, typename _FormatContext>
        _OutIter
        _M_subsecs(const _ChronoData<_CharT>& __t, _OutIter __out,
                   _FormatContext& __ctx) const
        {
          unsigned __prec = _M_spec._M_prec_kind != _WP_none
                          ? _M_spec._M_get_precision(__ctx)
                          : _M_spec._M_prec;
          if (__prec == 0)
            return __out;
 
          _CharT __dot = _S_dot;
          if (_M_spec._M_localized) [[unlikely]]
            {
              auto __loc = __ctx.locale();
              const auto& __np = use_facet<numpunct<_CharT>>(__loc);
              __dot = __np.decimal_point();
            }
          *__out = __dot;
          ++__out;
 
          if (_M_spec._M_floating_point_rep)
            {
              _Str_sink<_CharT> __sink;
              if (_M_spec._M_localized && _M_spec._M_custom_rep) [[unlikely]]
                 std::vformat_to(__sink.out(), __ctx.locale(),
                                 _GLIBCXX_WIDEN("{1:0.{2}Lf}"), __t._M_ereps);
              else
                 std::vformat_to(__sink.out(),
                                 _GLIBCXX_WIDEN("{1:0.{2}f}"), __t._M_ereps);
 
              auto __sv = __sink.view();
              // Skip leading zero and dot
              __sv.remove_prefix(2);
              return __format::__write(std::move(__out), __sv);
            }
 
          constexpr unsigned __max_prec = _ChronoData<_CharT>::_S_max_prec;
          constexpr typename _ChronoData<_CharT>::_Attoseconds::rep __pow10t[]
          {
            1u,
            10u,                     100u,                     1000u,
            10'000u,                 100'000u,                 1000'000u,
            10'000'000u,             100'000'000u,             1000'000'000u,
            10'000'000'000u,         100'000'000'000u,         1000'000'000'000u,
            10'000'000'000'000u,     100'000'000'000'000u,     1000'000'000'000'000u,
            10'000'000'000'000'000u, 100'000'000'000'000'000u, 1000'000'000'000'000'000u,
          };
 
          auto __subs = __t._M_subseconds.count();
          if (__prec < __max_prec)
            __subs /= __pow10t[__max_prec - __prec];
          else if (__prec > __max_prec)
            __prec = __max_prec;
 
          using _FmtStr = _Dynamic_format_string<_CharT>;
          return std::format_to(__out, _FmtStr(_GLIBCXX_WIDEN("{0:0{1}}")),
                                __subs, __prec);
        }
 
      // %t handled in _M_format
 
      template<typename _OutIter, typename _FormatContext>
        _OutIter
        _M_T(const _ChronoData<_CharT>& __t, _OutIter __out,
             _FormatContext& __ctx) const
        {
          // %T Equivalent to %H:%M:%S, with subseconds
          __out = _M_R_X(__t, std::move(__out), true);
          return _M_subsecs(__t, std::move(__out), __ctx);
        }
 
      template<typename _OutIter>
        _OutIter
        _M_u_w(chrono::weekday __wd, _OutIter __out, _CharT __conv) const
        {
          // %u  ISO weekday as a decimal number (1-7), where Monday is 1.
          // %Ou Locale's alternative numeric rep.
          // %w  Weekday as a decimal number (0-6), where Sunday is 0.
          // %Ow Locale's alternative numeric rep.
          unsigned __wdi = __conv == 'u' ? __wd.iso_encoding()
                                         : __wd.c_encoding();
          _CharT __buf[3];
          return __format::__write(std::move(__out), _S_str_d1(__buf, __wdi));
        }
 
      template<typename _OutIter>
        _OutIter
        _M_U_W(const _ChronoData<_CharT>& __t, _OutIter __out,
               _CharT __conv) const
        {
          // %U  Week number of the year as a decimal number, from first Sunday.
          // %OU Locale's alternative numeric rep.
          // %W  Week number of the year as a decimal number, from first Monday.
          // %OW Locale's alternative numeric rep.
 
          using namespace chrono;
          const weekday __weekstart = __conv == 'U' ? Sunday : Monday;
          const days __offset = __t._M_weekday - __weekstart;
          auto __weeks = chrono::floor<weeks>(__t._M_day_of_year - __offset - days(1));
          return __format::__write(std::move(__out), _S_two_digits(__weeks.count() + 1));
        }
 
      template<typename _OutIter>
        _OutIter
        _M_z(chrono::seconds __ts, _OutIter __out, bool __mod = false) const
        {
          if (__ts == 0s)
            {
              __string_view __zero
                = __mod ? _GLIBCXX_WIDEN("+00:00") : _GLIBCXX_WIDEN("+0000");
              return __format::__write(std::move(__out), __zero);
            }
 
          chrono::hh_mm_ss<chrono::seconds> __hms(__ts);
          unsigned __mo = 3 + __mod;
 
          _CharT __buf[6];
          __buf[0] = _S_plus_minus[__hms.is_negative()];
          __buf[3] = _S_colon;
          _S_fill_two_digits(__buf + 1, __hms.hours().count());
          _S_fill_two_digits(__buf + __mo, __hms.minutes().count());
 
          __string_view __sv(__buf, __mo + 2);
          return __format::__write(std::move(__out), __sv);
        }
 
      template<typename _OutIter>
        _OutIter
        _M_Z(__string_view __abbrev, _OutIter __out) const
        { return __format::__write(std::move(__out), __abbrev); }
 
      // %% handled in _M_format
 
      // A string view of single digit character, "0".."9".
      static basic_string_view<_CharT>
      _S_digit(int __n) noexcept
      {
        // Extra 9s avoid past-the-end read on bad input.
        return { _GLIBCXX_WIDEN("0123456789999999") + (__n & 0xf), 1 };
      }
 
      // A string view of two digit characters, "00".."99".
      static basic_string_view<_CharT>
      _S_two_digits(int __n) noexcept
      {
        return {
          _GLIBCXX_WIDEN("0001020304050607080910111213141516171819"
                         "2021222324252627282930313233343536373839"
                         "4041424344454647484950515253545556575859"
                         "6061626364656667686970717273747576777879"
                         "8081828384858687888990919293949596979899"
                         "9999999999999999999999999999999999999999"
                         "9999999999999999") + 2 * (__n & 0x7f),
          2
        };
      }
 
      // Fills __buf[0] and __buf[1] with 2 digit value of __n.
      [[__gnu__::__always_inline__]]
      static void
      _S_fill_two_digits(_CharT* __buf, unsigned __n)
      {
        auto __sv = _S_two_digits(__n);
        __buf[0] = __sv[0];
        __buf[1] = __sv[1];
      }
 
      // Fills __buf[0] and __buf[1] with "AM", "PM" depending on __h.
      [[__gnu__::__always_inline__]]
      static void
      _S_fill_ampm(_CharT* __buf, chrono::hours __h)
      {
        auto __hi =  __h.count();
        if (__hi >= 24) [[unlikely]]
          __hi %= 24;
 
        constexpr const _CharT* __apm = _GLIBCXX_WIDEN("APM");
        __buf[0] = __apm[__hi >= 12];
        __buf[1] = __apm[2];
      }
 
      // Returns decimal representation of __n.
      // Returned string_view may point to __buf.
      [[__gnu__::__always_inline__]]
      static basic_string_view<_CharT>
      _S_str_d1(span<_CharT, 3> __buf, unsigned __n)
      {
        if (__n < 10) [[likely]]
          return _S_digit(__n);
        return _S_str_d2(__buf, __n);
      }
 
      // Returns decimal representation of __n, padded to 2 digits.
      // Returned string_view may point to __buf.
      [[__gnu__::__always_inline__]]
      static basic_string_view<_CharT>
      _S_str_d2(span<_CharT, 3> __buf, unsigned __n)
      {
        if (__n < 100) [[likely]]
          return _S_two_digits(__n);
        return _S_str_d3(__buf, __n);
      }
 
      // Returns decimal representation of __n, padded to 3 digits.
      // Returned string_view points to __buf.
      [[__gnu__::__always_inline__]]
      static basic_string_view<_CharT>
      _S_str_d3(span<_CharT, 3> __buf, unsigned __n)
      {
        _S_fill_two_digits(__buf.data(), __n / 10);
        __buf[2] = _S_chars[__n % 10];
        return __string_view(__buf.data(), 3);
      }
    };
 
  template<typename _CharT>
    struct __formatter_duration : private __formatter_chrono<_CharT>
    {
      template<typename _Rep, typename _Period>
        constexpr static auto
        _S_subseconds(const chrono::duration<_Rep, _Period>& __d)
        {
          if constexpr (chrono::treat_as_floating_point_v<_Rep>)
            return chrono::duration<_Rep>(__d);
          else if constexpr (_Period::den == 1)
            return chrono::seconds(0);
          else
           {
             using _Attoseconds = _ChronoData<_CharT>::_Attoseconds;
             using _CRep = common_type_t<_Rep, typename _Attoseconds::rep>;
             chrono::duration<_CRep, _Period> __subs(__d.count());
             return chrono::duration_cast<_Attoseconds>(__subs);
           }
       }
 
    public:
      template<typename _Duration>
        static consteval
        _ChronoSpec<_CharT>
        _S_spec_for(_ChronoParts __parts)
        {
          using _Rep = typename _Duration::rep;
          using enum _ChronoParts;
 
          _ChronoSpec<_CharT> __res{};
          __res._M_floating_point_rep = chrono::treat_as_floating_point_v<_Rep>;
          __res._M_custom_rep = !is_arithmetic_v<_Rep>;
          __res._M_prec = chrono::hh_mm_ss<_Duration>::fractional_width;
          if ((__parts & _TimeOfDay) != 0)
             __res._M_localized = __res._M_prec > 0 || __res._M_floating_point_rep;
 
          if ((__parts & _TimeOfDay) != 0)
            __res._M_needed |= _TimeOfDay;
          if ((__parts & _Date) != 0)
            __res._M_needed |= _YearMonthDay;
          if ((__parts & _ZoneAbbrev) != 0)
            __res._M_needed |= _ZoneAbbrev;
 
          switch (__parts)
            {
            case _ZonedDateTime:
              __res._M_chrono_specs = _ChronoFormats<_CharT>::_S_ftz();
              break;
            case _DateTime:
              __res._M_chrono_specs = _ChronoFormats<_CharT>::_S_ft();
              break;
            case _Date:
              __res._M_chrono_specs = _ChronoFormats<_CharT>::_S_f();
              break;
            case _Time:
              __res._M_chrono_specs = _ChronoFormats<_CharT>::_S_t();
              break;
            case _None:
              break;
            default:
              __builtin_unreachable();
            }
          return __res;
        };
 
      template<typename _Duration>
        static consteval
        _ChronoSpec<_CharT>
        _S_spec_for_tp()
        {
          using enum _ChronoParts;
          // streaming of local_time is defined in terms of sys_time
          constexpr bool __stream_insertable =
            requires (basic_ostream<_CharT>& __os, chrono::sys_time<_Duration> __t)
              { __os << __t; };
          if constexpr (!__stream_insertable)
            return _S_spec_for<_Duration>(_None);
          else if constexpr (is_convertible_v<_Duration, chrono::days>)
            return _S_spec_for<_Duration>(_Date);
          else
            return _S_spec_for<_Duration>(_DateTime);
        }
 
      using __formatter_chrono<_CharT>::__formatter_chrono;
      using __formatter_chrono<_CharT>::_M_spec;
 
      template<typename _Duration>
        constexpr typename basic_format_parse_context<_CharT>::iterator
        _M_parse(basic_format_parse_context<_CharT>& __pc, _ChronoParts __parts,
                 const _ChronoSpec<_CharT>& __def)
        {
          using _Rep = typename _Duration::rep;
          using enum _ChronoParts;
 
          auto __res
            = __formatter_chrono<_CharT>::_M_parse(__pc, __parts, __def);
          // n.b. durations do not contain date parts, and for time point all
          // date parts are computed, and they are always ok.
          _M_spec._M_needs_ok_check = false;
 
          // check for custom floating point durations, if digits of output
          // will contain subseconds, then formatters must support specifying
          // precision.
          if constexpr (!is_floating_point_v<_Rep>)
            if constexpr (chrono::treat_as_floating_point_v<_Rep>)
              if (_M_spec._M_needs(_Subseconds|_EpochUnits)
                    || _M_spec._M_prec_kind != _WP_none
                    || _M_spec._M_prec_value > 0)
                {
                  constexpr const _CharT* __fs = _GLIBCXX_WIDEN("#02.5Lf");
                  basic_format_parse_context<_CharT> __npc(__fs);
                  formatter<_Rep, _CharT> __fmtter;
                  __fmtter.parse(__npc);
                }
          return __res;
        }
 
      // Return the formatting locale.
      template<typename _FormatContext>
        std::locale
        _M_locale(_FormatContext& __fc) const
        {
          if (!_M_spec._M_localized)
            return std::locale::classic();
          else
            return __fc.locale();
        }
 
      // Format duration for empty chrono-specs, e.g. "{}" (C++20 [time.format] p6).
      template<typename _Rep, typename _Period, typename _FormatContext>
        typename _FormatContext::iterator
        _M_format_to_ostream(const chrono::duration<_Rep, _Period>& __d,
                             bool __is_neg,
                             _FormatContext& __fc) const
        {
           basic_ostringstream<_CharT> __os;
           __os.imbue(this->_M_locale(__fc));
 
           if (__is_neg) [[unlikely]]
             __os << this->_S_plus_minus[1];
           __os << __d;
 
          auto __str = std::move(__os).str();
          return __format::__write_padded_as_spec(__str, __str.size(),
                                                  __fc, _M_spec);
        }
 
      template<typename _Rep1, typename _Period1,
               typename _Rep2, typename _Period2,
               typename _FormatContext>
        typename _FormatContext::iterator
        _M_format_units(_ChronoData<_CharT>& __cd,
                        const chrono::duration<_Rep1, _Period1>& __ed,
                        const chrono::duration<_Rep2, _Period2>& __ss,
                        _FormatContext& __fc) const
        {
          __format::_Str_sink<_CharT> __suffix_store;
          constexpr auto _S_unit_suffix
            = chrono::__detail::__units_suffix<_Period1, _CharT>();
          if constexpr (!_S_unit_suffix.empty())
            __cd._M_unit_suffix = _S_unit_suffix;
          else if (_M_spec._M_needs(_ChronoParts::_UnitSuffix))
            {
              chrono::__detail::
                __fmt_units_suffix<_Period1, _CharT>(__suffix_store.out());
              __cd._M_unit_suffix = __suffix_store.view();
            }
 
          const auto __prec = _M_spec._M_prec_kind != _WP_none
                            ? _M_spec._M_get_precision(__fc)
                            : _M_spec._M_prec;
 
          using _ErasedContext = typename _ChronoData<_CharT>::_FormatContext;
          // _GLIBCXX_RESOLVE_LIB_DEFECTS
          // 4118. How should duration formatters format custom rep?
          auto __ereps = +__ed.count();
          if (!_M_spec._M_needs(_ChronoParts::_Subseconds))
          {
            auto __ssreps = 0u;
            auto __args_store
              = std::make_format_args<_ErasedContext>(__ereps, __ssreps, __prec);
            __cd._M_ereps = __args_store;
            return this->_M_format(__cd, __fc);
          }
 
          using _Attoseconds = _ChronoData<_CharT>::_Attoseconds;
          auto __nss = _S_subseconds(__ss);
          __cd._M_subseconds = chrono::duration_cast<_Attoseconds>(__nss);
 
          auto __ssreps = __nss.count();
          auto __args_store
            = std::make_format_args<_ErasedContext>(__ereps, __ssreps, __prec);
          __cd._M_ereps = __args_store;
 
          return this->_M_format(__cd, __fc);
        }
 
      // pre: __cd._M_lseconds and __cd._M_eseconds are set.
      template<typename _Rep1, typename _Period1, typename _FormatContext>
        typename _FormatContext::iterator
        _M_format_time_point(_ChronoData<_CharT>& __cd,
                             const chrono::duration<_Rep1, _Period1>& __ed,
                             _FormatContext& __fc) const
        {
          auto __parts = _M_spec._M_needed - _ChronoParts::_TotalSeconds;
          if ((__parts & _ChronoParts::_DateTime) != 0)
            __cd._M_fill_date_time(__cd._M_lseconds, __parts);
          return _M_format_units(__cd, __ed, __ed - __cd._M_eseconds, __fc);
        }
    };
 
#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
  template<typename _CharT>
    struct __formatter_chrono_info
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, _ChronoParts(), {}); }
 
      template<typename _Info, typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const _Info& __i,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          // n.b. only acceptable chrono-spec for info is one containing
          // only whitespaces and %%, that do not depend on formatted object.
          if (!_M_f._M_spec._M_chrono_specs.empty()) [[unlikely]]
            return _M_f._M_format(_ChronoData<_CharT>{}, __fc);
 
          const size_t __padwidth = _M_f._M_spec._M_get_width(__fc);
          if (__padwidth == 0)
            return _M_format_to(__fc.out(), __i);
 
          _Padding_sink<_Out, _CharT> __sink(__fc.out(), __padwidth);
          _M_format_to(__sink.out(), __i);
          return __sink._M_finish(_M_f._M_spec._M_align, _M_f._M_spec._M_fill);
        }
 
    private:
       template<typename _Out>
         _Out
         _M_format_to(_Out __out, const chrono::sys_info& __si) const
         {
           using _FmtStr = _Dynamic_format_string<_CharT>;
           // n.b. only decimal separator is locale dependent for specifiers
           // used below, as sys_info uses seconds and minutes duration, the
           // output is locale-independent.
           constexpr auto* __fs
             = _GLIBCXX_WIDEN("[{0:%F %T},{1:%F %T},{2:%T},{3:%Q%q},{0:%Z}]");
           const chrono::local_seconds __lb(__si.begin.time_since_epoch());
           return std::format_to(std::move(__out), _FmtStr(__fs),
                                 chrono::local_time_format(__lb, &__si.abbrev),
                                 __si.end, __si.offset, __si.save);
         }
 
       template<typename _Out>
         _Out
         _M_format_to(_Out __out, const chrono::local_info& __li) const
         {
           *__out = _Separators<_CharT>::_S_squares()[0];
           ++__out;
           if (__li.result == chrono::local_info::unique)
             __out = _M_format_to(std::move(__out), __li.first);
           else
            {
              basic_string_view<_CharT> __sv;
              if (__li.result == chrono::local_info::nonexistent)
                __sv =_GLIBCXX_WIDEN("nonexistent");
              else
                __sv = _GLIBCXX_WIDEN("ambiguous");
              __out = __format::__write(std::move(__out), __sv);
 
              __sv = _GLIBCXX_WIDEN(" local time between ");
              __out = __format::__write(std::move(__out), __sv);
              __out = _M_format_to(std::move(__out), __li.first);
 
              __sv = _GLIBCXX_WIDEN(" and ");
              __out = __format::__write(std::move(__out), __sv);
              __out = _M_format_to(std::move(__out), __li.second);
            }
          *__out = _Separators<_CharT>::_S_squares()[1];
          ++__out;
          return std::move(__out);
        }
 
      __formatter_chrono<_CharT> _M_f;
    };
#endif
 
} // namespace __format
/// @endcond
 
  template<typename _Rep, typename _Period, typename _CharT>
    requires __format::__formattable_impl<_Rep, _CharT>
    struct formatter<chrono::duration<_Rep, _Period>, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f.template _M_parse<_Duration>(__pc, _EpochTime, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::duration<_Rep, _Period>& __d,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          if constexpr (numeric_limits<_Rep>::is_signed)
            if (__d < __d.zero()) [[unlikely]]
              {
                if constexpr (is_integral_v<_Rep>)
                  {
                    // -d is undefined for the most negative integer.
                    // Convert duration to corresponding unsigned rep.
                    using _URep = make_unsigned_t<_Rep>;
                    auto __ucnt = -static_cast<_URep>(__d.count());
                    auto __ud = chrono::duration<_URep, _Period>(__ucnt);
                    return _M_format(__ud, true, __fc);
                  }
                else
                  return _M_format(-__d, true, __fc);
              }
          return _M_format(__d, false, __fc);
        }
 
    private:
      using _Duration = chrono::duration<_Rep, _Period>;
 
      static constexpr __format::_ChronoSpec<_CharT> __defSpec = []
        {
          using enum __format::_ChronoParts;
          auto __res = __format::__formatter_duration<_CharT>::
                         template _S_spec_for<_Duration>(_None);
          __res._M_localized = !is_integral_v<_Rep>;
          // n.b. for integral format output is the same as ostream output
          if constexpr (is_integral_v<_Rep>)
            {
              __res._M_needed = _EpochUnits|_UnitSuffix;
              __res._M_chrono_specs = _GLIBCXX_WIDEN("%Q%q");
            }
          return __res;
        }();
 
      template<typename _Rep2, typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        _M_format(const chrono::duration<_Rep2, _Period>& __d,
                  bool __is_neg,
                  basic_format_context<_Out, _CharT>& __fc) const
        {
          using namespace chrono;
          using enum __format::_ChronoParts;
          if constexpr (!is_integral_v<_Rep>)
            if (_M_f._M_spec._M_chrono_specs.empty())
              return _M_f._M_format_to_ostream(__d, __is_neg, __fc);
 
          __format::_ChronoData<_CharT> __cd;
          __cd._M_is_neg = __is_neg;
          auto __ts = chrono::floor<chrono::seconds>(__d);
          __cd._M_eseconds = __ts;
          if (_M_f._M_spec._M_needs(_HoursMinutesSeconds))
            __cd._M_fill_time(__ts);
          return _M_f._M_format_units(__cd, __d, __d - __ts, __fc);
        }
 
      __format::__formatter_duration<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 4400. enable_nonlocking_formatter_optimization for durations with custom rep
  template<typename _Rep, typename _Period>
    constexpr bool
    enable_nonlocking_formatter_optimization<chrono::duration<_Rep, _Period>>
      = is_arithmetic_v<_Rep>;
#endif
 
  template<__format::__char _CharT>
    struct formatter<chrono::day, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f._M_parse(__pc, _Day|_WeekdayIndex, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::day& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          __format::_ChronoData<_CharT> __cd{};
          __cd._M_fill_day(__t, __defSpec._M_needed);
          return _M_f._M_format(__cd, __fc);
        }
 
    private:
      static constexpr __format::_ChronoSpec<_CharT> __defSpec = []
        {
          using __format::_ChronoFormats;
          using enum __format::_ChronoParts;
 
          __format::_ChronoSpec<_CharT> __res{};
          __res._M_debug = true;
          __res._M_needed = _Day;
          __res._M_chrono_specs = _ChronoFormats<_CharT>::_S_d();
          return __res;
        }();
 
      __format::__formatter_chrono<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  template<>
    inline constexpr bool
    enable_nonlocking_formatter_optimization<chrono::day> = true;
#endif
 
  template<__format::__char _CharT>
    struct formatter<chrono::month, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f._M_parse(__pc, _Month, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::month& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          __format::_ChronoData<_CharT> __cd{};
          __cd._M_month = __t;
          return _M_f._M_format(__cd, __fc);
        }
 
    private:
      static constexpr __format::_ChronoSpec<_CharT> __defSpec = []
        {
          using __format::_ChronoFormats;
          using enum __format::_ChronoParts;
 
          __format::_ChronoSpec<_CharT> __res{};
          __res._M_debug = true;
          __res._M_localized = true;
          __res._M_locale_specific = true;
          __res._M_needed = _Month;
          __res._M_chrono_specs = _ChronoFormats<_CharT>::_S_m();
          return __res;
        }();
 
      __format::__formatter_chrono<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  template<>
    inline constexpr bool
    enable_nonlocking_formatter_optimization<chrono::month> = true;
#endif
 
  template<__format::__char _CharT>
    struct formatter<chrono::year, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f._M_parse(__pc, _Year, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::year& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          __format::_ChronoData<_CharT> __cd{};
          __cd._M_year = __t;
          return _M_f._M_format(__cd, __fc);
        }
 
    private:
      static constexpr __format::_ChronoSpec<_CharT> __defSpec = []
        {
          using __format::_ChronoFormats;
          using enum __format::_ChronoParts;
 
          __format::_ChronoSpec<_CharT> __res{};
          __res._M_debug = true;
          __res._M_needed = _Year;
          __res._M_chrono_specs = _ChronoFormats<_CharT>::_S_y();
          return __res;
        }();
 
      __format::__formatter_chrono<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  template<>
    inline constexpr bool
    enable_nonlocking_formatter_optimization<chrono::year> = true;
#endif
 
  template<__format::__char _CharT>
    struct formatter<chrono::weekday, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f._M_parse(__pc, _Weekday, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::weekday& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          __format::_ChronoData<_CharT> __cd{};
          __cd._M_weekday = __t;
          return _M_f._M_format(__cd, __fc);
        }
 
    private:
      static constexpr __format::_ChronoSpec<_CharT> __defSpec = []
        {
          using __format::_ChronoFormats;
          using enum __format::_ChronoParts;
 
          __format::_ChronoSpec<_CharT> __res{};
          __res._M_debug = true;
          __res._M_localized = true;
          __res._M_locale_specific = true;
          __res._M_needed = _Weekday;
          __res._M_chrono_specs = _ChronoFormats<_CharT>::_S_w();
          return __res;
        }();
 
      __format::__formatter_chrono<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  template<>
    inline constexpr bool
    enable_nonlocking_formatter_optimization<chrono::weekday> = true;
#endif
 
  template<__format::__char _CharT>
    struct formatter<chrono::weekday_indexed, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f._M_parse(__pc, _IndexedWeekday, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::weekday_indexed& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          __format::_ChronoData<_CharT> __cd{};
          __cd._M_fill_weekday(__t, __defSpec._M_needed);
          return _M_f._M_format(__cd, __fc);
        }
 
    private:
      static constexpr __format::_ChronoSpec<_CharT> __defSpec = []
        {
          using __format::_ChronoFormats;
          using enum __format::_ChronoParts;
 
          __format::_ChronoSpec<_CharT> __res{};
          __res._M_debug = true;
          __res._M_localized = true;
          __res._M_locale_specific = true;
          __res._M_needed = _IndexedWeekday;
          __res._M_chrono_specs = _ChronoFormats<_CharT>::_S_wi();
          return __res;
        }();
 
      __format::__formatter_chrono<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  template<>
    inline constexpr bool
    enable_nonlocking_formatter_optimization<chrono::weekday_indexed> = true;
#endif
 
  template<__format::__char _CharT>
    struct formatter<chrono::weekday_last, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f._M_parse(__pc, _Weekday, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::weekday_last& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          __format::_ChronoData<_CharT> __cd{};
          __cd._M_weekday = __t.weekday();
          return _M_f._M_format(__cd, __fc);
        }
 
    private:
      static constexpr __format::_ChronoSpec<_CharT> __defSpec = []
        {
          using __format::_ChronoFormats;
          using enum __format::_ChronoParts;
 
          __format::_ChronoSpec<_CharT> __res{};
          __res._M_debug = true;
          __res._M_localized = true;
          __res._M_locale_specific = true;
          __res._M_needed = _Weekday;
          __res._M_chrono_specs = _ChronoFormats<_CharT>::_S_wl();
          return __res;
        }();
 
      __format::__formatter_chrono<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  template<>
    inline constexpr bool
    enable_nonlocking_formatter_optimization<chrono::weekday_last> = true;
#endif
 
  template<__format::__char _CharT>
    struct formatter<chrono::month_day, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f._M_parse(__pc, _Month|_Day|_WeekdayIndex, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::month_day& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          __format::_ChronoData<_CharT> __cd{};
          __cd._M_month = __t.month();
          __cd._M_fill_day(__t.day(), __defSpec._M_needed);
          return _M_f._M_format(__cd, __fc);
        }
 
    private:
      static constexpr __format::_ChronoSpec<_CharT> __defSpec = []
        {
          using __format::_ChronoFormats;
          using enum __format::_ChronoParts;
 
          __format::_ChronoSpec<_CharT> __res{};
          __res._M_debug = true;
          __res._M_localized = true;
          __res._M_locale_specific = true;
          __res._M_needed = _Month|_Day;
          __res._M_chrono_specs = _ChronoFormats<_CharT>::_S_md();
          return __res;
        }();
 
      __format::__formatter_chrono<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  template<>
    inline constexpr bool
    enable_nonlocking_formatter_optimization<chrono::month_day> = true;
#endif
 
  template<__format::__char _CharT>
    struct formatter<chrono::month_day_last, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f._M_parse(__pc, _Month, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::month_day_last& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          __format::_ChronoData<_CharT> __cd{};
          __cd._M_month = __t.month();
          return _M_f._M_format(__cd, __fc);
        }
 
    private:
       static constexpr __format::_ChronoSpec<_CharT> __defSpec = []
        {
          using __format::_ChronoFormats;
          using enum __format::_ChronoParts;
 
          __format::_ChronoSpec<_CharT> __res{};
          __res._M_debug = true;
          __res._M_localized = true;
          __res._M_locale_specific = true;
          __res._M_needed = _Month;
          __res._M_chrono_specs = _ChronoFormats<_CharT>::_S_ml();
          return __res;
        }();
 
      __format::__formatter_chrono<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  template<>
    inline constexpr bool
    enable_nonlocking_formatter_optimization<chrono::month_day_last> = true;
#endif
 
  template<__format::__char _CharT>
    struct formatter<chrono::month_weekday, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f._M_parse(__pc, _Month|_IndexedWeekday, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::month_weekday& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          __format::_ChronoData<_CharT> __cd{};
          __cd._M_month = __t.month();
          __cd._M_fill_weekday(__t.weekday_indexed(), __defSpec._M_needed);
          return _M_f._M_format(__cd, __fc);
        }
 
    private:
      static constexpr __format::_ChronoSpec<_CharT> __defSpec = []
        {
          using __format::_ChronoFormats;
          using enum __format::_ChronoParts;
 
          __format::_ChronoSpec<_CharT> __res{};
          __res._M_debug = true;
          __res._M_localized = true;
          __res._M_locale_specific = true;
          __res._M_needed = _Month|_IndexedWeekday;
          __res._M_chrono_specs = _ChronoFormats<_CharT>::_S_mwi();
          return __res;
        }();
 
      __format::__formatter_chrono<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  template<>
    inline constexpr bool
    enable_nonlocking_formatter_optimization<chrono::month_weekday> = true;
#endif
 
  template<__format::__char _CharT>
    struct formatter<chrono::month_weekday_last, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f._M_parse(__pc, _Month|_Weekday, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::month_weekday_last& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          __format::_ChronoData<_CharT> __cd{};
          __cd._M_month = __t.month();
          __cd._M_weekday = __t.weekday_last().weekday();
          return _M_f._M_format(__cd, __fc);
        }
 
    private:
       static constexpr __format::_ChronoSpec<_CharT> __defSpec = []
        {
          using __format::_ChronoFormats;
          using enum __format::_ChronoParts;
 
          __format::_ChronoSpec<_CharT> __res{};
          __res._M_debug = true;
          __res._M_localized = true;
          __res._M_locale_specific = true;
          __res._M_needed = _Month|_Weekday;
          __res._M_chrono_specs = _ChronoFormats<_CharT>::_S_mwl();
          return __res;
        }();
 
      __format::__formatter_chrono<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  template<>
    inline constexpr bool
    enable_nonlocking_formatter_optimization<chrono::month_weekday_last> = true;
#endif
 
  template<__format::__char _CharT>
    struct formatter<chrono::year_month, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f._M_parse(__pc, _Year|_Month, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::year_month& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          __format::_ChronoData<_CharT> __cd{};
          __cd._M_fill_year_month(__t, __defSpec._M_needed);
          return _M_f._M_format(__cd, __fc);
        }
 
    private:
       static constexpr __format::_ChronoSpec<_CharT> __defSpec = []
        {
          using __format::_ChronoFormats;
          using enum __format::_ChronoParts;
 
          __format::_ChronoSpec<_CharT> __res{};
          __res._M_debug = true;
          __res._M_localized = true;
          __res._M_locale_specific = true;
          __res._M_needed = _Year|_Month;
          __res._M_chrono_specs = _ChronoFormats<_CharT>::_S_ym();
          return __res;
        }();
 
      __format::__formatter_chrono<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  template<>
    inline constexpr bool
    enable_nonlocking_formatter_optimization<chrono::year_month> = true;
#endif
 
  template<__format::__char _CharT>
    struct formatter<chrono::year_month_day, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f._M_parse(__pc, _Date, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::year_month_day& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          __format::_ChronoData<_CharT> __cd{};
          auto __parts = _M_f._M_spec._M_needed;
          __parts = __cd._M_fill_year_month(__t, __parts);
          __parts = __cd._M_fill_day(__t.day(), __parts);
          if (__parts == 0)
            return _M_f._M_format(__cd, __fc);
 
          __cd._M_fill_ldays(chrono::local_days(__t), __parts);
          return _M_f._M_format(__cd, __fc);
        }
 
    private:
      static constexpr __format::_ChronoSpec<_CharT> __defSpec = []
        {
          using __format::_ChronoFormats;
          using enum __format::_ChronoParts;
 
          __format::_ChronoSpec<_CharT> __res{};
          __res._M_debug = true;
          __res._M_needed = _YearMonthDay;
          __res._M_chrono_specs = _ChronoFormats<_CharT>::_S_f();
          return __res;
        }();
 
      __format::__formatter_chrono<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  template<>
    inline constexpr bool
    enable_nonlocking_formatter_optimization<chrono::year_month_day> = true;
#endif
 
  template<__format::__char _CharT>
    struct formatter<chrono::year_month_day_last, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f._M_parse(__pc, _Date, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::year_month_day_last& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          using enum __format::_ChronoParts;
 
          __format::_ChronoData<_CharT> __cd{};
          auto __parts = _M_f._M_spec._M_needed;
          __parts = __cd._M_fill_year_month(__t, __parts);
          if (_M_f._M_spec._M_needs(_Day|_WeekdayIndex))
            __parts = __cd._M_fill_day(__t.day(), __parts);
          if (__parts == 0)
            return _M_f._M_format(__cd, __fc);
 
          __cd._M_fill_ldays(chrono::local_days(__t), __parts);
          return _M_f._M_format(__cd, __fc);
        }
 
    private:
        static constexpr __format::_ChronoSpec<_CharT> __defSpec = []
        {
          using __format::_ChronoFormats;
          using enum __format::_ChronoParts;
 
          __format::_ChronoSpec<_CharT> __res{};
          __res._M_debug = true;
          __res._M_localized = true;
          __res._M_locale_specific = true;
          __res._M_needed = _Year|_Month;
          __res._M_chrono_specs = _ChronoFormats<_CharT>::_S_yml();
          return __res;
        }();
 
      __format::__formatter_chrono<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  template<>
    inline constexpr bool
    enable_nonlocking_formatter_optimization<chrono::year_month_day_last> = true;
#endif
 
  template<__format::__char _CharT>
    struct formatter<chrono::year_month_weekday, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f._M_parse(__pc, _Date, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::year_month_weekday& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          __format::_ChronoData<_CharT> __cd{};
          auto __parts = _M_f._M_spec._M_needed;
          __parts = __cd._M_fill_year_month(__t, __parts);
          __parts = __cd._M_fill_weekday(__t.weekday_indexed(), __parts);
          if (__t.index() == 0) [[unlikely]]
            // n.b. day cannot be negative, so any 0th weekday uses
            // value-initialized (0) day of month
            __parts -= __format::_ChronoParts::_Day;
          if (__parts == 0)
            return _M_f._M_format(__cd, __fc);
 
          chrono::local_days __ld(__t);
          __parts = __cd._M_fill_ldays(__ld, __parts);
          if (__parts == 0)
            return _M_f._M_format(__cd, __fc);
 
          auto __dom = __ld - chrono::local_days(__t.year()/__t.month()/0);
          // n.b. weekday index is supplied by input, do not override it
          __cd._M_day = chrono::day(__dom.count());
          return _M_f._M_format(__cd, __fc);
        }
 
    private:
        static constexpr __format::_ChronoSpec<_CharT> __defSpec = []
        {
          using __format::_ChronoFormats;
          using enum __format::_ChronoParts;
 
          __format::_ChronoSpec<_CharT> __res{};
          __res._M_debug = true;
          __res._M_localized = true;
          __res._M_locale_specific = true;
          __res._M_needed = _Year|_Month|_IndexedWeekday;
          __res._M_chrono_specs = _ChronoFormats<_CharT>::_S_ymwi();
          return __res;
        }();
 
      __format::__formatter_chrono<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  template<>
    inline constexpr bool
    enable_nonlocking_formatter_optimization<chrono::year_month_weekday> = true;
#endif
 
  template<__format::__char _CharT>
    struct formatter<chrono::year_month_weekday_last, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f._M_parse(__pc, _Date, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::year_month_weekday_last& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          __format::_ChronoData<_CharT> __cd{};
          auto __parts = _M_f._M_spec._M_needed;
          __parts = __cd._M_fill_year_month(__t, __parts);
          __cd._M_weekday = __t.weekday_last().weekday();
          __parts -= __format::_ChronoParts::_Weekday;
          if (__parts == 0)
            return _M_f._M_format(__cd, __fc);
 
          chrono::local_days __ld(__t);
          __parts = __cd._M_fill_ldays(__ld, __parts);
          if (__parts == 0)
            return _M_f._M_format(__cd, __fc);
 
          auto __dom = __ld - chrono::local_days(__t.year()/__t.month()/0);
          __cd._M_fill_day(chrono::day(__dom.count()), __parts);
          return _M_f._M_format(__cd, __fc);
        }
 
    private:
        static constexpr __format::_ChronoSpec<_CharT> __defSpec = []
        {
          using __format::_ChronoFormats;
          using enum __format::_ChronoParts;
 
          __format::_ChronoSpec<_CharT> __res{};
          __res._M_debug = true;
          __res._M_localized = true;
          __res._M_locale_specific = true;
          __res._M_needed = _Year|_Month|_Weekday;
          __res._M_chrono_specs = _ChronoFormats<_CharT>::_S_ymwl();
          return __res;
        }();
 
      __format::__formatter_chrono<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  template<>
    inline constexpr bool
    enable_nonlocking_formatter_optimization<chrono::year_month_weekday_last> = true;
#endif
 
  template<typename _Rep, typename _Period, __format::__char _CharT>
    struct formatter<chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f.template _M_parse<_Precision>(__pc, _Time, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          using enum __format::_ChronoParts;
 
          __format::_ChronoData<_CharT> __cd;
          __cd._M_is_neg = __t.is_negative();
          __cd._M_hours = __t.hours();
          __cd._M_minutes = __t.minutes();
          __cd._M_seconds = __t.seconds();
 
          _Precision __d(0);
          // n.b. computing total duration or total seconds may overflow,
          // do not compute them if not requested.
          if (_M_f._M_spec._M_needs(_EpochUnits))
            __d = __t.to_duration();
          if (_M_f._M_spec._M_needs(_TotalSeconds))
            __cd._M_eseconds
              = __cd._M_hours + __cd._M_minutes + __cd._M_seconds;
          return _M_f._M_format_units(__cd, __d, __t.subseconds(), __fc);
        }
 
    private:
      using _Precision
        = typename chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>::precision;
      static constexpr __format::_ChronoSpec<_CharT> __defSpec =
        __format::__formatter_duration<_CharT>::
           template _S_spec_for<_Precision>(__format::_ChronoParts::_Time);
 
      __format::__formatter_duration<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 4400. enable_nonlocking_formatter_optimization for durations with custom rep
  template<typename _Duration>
    constexpr bool
    enable_nonlocking_formatter_optimization<chrono::hh_mm_ss<_Duration>>
      = enable_nonlocking_formatter_optimization<_Duration>;
#endif
 
#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
  template<__format::__char _CharT>
    struct formatter<chrono::sys_info, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f.parse(__pc); }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::sys_info& __i,
               basic_format_context<_Out, _CharT>& __fc) const
        { return _M_f.format(__i, __fc); }
 
    private:
      __format::__formatter_chrono_info<_CharT> _M_f;
    };
 
#if __glibcxx_print >= 202406L
  template<>
    inline constexpr bool
    enable_nonlocking_formatter_optimization<chrono::sys_info> = true;
#endif
 
  template<__format::__char _CharT>
    struct formatter<chrono::local_info, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f.parse(__pc); }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::local_info& __i,
               basic_format_context<_Out, _CharT>& __fc) const
        { return _M_f.format(__i, __fc); }
 
    private:
      __format::__formatter_chrono_info<_CharT> _M_f;
    };
 
#if __glibcxx_print >= 202406L
  template<>
    inline constexpr bool
    enable_nonlocking_formatter_optimization<chrono::local_info> = true;
#endif
#endif
 
  template<typename _Duration, __format::__char _CharT>
    struct formatter<chrono::sys_time<_Duration>, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        auto __res
          = _M_f.template _M_parse<_Duration>(__pc, _ZonedDateTime, __defSpec);
        if constexpr (__defSpec._M_chrono_specs.empty())
          if (_M_f._M_spec._M_chrono_specs.empty())
            __format::__invalid_chrono_spec(); // chrono-specs can't be empty
        return __res;
     }
 
     template<typename _Out>
       typename basic_format_context<_Out, _CharT>::iterator
       format(const chrono::sys_time<_Duration>& __t,
              basic_format_context<_Out, _CharT>& __fc) const
       {
         __format::_ChronoData<_CharT> __cd{};
         __cd._M_fill_utc_zone();
 
         _Duration __ed = __t.time_since_epoch();
         __cd._M_eseconds = chrono::floor<chrono::seconds>(__ed);
         __cd._M_lseconds = chrono::local_seconds(__cd._M_eseconds);
         return _M_f._M_format_time_point(__cd, __ed, __fc);
       }
 
    private:
      static constexpr __format::_ChronoSpec<_CharT> __defSpec =
        __format::__formatter_duration<_CharT>::template _S_spec_for_tp<_Duration>();
 
      __format::__formatter_duration<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 4400. enable_nonlocking_formatter_optimization for durations with custom rep
  template<typename _Duration>
    constexpr bool
    enable_nonlocking_formatter_optimization<chrono::sys_time<_Duration>>
      = enable_nonlocking_formatter_optimization<_Duration>;
#endif
 
  template<typename _Duration, __format::__char _CharT>
    struct formatter<chrono::utc_time<_Duration>, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f.template _M_parse<_Duration>(__pc, _ZonedDateTime, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::utc_time<_Duration>& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          using __format::_ChronoParts;
          using namespace chrono;
          __format::_ChronoData<_CharT> __cd{};
          __cd._M_fill_utc_zone();
 
          _Duration __ed = __t.time_since_epoch();
          __cd._M_eseconds = chrono::floor<seconds>(__ed);
          // Adjust by removing leap seconds to get equivalent sys_time.
          // We can't just use clock_cast because we want to know if the time
          // falls within a leap second insertion, and format seconds as "60".
          const auto __li = chrono::get_leap_second_info(__t);
          __cd._M_lseconds = local_seconds(__cd._M_eseconds - __li.elapsed);
          auto __parts = _M_f._M_spec._M_needed - _ChronoParts::_TotalSeconds;
          if ((__parts & _ChronoParts::_DateTime) != 0)
          {
            __cd._M_fill_date_time(__cd._M_lseconds, __parts);
            __cd._M_seconds += seconds(__li.is_leap_second);
          }
          return _M_f._M_format_units(__cd, __ed, __ed - __cd._M_eseconds, __fc);
        }
 
    private:
      static constexpr __format::_ChronoSpec<_CharT> __defSpec =
        __format::__formatter_duration<_CharT>::
          template _S_spec_for<_Duration>(__format::_ChronoParts::_DateTime);
 
      __format::__formatter_duration<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 4400. enable_nonlocking_formatter_optimization for durations with custom rep
  template<typename _Duration>
    constexpr bool
    enable_nonlocking_formatter_optimization<chrono::utc_time<_Duration>>
      = enable_nonlocking_formatter_optimization<_Duration>;
#endif
 
  template<typename _Duration, __format::__char _CharT>
    struct formatter<chrono::tai_time<_Duration>, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f.template _M_parse<_Duration>(__pc, _ZonedDateTime, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::tai_time<_Duration>& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          using namespace chrono;
          __format::_ChronoData<_CharT> __cd{};
          __cd._M_fill_zone("TAI", L"TAI");
 
          _Duration __ed = __t.time_since_epoch();
          __cd._M_eseconds = chrono::floor<seconds>(__ed);
          // Offset is 1970y/January/1 - 1958y/January/1
          constexpr chrono::days __tai_offset = chrono::days(4383);
          __cd._M_lseconds = local_seconds(__cd._M_eseconds - __tai_offset);
          return _M_f._M_format_time_point(__cd, __ed, __fc);
        }
 
    private:
      static constexpr __format::_ChronoSpec<_CharT> __defSpec =
        __format::__formatter_duration<_CharT>::
          template _S_spec_for<_Duration>(__format::_ChronoParts::_DateTime);
 
      __format::__formatter_duration<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 4400. enable_nonlocking_formatter_optimization for durations with custom rep
  template<typename _Duration>
    constexpr bool
    enable_nonlocking_formatter_optimization<chrono::tai_time<_Duration>>
      = enable_nonlocking_formatter_optimization<_Duration>;
#endif
 
  template<typename _Duration, __format::__char _CharT>
    struct formatter<chrono::gps_time<_Duration>, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f.template _M_parse<_Duration>(__pc, _ZonedDateTime, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::gps_time<_Duration>& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          using namespace chrono;
          __format::_ChronoData<_CharT> __cd{};
          __cd._M_fill_zone("GPS", L"GPS");
 
          _Duration __ed = __t.time_since_epoch();
          __cd._M_eseconds = chrono::floor<seconds>(__ed);
          // Offset is 1980y/January/Sunday[1] - 1970y/January/1
          constexpr chrono::days __gps_offset = chrono::days(3657);
          __cd._M_lseconds = local_seconds(__cd._M_eseconds + __gps_offset);
          return _M_f._M_format_time_point(__cd, __ed, __fc);
        }
 
    private:
      static constexpr __format::_ChronoSpec<_CharT> __defSpec =
        __format::__formatter_duration<_CharT>::
          template _S_spec_for<_Duration>(__format::_ChronoParts::_DateTime);
 
      __format::__formatter_duration<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 4400. enable_nonlocking_formatter_optimization for durations with custom rep
  template<typename _Duration>
    constexpr bool
    enable_nonlocking_formatter_optimization<chrono::gps_time<_Duration>>
      = enable_nonlocking_formatter_optimization<_Duration>;
#endif
 
  template<typename _Duration, __format::__char _CharT>
    struct formatter<chrono::file_time<_Duration>, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f.template _M_parse<_Duration>(__pc, _ZonedDateTime, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::file_time<_Duration>& __t,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          using namespace chrono;
          __format::_ChronoData<_CharT> __cd{};
          __cd._M_fill_utc_zone();
 
          _Duration __ed = __t.time_since_epoch();
          __cd._M_eseconds = chrono::floor<seconds>(__ed);
          auto __st = chrono::clock_cast<system_clock>(__t);
          __cd._M_lseconds
            = local_seconds(chrono::floor<seconds>(__st.time_since_epoch()));
          return _M_f._M_format_time_point(__cd, __ed, __fc);
        }
 
    private:
      static constexpr __format::_ChronoSpec<_CharT> __defSpec =
        __format::__formatter_duration<_CharT>::
          template _S_spec_for<_Duration>(__format::_ChronoParts::_DateTime);
 
      __format::__formatter_duration<_CharT> _M_f{__defSpec};
     };
 
#if __glibcxx_print >= 202406L
  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 4400. enable_nonlocking_formatter_optimization for durations with custom rep
  template<typename _Duration>
    constexpr bool
    enable_nonlocking_formatter_optimization<chrono::file_time<_Duration>>
      = enable_nonlocking_formatter_optimization<_Duration>;
#endif
 
  template<typename _Duration, __format::__char _CharT>
    struct formatter<chrono::local_time<_Duration>, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        auto __res
          = _M_f.template _M_parse<_Duration>(__pc, _DateTime, __defSpec);
        if constexpr (__defSpec._M_chrono_specs.empty())
          if (_M_f._M_spec._M_chrono_specs.empty())
            __format::__invalid_chrono_spec(); // chrono-specs can't be empty
        return __res;
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::local_time<_Duration>& __lt,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          __format::_ChronoData<_CharT> __cd{};
          _Duration __ed = __lt.time_since_epoch();
          __cd._M_lseconds = chrono::floor<chrono::seconds>(__lt);
          __cd._M_eseconds = __cd._M_lseconds.time_since_epoch();
          return _M_f._M_format_time_point(__cd, __ed, __fc);
        }
 
    private:
      static constexpr __format::_ChronoSpec<_CharT> __defSpec =
        __format::__formatter_duration<_CharT>::template _S_spec_for_tp<_Duration>();
 
      __format::__formatter_duration<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 4400. enable_nonlocking_formatter_optimization for durations with custom rep
  template<typename _Duration>
    constexpr bool
    enable_nonlocking_formatter_optimization<chrono::local_time<_Duration>>
      = enable_nonlocking_formatter_optimization<_Duration>;
#endif
 
  template<typename _Duration, __format::__char _CharT>
    struct formatter<chrono::__detail::__local_time_fmt<_Duration>, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
        using enum __format::_ChronoParts;
        return _M_f.template _M_parse<_Duration>(__pc, _ZonedDateTime, __defSpec);
      }
 
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::__detail::__local_time_fmt<_Duration>& __zt,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          using enum __format::_ChronoParts;
          __format::_ChronoData<_CharT> __cd{};
 
          if (_M_f._M_spec._M_needs(_ZoneOffset))
            {
              if (!__zt._M_offset_sec)
                std::__throw_format_error("format error: no timezone available for %z");
              __cd._M_zone_offset = *__zt._M_offset_sec;
            }
 
          basic_string<_CharT> __zone_store;
          if (_M_f._M_spec._M_needs(_ZoneAbbrev))
            {
              if (!__zt._M_abbrev)
                std::__throw_format_error("format error: no timezone available for %Z");
 
              __cd._M_zone_cstr = __zt._M_abbrev->data();
              if constexpr (is_same_v<_CharT, char>)
                __cd._M_zone_abbrev = *__zt._M_abbrev;
              else
                {
                  // TODO: use resize_for_override
                  __zone_store.resize(__zt._M_abbrev->size());
                  auto& __ct = use_facet<ctype<_CharT>>(_M_f._M_locale(__fc));
                  __ct.widen(__zt._M_abbrev->data(),
                             __zt._M_abbrev->data() + __zt._M_abbrev->size(),
                             __zone_store.data());
                  __cd._M_zone_abbrev = __zone_store;
                }
            }
 
          _Duration __ed = __zt._M_time.time_since_epoch();
          __cd._M_lseconds = chrono::floor<chrono::seconds>(__zt._M_time);
          __cd._M_eseconds = __cd._M_lseconds.time_since_epoch();
          return _M_f._M_format_time_point(__cd, __ed, __fc);
        }
 
    private:
      static constexpr __format::_ChronoSpec<_CharT> __defSpec =
        __format::__formatter_duration<_CharT>::
          template _S_spec_for<_Duration>(__format::_ChronoParts::_ZonedDateTime);
 
      __format::__formatter_duration<_CharT> _M_f{__defSpec};
    };
 
#if __glibcxx_print >= 202406L
  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 4400. enable_nonlocking_formatter_optimization for durations with custom rep
  template<typename _Duration>
    constexpr bool
    enable_nonlocking_formatter_optimization<
      chrono::__detail::__local_time_fmt<_Duration>>
      = enable_nonlocking_formatter_optimization<_Duration>;
#endif
 
#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
  template<typename _Duration, typename _TimeZonePtr, __format::__char _CharT>
    struct formatter<chrono::zoned_time<_Duration, _TimeZonePtr>, _CharT>
    : formatter<chrono::__detail::__local_time_fmt_for<_Duration>, _CharT>
    {
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::zoned_time<_Duration, _TimeZonePtr>& __tp,
               basic_format_context<_Out, _CharT>& __fc) const
        {
          using _Ltf = chrono::__detail::__local_time_fmt_for<_Duration>;
          using _Base = formatter<_Ltf, _CharT>;
          const chrono::sys_info __info = __tp.get_info();
          const auto __lf = chrono::local_time_format(__tp.get_local_time(),
                                                      &__info.abbrev,
                                                      &__info.offset);
          return _Base::format(__lf, __fc);
        }
    };
 
#if __glibcxx_print >= 202406L
  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 4400. enable_nonlocking_formatter_optimization for durations with custom rep
  template<typename _Duration>
    constexpr bool
    enable_nonlocking_formatter_optimization<
      chrono::zoned_time<_Duration, const chrono::time_zone*>>
      = enable_nonlocking_formatter_optimization<_Duration>;
#endif
#endif
 
namespace chrono
{
/// @addtogroup chrono
/// @{
 
/// @cond undocumented
namespace __detail
{
  template<typename _Duration = seconds>
    struct _Parser
    {
      static_assert(is_same_v<common_type_t<_Duration, seconds>, _Duration>);
 
      explicit
      _Parser(__format::_ChronoParts __need) : _M_need(__need) { }
 
      _Parser(_Parser&&) = delete;
      void operator=(_Parser&&) = delete;
 
      _Duration _M_time{}; // since midnight
      sys_days _M_sys_days{};
      year_month_day _M_ymd{};
      weekday _M_wd{};
      __format::_ChronoParts _M_need;
      unsigned _M_is_leap_second : 1 {};
      unsigned _M_reserved : 15 {};
 
      template<typename _CharT, typename _Traits, typename _Alloc>
        basic_istream<_CharT, _Traits>&
        operator()(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
                   basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
                   minutes* __offset = nullptr);
 
    private:
      // Read an unsigned integer from the stream and return it.
      // Extract no more than __n digits. Set failbit if an integer isn't read.
      template<typename _CharT, typename _Traits>
        static int_least32_t
        _S_read_unsigned(basic_istream<_CharT, _Traits>& __is,
                         ios_base::iostate& __err, int __n)
        {
          int_least32_t __val = _S_try_read_digit(__is, __err);
          if (__val == -1) [[unlikely]]
            __err |= ios_base::failbit;
          else
            {
              int __n1 = (std::min)(__n, 9);
              // Cannot overflow __val unless we read more than 9 digits
              for (int __i = 1; __i < __n1; ++__i)
                if (auto __dig = _S_try_read_digit(__is, __err); __dig != -1)
                  {
                    __val *= 10;
                    __val += __dig;
                  }
 
              while (__n1++ < __n) [[unlikely]]
                if (auto __dig = _S_try_read_digit(__is, __err); __dig != -1)
                  {
                    if (__builtin_mul_overflow(__val, 10, &__val)
                          || __builtin_add_overflow(__val, __dig, &__val))
                      {
                        __err |= ios_base::failbit;
                        return -1;
                      }
                  }
            }
          return __val;
        }
 
      // Read an unsigned integer from the stream and return it.
      // Extract no more than __n digits. Set failbit if an integer isn't read.
      template<typename _CharT, typename _Traits>
        static int_least32_t
        _S_read_signed(basic_istream<_CharT, _Traits>& __is,
                         ios_base::iostate& __err, int __n)
        {
          auto __sign = __is.peek();
          if (__sign == '-' || __sign == '+')
            (void) __is.get();
          int_least32_t __val = _S_read_unsigned(__is, __err, __n);
          if (__err & ios_base::failbit)
            {
              if (__sign == '-') [[unlikely]]
                __val *= -1;
            }
          return __val;
        }
 
      // Read a digit from the stream and return it, or return -1.
      // If no digit is read eofbit will be set (but not failbit).
      template<typename _CharT, typename _Traits>
        static int_least32_t
        _S_try_read_digit(basic_istream<_CharT, _Traits>& __is,
                          ios_base::iostate& __err)
        {
          int_least32_t __val = -1;
          auto __i = __is.peek();
          if (!_Traits::eq_int_type(__i, _Traits::eof())) [[likely]]
            {
              _CharT __c = _Traits::to_char_type(__i);
              if (_CharT('0') <= __c && __c <= _CharT('9')) [[likely]]
                {
                  (void) __is.get();
                  __val = __c - _CharT('0');
                }
            }
          else
            __err |= ios_base::eofbit;
          return __val;
        }
 
      // Read the specified character and return true.
      // If the character is not found, set failbit and return false.
      template<typename _CharT, typename _Traits>
        static bool
        _S_read_chr(basic_istream<_CharT, _Traits>& __is,
                    ios_base::iostate& __err, _CharT __c)
        {
          auto __i = __is.peek();
          if (_Traits::eq_int_type(__i, _Traits::eof()))
            __err |= ios_base::eofbit;
          else if (_Traits::to_char_type(__i) == __c) [[likely]]
            {
              (void) __is.get();
              return true;
            }
          __err |= ios_base::failbit;
          return false;
        }
    };
 
  template<typename _Duration>
    using _Parser_t = _Parser<common_type_t<_Duration, seconds>>;
 
  template<typename _Duration>
    consteval bool
    __use_floor()
    {
      if constexpr (_Duration::period::den == 1)
        {
          switch (_Duration::period::num)
          {
            case minutes::period::num:
            case hours::period::num:
            case days::period::num:
            case weeks::period::num:
            case years::period::num:
              return true;
          }
        }
      return false;
    }
 
  // A "do the right thing" rounding function for duration and time_point
  // values extracted by from_stream. When treat_as_floating_point is true
  // we don't want to do anything, just a straightforward conversion.
  // When the destination type has a period of minutes, hours, days, weeks,
  // or years, we use chrono::floor to truncate towards negative infinity.
  // This ensures that an extracted timestamp such as 2024-09-05 13:00:00
  // will produce 2024-09-05 when rounded to days, rather than rounding up
  // to 2024-09-06 (a different day).
  // Otherwise, use chrono::round to get the nearest value representable
  // in the destination type.
  template<typename _ToDur, typename _Tp>
    constexpr auto
    __round(const _Tp& __t)
    {
      if constexpr (__is_duration_v<_Tp>)
        {
          if constexpr (treat_as_floating_point_v<typename _Tp::rep>)
            return chrono::duration_cast<_ToDur>(__t);
          else if constexpr (__detail::__use_floor<_ToDur>())
            return chrono::floor<_ToDur>(__t);
          else
            return chrono::round<_ToDur>(__t);
        }
      else
        {
          static_assert(__is_time_point_v<_Tp>);
          using _Tpt = time_point<typename _Tp::clock, _ToDur>;
          return _Tpt(__detail::__round<_ToDur>(__t.time_since_epoch()));
        }
    }
 
} // namespace __detail
/// @endcond
 
  template<typename _CharT, typename _Traits, typename _Rep, typename _Period,
           typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
                duration<_Rep, _Period>& __d,
                basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
                minutes* __offset = nullptr)
    {
      auto __need = __format::_ChronoParts::_TimeOfDay;
      __detail::_Parser_t<duration<_Rep, _Period>> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
        __d = __detail::__round<duration<_Rep, _Period>>(__p._M_time);
      return __is;
    }
 
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const day& __d)
    {
      using _Ctx = __format::__format_context<_CharT>;
      using _Str = basic_string_view<_CharT>;
      _Str __s = _GLIBCXX_WIDEN("{:02d} is not a valid day");
      if (__d.ok())
        __s = __s.substr(0, 6);
      auto __u = (unsigned)__d;
      __os << std::vformat(__s, make_format_args<_Ctx>(__u));
      return __os;
    }
 
  template<typename _CharT, typename _Traits,
           typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
                day& __d,
                basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
                minutes* __offset = nullptr)
    {
      __detail::_Parser<> __p(__format::_ChronoParts::_Day);
      if (__p(__is, __fmt, __abbrev, __offset))
        __d = __p._M_ymd.day();
      return __is;
    }
 
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const month& __m)
    {
      using _Ctx = __format::__format_context<_CharT>;
      using _Str = basic_string_view<_CharT>;
      _Str __s = _GLIBCXX_WIDEN("{:L%b}{} is not a valid month");
      if (__m.ok())
        __os << std::vformat(__os.getloc(), __s.substr(0, 6),
                             make_format_args<_Ctx>(__m));
      else
        {
          auto __u = (unsigned)__m;
          __os << std::vformat(__s.substr(6), make_format_args<_Ctx>(__u));
        }
      return __os;
    }
 
  template<typename _CharT, typename _Traits,
           typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
                month& __m,
                basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
                minutes* __offset = nullptr)
    {
      __detail::_Parser<> __p(__format::_ChronoParts::_Month);
      if (__p(__is, __fmt, __abbrev, __offset))
        __m = __p._M_ymd.month();
      return __is;
    }
 
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const year& __y)
    {
      using _Ctx = __format::__format_context<_CharT>;
      using _Str = basic_string_view<_CharT>;
      _Str __s = _GLIBCXX_WIDEN("-{:04d} is not a valid year");
      if (__y.ok())
        __s = __s.substr(0, 7);
      int __i = (int)__y;
      if (__i >= 0) [[likely]]
        __s.remove_prefix(1);
      else
        __i = -__i;
      __os << std::vformat(__s, make_format_args<_Ctx>(__i));
      return __os;
    }
 
  template<typename _CharT, typename _Traits,
           typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
                year& __y,
                basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
                minutes* __offset = nullptr)
    {
      __detail::_Parser<> __p(__format::_ChronoParts::_Year);
      if (__p(__is, __fmt, __abbrev, __offset))
        __y = __p._M_ymd.year();
      return __is;
    }
 
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const weekday& __wd)
    {
      using _Ctx = __format::__format_context<_CharT>;
      using _Str = basic_string_view<_CharT>;
      _Str __s = _GLIBCXX_WIDEN("{:L%a}{} is not a valid weekday");
      if (__wd.ok())
        __os << std::vformat(__os.getloc(), __s.substr(0, 6),
                             make_format_args<_Ctx>(__wd));
      else
        {
          auto __c = __wd.c_encoding();
          __os << std::vformat(__s.substr(6), make_format_args<_Ctx>(__c));
        }
      return __os;
    }
 
  template<typename _CharT, typename _Traits,
           typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
                weekday& __wd,
                basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
                minutes* __offset = nullptr)
    {
      __detail::_Parser<> __p(__format::_ChronoParts::_Weekday);
      if (__p(__is, __fmt, __abbrev, __offset))
        __wd = __p._M_wd;
      return __is;
    }
 
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const weekday_indexed& __wdi)
    {
      // The standard says to format wdi.weekday() and wdi.index() using
      // either "{:L}[{}]" or "{:L}[{} is not a valid index]". The {:L} spec
      // means to format the weekday using ostringstream, so just do that.
      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __wdi.weekday();
      const auto __i = __wdi.index();
      basic_string_view<_CharT> __s
        = _GLIBCXX_WIDEN("[ is not a valid index]");
      __os2 << __s[0];
      __os2 << std::format(_GLIBCXX_WIDEN("{}"), __i);
      if (__i >= 1 && __i <= 5)
        __os2 << __s.back();
      else
        __os2 << __s.substr(1);
      __os << __os2.view();
      return __os;
    }
 
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const weekday_last& __wdl)
    {
      // As above, just write straight to a stringstream, as if by "{:L}[last]"
      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __wdl.weekday() << _GLIBCXX_WIDEN("[last]");
      __os << __os2.view();
      return __os;
    }
 
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const month_day& __md)
    {
      // As above, just write straight to a stringstream, as if by "{:L}/{}"
      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __md.month();
      if constexpr (is_same_v<_CharT, char>)
        __os2 << '/';
      else
        __os2 << L'/';
      __os2 << __md.day();
      __os << __os2.view();
      return __os;
    }
 
  template<typename _CharT, typename _Traits,
           typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
                month_day& __md,
                basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
                minutes* __offset = nullptr)
    {
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Month | _ChronoParts::_Day;
      __detail::_Parser<> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
        __md = month_day(__p._M_ymd.month(), __p._M_ymd.day());
      return __is;
    }
 
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const month_day_last& __mdl)
    {
      // As above, just write straight to a stringstream, as if by "{:L}/last"
      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __mdl.month() << _GLIBCXX_WIDEN("/last");
      __os << __os2.view();
      return __os;
    }
 
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const month_weekday& __mwd)
    {
      // As above, just write straight to a stringstream, as if by "{:L}/{:L}"
      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __mwd.month();
      if constexpr (is_same_v<_CharT, char>)
        __os2 << '/';
      else
        __os2 << L'/';
      __os2 << __mwd.weekday_indexed();
      __os << __os2.view();
      return __os;
    }
 
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const month_weekday_last& __mwdl)
    {
      // As above, just write straight to a stringstream, as if by "{:L}/{:L}"
      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __mwdl.month();
      if constexpr (is_same_v<_CharT, char>)
        __os2 << '/';
      else
        __os2 << L'/';
      __os2 << __mwdl.weekday_last();
      __os << __os2.view();
      return __os;
    }
 
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const year_month& __ym)
    {
      // As above, just write straight to a stringstream, as if by "{}/{:L}"
      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __ym.year();
      if constexpr (is_same_v<_CharT, char>)
        __os2 << '/';
      else
        __os2 << L'/';
      __os2 << __ym.month();
      __os << __os2.view();
      return __os;
    }
 
  template<typename _CharT, typename _Traits,
           typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
                year_month& __ym,
                basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
                minutes* __offset = nullptr)
    {
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Year | _ChronoParts::_Month;
      __detail::_Parser<> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
        __ym = year_month(__p._M_ymd.year(), __p._M_ymd.month());
      return __is;
    }
 
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const year_month_day& __ymd)
    {
      using _Ctx = __format::__format_context<_CharT>;
      using _Str = basic_string_view<_CharT>;
      _Str __s = _GLIBCXX_WIDEN("{:%F} is not a valid date");
      __os << std::vformat(__ymd.ok() ? __s.substr(0, 5) : __s,
                           make_format_args<_Ctx>(__ymd));
      return __os;
    }
 
  template<typename _CharT, typename _Traits,
           typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
                year_month_day& __ymd,
                basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
                minutes* __offset = nullptr)
    {
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Year | _ChronoParts::_Month
                    | _ChronoParts::_Day;
      __detail::_Parser<> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
        __ymd = __p._M_ymd;
      return __is;
    }
 
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const year_month_day_last& __ymdl)
    {
      // As above, just write straight to a stringstream, as if by "{}/{:L}"
      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __ymdl.year();
      if constexpr (is_same_v<_CharT, char>)
        __os2 << '/';
      else
        __os2 << L'/';
      __os2 << __ymdl.month_day_last();
      __os << __os2.view();
      return __os;
    }
 
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const year_month_weekday& __ymwd)
    {
      // As above, just write straight to a stringstream, as if by
      // "{}/{:L}/{:L}"
      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      _CharT __slash;
      if constexpr (is_same_v<_CharT, char>)
        __slash = '/';
      else
        __slash = L'/';
      __os2 << __ymwd.year() << __slash << __ymwd.month() << __slash
            << __ymwd.weekday_indexed();
      __os << __os2.view();
      return __os;
    }
 
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const year_month_weekday_last& __ymwdl)
    {
      // As above, just write straight to a stringstream, as if by
      // "{}/{:L}/{:L}"
      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      _CharT __slash;
      if constexpr (is_same_v<_CharT, char>)
        __slash = '/';
      else
        __slash = L'/';
      __os2 << __ymwdl.year() << __slash << __ymwdl.month() << __slash
            << __ymwdl.weekday_last();
      __os << __os2.view();
      return __os;
    }
 
  template<typename _CharT, typename _Traits, typename _Duration>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const hh_mm_ss<_Duration>& __hms)
    {
      return __os << format(__os.getloc(), _GLIBCXX_WIDEN("{:L%T}"), __hms);
    }
 
#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
  /// Writes a sys_info object to an ostream in an unspecified format.
  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_info& __i)
    {
      return __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{}"), __i);
    }
 
  /// Writes a local_info object to an ostream in an unspecified format.
  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const local_info& __li)
    {
      __os << __format::_Separators<_CharT>::_S_squares()[0];
      if (__li.result == local_info::unique)
        __os << __li.first;
      else
        {
          if (__li.result == local_info::nonexistent)
            __os << _GLIBCXX_WIDEN("nonexistent");
          else
            __os << _GLIBCXX_WIDEN("ambiguous");
          __os << _GLIBCXX_WIDEN(" local time between ") << __li.first;
          __os << _GLIBCXX_WIDEN(" and ") << __li.second;
        }
      __os << __format::_Separators<_CharT>::_S_squares()[1];
      return __os;
    }
 
  template<typename _CharT, typename _Traits, typename _Duration,
           typename _TimeZonePtr>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const zoned_time<_Duration, _TimeZonePtr>& __t)
    {
      __os << format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T %Z}"), __t);
      return __os;
    }
#endif
 
  template<typename _CharT, typename _Traits, typename _Duration>
    requires (!treat_as_floating_point_v<typename _Duration::rep>)
      && ratio_less_v<typename _Duration::period, days::period>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const sys_time<_Duration>& __tp)
    {
      __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}"), __tp);
      return __os;
    }
 
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_days& __dp)
    {
      __os << year_month_day{__dp};
      return __os;
    }
 
  template<typename _CharT, typename _Traits, typename _Duration,
           typename _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
                sys_time<_Duration>& __tp,
                basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
                minutes* __offset = nullptr)
    {
      minutes __off{};
      if (!__offset)
        __offset = &__off;
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Year | _ChronoParts::_Month
                    | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
      __detail::_Parser_t<_Duration> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
        {
          if (__p._M_is_leap_second)
            __is.setstate(ios_base::failbit);
          else
            {
              auto __st = __p._M_sys_days + __p._M_time - *__offset;
              __tp = __detail::__round<_Duration>(__st);
            }
        }
      return __is;
    }
 
  template<typename _CharT, typename _Traits, typename _Duration>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const utc_time<_Duration>& __t)
    {
      __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}"), __t);
      return __os;
    }
 
  template<typename _CharT, typename _Traits, typename _Duration,
           typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
                utc_time<_Duration>& __tp,
                basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
                minutes* __offset = nullptr)
    {
      minutes __off{};
      if (!__offset)
        __offset = &__off;
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Year | _ChronoParts::_Month
                    | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
      __detail::_Parser_t<_Duration> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
        {
          // Converting to utc_time before adding _M_time is necessary for
          // "23:59:60" to correctly produce a time within a leap second.
          auto __ut = utc_clock::from_sys(__p._M_sys_days) + __p._M_time
                        - *__offset;
          __tp = __detail::__round<_Duration>(__ut);
        }
      return __is;
    }
 
  template<typename _CharT, typename _Traits, typename _Duration>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const tai_time<_Duration>& __t)
    {
      __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}"), __t);
      return __os;
    }
 
  template<typename _CharT, typename _Traits, typename _Duration,
           typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
                tai_time<_Duration>& __tp,
                basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
                minutes* __offset = nullptr)
    {
      minutes __off{};
      if (!__offset)
        __offset = &__off;
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Year | _ChronoParts::_Month
                    | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
      __detail::_Parser_t<_Duration> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
        {
          if (__p._M_is_leap_second)
            __is.setstate(ios_base::failbit);
          else
            {
              constexpr sys_days __epoch(-days(4383)); // 1958y/1/1
              auto __d = __p._M_sys_days - __epoch + __p._M_time - *__offset;
              tai_time<common_type_t<_Duration, seconds>> __tt(__d);
              __tp = __detail::__round<_Duration>(__tt);
            }
        }
      return __is;
    }
 
  template<typename _CharT, typename _Traits, typename _Duration>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const gps_time<_Duration>& __t)
    {
      __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}"), __t);
      return __os;
    }
 
  template<typename _CharT, typename _Traits, typename _Duration,
           typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
                gps_time<_Duration>& __tp,
                basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
                minutes* __offset = nullptr)
    {
      minutes __off{};
      if (!__offset)
        __offset = &__off;
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_YearMonthDay | _ChronoParts::_TimeOfDay;
      __detail::_Parser_t<_Duration> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
        {
          if (__p._M_is_leap_second)
            __is.setstate(ios_base::failbit);
          else
            {
              constexpr sys_days __epoch(days(3657)); // 1980y/1/Sunday[1]
              auto __d = __p._M_sys_days - __epoch + __p._M_time - *__offset;
              gps_time<common_type_t<_Duration, seconds>> __gt(__d);
              __tp = __detail::__round<_Duration>(__gt);
            }
        }
      return __is;
    }
 
  template<typename _CharT, typename _Traits, typename _Duration>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const file_time<_Duration>& __t)
    {
      __os << std::format(__os.getloc(), _GLIBCXX_WIDEN("{:L%F %T}"), __t);
      return __os;
    }
 
  template<typename _CharT, typename _Traits, typename _Duration,
           typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
                file_time<_Duration>& __tp,
                basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
                minutes* __offset = nullptr)
    {
      sys_time<_Duration> __st;
      if (chrono::from_stream(__is, __fmt, __st, __abbrev, __offset))
        __tp = __detail::__round<_Duration>(file_clock::from_sys(__st));
      return __is;
    }
 
  template<typename _CharT, typename _Traits, typename _Duration>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const local_time<_Duration>& __lt)
    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 4257. Stream insertion for chrono::local_time should be constrained
    requires requires(const sys_time<_Duration>& __st) { __os << __st; }
    {
      __os << sys_time<_Duration>{__lt.time_since_epoch()};
      return __os;
    }
 
  template<typename _CharT, typename _Traits, typename _Duration,
           typename _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
                local_time<_Duration>& __tp,
                basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
                minutes* __offset = nullptr)
    {
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_YearMonthDay | _ChronoParts::_TimeOfDay;
      __detail::_Parser_t<_Duration> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
        {
          days __d = __p._M_sys_days.time_since_epoch();
          auto __t = local_days(__d) + __p._M_time; // ignore offset
          __tp = __detail::__round<_Duration>(__t);
        }
      return __is;
    }
 
  // [time.parse] parsing
 
namespace __detail
{
  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 3956. chrono::parse uses from_stream as a customization point
  void from_stream() = delete;
 
  template<typename _Parsable, typename _CharT,
           typename _Traits = std::char_traits<_CharT>,
           typename... _OptArgs>
    concept __parsable = requires (basic_istream<_CharT, _Traits>& __is,
                                   const _CharT* __fmt, _Parsable& __tp,
                                   _OptArgs*... __args)
    { from_stream(__is, __fmt, __tp, __args...); };
 
  template<typename _Parsable, typename _CharT,
           typename _Traits = char_traits<_CharT>,
           typename _Alloc = allocator<_CharT>>
    struct _Parse
    {
    private:
      using __string_type = basic_string<_CharT, _Traits, _Alloc>;
 
    public:
      _Parse(const _CharT* __fmt, _Parsable& __tp,
             basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
             minutes* __offset = nullptr)
      : _M_fmt(__fmt), _M_tp(std::__addressof(__tp)),
        _M_abbrev(__abbrev), _M_offset(__offset)
      { }
 
      _Parse(_Parse&&) = delete;
      _Parse& operator=(_Parse&&) = delete;
 
    private:
      using __stream_type = basic_istream<_CharT, _Traits>;
 
      const _CharT* const  _M_fmt;
      _Parsable* const     _M_tp;
      __string_type* const _M_abbrev;
      minutes* const       _M_offset;
 
      friend __stream_type&
      operator>>(__stream_type& __is, _Parse&& __p)
      {
        if (__p._M_offset)
          from_stream(__is, __p._M_fmt, *__p._M_tp, __p._M_abbrev,
                      __p._M_offset);
        else if (__p._M_abbrev)
          from_stream(__is, __p._M_fmt, *__p._M_tp, __p._M_abbrev);
        else
          from_stream(__is, __p._M_fmt, *__p._M_tp);
        return __is;
      }
 
      friend void operator>>(__stream_type&, _Parse&) = delete;
      friend void operator>>(__stream_type&, const _Parse&) = delete;
    };
} // namespace __detail
 
  template<typename _CharT, __detail::__parsable<_CharT> _Parsable>
    [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
    inline auto
    parse(const _CharT* __fmt, _Parsable& __tp)
    { return __detail::_Parse<_Parsable, _CharT>(__fmt, __tp); }
 
  template<typename _CharT, typename _Traits, typename _Alloc,
           __detail::__parsable<_CharT, _Traits> _Parsable>
    [[nodiscard]]
    inline auto
    parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp)
    {
      return __detail::_Parse<_Parsable, _CharT, _Traits>(__fmt.c_str(), __tp);
    }
 
  template<typename _CharT, typename _Traits, typename _Alloc,
           typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
           __detail::__parsable<_CharT, _Traits, _StrT> _Parsable>
    [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
    inline auto
    parse(const _CharT* __fmt, _Parsable& __tp,
          basic_string<_CharT, _Traits, _Alloc>& __abbrev)
    {
      auto __pa = std::__addressof(__abbrev);
      return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt, __tp,
                                                                  __pa);
    }
 
  template<typename _CharT, typename _Traits, typename _Alloc,
           typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
           __detail::__parsable<_CharT, _Traits, _StrT> _Parsable>
    [[nodiscard]]
    inline auto
    parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
          basic_string<_CharT, _Traits, _Alloc>& __abbrev)
    {
      auto __pa = std::__addressof(__abbrev);
      return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
                                                                  __tp, __pa);
    }
 
  template<typename _CharT, typename _Traits = char_traits<_CharT>,
           typename _StrT = basic_string<_CharT, _Traits>,
           __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
    [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
    inline auto
    parse(const _CharT* __fmt, _Parsable& __tp, minutes& __offset)
    {
      return __detail::_Parse<_Parsable, _CharT>(__fmt, __tp, nullptr,
                                                 &__offset);
    }
 
  template<typename _CharT, typename _Traits, typename _Alloc,
           typename _StrT = basic_string<_CharT, _Traits>,
           __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
    [[nodiscard]]
    inline auto
    parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
          minutes& __offset)
    {
      return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
                                                                  __tp, nullptr,
                                                                  &__offset);
    }
 
  template<typename _CharT, typename _Traits, typename _Alloc,
           typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
           __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
    [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
    inline auto
    parse(const _CharT* __fmt, _Parsable& __tp,
          basic_string<_CharT, _Traits, _Alloc>& __abbrev, minutes& __offset)
    {
      auto __pa = std::__addressof(__abbrev);
      return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt, __tp,
                                                                  __pa,
                                                                  &__offset);
    }
 
  template<typename _CharT, typename _Traits, typename _Alloc,
           typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
           __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
    [[nodiscard]]
    inline auto
    parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
          basic_string<_CharT, _Traits, _Alloc>& __abbrev, minutes& __offset)
    {
      auto __pa = std::__addressof(__abbrev);
      return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
                                                                  __tp, __pa,
                                                                  &__offset);
    }
 
  /// @cond undocumented
  template<typename _Duration>
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    __detail::_Parser<_Duration>::
    operator()(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
               basic_string<_CharT, _Traits, _Alloc>* __abbrev,
               minutes* __offset)
    {
      using sentry = typename basic_istream<_CharT, _Traits>::sentry;
      ios_base::iostate __err = ios_base::goodbit;
      if (sentry __cerb(__is, true); __cerb)
        {
          locale __loc = __is.getloc();
          auto& __tmget = std::use_facet<std::time_get<_CharT>>(__loc);
          auto& __tmpunct = std::use_facet<std::__timepunct<_CharT>>(__loc);
 
          // RAII type to save and restore stream state.
          struct _Stream_state
          {
            explicit
            _Stream_state(basic_istream<_CharT, _Traits>& __i)
            : _M_is(__i),
              _M_flags(__i.flags(ios_base::skipws | ios_base::dec)),
              _M_w(__i.width(0))
            { }
 
            ~_Stream_state()
            {
              _M_is.flags(_M_flags);
              _M_is.width(_M_w);
            }
 
            _Stream_state(_Stream_state&&) = delete;
 
            basic_istream<_CharT, _Traits>& _M_is;
            ios_base::fmtflags _M_flags;
            streamsize _M_w;
          };
 
          auto __is_failed = [](ios_base::iostate __e) {
            return static_cast<bool>(__e & ios_base::failbit);
          };
 
          // Read an unsigned integer from the stream and return it.
          // Extract no more than __n digits. Set __err on error.
          auto __read_unsigned = [&] (int __n) {
            return _S_read_unsigned(__is, __err, __n);
          };
 
          // Read a signed integer from the stream and return it.
          // Extract no more than __n digits. Set __err on error.
          auto __read_signed = [&] (int __n) {
            return _S_read_signed(__is, __err, __n);
          };
 
          // Read an expected character from the stream.
          auto __read_chr = [&__is, &__err] (_CharT __c) {
            return _S_read_chr(__is, __err, __c);
          };
 
          using __format::_ChronoParts;
          _ChronoParts __parts{};
 
          const year __bad_y = --year::min(); // SHRT_MIN
          const month __bad_mon(255);
          const day __bad_day(255);
          const weekday __bad_wday(255);
          const hours __bad_h(-1);
          const minutes __bad_min(-9999);
          const seconds __bad_sec(-1);
 
          year __y = __bad_y, __yy = __bad_y;         // %Y, %yy
          year __iso_y = __bad_y, __iso_yy = __bad_y; // %G, %g
          month __m = __bad_mon;                      // %m
          day __d = __bad_day;                        // %d
          weekday __wday = __bad_wday;                // %a %A %u %w
          hours __h = __bad_h, __h12 = __bad_h;       // %H, %I
          minutes __min = __bad_min;                  // %M
          _Duration __s = __bad_sec;                  // %S
          int __ampm = 0;                             // %p
          int __iso_wk = -1, __sunday_wk = -1, __monday_wk = -1; // %V, %U, %W
          int __century = -1;                         // %C
          int __dayofyear = -1;                       // %j (for non-duration)
 
          minutes __tz_offset = __bad_min;
          basic_string<_CharT, _Traits> __tz_abbr;
 
          if ((_M_need & _ChronoParts::_TimeOfDay) != 0
                && (_M_need & _ChronoParts::_Year) != 0)
            {
              // For time_points assume "00:00:00" is implicitly present,
              // so we don't fail to parse if it's not (PR libstdc++/114240).
              // We will still fail to parse if there's no year+month+day.
              __h = hours(0);
              __parts = _ChronoParts::_TimeOfDay;
            }
 
          // bool __is_neg = false; // TODO: how is this handled for parsing?
 
          _CharT __mod{}; // One of 'E' or 'O' or nul.
          unsigned __num = 0; // Non-zero for N modifier.
          bool __is_flag = false; // True if we're processing a % flag.
 
          constexpr bool __is_floating
            = treat_as_floating_point_v<typename _Duration::rep>;
 
          // If an out-of-range value is extracted (e.g. 61min for %M),
          // do not set failbit immediately because we might not need it
          // (e.g. parsing chrono::year doesn't care about invalid %M values).
          // Instead set the variable back to its initial 'bad' state,
          // and also set related variables corresponding to the same field
          // (e.g. a bad %M value for __min should also reset __h and __s).
          // If a valid value is needed later the bad value will cause failure.
 
          // For some fields we don't know the correct range when parsing and
          // we have to be liberal in what we accept, e.g. we allow 366 for
          // day-of-year because that's valid in leap years, and we allow 31
          // for day-of-month. If those values are needed to determine the
          // result then we can do a correct range check at the end when we
          // know the how many days the relevant year or month actually has.
 
          while (*__fmt)
            {
              _CharT __c = *__fmt++;
              if (!__is_flag)
                {
                  if (__c == '%')
                    __is_flag = true; // This is the start of a flag.
                  else if (std::isspace(__c, __loc))
                    std::ws(__is); // Match zero or more whitespace characters.
                  else if (!__read_chr(__c)) [[unlikely]]
                    break; // Failed to match the expected character.
 
                  continue; // Process next character in the format string.
                }
 
              // Now processing a flag.
              switch (__c)
              {
                case 'a': // Locale's weekday name
                case 'A': // (full or abbreviated, matched case-insensitively).
                  if (__mod || __num) [[unlikely]]
                    __err = ios_base::failbit;
                  else
                    {
                      struct tm __tm{};
                      __tmget.get(__is, {}, __is, __err, &__tm,
                                  __fmt - 2, __fmt);
                      if (!__is_failed(__err))
                        __wday = weekday(__tm.tm_wday);
                    }
                  __parts |= _ChronoParts::_Weekday;
                  break;
 
                case 'b': // Locale's month name
                case 'h': // (full or abbreviated, matched case-insensitively).
                case 'B':
                  if (__mod || __num) [[unlikely]]
                    __err = ios_base::failbit;
                  else
                    {
                      // strptime behaves differently for %b and %B,
                      // but chrono::parse says they're equivalent.
                      // Luckily libstdc++ std::time_get works as needed.
                      struct tm __tm{};
                      __tmget.get(__is, {}, __is, __err, &__tm,
                                  __fmt - 2, __fmt);
                      if (!__is_failed(__err))
                        __m = month(__tm.tm_mon + 1);
                    }
                  __parts |= _ChronoParts::_Month;
                  break;
 
                case 'c': // Locale's date and time representation.
                  if (__mod == 'O' || __num) [[unlikely]]
                    __err |= ios_base::failbit;
                  else
                    {
                      struct tm __tm{};
                      __tmget.get(__is, {}, __is, __err, &__tm,
                                  __fmt - 2 - (__mod == 'E'), __fmt);
                      if (!__is_failed(__err))
                        {
                          __y = year(__tm.tm_year + 1900);
                          __m = month(__tm.tm_mon + 1);
                          __d = day(__tm.tm_mday);
                          __h = hours(__tm.tm_hour);
                          __min = minutes(__tm.tm_min);
                          __s = seconds(__tm.tm_sec);
                        }
                    }
                  __parts |= _ChronoParts::_DateTime;
                  break;
 
                case 'C': // Century
                  if (!__mod) [[likely]]
                    {
                      auto __v = __read_signed(__num ? __num : 2);
                      if (!__is_failed(__err))
                        {
                          int __cmin = (int)year::min() / 100;
                          int __cmax = (int)year::max() / 100;
                          if (__cmin <= __v && __v <= __cmax)
                            __century = __v * 100;
                          else
                            __century = -2; // This prevents guessing century.
                        }
                    }
                  else if (__mod == 'E')
                    {
                      struct tm __tm{};
                      __tmget.get(__is, {}, __is, __err, &__tm,
                                  __fmt - 3, __fmt);
                      if (!__is_failed(__err))
                        __century = __tm.tm_year;
                    }
                  else [[unlikely]]
                    __err |= ios_base::failbit;
                  // N.B. don't set this here: __parts |= _ChronoParts::_Year;
                  break;
 
                case 'd': // Day of month (1-31)
                case 'e':
                  if (!__mod) [[likely]]
                    {
                      auto __v = __read_unsigned(__num ? __num : 2);
                      if (!__is_failed(__err))
                        __d = day(__v);
                    }
                  else if (__mod == 'O')
                    {
                      struct tm __tm{};
                      __tmget.get(__is, {}, __is, __err, &__tm,
                                  __fmt - 3, __fmt);
                      if (!__is_failed(__err))
                        __d = day(__tm.tm_mday);
                    }
                  else [[unlikely]]
                    __err |= ios_base::failbit;
                  __parts |= _ChronoParts::_Day;
                  break;
 
                case 'D': // %m/%d/%y
                  if (__mod || __num) [[unlikely]]
                    __err |= ios_base::failbit;
                  else
                    {
                      auto __month = __read_unsigned(2); // %m
                      __read_chr('/');
                      auto __day = __read_unsigned(2); // %d
                      __read_chr('/');
                      auto __year = __read_unsigned(2); // %y
                      if (__is_failed(__err))
                        break;
                      __y = year(__year + 1900 + 100 * int(__year < 69));
                      __m = month(__month);
                      __d = day(__day);
                      if (!year_month_day(__y, __m, __d).ok())
                        {
                          __y = __yy = __iso_y = __iso_yy = __bad_y;
                          __m = __bad_mon;
                          __d = __bad_day;
                          break;
                        }
                    }
                  __parts |= _ChronoParts::_Date;
                  break;
 
                case 'F': // %Y-%m-%d - any N modifier only applies to %Y.
                  if (__mod) [[unlikely]]
                    __err |= ios_base::failbit;
                  else
                    {
                      auto __year = __read_signed(__num ? __num : 4); // %Y
                      __read_chr('-');
                      auto __month = __read_unsigned(2); // %m
                      __read_chr('-');
                      auto __day = __read_unsigned(2); // %d
                      if (__is_failed(__err))
                        break;
                      __y = year(__year);
                      __m = month(__month);
                      __d = day(__day);
                      if (!year_month_day(__y, __m, __d).ok())
                        {
                          __y = __yy = __iso_y = __iso_yy = __bad_y;
                          __m = __bad_mon;
                          __d = __bad_day;
                          break;
                        }
                    }
                  __parts |= _ChronoParts::_Date;
                  break;
 
                case 'g': // Last two digits of ISO week-based year.
                  if (__mod) [[unlikely]]
                    __err |= ios_base::failbit;
                  else
                    {
                      auto __val = __read_unsigned(__num ? __num : 2);
                      if (__val >= 0 && __val <= 99)
                        {
                          __iso_yy = year(__val);
                          if (__century == -1) // No %C has been parsed yet.
                            __century = 2000;
                        }
                      else
                        __iso_yy = __iso_y = __y = __yy = __bad_y;
                    }
                  __parts |= _ChronoParts::_Year;
                  break;
 
                case 'G': // ISO week-based year.
                  if (__mod) [[unlikely]]
                    __err |= ios_base::failbit;
                  else
                    __iso_y = year(__read_unsigned(__num ? __num : 4));
                  __parts |= _ChronoParts::_Year;
                  break;
 
                case 'H': // 24-hour (00-23)
                case 'I': // 12-hour (1-12)
                  if (__mod == 'E') [[unlikely]]
                    __err |= ios_base::failbit;
                  else if (__mod == 'O')
                    {
#if 0
                      struct tm __tm{};
                      __tm.tm_ampm = 1;
                      __tmget.get(__is, {}, __is, __err, &__tm,
                                  __fmt - 3, __fmt);
                      if (!__is_failed(__err))
                        {
                          if (__c == 'I')
                            {
                              __h12 = hours(__tm.tm_hour);
                              __h = __bad_h;
                            }
                          else
                            __h = hours(__tm.tm_hour);
                        }
#else
                      // XXX %OI seems to be unimplementable.
                      __err |= ios_base::failbit;
#endif
                    }
                  else
                    {
                      auto __val = __read_unsigned(__num ? __num : 2);
                      if (__c == 'I' && __val >= 1 && __val <= 12)
                        {
                          __h12 = hours(__val);
                          __h = __bad_h;
                        }
                      else if (__c == 'H' && __val >= 0 && __val <= 23)
                        {
                          __h = hours(__val);
                          __h12 = __bad_h;
                        }
                      else
                        {
                          if ((_M_need & _ChronoParts::_TimeOfDay) != 0)
                            __err |= ios_base::failbit;
                          break;
                        }
                    }
                  __parts |= _ChronoParts::_TimeOfDay;
                  break;
 
                case 'j': // For duration, count of days, otherwise day of year
                  if (__mod) [[unlikely]]
                    __err |= ios_base::failbit;
                  else if (_M_need == _ChronoParts::_TimeOfDay) // duration
                    {
                      auto __val = __read_signed(__num ? __num : 3);
                      if (!__is_failed(__err))
                        {
                          __h = days(__val); // __h will get added to _M_time
                          __parts |= _ChronoParts::_TimeOfDay;
                        }
                    }
                  else
                    {
                      __dayofyear = __read_unsigned(__num ? __num : 3);
                      // N.B. do not alter __parts here, done after loop.
                      // No need for range checking here either.
                    }
                  break;
 
                case 'm': // Month (1-12)
                  if (__mod == 'E') [[unlikely]]
                    __err |= ios_base::failbit;
                  else if (__mod == 'O')
                    {
                      struct tm __tm{};
                      __tmget.get(__is, {}, __is, __err, &__tm,
                                  __fmt - 2, __fmt);
                      if (!__is_failed(__err))
                        __m = month(__tm.tm_mon + 1);
                    }
                  else
                    {
                      auto __val = __read_unsigned(__num ? __num : 2);
                      if (__val >= 1 && __val <= 12)
                        __m = month(__val);
                      else
                        __m = __bad_mon;
                    }
                  __parts |= _ChronoParts::_Month;
                  break;
 
                case 'M': // Minutes
                  if (__mod == 'E') [[unlikely]]
                    __err |= ios_base::failbit;
                  else if (__mod == 'O')
                    {
                      struct tm __tm{};
                      __tmget.get(__is, {}, __is, __err, &__tm,
                                  __fmt - 2, __fmt);
                      if (!__is_failed(__err))
                        __min = minutes(__tm.tm_min);
                    }
                  else
                    {
                      auto __val = __read_unsigned(__num ? __num : 2);
                      if (0 <= __val && __val < 60)
                        __min = minutes(__val);
                      else
                        {
                          if ((_M_need & _ChronoParts::_TimeOfDay) != 0)
                            __err |= ios_base::failbit;
                          break;
                        }
                    }
                  __parts |= _ChronoParts::_TimeOfDay;
                  break;
 
                case 'p': // Locale's AM/PM designation for 12-hour clock.
                  if (__mod || __num)
                    __err |= ios_base::failbit;
                  else
                    {
                      // Can't use std::time_get here as it can't parse %p
                      // in isolation without %I. This might be faster anyway.
                      const _CharT* __ampms[2];
                      __tmpunct._M_am_pm(__ampms);
                      int __n = 0, __which = 3;
                      while (__which != 0)
                        {
                          auto __i = __is.peek();
                          if (_Traits::eq_int_type(__i, _Traits::eof()))
                            {
                              __err |= ios_base::eofbit | ios_base::failbit;
                              break;
                            }
                          __i = std::toupper(_Traits::to_char_type(__i), __loc);
                          if (__which & 1)
                            {
                              if (__i != std::toupper(__ampms[0][__n], __loc))
                                __which ^= 1;
                              else if (__ampms[0][__n + 1] == _CharT())
                                {
                                  __which = 1;
                                  (void) __is.get();
                                  break;
                                }
                            }
                          if (__which & 2)
                            {
                              if (__i != std::toupper(__ampms[1][__n], __loc))
                                __which ^= 2;
                              else if (__ampms[1][__n + 1] == _CharT())
                                {
                                  __which = 2;
                                  (void) __is.get();
                                  break;
                                }
                            }
                          if (__which)
                            (void) __is.get();
                          ++__n;
                        }
                      if (__which == 0 || __which == 3)
                        __err |= ios_base::failbit;
                      else
                        __ampm = __which;
                    }
                  break;
 
                case 'r': // Locale's 12-hour time.
                  if (__mod || __num)
                    __err |= ios_base::failbit;
                  else
                    {
                      struct tm __tm{};
                      __tmget.get(__is, {}, __is, __err, &__tm,
                                  __fmt - 2, __fmt);
                      if (!__is_failed(__err))
                        {
                          __h = hours(__tm.tm_hour);
                          __min = minutes(__tm.tm_min);
                          __s = seconds(__tm.tm_sec);
                        }
                    }
                  __parts |= _ChronoParts::_TimeOfDay;
                  break;
 
                case 'R': // %H:%M
                case 'T': // %H:%M:%S
                  if (__mod || __num) [[unlikely]]
                    {
                      __err |= ios_base::failbit;
                      break;
                    }
                  else
                    {
                      auto __val = __read_unsigned(2);
                      if (__val == -1 || __val > 23) [[unlikely]]
                        {
                          if ((_M_need & _ChronoParts::_TimeOfDay) != 0)
                            __err |= ios_base::failbit;
                          break;
                        }
                      if (!__read_chr(':')) [[unlikely]]
                        break;
                      __h = hours(__val);
 
                      __val = __read_unsigned(2);
                      if (__val == -1 || __val > 60) [[unlikely]]
                        {
                          if ((_M_need & _ChronoParts::_TimeOfDay) != 0)
                            __err |= ios_base::failbit;
                          break;
                        }
                      __min = minutes(__val);
 
                      if (__c == 'R')
                        {
                          __parts |= _ChronoParts::_TimeOfDay;
                          break;
                        }
                      else if (!__read_chr(':')) [[unlikely]]
                        break;
                    }
                  [[fallthrough]];
 
                case 'S': // Seconds
                  if (__mod == 'E') [[unlikely]]
                    __err |= ios_base::failbit;
                  else if (__mod == 'O')
                    {
                      struct tm __tm{};
                      __tmget.get(__is, {}, __is, __err, &__tm,
                                  __fmt - 3, __fmt);
                      if (!__is_failed(__err))
                        __s = seconds(__tm.tm_sec);
                    }
                  else if constexpr (_Duration::period::den == 1
                                       && !__is_floating)
                    {
                      auto __val = __read_unsigned(__num ? __num : 2);
                      if (0 <= __val && __val <= 59) [[likely]]
                        __s = seconds(__val);
                      else
                        {
                          if ((_M_need & _ChronoParts::_TimeOfDay) != 0)
                            __err |= ios_base::failbit;
                          break;
                        }
                    }
                  else // Read fractional seconds
                    {
                      stringstream __buf;
                      auto __digit = _S_try_read_digit(__is, __err);
                      if (__digit != -1)
                        {
                          __buf.put('0' + __digit);
                          __digit = _S_try_read_digit(__is, __err);
                          if (__digit != -1)
                            __buf.put('0' + __digit);
                        }
 
                      auto __i = __is.peek();
                      if (_Traits::eq_int_type(__i, _Traits::eof()))
                        __err |= ios_base::eofbit;
                      else
                        {
                          _CharT __dp = '.';
                          if (__loc != locale::classic())
                            {
                              auto& __np = use_facet<numpunct<_CharT>>(__loc);
                              __dp = __np.decimal_point();
                            }
                          _CharT __c = _Traits::to_char_type(__i);
                          if (__c == __dp)
                            {
                              (void) __is.get();
                              __buf.put('.');
                              int __prec
                                = hh_mm_ss<_Duration>::fractional_width;
                              do
                                {
                                  __digit = _S_try_read_digit(__is, __err);
                                  if (__digit != -1)
                                    __buf.put('0' + __digit);
                                  else
                                    break;
                                }
                              while (--__prec);
                            }
                        }
 
                      if (!__is_failed(__err)) [[likely]]
                        {
                          long double __val{};
#if __cpp_lib_to_chars
                          string __str = std::move(__buf).str();
                          auto __first = __str.data();
                          auto __last = __first + __str.size();
                          using enum chars_format;
                          auto [ptr, ec] = std::from_chars(__first, __last,
                                                           __val, fixed);
                          if ((bool)ec || ptr != __last) [[unlikely]]
                            __err |= ios_base::failbit;
                          else
#else
                          if (__buf >> __val)
#endif
                            {
                              duration<long double> __fs(__val);
                              if constexpr (__is_floating)
                                __s = __fs;
                              else
                                __s = chrono::round<_Duration>(__fs);
                            }
                        }
                    }
                  __parts |= _ChronoParts::_TimeOfDay;
                  break;
 
                case 'u': // ISO weekday (1-7)
                case 'w': // Weekday (0-6)
                  if (__mod == 'E') [[unlikely]]
                    __err |= ios_base::failbit;
                  else if (__mod == 'O')
                    {
                      if (__c == 'w')
                        {
                          struct tm __tm{};
                          __tmget.get(__is, {}, __is, __err, &__tm,
                                      __fmt - 3, __fmt);
                          if (!__is_failed(__err))
                            __wday = weekday(__tm.tm_wday);
                        }
                      else
                        __err |= ios_base::failbit;
                    }
                  else
                    {
                      const int __lo = __c == 'u' ? 1 : 0;
                      const int __hi = __lo + 6;
                      auto __val = __read_unsigned(__num ? __num : 1);
                      if (__lo <= __val && __val <= __hi)
                        __wday = weekday(__val);
                      else
                        {
                          __wday = __bad_wday;
                          break;
                        }
                    }
                  __parts |= _ChronoParts::_Weekday;
                  break;
 
                case 'U': // Week number of the year (from first Sunday).
                case 'V': // ISO week-based week number.
                case 'W': // Week number of the year (from first Monday).
                  if (__mod == 'E') [[unlikely]]
                    __err |= ios_base::failbit;
                  else if (__mod == 'O')
                    {
                      if (__c == 'V') [[unlikely]]
                        __err |= ios_base::failbit;
                      else
                        {
                          // TODO nl_langinfo_l(ALT_DIGITS) ?
                          // Not implementable using std::time_get.
                        }
                    }
                  else
                    {
                      const int __lo = __c == 'V' ? 1 : 0;
                      const int __hi = 53;
                      auto __val = __read_unsigned(__num ? __num : 2);
                      if (__lo <= __val && __val <= __hi)
                        {
                          switch (__c)
                          {
                            case 'U':
                              __sunday_wk = __val;
                              break;
                            case 'V':
                              __iso_wk = __val;
                              break;
                            case 'W':
                              __monday_wk = __val;
                              break;
                          }
                        }
                      else
                        __iso_wk = __sunday_wk = __monday_wk = -1;
                    }
                  // N.B. do not alter __parts here, done after loop.
                  break;
 
                case 'x': // Locale's date representation.
                  if (__mod == 'O' || __num) [[unlikely]]
                    __err |= ios_base::failbit;
                  else
                    {
                      struct tm __tm{};
                      __tmget.get(__is, {}, __is, __err, &__tm,
                                  __fmt - 2 - (__mod == 'E'), __fmt);
                      if (!__is_failed(__err))
                        {
                          __y = year(__tm.tm_year + 1900);
                          __m = month(__tm.tm_mon + 1);
                          __d = day(__tm.tm_mday);
                        }
                    }
                  __parts |= _ChronoParts::_Date;
                  break;
 
                case 'X': // Locale's time representation.
                  if (__mod == 'O' || __num) [[unlikely]]
                    __err |= ios_base::failbit;
                  else
                    {
                      struct tm __tm{};
                      __tmget.get(__is, {}, __is, __err, &__tm,
                                  __fmt - 2 - (__mod == 'E'), __fmt);
                      if (!__is_failed(__err))
                        {
                          __h = hours(__tm.tm_hour);
                          __min = minutes(__tm.tm_min);
                          __s = seconds(__tm.tm_sec);
                        }
                    }
                  __parts |= _ChronoParts::_TimeOfDay;
                  break;
 
                case 'y': // Last two digits of year.
                  if (__mod) [[unlikely]]
                    {
                      struct tm __tm{};
                      __tmget.get(__is, {}, __is, __err, &__tm,
                                  __fmt - 3, __fmt);
                      if (!__is_failed(__err))
                        {
                          int __cent = __tm.tm_year < 2000 ? 1900 : 2000;
                          __yy = year(__tm.tm_year - __cent);
                          if (__century == -1) // No %C has been parsed yet.
                            __century = __cent;
                        }
                    }
                  else
                    {
                      auto __val = __read_unsigned(__num ? __num : 2);
                      if (__val >= 0 && __val <= 99)
                        {
                          __yy = year(__val);
                          if (__century == -1) // No %C has been parsed yet.
                            __century = __val < 69 ? 2000 : 1900;
                        }
                      else
                        __y = __yy = __iso_yy = __iso_y = __bad_y;
                    }
                  __parts |= _ChronoParts::_Year;
                  break;
 
                case 'Y': // Year
                  if (__mod == 'O') [[unlikely]]
                    __err |= ios_base::failbit;
                  else if (__mod == 'E')
                    {
                      struct tm __tm{};
                      __tmget.get(__is, {}, __is, __err, &__tm,
                                  __fmt - 3, __fmt);
                      if (!__is_failed(__err))
                        __y = year(__tm.tm_year);
                    }
                  else
                    {
                      auto __val = __read_unsigned(__num ? __num : 4);
                      if (!__is_failed(__err))
                        __y = year(__val);
                    }
                  __parts |= _ChronoParts::_Year;
                  break;
 
                case 'z':
                  if (__num) [[unlikely]]
                    __err |= ios_base::failbit;
                  else
                    {
                      // For %Ez and %Oz read [+|-][h]h[:mm].
                      // For %z read [+|-]hh[mm].
 
                      auto __i = __is.peek();
                      if (_Traits::eq_int_type(__i, _Traits::eof()))
                        {
                          __err |= ios_base::eofbit | ios_base::failbit;
                          break;
                        }
                      _CharT __ic = _Traits::to_char_type(__i);
                      const bool __neg = __ic == _CharT('-');
                      if (__ic == _CharT('-') || __ic == _CharT('+'))
                        (void) __is.get();
 
                      int_least32_t __hh;
                      if (__mod)
                        {
                          // Read h[h]
                          __hh = __read_unsigned(2);
                        }
                      else
                        {
                          // Read hh
                          __hh = 10 * _S_try_read_digit(__is, __err);
                          __hh += _S_try_read_digit(__is, __err);
                        }
 
                      if (__is_failed(__err))
                        break;
 
                      __i = __is.peek();
                      if (_Traits::eq_int_type(__i, _Traits::eof()))
                        {
                          __err |= ios_base::eofbit;
                          __tz_offset = minutes(__hh * (__neg ? -60 : 60));
                          break;
                        }
                      __ic = _Traits::to_char_type(__i);
 
                      bool __read_mm = false;
                      if (__mod)
                        {
                          if (__ic == _GLIBCXX_WIDEN(":")[0])
                            {
                              // Read [:mm] part.
                              (void) __is.get();
                              __read_mm = true;
                            }
                        }
                      else if (_CharT('0') <= __ic && __ic <= _CharT('9'))
                        {
                          // Read [mm] part.
                          __read_mm = true;
                        }
 
                      int_least32_t __mm = 0;
                      if (__read_mm)
                        {
                          __mm = 10 * _S_try_read_digit(__is, __err);
                          __mm += _S_try_read_digit(__is, __err);
                        }
 
                      if (!__is_failed(__err))
                        {
                          auto __z = __hh * 60 + __mm;
                          __tz_offset = minutes(__neg ? -__z : __z);
                        }
                    }
                  break;
 
                case 'Z':
                  if (__mod || __num) [[unlikely]]
                    __err |= ios_base::failbit;
                  else
                    {
                      basic_string_view<_CharT> __x = _GLIBCXX_WIDEN("_/-+");
                      __tz_abbr.clear();
                      while (true)
                        {
                          auto __i = __is.peek();
                          if (!_Traits::eq_int_type(__i, _Traits::eof()))
                            {
                              _CharT __a = _Traits::to_char_type(__i);
                              if (std::isalnum(__a, __loc)
                                    || __x.find(__a) != __x.npos)
                                {
                                  __tz_abbr.push_back(__a);
                                  (void) __is.get();
                                  continue;
                                }
                            }
                          else
                            __err |= ios_base::eofbit;
                          break;
                        }
                      if (__tz_abbr.empty())
                        __err |= ios_base::failbit;
                    }
                  break;
 
                case 'n': // Exactly one whitespace character.
                  if (__mod || __num) [[unlikely]]
                    __err |= ios_base::failbit;
                  else
                    {
                      _CharT __i = __is.peek();
                      if (_Traits::eq_int_type(__i, _Traits::eof()))
                        __err |= ios_base::eofbit | ios_base::failbit;
                      else if (std::isspace(_Traits::to_char_type(__i), __loc))
                        (void) __is.get();
                      else
                        __err |= ios_base::failbit;
                    }
                  break;
 
                case 't': // Zero or one whitespace characters.
                  if (__mod || __num) [[unlikely]]
                    __err |= ios_base::failbit;
                  else
                    {
                      _CharT __i = __is.peek();
                      if (_Traits::eq_int_type(__i, _Traits::eof()))
                        __err |= ios_base::eofbit;
                      else if (std::isspace(_Traits::to_char_type(__i), __loc))
                        (void) __is.get();
                    }
                  break;
 
                case '%': // A % character.
                  if (__mod || __num) [[unlikely]]
                    __err |= ios_base::failbit;
                  else
                    __read_chr('%');
                  break;
 
                case 'O': // Modifiers
                case 'E':
                  if (__mod || __num) [[unlikely]]
                    {
                      __err |= ios_base::failbit;
                      break;
                    }
                  __mod = __c;
                  continue;
 
                default:
                  if (_CharT('1') <= __c && __c <= _CharT('9'))
                    {
                      if (!__mod) [[likely]]
                        {
                          // %Nx - extract positive decimal integer N
                          auto __end = __fmt + _Traits::length(__fmt);
                          auto [__v, __ptr]
                            = __format::__parse_integer(__fmt - 1, __end);
                          if (__ptr) [[likely]]
                            {
                              __num = __v;
                              __fmt = __ptr;
                              continue;
                            }
                        }
                    }
                  __err |= ios_base::failbit;
                }
 
              if (__is_failed(__err)) [[unlikely]]
                break;
 
              __is_flag = false;
              __num = 0;
              __mod = _CharT();
            }
 
          if (__century >= 0)
            {
              if (__yy != __bad_y && __y == __bad_y)
                __y = years(__century) + __yy; // Use %y instead of %Y
              if (__iso_yy != __bad_y && __iso_y == __bad_y)
                __iso_y = years(__century) + __iso_yy; // Use %g instead of %G
            }
 
          bool __can_use_doy = false;
          bool __can_use_iso_wk = false;
          bool __can_use_sun_wk = false;
          bool __can_use_mon_wk = false;
 
          // A year + day-of-year can be converted to a full date.
          if (__y != __bad_y && __dayofyear >= 0)
            {
              __can_use_doy = true;
              __parts |= _ChronoParts::_Date;
            }
          else if (__y != __bad_y && __wday != __bad_wday && __sunday_wk >= 0)
            {
              __can_use_sun_wk = true;
              __parts |= _ChronoParts::_Date;
            }
          else if (__y != __bad_y && __wday != __bad_wday && __monday_wk >= 0)
            {
              __can_use_mon_wk = true;
              __parts |= _ChronoParts::_Date;
            }
          else if (__iso_y != __bad_y && __wday != __bad_wday && __iso_wk > 0)
            {
              // An ISO week date can be converted to a full date.
              __can_use_iso_wk = true;
              __parts |= _ChronoParts::_Date;
            }
 
          if (__is_failed(__err)) [[unlikely]]
            ; // Don't bother doing any more work.
          else if (__is_flag) [[unlikely]] // incomplete format flag
            __err |= ios_base::failbit;
          else if ((_M_need & __parts) == _M_need) [[likely]]
            {
              // We try to avoid calculating _M_sys_days and _M_ymd unless
              // necessary, because converting sys_days to year_month_day
              // (or vice versa) requires non-trivial calculations.
              // If we have y/m/d values then use them to populate _M_ymd
              // and only convert it to _M_sys_days if the caller needs that.
              // But if we don't have y/m/d and need to calculate the date
              // from the day-of-year or a week+weekday then we set _M_sys_days
              // and only convert it to _M_ymd if the caller needs that.
 
              // We do more error checking here, but only for the fields that
              // we actually need to use. For example, we will not diagnose
              // an invalid dayofyear==366 for non-leap years unless actually
              // using __dayofyear. This should mean we never produce invalid
              // results, but it means not all invalid inputs are diagnosed,
              // e.g. "2023-01-01 366" >> "%F %j" ignores the invalid 366.
              // We also do not diagnose inconsistent values for the same
              // field, e.g. "2021 2022 2023" >> "%C%y %Y %Y" just uses 2023.
 
              // Whether the caller wants _M_wd.
              // The _Weekday bit is only set for chrono::weekday.
              const bool __need_wday = (_M_need & _ChronoParts::_Weekday) != 0;
 
              // Whether the caller wants _M_sys_days and _M_time.
              // Only true for durations and time_points.
              const bool __need_time = (_M_need & _ChronoParts::_TimeOfDay) != 0;
 
              if (__need_wday && __wday != __bad_wday)
                _M_wd = __wday; // Caller only wants a weekday and we have one.
              else if ((_M_need & _ChronoParts::_Date) != 0) // subsumes __need_wday
                {
                  // Whether the caller wants _M_ymd.
                  // True for chrono::year etc., false for time_points.
                  const bool __need_ymd = !__need_wday && !__need_time;
 
                  if (((_M_need & _ChronoParts::_Year) != 0 && __y == __bad_y)
                     || ((_M_need & _ChronoParts::_Month) != 0 && __m == __bad_mon)
                     || ((_M_need & _ChronoParts::_Day) != 0 && __d == __bad_day))
                    {
                      // Missing at least one of y/m/d so calculate sys_days
                      // from the other data we have available.
 
                      if (__can_use_doy)
                        {
                          if ((0 < __dayofyear && __dayofyear <= 365)
                                || (__dayofyear == 366 && __y.is_leap()))
                            [[likely]]
                            {
                              _M_sys_days = sys_days(__y/January/1)
                                              + days(__dayofyear - 1);
                              if (__need_ymd)
                                _M_ymd = year_month_day(_M_sys_days);
                            }
                          else
                            __err |= ios_base::failbit;
                        }
                      else if (__can_use_iso_wk)
                        {
                          // Calculate y/m/d from ISO week date.
 
                          if (__iso_wk == 53)
                            {
                              // A year has 53 weeks iff Jan 1st is a Thursday
                              // or Jan 1 is a Wednesday and it's a leap year.
                              const sys_days __jan4(__iso_y/January/4);
                              weekday __wd1(__jan4 - days(3));
                              if (__wd1 != Thursday)
                                if (__wd1 != Wednesday || !__iso_y.is_leap())
                                  __err |= ios_base::failbit;
                            }
 
                          if (!__is_failed(__err)) [[likely]]
                            {
                              // First Thursday is always in week one:
                              sys_days __w(Thursday[1]/January/__iso_y);
                              // First day of week-based year:
                              __w -= Thursday - Monday;
                              __w += days(weeks(__iso_wk - 1));
                              __w += __wday - Monday;
                              _M_sys_days = __w;
 
                              if (__need_ymd)
                                _M_ymd = year_month_day(_M_sys_days);
                            }
                        }
                      else if (__can_use_sun_wk)
                        {
                          // Calculate y/m/d from week number + weekday.
                          sys_days __wk1(__y/January/Sunday[1]);
                          _M_sys_days = __wk1 + weeks(__sunday_wk - 1)
                                        + days(__wday.c_encoding());
                          _M_ymd = year_month_day(_M_sys_days);
                          if (_M_ymd.year() != __y) [[unlikely]]
                            __err |= ios_base::failbit;
                        }
                      else if (__can_use_mon_wk)
                        {
                          // Calculate y/m/d from week number + weekday.
                          sys_days __wk1(__y/January/Monday[1]);
                          _M_sys_days = __wk1 + weeks(__monday_wk - 1)
                                        + days(__wday.c_encoding() - 1);
                          _M_ymd = year_month_day(_M_sys_days);
                          if (_M_ymd.year() != __y) [[unlikely]]
                            __err |= ios_base::failbit;
                        }
                      else // Should not be able to get here.
                        __err |= ios_base::failbit;
                    }
                  else
                    {
                      // We know that all fields the caller needs are present,
                      // but check that their values are in range.
                      // Make unwanted fields valid so that _M_ymd.ok() is true.
 
                      if ((_M_need & _ChronoParts::_Year) != 0)
                        {
                          if (!__y.ok()) [[unlikely]]
                            __err |= ios_base::failbit;
                        }
                      else if (__y == __bad_y)
                        __y = 1972y; // Leap year so that Feb 29 is valid.
 
                      if ((_M_need & _ChronoParts::_Month) != 0)
                        {
                          if (!__m.ok()) [[unlikely]]
                            __err |= ios_base::failbit;
                        }
                      else if (__m == __bad_mon)
                        __m = January;
 
                      if ((_M_need & _ChronoParts::_Day) != 0)
                        {
                          if (__d < day(1) || __d > (__y/__m/last).day())
                            __err |= ios_base::failbit;
                        }
                      else if (__d == __bad_day)
                        __d = 1d;
 
                      if (year_month_day __ymd(__y, __m, __d); __ymd.ok())
                        {
                          _M_ymd = __ymd;
                          if (__need_wday || __need_time)
                            _M_sys_days = sys_days(_M_ymd);
                        }
                      else [[unlikely]]
                        __err |= ios_base::failbit;
                    }
 
                  if (__need_wday)
                    _M_wd = weekday(_M_sys_days);
                }
 
              // Need to set _M_time for both durations and time_points.
              if (__need_time)
                {
                  if (__h == __bad_h && __h12 != __bad_h)
                    {
                      if (__ampm == 1)
                        __h = __h12 == hours(12) ? hours(0) : __h12;
                      else if (__ampm == 2)
                        __h = __h12 == hours(12) ? __h12 : __h12 + hours(12);
                      else [[unlikely]]
                        __err |= ios_base::failbit;
                    }
 
                  auto __t = _M_time.zero();
                  bool __ok = false;
 
                  if (__h != __bad_h)
                    {
                      __ok = true;
                      __t += __h;
                    }
 
                  if (__min != __bad_min)
                    {
                      __ok = true;
                      __t += __min;
                    }
 
                  if (__s != __bad_sec)
                    {
                      __ok = true;
                      __t += __s;
                      _M_is_leap_second = __s >= seconds(60);
                    }
 
                  if (__ok)
                    _M_time = __t;
                  else
                    __err |= ios_base::failbit;
                }
 
              if (!__is_failed(__err)) [[likely]]
                {
                  if (__offset && __tz_offset != __bad_min)
                    *__offset = __tz_offset;
                  if (__abbrev && !__tz_abbr.empty())
                    *__abbrev = std::move(__tz_abbr);
                }
            }
          else
            __err |= ios_base::failbit;
        }
      if (__err)
        __is.setstate(__err);
      return __is;
    }
  /// @endcond
#undef _GLIBCXX_WIDEN
 
  /// @} group chrono
} // namespace chrono
 
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
 
#endif // C++20
 
#endif //_GLIBCXX_CHRONO_IO_H