// <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 associates 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;

    public:
      [[__gnu__::__always_inline__]]
      static _Dynamic_format_string<_CharT>
      _S_empty_fs()
      { return _Dynamic_format_string<_CharT>(_S_empty_spec); }

    protected:
      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_and_overwrite
		  __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()));
	}
    }

  // Format into a stack buffer via std::format_to_n with the empty
  // chrono-spec (_S_empty_fs), then write through __ostream_insert.
  // The empty spec lets each formatter use its __defSpec, producing
  // output equivalent to the corresponding operator<<.
  // _BufSize allows per-type tuning of the stack buffer size.
  template<size_t _BufSize, typename _CharT, typename _Traits,
	   typename _Arg, typename... _OptLocale>
    inline basic_ostream<_CharT, _Traits>&
    __chrono_write(basic_ostream<_CharT, _Traits>& __os,
		   const _Arg& __arg, const _OptLocale&... __loc)
    {
      static_assert(sizeof...(_OptLocale) <= 1);
      constexpr auto __fs
	= __format::__formatter_chrono<_CharT>::_S_empty_fs;
      constexpr size_t __bufsize = _BufSize;
      _CharT __buf[__bufsize];
      auto __res = std::format_to_n(__buf, __bufsize, __loc...,
				    __fs(), __arg);

      if (static_cast<size_t>(__res.size) <= __bufsize) [[likely]]
	return std::__ostream_insert(__os, __buf, __res.size);

      auto __s = std::format(__loc..., __fs(), __arg);
      return std::__ostream_insert(__os, __s.data(), __s.size());
    }

} // 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)
    { return __detail::__chrono_write<32>(__os, __d); }

  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)
    { return __detail::__chrono_write<64>(__os, __m, __os.getloc()); }

  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)
    { return __detail::__chrono_write<32>(__os, __y); }

  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)
    { return __detail::__chrono_write<64>(__os, __wd, __os.getloc()); }

  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)
    { return __detail::__chrono_write<128>(__os, __wdi, __os.getloc()); }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
	       const weekday_last& __wdl)
    { return __detail::__chrono_write<128>(__os, __wdl, __os.getloc()); }
    
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const month_day& __md)
    { return __detail::__chrono_write<128>(__os, __md, __os.getloc()); }

  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)
    { return __detail::__chrono_write<128>(__os, __mdl, __os.getloc()); }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
	       const month_weekday& __mwd)
    { return __detail::__chrono_write<128>(__os, __mwd, __os.getloc()); }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
	       const month_weekday_last& __mwdl)
    { return __detail::__chrono_write<128>(__os, __mwdl, __os.getloc()); }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const year_month& __ym)
    { return __detail::__chrono_write<128>(__os, __ym, __os.getloc()); }

  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)
    { return __detail::__chrono_write<64>(__os, __ymd); }

  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)
    { return __detail::__chrono_write<128>(__os, __ymdl, __os.getloc()); }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
	       const year_month_weekday& __ymwd)
    { return __detail::__chrono_write<128>(__os, __ymwd, __os.getloc()); }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
	       const year_month_weekday_last& __ymwdl)
    { return __detail::__chrono_write<128>(__os, __ymwdl, __os.getloc()); }

  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 __detail::__chrono_write<64>(__os, __hms, __os.getloc()); }

#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 __detail::__chrono_write<128>(__os, __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)
    { return __detail::__chrono_write<256>(__os, __li); }

  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)
    { return __detail::__chrono_write<128>(__os, __t, __os.getloc()); }
#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)
    { return __detail::__chrono_write<64>(__os, __tp, __os.getloc()); }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_days& __dp)
    { return __detail::__chrono_write<32>(__os, __dp); };

  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)
    { return __detail::__chrono_write<64>(__os, __t, __os.getloc()); }

  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)
    { return __detail::__chrono_write<64>(__os, __t, __os.getloc()); }

  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)
    { return __detail::__chrono_write<64>(__os, __t, __os.getloc()); }

  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)
    { return __detail::__chrono_write<64>(__os, __t, __os.getloc()); }

  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; }
    { return __detail::__chrono_write<64>(__os, __lt, __os.getloc()); }

  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
			  auto __d1 = _S_try_read_digit(__is, __err);
			  auto __d2 = _S_try_read_digit(__is, __err);
			  if (__d1 >= 0 && __d2 >= 0) [[likely]]
			    __hh = 10 * __d1 + __d2;
			  else
			    __err |= ios_base::failbit;
			}

		      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)
			{
			  auto __d1 = _S_try_read_digit(__is, __err);
			  auto __d2 = _S_try_read_digit(__is, __err);
			  if (__d1 >= 0 && __d2 >= 0) [[likely]]
			    __mm = 10 * __d1 + __d2;
			  else
			    __err |= ios_base::failbit;
			}

		      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
