29.8 The civil calendar [time.cal] C++N4910:2022 (676) p1393.cpp


# はじめに(Introduction)

N4910  Working Draft, Standard for Programming Language C++

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/n4910.pdf

n4910は、ISO/IEC JTC1 SC22 WG21の作業原案(Working Draft)です。
公式のISO/IEC 14882原本ではありません。
ISO/IEC JTC1 SC22 WG21では、可能な限り作業文書を公開し、幅広い意見を求めています。
一連の記事はコード断片をコンパイルできる形にする方法を検討してコンパイル、リンク、実行して、規格案の原文と処理系(g++, Clang++)との違いを確認し、技術内容を検討し、ISO/IEC JTC1 SC22 WG21にフィードバックするために用います。
また、CERT C++, MISRA C++等のコーディング標準のコード断片をコンパイルする際の参考にさせていただこうと考えています。CERT C++, MISRA C++が標準化の動きとの時間的なずれがあれば確認できれば幸いです。また、boostライブラリとの関連、Linux OS, TOPPERSカーネル、g++(GCC), clang++(LLVM）との関係も調査中です。
何か、抜け漏れ、耳より情報がありましたらおしらせくださると幸いです。

 <この項は書きかけです。順次追記します。>

## 背景(back ground)
C/C++でコンパイルエラーが出ると、途方にくれることがしばしばあります。
何回かに１回は、該当するエラーが検索できます。
ただ、条件が違っていて、そこでの修正方法では目的を達成しないこともしばしばです。いろいろな条件のコンパイルエラーとその対応方法について、広く記録することによって、いつか同じエラーに遭遇した時にやくに立つことを目指しています。

この半年の間で、三度、自分のネットでの記録に助けられたことがあります。
また過去に解決できなかった記録を１０種類以上、最近になって解決できたことがあります。それは、主に次の３つの情報に基づいています。

https://stackoverflow.com

http://ja.cppreference.com/

cpprefjp - C++日本語リファレンス

https://cpprefjp.github.io/

コンパイラの実装状況

https://cpprefjp.github.io/implementation-status.html

また
https://researchmap.jp/joub9b3my-1797580/#_1797580
に記載したサイトのお世話になっています。

## 作業方針(sequence)
Clang++では-std=c++03, C++2bの2種類
g++では-std=c++03, c++2bの２種類
でコンパイルし、

１）コンパイルエラーを収集する。
２）コンパイルエラーをなくす方法を検討する。
コンパイルエラーになる例を示すだけが目的のコードは、コンパイルエラーをなくすのではなく、コンパイルエラーの種類を収集するだけにする。
文法を示すのが目的のコード場合に、コンパイルエラーをなくすのに手間がかかる場合は、順次作業します。
３）リンクエラーをなくす方法を検討する。
文法を示すのが目的のコード場合に、リンクエラーをなくすのに手間がかかる場合は、順次作業します。
４）意味のある出力を作る。
コンパイル、リンクが通っても、意味のある出力を示そうとすると、コンパイル・リンクエラーが出て収拾できそうにない場合がある。順次作業します。

１）だけのものから４）まで進んだものと色々ある状態です。一歩でも前に進むご助言をお待ちしています。「検討事項」の欄に現状を記録するようにしています。

### C++N4910:2022 Standard Working Draft on ISO/IEC 14882(0) sample code compile list  

https://qiita.com/kaizen_nagoya/items/fc957ddddd402004bb91

### C++N4741, 2018 Standard Working Draft on ISO/IEC 14882 sample code compile list
https://qiita.com/kaizen_nagoya/items/3294c014044550896010

### C++N4606, 2016符号断片編纂一覧(example code compile list)
C++N4606, 2016 Working Draft 2016, ISO/IEC 14882, C++ standard(1) Example code compile list
https://qiita.com/kaizen_nagoya/items/df5d62c35bd6ed1c3d43/

### C++N3242, 2011 sample code compile list on clang++ and g++
https://qiita.com/kaizen_nagoya/items/685b5c1a2c17c1bf1318

## 編纂器(Compiler)
### clang++ --version
> Debian clang version 14.0.5-++20220610033153+c12386ae247c-1~exp1~20220610153237.151
Target: x86_64-pc-linux-gnu, Thread model: posix, InstalledDir: /usr/bin

### g++- --version
> g++ (GCC) 12.1.0  Copyright (C) 2022 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

# 29.8 The civil calendar [time.cal] C++N4910:2022 (676) p1393.cpp

## 算譜(source code)

```c++:p1393.cpp
// C++N4910 Committee Draft, Standard for Programming Language C++
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/n4910.pdf
const char * n4910 = "29.8 The civil calendar [time.cal] C++N4910:2022 (676) p1393.cpp";
// Debian clang version 14.0.5-++20220610033153+c12386ae247c-
// g++ (GCC) 12.1.0 Copyright (C) 2022 Free Software Foundation, Inc.
// Edited by Dr. OGAWA Kiyoshi. Compile procedure and results record.
// C++N4910:2022 Standard Working Draft on ISO/IEC 14882(0) sample code compile list
// https://qiita.com/kaizen_nagoya/items/fc957ddddd402004bb91

#include "N4910.h"

using namespace std;

// 29.8 The civil calendar [time.cal]
// 29.8.1 In general [time.cal.general]
// 29.8.2 Class last_spec [time.cal.last]
namespace std::chrono {
struct last_spec {
    explicit last_spec() = default;
};
}
// The type last_spec is used in conjunction with other calendar types to specify the last in a sequence. For example, depending on context, it can represent the last day of a month, or the last day of the week of a month.
// 29.8.3 Class day [time.cal.day]
// 29.8.3.1 Overview [time.cal.day.overview]
namespace std::chrono {
class day {
    unsigned char d_;
public:
    day() = default;
    constexpr explicit day(unsigned d) noexcept;
    constexpr day& operator++()    noexcept;
    constexpr day  operator++(int) noexcept;
    constexpr day& operator--()    noexcept;
    constexpr day  operator--(int) noexcept;
    constexpr day& operator+=(const days& d) noexcept;
    constexpr day& operator-=(const days& d) noexcept;
    constexpr explicit operator unsigned() const noexcept;
    constexpr bool ok() const noexcept;
};
}
constexpr day& operator++() noexcept;
// Effects: ++d_. Returns: *this.
// exposition only
//  day represents a day of a month. It normally holds values in the range 1 to 31, but may hold non-negative values outside this range. It can be constructed with any unsigned value, which will be subsequently truncated to fit into day’s unspecified internal storage. day meets the Cpp17EqualityComparable (Table 27) and Cpp17LessThanComparable (Table 28) requirements, and participates in basic arithmetic with days objects, which represent a difference between two day objects.
//  day is a trivially copyable and standard-layout class type.
// 29.8.3.2 Member functions [time.cal.day.members]
constexpr explicit day(unsigned d) noexcept;
constexpr day operator++(int) noexcept;
// Effects: ++(*this).
// Returns: A copy of *this as it existed on entry to this member function.
constexpr day& operator--() noexcept;
// Effects: Equivalent to: --d_. Returns: *this.
constexpr day operator--(int) noexcept;
// Effects: --(*this).
// Returns: A copy of *this as it existed on entry to this member function.
constexpr day& operator+=(const days& d) noexcept;
// Effects: *this = *this + d. Returns: *this.
constexpr day& operator-=(const days& d) noexcept;
// Effects: *this = *this - d. Returns: *this.
constexpr explicit operator unsigned() const noexcept;
// Returns: d_.
constexpr bool ok() const noexcept;
// Returns: 1 <= d_ && d_ <= 31.
// 29.8.3.3 Non-member functions [time.cal.day.nonmembers]
constexpr bool operator==(const day& x, const day& y) noexcept;
// Returns: unsigned{x} == unsigned{y}.
constexpr strong_ordering operator<=>(const day& x, const day& y) noexcept;
// Returns: unsigned{x} <=> unsigned{y}.
constexpr day operator+(const day& x, const days& y) noexcept;
// Returns: day(unsigned{x} + y.count()).
constexpr day operator+(const days& x, const day& y) noexcept;
// Returns: y + x.
constexpr day operator-(const day& x, const days& y) noexcept;
// Returns: x + -y.
constexpr days operator-(const day& x, const day& y) noexcept;
// Returns: days{int(unsigned{x}) - int(unsigned{y})}.
template<class charT, class traits>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os, const day& d);
// Effects: Equivalent to:
return os << (d.ok() ?
              format(STATICALLY-WIDEN<charT>("{:%d}"), d) : format(STATICALLY-WIDEN<charT>("{:%d} is not a valid day"), d));
template<class charT, class traits, class Alloc = allocator<charT>>
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);
// Effects: Attempts to parse the input stream is into the day d using the format flags given in the NTCTS fmt as specified in 29.13. If the parse fails to decode a valid day, is.setstate(ios_base::failbit) is called and d is not modified. If %Z is used and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null. If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
// Returns: is.
constexpr chrono::day operator""d(unsigned long long d) noexcept;
// Returns: day{static_cast<unsigned>(d)}.
// 29.8.4 Class month  [time.cal.month]
// 29.8.4.1 Overview [time.cal.month.overview]
namespace std::chrono {
class month {
    unsigned char m_;
public:
};
month() = default;
constexpr explicit month(unsigned m) noexcept;
constexpr month& operator++()    noexcept;
constexpr month  operator++(int) noexcept;
constexpr month& operator--()    noexcept;
constexpr month  operator--(int) noexcept;
constexpr month& operator+=(const months& m) noexcept;
constexpr month& operator-=(const months& m) noexcept;
constexpr explicit operator unsigned() const noexcept;
constexpr bool ok() const noexcept;
}
// exposition only
//  month represents a month of a year. It normally holds values in the range 1 to 12, but may hold non-negative values outside this range. It can be constructed with any unsigned value, which will be subsequently truncated to fit into month’s unspecified internal storage. month meets the Cpp17EqualityComparable (Table 27) and Cpp17LessThanComparable (Table 28) requirements, and participates in basic arithmetic with months objects, which represent a difference between two month objects.
// month is a trivially copyable and standard-layout class type.
// 29.8.4.2 Member functions [time.cal.month.members]
constexpr explicit month(unsigned m) noexcept;
// Effects: Initializes m_ with m. The value held is unspecified if m is not in the range [0, 255].
constexpr month& operator++() noexcept;
// Effects: *this += months{1}. Returns: *this.
constexpr month operator++(int) noexcept;
// Effects: ++(*this).
// Returns: A copy of *this as it existed on entry to this member function.
constexpr month& operator--() noexcept;
// Effects: *this -= months{1}. Returns: *this.
constexpr month operator--(int) noexcept;
// Effects: --(*this).
// Returns: A copy of *this as it existed on entry to this member function.
constexpr month& operator+=(const months& m) noexcept;
// Effects: *this = *this + m. Returns: *this.
constexpr month& operator-=(const months& m) noexcept;
// Effects: *this = *this - m. Returns: *this.
constexpr explicit operator unsigned() const noexcept;
// Returns: m_.
constexpr bool ok() const noexcept;
// Returns: 1 <= m_ && m_ <= 12.
// 29.8.4.3 Non-member functions [time.cal.month.nonmembers]
constexpr bool operator==(const month& x, const month& y) noexcept;
// Returns: unsigned{x} == unsigned{y}.
constexpr strong_ordering operator<=>(const month& x, const month& y) noexcept;
// Returns: unsigned{x} <=> unsigned{y}.
constexpr month operator+(const month& x, const months& y) noexcept;
// Returns: month{modulo(static_cast<long long>(unsigned{x}) + (y.count() - 1), 12) + 1} where modulo(n, 12) computes the remainder of n divided by 12 using Euclidean division.
// [Note 1: Given a divisor of 12, Euclidean division truncates towards negative infinity and always produces a remainder in the range of [0, 11]. Assuming no overflow in the signed summation, this operation results in a month holding a value in the range [1,12] even if !x.ok().
// [Example 1: February + months{11} == January. —end example] constexpr month operator+(const months& x, const month& y) noexcept;
// Returns: y + x.
constexpr month operator-(const month& x, const months& y) noexcept;
// Returns: x + -y.
constexpr months operator-(const month& x, const month& y) noexcept;
// Returns: If x.ok() == true and y.ok() == true, returns a value m in the range [months{0}, months{11}] satisfying y + m == x. Otherwise the value returned is unspecified.
// [Example 2: January - February == months{11}.
template<class charT, class traits>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os, const month& m);
// Effects: Equivalent to:
return os << (m.ok() ?
              format(os.getloc(), STATICALLY-WIDEN<charT>("{:L%b}"), m) : format(os.getloc(), STATICALLY-WIDEN<charT>("{} is not a valid month"),
                      static_cast<unsigned>(m)));
template<class charT, class traits, class Alloc = allocator<charT>>
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);
// Effects: Attempts to parse the input stream is into the month m using the format flags given in the NTCTS fmt as specified in 29.13. If the parse fails to decode a valid month, is.setstate(ios_- base::failbit) is called and m is not modified. If %Z is used and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null. If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
// Returns: is.
// 29.8.5 Class year [time.cal.year]
// 29.8.5.1 Overview [time.cal.year.overview]
namespace std::chrono {
class year {
    short y_;
public:
};
year() = default;
constexpr explicit year(int y) noexcept;
constexpr year& operator++()    noexcept;
constexpr year  operator++(int) noexcept;
constexpr year& operator--()    noexcept;
constexpr year  operator--(int) noexcept;
constexpr year& operator+=(const years& y) noexcept;
constexpr year& operator-=(const years& y) noexcept;
constexpr year operator+() const noexcept;
constexpr year operator-() const noexcept;
constexpr bool is_leap() const noexcept;
constexpr explicit operator int() const noexcept;
constexpr bool ok() const noexcept;
static constexpr year min() noexcept;
static constexpr year max() noexcept;
}
// exposition only
//  year represents a year in the civil calendar. It can represent values in the range [min(), max()]. It can be constructed with any int value, which will be subsequently truncated to fit into year’s unspecified internal storage. year meets the Cpp17EqualityComparable (Table 27) and Cpp17LessThanComparable (Table 28) requirements, and participates in basic arithmetic with years objects, which represent a difference between two year objects.
//  year is a trivially copyable and standard-layout class type.
// 29.8.5.2 Member functions [time.cal.year.members]
constexpr explicit year(int y) noexcept;
// Effects: Initializes y_ with y. The value held is unspecified if y is not in the range [-32767, 32767].
constexpr year& operator++() noexcept;
// Effects: ++y_. Returns: *this.
constexpr year operator++(int) noexcept;
// Effects: ++(*this).
// Effects: --y_. Returns: *this.
// Returns: A copy of *this as it existed on entry to this member function.
constexpr year& operator--() noexcept;
constexpr year operator--(int) noexcept;
// Effects: --(*this).
// Returns: A copy of *this as it existed on entry to this member function.
constexpr year& operator+=(const years& y) noexcept;
// Effects: *this = *this + y. Returns: *this.
constexpr year& operator-=(const years& y) noexcept;
// Effects: *this = *this - y. Returns: *this.
constexpr year operator+() const noexcept;
// Returns: *this.
constexpr year year::operator-() const noexcept;
// Returns: year{-y_}.
constexpr bool is_leap() const noexcept;
// Returns: y_ % 4 == 0 && (y_ % 100 != 0 || y_ % 400 == 0).
constexpr explicit operator int() const noexcept;
// Returns: y_.
constexpr bool ok() const noexcept;
// Returns: min().y_ <= y_ && y_ <= max().y_.
static constexpr year min() noexcept;
// Returns: year{-32767}.
static constexpr year max() noexcept;
// Returns: year{32767}.
// 29.8.5.3 Non-member functions [time.cal.year.nonmembers]
constexpr bool operator==(const year& x, const year& y) noexcept;
// Returns: int{x} == int{y}.
constexpr strong_ordering operator<=>(const year& x, const year& y) noexcept;
// Returns: int{x} <=> int{y}.
constexpr year operator+(const year& x, const years& y) noexcept;
// Returns: year{int{x} + static_cast<int>(y.count())}. constexpr year operator+(const years& x, const year& y) noexcept;
// Returns: y + x.
constexpr year operator-(const year& x, const years& y) noexcept;
// Returns: x + -y.
constexpr years operator-(const year& x, const year& y) noexcept;
// Returns: years{int{x} - int{y}}.
template<class charT, class traits>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os, const year& y);
// Effects: Equivalent to:
return os << (y.ok() ?
              format(STATICALLY-WIDEN<charT>("{:%Y}"), y) : format(STATICALLY-WIDEN<charT>("{:%Y} is not a valid year"), y));
template<class charT, class traits, class Alloc = allocator<charT>>
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);
// Effects: Attempts to parse the input stream is into the year y using the format flags given in the NTCTS fmt as specified in 29.13. If the parse fails to decode a valid year, is.setstate(ios_base::failbit) is called and y is not modified. If %Z is used and successfully parsed, that value will be assigned to*abbrev if abbrev is non-null. If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
// Returns: is.
constexpr chrono::year operator""y(unsigned long long y) noexcept;
// Returns: year{static_cast<int>(y)}.
// 29.8.6 Class weekday  [time.cal.wd]
// 29.8.6.1 Overview [time.cal.wd.overview]
namespace std::chrono {
class weekday {
    unsigned char wd_;
public:
};
// exposition only
weekday() = default;
constexpr explicit weekday(unsigned wd) noexcept;
constexpr weekday(const sys_days& dp) noexcept;
constexpr explicit weekday(const local_days& dp) noexcept;
constexpr weekday& operator++()    noexcept;
constexpr weekday  operator++(int) noexcept;
constexpr weekday& operator--()    noexcept;
constexpr weekday  operator--(int) noexcept;
constexpr weekday& operator+=(const days& d) noexcept;
constexpr weekday& operator-=(const days& d) noexcept;
constexpr unsigned c_encoding() const noexcept;
constexpr unsigned iso_encoding() const noexcept;
constexpr bool ok() const noexcept;
constexpr weekday_indexed operator[](unsigned index) const noexcept;
constexpr weekday_last    operator[](last_spec) const noexcept;
}
//  weekday represents a day of the week in the civil calendar. It normally holds values in the range 0 to 6, corresponding to Sunday through Saturday, but it may hold non-negative values outside this range. It can be constructed with any unsigned value, which will be subsequently truncated to fit into weekday’s unspecified internal storage. weekday meets the Cpp17EqualityComparable (Table 27) requirements.
// [Note 1: weekday is not Cpp17LessThanComparable because there is no universal consensus on which day is the first day of the week. weekday’s arithmetic operations treat the days of the week as a circular range, with no beginning and no end.
//  weekday is a trivially copyable and standard-layout class type.
// 29.8.6.2 Member functions [time.cal.wd.members]
constexpr explicit weekday(unsigned wd) noexcept;
// Effects: Initializes wd_ with wd == 7 ? 0 : wd. The value held is unspecified if wd is not in the range [0, 255].
constexpr weekday(const sys_days& dp) noexcept;
// Effects: Computes what day of the week corresponds to the sys_days dp, and initializes that day of the week in wd_.
// [Example 1: If dp represents 1970-01-01, the constructed weekday represents Thursday by storing 4 in wd_. —end example]
constexpr explicit weekday(const local_days& dp) noexcept;
// Effects: Computes what day of the week corresponds to the local_days dp, and initializes that day of the week in wd_.
// Postconditions: The value is identical to that constructed from sys_days{dp.time_since_epoch()}.
constexpr weekday& operator++() noexcept;
// Effects: *this += days{1}. Returns: *this.
constexpr weekday operator++(int) noexcept;
// Effects: ++(*this).
// Returns: A copy of *this as it existed on entry to this member function.
constexpr weekday& operator--() noexcept;
// Effects: *this -= days{1}. Returns: *this.
constexpr weekday operator--(int) noexcept;
// Effects: --(*this).
// Returns: A copy of *this as it existed on entry to this member function.
constexpr weekday& operator+=(const days& d) noexcept;
// Effects: *this = *this + d. Returns: *this.
constexpr weekday& operator-=(const days& d) noexcept;
// Effects: *this = *this - d. Returns: *this.
constexpr unsigned c_encoding() const noexcept;
// Returns: wd_.
constexpr unsigned iso_encoding() const noexcept;
// Returns: wd_ == 0u ? 7u : wd_.
constexpr bool ok() const noexcept;
// Returns: wd_ <= 6.
constexpr weekday_indexed operator[](unsigned index) const noexcept;
// Returns: {*this, index}.
constexpr weekday_last operator[](last_spec) const noexcept;
// Returns: weekday_last{*this}.
constexpr weekday operator+(const weekday& x, const days& y) noexcept;
// 29.8.6.3 Non-member functions [time.cal.wd.nonmembers]
constexpr bool operator==(const weekday& x, const weekday& y) noexcept;
// Returns: x.wd_ == y.wd_.
// Returns:
weekday{modulo(static_cast<long long>(x.wd_) + y.count(), 7)}
// where modulo(n, 7) computes the remainder of n divided by 7 using Euclidean division.
// [Note 1: Given a divisor of 7, Euclidean division truncates towards negative infinity and always produces a remainder in the range of [0, 6]. Assuming no overflow in the signed summation, this operation results in a weekday holding a value in the range [0,6] even if !x.ok().
// [Example 1: Monday + days{6} == Sunday.
constexpr weekday operator+(const days& x, const weekday& y) noexcept;
// Returns: y + x.
constexpr weekday operator-(const weekday& x, const days& y) noexcept;
// Returns: x + -y.
constexpr days operator-(const weekday& x, const weekday& y) noexcept;
// Returns: If x.ok() == true and y.ok() == true, returns a value d in the range [days{0}, days{6}] satisfying y + d == x. Otherwise the value returned is unspecified.
// [Example 2: Sunday - Monday == days{6}. —end example]
template<class charT, class traits>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os, const weekday& wd);
// Effects: Equivalent to:
return os << (wd.ok() ?
              format(os.getloc(), STATICALLY-WIDEN<charT>("{:L%a}"), wd) : format(os.getloc(), STATICALLY-WIDEN<charT>("{} is not a valid weekday"),
                      static_cast<unsigned>(wd.wd_)));
template<class charT, class traits, class Alloc = allocator<charT>>
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);
// Effects: Attempts to parse the input stream is into the weekday wd using the format flags given in the NTCTS fmt as specified in 29.13. If the parse fails to decode a valid weekday, is.setstate(ios_- base::failbit) is called and wd is not modified. If %Z is used and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null. If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
// Returns: is.
// 29.8.7 Class weekday_indexed [time.cal.wdidx]
// 29.8.7.1 Overview [time.cal.wdidx.overview]
namespace std::chrono {
class weekday_indexed {
    chrono::weekday  wd_;
    unsigned char    index_;
// exposition only // exposition only
public:
    weekday_indexed() = default;
    constexpr weekday_indexed(const chrono::weekday& wd, unsigned index) noexcept;
// Effects: Initializes wd_ with wd and index_ with index. The values held are unspecified if !wd.ok() or index is not in the range [0, 7].
    constexpr chrono::weekday weekday() const noexcept;
    constexpr unsigned        index()   const noexcept;
    constexpr bool ok() const noexcept;
};
}
//  weekday_indexed represents a weekday and a small index in the range 1 to 5. This class is used to represent the first, second, third, fourth, or fifth weekday of a month.
//  [Note 1: A weekday_indexed object can be constructed by indexing a weekday with an unsigned.
// [Example 1:
constexpr auto wdi = Sunday[2]; // wdi is the second Sunday of an as yet unspecified month
static_assert(wdi.weekday() == Sunday);
static_assert(wdi.index() == 2);
// weekday_indexed is a trivially copyable and standard-layout class type.
// 29.8.7.2 Member functions [time.cal.wdidx.members]
constexpr weekday_indexed(const chrono::weekday& wd, unsigned index) noexcept;
constexpr chrono::weekday weekday() const noexcept;
// Returns: wd_.
constexpr unsigned index() const noexcept;
// Returns: index_.
constexpr bool ok() const noexcept;
// Returns: wd_.ok() && 1 <= index_ && index_ <= 5.
// 29.8.7.3 Non-member functions [time.cal.wdidx.nonmembers]
constexpr bool operator==(const weekday_indexed& x, const weekday_indexed& y) noexcept;
// Returns: x.weekday() == y.weekday() && x.index() == y.index().
template<class charT, class traits>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os, const weekday_indexed& wdi);
// Effects: Equivalent to:
auto i = wdi.index();
return os << (i >= 1 && i <= 5 ?
// format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}[{}]"), wdi.weekday(), i) : format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}[{} is not a valid index]"),
// 9.8.8 [time.cal.wdlast]
// 29.8.8.1 Overview [time.cal.wdlast.overview]
namespace std::chrono {
    class weekday_last {
        chrono::weekday wd_;
// exposition only
    };
    wdi.weekday(), i));
    Class weekday_last
public:
    constexpr explicit weekday_last(const chrono::weekday& wd) noexcept;
    constexpr chrono::weekday weekday() const noexcept;
    constexpr bool ok() const noexcept;
}
// Returns: m_.
//  weekday_last represents the last weekday of a month.
//  [Note 1 : A weekday_last object can be constructed by indexing a weekday with last. — end note ]
// [Example 1:
constexpr auto wdl = Sunday[last]; // wdl is the last Sunday of an as yet unspecified month
                     static_assert(wdl.weekday() == Sunday);
// weekday_last is a trivially copyable and standard-layout class type.
// 29.8.8.2 Member functions [time.cal.wdlast.members]
                     constexpr explicit weekday_last(const chrono::weekday& wd) noexcept;
// Effects: Initializes wd_ with wd.
                     constexpr chrono::weekday weekday() const noexcept;
// Returns: wd_.
                     constexpr bool ok() const noexcept;
// Returns: wd_.ok().
// 29.8.8.3 Non-member functions [time.cal.wdlast.nonmembers]
                     constexpr bool operator==(const weekday_last& x, const weekday_last& y) noexcept;
// Returns: x.weekday() == y.weekday().
                     template<class charT, class traits>
                     basic_ostream<charT, traits>&
                     operator<<(basic_ostream<charT, traits>& os, const weekday_last& wdl);
// Effects: Equivalent to:
                     return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}[last]"), wdl.weekday());
// 29.8.9 Class month_day [time.cal.md]
// 29.8.9.1 Overview [time.cal.md.overview]
namespace std::chrono {
    class month_day {
        chrono::month m_;
        chrono::day   d_;
// exposition only // exposition only
    public:
        month_day() = default;
        constexpr month_day(const chrono::month& m, const chrono::day& d) noexcept;
        constexpr chrono::month month() const noexcept;
        constexpr chrono::day   day()   const noexcept;
        constexpr bool ok() const noexcept;
    };
}
// month_day represents a specific day of a specific month, but with an unspecified year. month_day meets the Cpp17EqualityComparable (Table 27) and Cpp17LessThanComparable (Table 28) requirements.
//  month_day is a trivially copyable and standard-layout class type.
// 29.8.9.2 Member functions [time.cal.md.members]
constexpr month_day(const chrono::month& m, const chrono::day& d) noexcept;
// Effects: Initializes m_ with m, and d_ with d.
constexpr chrono::month month() const noexcept;
constexpr chrono::day day() const noexcept;
// Returns: d_.
constexpr bool ok() const noexcept;
// Returns: true if m_.ok() is true, 1d <= d_, and d_ is less than or equal to the number of days in month m_; otherwise returns false. When m_ == February, the number of days is considered to be 29.
// 29.8.9.3 Non-member functions [time.cal.md.nonmembers]
constexpr bool operator==(const month_day& x, const month_day& y) noexcept;
// Returns: x.month() == y.month() && x.day() == y.day().
constexpr strong_ordering operator<=>(const month_day& x, const month_day& y) noexcept;
// Effects: Equivalent to:
if (auto c = x.month() <=> y.month(); c != 0) return c;
        return x.day() <=> y.day();
        template<class charT, class traits>
        basic_ostream<charT, traits>&
}
operator<<(basic_ostream<charT, traits>& os, const month_day& md);
// Effects: Equivalent to:
return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}/{}"),
                    md.month(), md.day());
       template<class charT, class traits, class Alloc = allocator<charT>>
       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);
// Effects: Attempts to parse the input stream is into the month_day md using the format flags given in the NTCTS fmt as specified in 29.13. If the parse fails to decode a valid month_day, is.setstate(ios_- base::failbit) is called and md is not modified. If %Z is used and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null. If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
// Returns: is.
// 29.8.10 Class month_day_last [time.cal.mdlast]
       namespace std::chrono {
           class month_day_last {
               chrono::month m_;
               public:
               constexpr explicit month_day_last(const chrono::month& m) noexcept;
               constexpr chrono::month month() const noexcept;
               constexpr bool ok() const noexcept;
           };
// exposition only
//  month_day_last represents the last day of a month.
//  [Note 1 : A month_day_last object can be constructed using the expression m/last or last/m, where m is an expression of type month.
// [Example 1:
           constexpr auto mdl = February/last; // mdl is the last day of February of an as yet unspecified year
           static_assert(mdl.month() == February);
//  month_day_last is a trivially copyable and standard-layout class type.
           constexpr explicit month_day_last(const chrono::month& m) noexcept;
// Effects: Initializes m_ with m.
           constexpr month month() const noexcept;
// Returns: m_.
           constexpr bool ok() const noexcept;
// Returns: m_.ok().
           constexpr bool operator==(const month_day_last& x, const month_day_last& y) noexcept;
// Returns: x.month() == y.month().
           constexpr strong_ordering operator<=>(const month_day_last& x, const month_day_last& y) noexcept;
// Returns: x.month() <=> y.month().
           template<class charT, class traits>
           basic_ostream<charT, traits>&
           operator<<(basic_ostream<charT, traits>& os, const month_day_last& mdl);
// Effects: Equivalent to:
           return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}/last"), mdl.month());
                   }
// 29.8.11 Class month_weekday [time.cal.mwd]
// 29.8.11.1 Overview  [time.cal.mwd.overview]
namespace std::chrono {
class month_weekday {
    chrono::month           m_;
    chrono::weekday_indexed wdi_;
public:
// exposition only // exposition only
    constexpr month_weekday(const chrono::month& m, const chrono::weekday_indexed& wdi) noexcept;
        constexpr chrono::month           month()           const noexcept;
        constexpr chrono::weekday_indexed weekday_indexed() const noexcept;
        constexpr bool ok() const noexcept;
    };
}
// month_weekday represents the nth weekday of a month, of an as yet unspecified year. To do this the month_weekday stores a month and a weekday_indexed.
// [Example 1 :
constexpr auto mwd
    = February/Tuesday[3]; // mwd is the third Tuesday of February of an as yet unspecified year
      static_assert(mwd.month() == February);
      static_assert(mwd.weekday_indexed() == Tuesday[3]);
// month_weekday is a trivially copyable and standard-layout class type.
// 29.8.11.2 Member functions [time.cal.mwd.members]
      constexpr month_weekday(const chrono::month& m, const chrono::weekday_indexed& wdi) noexcept;
// Effects: Initializes m_ with m, and wdi_ with wdi. constexpr chrono::month month() const noexcept;
// Returns: m_.
      constexpr chrono::weekday_indexed weekday_indexed() const noexcept;
// Returns: wdi_.
      constexpr bool ok() const noexcept;
// Returns: m_.ok() && wdi_.ok().
// 29.8.11.3 Non-member functions [time.cal.mwd.nonmembers]
      constexpr bool operator==(const month_weekday& x, const month_weekday& y) noexcept;
// Returns: x.month() == y.month() && x.weekday_indexed() == y.weekday_indexed().
      template<class charT, class traits>
      basic_ostream<charT, traits>&
      operator<<(basic_ostream<charT, traits>& os, const month_weekday& mwd);
// Effects: Equivalent to:
      return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}/{:L}"),
                          mwd.month(), mwd.weekday_indexed());
// 29.8.12 Class month_weekday_last [time.cal.mwdlast]
// 29.8.12.1 Overview [time.cal.mwdlast.overview]
namespace std::chrono {
    class month_weekday_last {
        chrono::month        m_;
        chrono::weekday_last wdl_;
    public:
// exposition only // exposition only
        constexpr month_weekday_last(const chrono::month& m,
                                     const chrono::weekday_last& wdl) noexcept;
        constexpr chrono::month        month()        const noexcept;
        constexpr chrono::weekday_last weekday_last() const noexcept;
        constexpr bool ok() const noexcept;
    };
}
//  month_weekday_last represents the last weekday of a month, of an as yet unspecified year. To do this the month_weekday_last stores a month and a weekday_last.
//  [Example 1 :
constexpr auto mwd
    = February/Tuesday[last]; // mwd is the last Tuesday of February of an as yet unspecified year
      static_assert(mwd.month() == February);
      static_assert(mwd.weekday_last() == Tuesday[last]);
//  month_weekday_last is a trivially copyable and standard-layout class type.
// 29.8.12.2 Member functions [time.cal.mwdlast.members]
      constexpr month_weekday_last(const chrono::month& m,
                                   const chrono::weekday_last& wdl) noexcept;
// Effects: Initializes m_ with m, and wdl_ with wdl. constexpr chrono::month month() const noexcept;
// Returns: m_.
      constexpr chrono::weekday_last weekday_last() const noexcept;
// Returns: wdl_.
      constexpr bool ok() const noexcept;
// Returns: m_.ok() && wdl_.ok().
// 29.8.12.3 Non-member functions [time.cal.mwdlast.nonmembers]
      constexpr bool operator==(const month_weekday_last& x, const month_weekday_last& y) noexcept;
      Returns:
      x.month() == y.month() && x.weekday_last() == y.weekday_last().
      template<class charT, class traits>
      basic_ostream<charT, traits>&
      operator<<(basic_ostream<charT, traits>& os, const month_weekday_last& mwdl);
// Effects: Equivalent to:
      return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}/{:L}"),
                          mwdl.month(), mwdl.weekday_last());
// 29.8.13 Class year_month  [time.cal.ym]
// 29.8.13.1 Overview v
namespace std::chrono {
    class year_month {
        chrono::year  y_;
        chrono::month m_;
// exposition only // exposition only
    public:
        year_month() = default;
        constexpr year_month(const chrono::year& y, const chrono::month& m) noexcept;
        constexpr chrono::year  year()  const noexcept;
        constexpr chrono::month month() const noexcept;
        constexpr year_month& operator+=(const months& dm) noexcept;
        constexpr year_month& operator-=(const months& dm) noexcept;
        constexpr year_month& operator+=(const years& dy)  noexcept;
        constexpr year_month& operator-=(const years& dy)  noexcept;
        constexpr bool ok() const noexcept;
    };
}
//  year_month represents a specific month of a specific year, but with an unspecified day. year_month is a field-based time point with a resolution of months. year_month meets the Cpp17EqualityComparable (Table 27) and Cpp17LessThanComparable (Table 28) requirements.
//  year_month is a trivially copyable and standard-layout class type.
// 29.8.13.2 Member functions [time.cal.ym.members]
constexpr year_month(const chrono::year& y, const chrono::month& m) noexcept;
// Effects: Initializes y_ with y, and m_ with m. constexpr chrono::year year() const noexcept;
// Returns: y_.
constexpr chrono::month month() const noexcept;
// Returns: m_.
constexpr year_month& operator+=(const months& dm) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Effects: *this = *this + dm. Returns: *this.
constexpr year_month& operator-=(const months& dm) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Effects: *this = *this - dm. Returns: *this.
constexpr year_month& operator+=(const years& dy) noexcept;
// Effects: *this = *this + dy. Returns: *this.
constexpr year_month& operator-=(const years& dy) noexcept;
// Effects: *this = *this - dy. Returns: *this.
constexpr bool ok() const noexcept;
// Returns: y_.ok() && m_.ok().
// 29.8.13.3 Non-member functions [time.cal.ym.nonmembers]
constexpr bool operator==(const year_month& x, const year_month& y) noexcept;
// Returns: x.year() == y.year() && x.month() == y.month().
constexpr strong_ordering operator<=>(const year_month& x, const year_month& y) noexcept;
// Effects: Equivalent to:
if (auto c = x.year() <=> y.year(); c != 0) return c;
        return x.month() <=> y.month();
        constexpr year_month operator+(const year_month& ym, const months& dm) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Returns: A year_month value z such that z.ok() && z - ym == dm is true. Complexity: O(1) with respect to the value of dm.
        constexpr year_month operator+(const months& dm, const year_month& ym) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Returns: ym + dm.
        constexpr year_month operator-(const year_month& ym, const months& dm) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Returns: ym + -dm.
        constexpr months operator-(const year_month& x, const year_month& y) noexcept;
// Returns:
        x.year() - y.year() + months{static_cast<int>(unsigned{x.month()}) -
                                     static_cast<int>(unsigned{y.month()})}
        constexpr year_month operator+(const year_month& ym, const years& dy) noexcept;
// Returns: (ym.year() + dy) / ym.month().
        constexpr year_month operator+(const years& dy, const year_month& ym) noexcept;
// Returns: ym + dy.
        constexpr year_month operator-(const year_month& ym, const years& dy) noexcept;
// Returns: ym + -dy.
        template<class charT, class traits>
        basic_ostream<charT, traits>&
        operator<<(basic_ostream<charT, traits>& os, const year_month& ym);
// Effects: Equivalent to:
        return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{:L}"), ym.year(), ym.month());
        template<class charT, class traits, class Alloc = allocator<charT>>
        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);
// Effects: Attempts to parse the input stream is into the year_month ym using the format flags given in the NTCTS fmt as specified in 29.13. If the parse fails to decode a valid year_month, is.setstate(ios_- base::failbit) is called and ym is not modified. If %Z is used and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null. If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
        const chrono::day& d) noexcept;
// Effects: Initializes y_ with y, m_ with m, and d_ with d.
// Returns: is.
// 29.8.14 Class year_month_day  [time.cal.ymd]
// 29.8.14.1 Overview [time.cal.ymd.overview]
namespace std::chrono {
class year_month_day {
    chrono::year  y_;
    chrono::month m_;
    chrono::day   d_;
// exposition only // exposition only // exposition only
public:
    year_month_day() = default;
    constexpr year_month_day(const chrono::year& y, const chrono::month& m,
                             const chrono::day& d) noexcept;
    constexpr year_month_day(const year_month_day_last& ymdl) noexcept;
    constexpr year_month_day(const sys_days& dp) noexcept;
    constexpr explicit year_month_day(const local_days& dp) noexcept;
    constexpr year_month_day& operator+=(const months& m) noexcept;
    constexpr year_month_day& operator-=(const months& m) noexcept;
    constexpr year_month_day& operator+=(const years& y)  noexcept;
    constexpr year_month_day& operator-=(const years& y)  noexcept;
    constexpr chrono::year  year()  const noexcept;
    constexpr chrono::month month() const noexcept;
    constexpr chrono::day   day()   const noexcept;
    constexpr          operator sys_days()   const noexcept;
    constexpr explicit operator local_days() const noexcept;
    constexpr bool ok() const noexcept;
};
}
//  year_month_day represents a specific year, month, and day. year_month_day is a field-based time point with a resolution of days.
// [Note 1: year_month_day supports years- and months-oriented arithmetic, but not days-oriented arithmetic. For the latter, there is a conversion to sys_days, which efficiently supports days-oriented arithmetic. year_month_day meets the Cpp17EqualityComparable (Table 27) and Cpp17LessThanComparable (Table 28) requirements.
//  year_month_day is a trivially copyable and standard-layout class type.
// 29.8.14.2 Member functions [time.cal.ymd.members]
constexpr year_month_day(const chrono::year& y, const chrono::month& m,
                         constexpr year_month_day(const year_month_day_last& ymdl) noexcept;
// Effects: Initializes y_ with ymdl.year(), m_ with ymdl.month(), and d_ with ymdl.day().
// [Note 1: This conversion from year_month_day_last to year_month_day can be more efficient than converting a year_month_day_last to a sys_days, and then converting that sys_days to a year_month_day. —
                         constexpr year_month_day(const sys_days& dp) noexcept;
// Effects: Constructs an object of type year_month_day that corresponds to the date represented by dp. Remarks: For any value ymd of type year_month_day for which ymd.ok() is true, ymd == year_- month_day{sys_days{ymd}} is true.
                         constexpr explicit year_month_day(const local_days& dp) noexcept;
// Effects: Equivalent to constructing with sys_days{dp.time_since_epoch()}. constexpr year_month_day& operator+=(const months& m) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Effects: *this = *this + m. Returns: *this.
                         constexpr year_month_day& operator-=(const months& m) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Effects: *this = *this - m. Returns: *this.
                         constexpr year_month_day& year_month_day::operator+=(const years& y) noexcept;
// Effects: *this = *this + y. Returns: *this.
                         constexpr year_month_day& year_month_day::operator-=(const years& y) noexcept;
// Effects: *this = *this - y. Returns: *this.
                         constexpr chrono::year year() const noexcept;
// Returns: y_.
                         constexpr chrono::month month() const noexcept;
// Returns: m_.
                         constexpr chrono::day day() const noexcept;
// Returns: d_.
                         constexpr operator sys_days() const noexcept;
// Returns: If ok(), returns a sys_days holding a count of days from the sys_days epoch to *this (a negative value if *this represents a date prior to the sys_days epoch). Otherwise, if y_.ok() && m_.ok() is true, returns sys_days{y_/m_/1d} + (d_ - 1d). Otherwise the value returned is unspecified.
// Remarks: A sys_days in the range [days{-12687428},days{11248737}] which is converted to a year_month_day has the same value when converted back to a sys_days. // [Example 1:
static_assert(year_month_day{sys_days{2017y/January/0}}  == 2016y/December/31);
static_assert(year_month_day{sys_days{2017y/January/31}} == 2017y/January/31);
static_assert(year_month_day{sys_days{2017y/January/32}} == 2017y/February/1);
constexpr explicit operator local_days() const noexcept;
// Returns: local_days{sys_days{*this}.time_since_epoch()}. constexpr bool ok() const noexcept;
// Returns: If y_.ok() is true, and m_.ok() is true, and d_ is in the range [1d, (y_/m_/last).day()], then returns true; otherwise returns false.
// 29.8.14.3 Non-member functions [time.cal.ymd.nonmembers]
constexpr bool operator==(const year_month_day& x, const year_month_day& y) noexcept;
// Returns: x.year() == y.year() && x.month() == y.month() && x.day() == y.day().
constexpr strong_ordering operator<=>(const year_month_day& x, const year_month_day& y) noexcept;
// Effects: Equivalent to:
if (auto c = x.year() <=> y.year(); c != 0) return c;
        if (auto c = x.month() <=> y.month(); c != 0) return c;
            return x.day() <=> y.day();
            constexpr year_month_day operator+(const year_month_day& ymd, const months& dm) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Returns: (ymd.year() / ymd.month() + dm) / ymd.day().
// [Note 1 : If ymd.day() is in the range [1d, 28d], ok() will return true for the resultant year_month_day.
            constexpr year_month_day operator+(const months& dm, const year_month_day& ymd) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Returns: ymd + dm.
            constexpr year_month_day operator-(const year_month_day& ymd, const months& dm) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Returns: ymd + (-dm).
            constexpr year_month_day operator+(const year_month_day& ymd, const years& dy) noexcept;
// Returns: (ymd.year() + dy) / ymd.month() / ymd.day().
// [Note 2: If ymd.month() is February and ymd.day() is not in the range [1d,28d], ok() can return false for the resultant year_month_day. —end note]
            constexpr year_month_day operator+(const years& dy, const year_month_day& ymd) noexcept;
// Returns: ymd + dy.
            constexpr year_month_day operator-(const year_month_day& ymd, const years& dy) noexcept;
// Returns: ymd + (-dy).
            template<class charT, class traits>
            basic_ostream<charT, traits>&
            operator<<(basic_ostream<charT, traits>& os, const year_month_day& ymd);
// Effects: Equivalent to:
            return os << (ymd.ok() ?
                          format(STATICALLY-WIDEN<charT>("{:%F}"), ymd) : format(STATICALLY-WIDEN<charT>("{:%F} is not a valid date"), ymd));
            template<class charT, class traits, class Alloc = allocator<charT>>
            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);
// Effects: Attempts to parse the input stream is into the year_month_day ymd using the format flags given in the NTCTS fmt as specified in 29.13. If the parse fails to decode a valid year_month_day, is.setstate(ios_base::failbit) is called and ymd is not modified. If %Z is used and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null. If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
// Returns: is.
// 29.8.15 Class year_month_day_last  [time.cal.ymdlast]
// 29.8.15.1 Overview [time.cal.ymdlast.overview]
    namespace std::chrono {
    class year_month_day_last {
        chrono::year           y_;
        chrono::month_day_last mdl_;
    public:
        constexpr year_month_day_last(const chrono::year& y,
                                      const chrono::month_day_last& mdl) noexcept;
            constexpr year_month_day_last& operator+=(const months& m) noexcept;
            constexpr year_month_day_last& operator-=(const months& m) noexcept;
            constexpr year_month_day_last& operator+=(const years& y)  noexcept;
            constexpr year_month_day_last& operator-=(const years& y)  noexcept;
            constexpr chrono::year           year()           const noexcept;
            constexpr chrono::month          month()          const noexcept;
            constexpr chrono::month_day_last month_day_last() const noexcept;
            constexpr chrono::day            day()            const noexcept;
            constexpr          operator sys_days()   const noexcept;
            constexpr explicit operator local_days() const noexcept;
            constexpr bool ok() const noexcept;
        }; }
// exposition only // exposition only
//  year_month_day_last represents the last day of a specific year and month. year_month_day_last is a field-based time point with a resolution of days, except that it is restricted to pointing to the last day of a year and month.
// [Note 1: year_month_day_last supports years- and months-oriented arithmetic, but not days-oriented arithmetic. For the latter, there is a conversion to sys_days, which efficiently supports days-oriented arithmetic.  year_month_day_last meets the Cpp17EqualityComparable (Table 27) and Cpp17LessThanComparable (Table 28) requirements.
// year_month_day_last is a trivially copyable and standard-layout class type.
// 9.8.15.2 Member functions [time.cal.ymdlast.members]
constexpr year_month_day_last(const chrono::year& y,
                              const chrono::month_day_last& mdl) noexcept;
// Effects: Initializes y_ with y and mdl_ with mdl.
constexpr year_month_day_last& operator+=(const months& m) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Effects: *this = *this + m. Returns: *this.
constexpr year_month_day_last& operator-=(const months& m) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Effects: *this = *this - m. Returns: *this.
constexpr year_month_day_last& operator+=(const years& y) noexcept;
// Effects: *this = *this + y. Returns: *this.
constexpr year_month_day_last& operator-=(const years& y) noexcept;
// Effects: *this = *this - y. Returns: *this.
constexpr chrono::year year() const noexcept;
// Returns: y_.
constexpr chrono::month month() const noexcept;
// Returns: mdl_.month().
constexpr chrono::month_day_last month_day_last() const noexcept;
// Returns: mdl_.
constexpr chrono::day day() const noexcept;
// Returns: If ok() is true, returns a day representing the last day of the (year, month) pair represented by *this. Otherwise, the returned value is unspecified.
// [Note 1: This value might be computed on demand.
constexpr operator sys_days() const noexcept;
// Returns: sys_days{year()/month()/day()}.
constexpr explicit operator local_days() const noexcept;
// Returns: local_days{sys_days{*this}.time_since_epoch()}.
constexpr bool ok() const noexcept;
// Returns: y_.ok() && mdl_.ok().
// 29.8.15.3 Non-member functions [time.cal.ymdlast.nonmembers]
constexpr bool operator==(const year_month_day_last& x, const year_month_day_last& y) noexcept;
// Returns: x.year() == y.year() && x.month_day_last() == y.month_day_last(). constexpr strong_ordering operator<=>(const year_month_day_last& x,
const year_month_day_last& y) noexcept;
// Effects: Equivalent to:
if (auto c = x.year() <=> y.year(); c != 0) return c;
return x.month_day_last() <=> y.month_day_last();
constexpr year_month_day_last
operator+(const year_month_day_last& ymdl, const months& dm) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Returns: (ymdl.year() / ymdl.month() + dm) / last. constexpr year_month_day_last
operator+(const months& dm, const year_month_day_last& ymdl) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Returns: ymdl + dm.
constexpr year_month_day_last
operator-(const year_month_day_last& ymdl, const months& dm) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Returns: ymdl + (-dm).
constexpr year_month_day_last
operator+(const year_month_day_last& ymdl, const years& dy) noexcept;
// Returns: {ymdl.year()+dy, ymdl.month_day_last()}. constexpr year_month_day_last
operator+(const years& dy, const year_month_day_last& ymdl) noexcept;
// Returns: ymdl + dy.
constexpr year_month_day_last
operator-(const year_month_day_last& ymdl, const years& dy) noexcept;
// Returns: ymdl + (-dy).
template<class charT, class traits>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os, const year_month_day_last& ymdl);
// Effects: Equivalent to:
return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{:L}"),
// 29.8.16 Class year_month_weekday  [time.cal.ymwd]
// 29.8.16.1 Overview [time.cal.ymwd.overview]
namespace std::chrono {
    class year_month_weekday {
        chrono::year
        chrono::month
        chrono::weekday_indexed wdi_;
        ymdl.year(), ymdl.month_day_last());
        y_;
        m_;
// exposition only // exposition only // exposition only
    public:
        year_month_weekday() = default;
        constexpr year_month_weekday(const chrono::year& y, const chrono::month& m,
                                     const chrono::weekday_indexed& wdi) noexcept;
        constexpr year_month_weekday(const sys_days& dp) noexcept;
        constexpr explicit year_month_weekday(const local_days& dp) noexcept;
        constexpr year_month_weekday& operator+=(const months& m) noexcept;
        constexpr year_month_weekday& operator-=(const months& m) noexcept;
        constexpr year_month_weekday& operator+=(const years& y)  noexcept;
        constexpr year_month_weekday& operator-=(const years& y)  noexcept;
        constexpr chrono::year
        constexpr chrono::month
        constexpr chrono::weekday
        constexpr unsigned
        constexpr chrono::weekday_indexed weekday_indexed() const noexcept;
        constexpr          operator sys_days()   const noexcept;
        constexpr explicit operator local_days() const noexcept;
        constexpr bool ok() const noexcept;
    };
}
year()            const noexcept;
month()           const noexcept;
weekday()         const noexcept;
index()           const noexcept;
//  year_month_weekday represents a specific year, month, and nth weekday of the month. year_month_weekday is a field-based time point with a resolution of days.
// [Note 1: year_month_weekday supports years- and months-oriented arithmetic, but not days-oriented arithmetic. For the latter, there is a conversion to sys_days, which efficiently supports days-oriented arithmetic.
// Effects: Constructs an object of type year_month_weekday which corresponds to the date represented by dp.
//Remarks: For any value ymwd of type year_month_weekday for which ymwd.ok() is true, ymwd == year_month_weekday{sys_days{ymwd}} is true. year_month_weekday meets the Cpp17EqualityComparable (Table 27) requirements. 2 year_month_weekday is a trivially copyable and standard-layout class type.
// 29.8.16.2 Member functions [time.cal.ymwd.members]
constexpr year_month_weekday(const chrono::year& y, const chrono::month& m,
                             const chrono::weekday_indexed& wdi) noexcept;
// Effects: Initializes y_ with y, m_ with m, and wdi_ with wdi.
constexpr year_month_weekday(const sys_days& dp) noexcept;
constexpr explicit year_month_weekday(const local_days& dp) noexcept;
// Effects: Equivalent to constructing with sys_days{dp.time_since_epoch()}.
constexpr year_month_weekday& operator+=(const months& m) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Effects: *this = *this + m. Returns: *this.
constexpr year_month_weekday& operator-=(const months& m) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Effects: *this = *this - m. Returns: *this.
constexpr year_month_weekday& operator+=(const years& y) noexcept;
// Effects: *this = *this + y. Returns: *this.
constexpr year_month_weekday& operator-=(const years& y) noexcept;
// Effects: *this = *this - y. Returns: *this.
constexpr chrono::year year() const noexcept;
// Returns: y_.
constexpr chrono::month month() const noexcept;
// Returns: m_.
constexpr chrono::weekday weekday() const noexcept;
// Returns: wdi_.weekday().
constexpr unsigned index() const noexcept;
// Returns: wdi_.index().
constexpr chrono::weekday_indexed weekday_indexed() const noexcept;
// Returns: wdi_.
constexpr operator sys_days() const noexcept;
// Returns: If y_.ok() && m_.ok() && wdi_.weekday().ok(), returns a sys_days that represents the date (index() - 1) * 7 days after the first weekday() of year()/month(). If index() is 0 the returned sys_days represents the date 7 days prior to the first weekday() of year()/month(). Otherwise the returned value is unspecified.
constexpr explicit operator local_days() const noexcept;
// Returns: local_days{sys_days{*this}.time_since_epoch()}. constexpr bool ok() const noexcept;
// Returns: If any of y_.ok(), m_.ok(), or wdi_.ok() is false, returns false. Otherwise, if *this represents a valid date, returns true. Otherwise, returns false.
// 29.8.16.3 Non-member functions [time.cal.ymwd.nonmembers]
constexpr bool operator==(const year_month_weekday& x, const year_month_weekday& y) noexcept;
// Returns: x.year() == y.year() && x.month() == y.month() && x.weekday_indexed() == y.weekday_indexed()
constexpr year_month_weekday operator+(const year_month_weekday& ymwd, const months& dm) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Returns: (ymwd.year() / ymwd.month() + dm) / ymwd.weekday_indexed().
constexpr year_month_weekday operator+(const months& dm, const year_month_weekday& ymwd) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Returns: ymwd + dm.
constexpr year_month_weekday operator-(const year_month_weekday& ymwd, const months& dm) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Returns: ymwd + (-dm).
constexpr year_month_weekday operator+(const year_month_weekday& ymwd, const years& dy) noexcept;
// Returns: {ymwd.year()+dy, ymwd.month(), ymwd.weekday_indexed()}.
constexpr year_month_weekday operator+(const years& dy, const year_month_weekday& ymwd) noexcept;
// Returns: ymwd + dy.
constexpr year_month_weekday operator-(const year_month_weekday& ymwd, const years& dy) noexcept;
// Returns: ymwd + (-dy).
template<class charT, class traits>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os, const year_month_weekday& ymwd);
// Effects: Equivalent to:
return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{:L}/{:L}"), ymwd.year(), ymwd.month(), ymwd.weekday_indexed());
// 29.8.17 Class year_month_weekday_last  [time.cal.ymwdlast]
// 29.8.17.1 Overview  [time.cal.ymwdlast.overview]
       namespace std::chrono {
           class year_month_weekday_last {
               chrono::year         y_;
               chrono::month        m_;
               chrono::weekday_last wdl_;
// exposition only // exposition only // exposition only
               public:
               constexpr year_month_weekday_last(const chrono::year& y, const chrono::month& m,
                       const chrono::weekday_last& wdl) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Effects: *this = *this + m. Returns: *this.
               constexpr year_month_weekday_last& operator+=(const months& m) noexcept;
               constexpr year_month_weekday_last& operator-=(const months& m) noexcept;
               constexpr year_month_weekday_last& operator+=(const years& y)  noexcept;
               constexpr year_month_weekday_last& operator-=(const years& y)  noexcept;
               constexpr chrono::year         year()
               constexpr chrono::month        month()
               constexpr chrono::weekday      weekday()
               constexpr chrono::weekday_last weekday_last() const noexcept;
               constexpr          operator sys_days()   const noexcept;
               constexpr explicit operator local_days() const noexcept;
               constexpr bool ok() const noexcept;
           };
       }
//  year_month_weekday_last represents a specific year, month, and last weekday of the month. year_month_- weekday_last is a field-based time point with a resolution of days, except that it is restricted to pointing to the last weekday of a year and month.
// [Note 1 : year_month_weekday_last supports years- and months-oriented arithmetic, but not days-oriented arithmetic. For the latter, there is a conversion to sys_days, which efficiently supports days-oriented arithmetic.  year_month_weekday_last meets the Cpp17EqualityComparable (Table 27) requirements.
//  year_month_weekday_last is a trivially copyable and standard-layout class type.
// 29.8.17.2 Member functions [time.cal.ymwdlast.members]
       constexpr year_month_weekday_last(const chrono::year& y, const chrono::month& m,
               const chrono::weekday_last& wdl) noexcept;
// Effects: Initializes y_ with y, m_ with m, and wdl_ with wdl.
       constexpr year_month_weekday_last& operator+=(const months& m) noexcept;
       constexpr year_month_weekday_last& operator-=(const months& m) noexcept;
       const noexcept;
       const noexcept;
       const noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Effects: *this = *this - m. Returns: *this.
       constexpr year_month_weekday_last& operator+=(const years& y) noexcept;
// Effects: *this = *this + y. Returns: *this.
       constexpr year_month_weekday_last& operator-=(const years& y) noexcept;
// Effects: *this = *this - y. Returns: *this.
       constexpr chrono::year year() const noexcept;
// Returns: y_.
       constexpr chrono::month month() const noexcept;
// Returns: m_.
       constexpr chrono::weekday weekday() const noexcept;
// Returns: wdl_.weekday().
       constexpr chrono::weekday_last weekday_last() const noexcept;
// Returns: wdl_.
       constexpr operator sys_days() const noexcept;
// Returns: If ok() == true, returns a sys_days that represents the last weekday() of year()/month(). Otherwise the returned value is unspecified.
       constexpr explicit operator local_days() const noexcept;
// Returns: local_days{sys_days{*this}.time_since_epoch()}. constexpr bool ok() const noexcept;
// Returns: y_.ok() && m_.ok() && wdl_.ok().
// 9.8.17.3 Non-member functions [time.cal.ymwdlast.nonmembers] constexpr bool operator==(const year_month_weekday_last& x,
       const year_month_weekday_last& y) noexcept;
// Returns: x.year() == y.year() && x.month() == y.month() && x.weekday_last() == y.weekday_last()
constexpr year_month_weekday_last
operator+(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Returns: (ymwdl.year() / ymwdl.month() + dm) / ymwdl.weekday_last().
constexpr year_month_weekday_last
operator+(const months& dm, const year_month_weekday_last& ymwdl) noexcept;
// Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Returns: ymwdl + dm.
constexpr year_month_weekday_last
operator-(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
//Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months (12.2.4.3).
// Returns: ymwdl + (-dm).
constexpr year_month_weekday_last
operator+(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
// Returns: {ymwdl.year()+dy, ymwdl.month(), ymwdl.weekday_last()}.
constexpr year_month_weekday_last
operator+(const years& dy, const year_month_weekday_last& ymwdl) noexcept;
// Returns: ymwdl + dy.
constexpr year_month_weekday_last
operator-(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
// Returns: ymwdl + (-dy).
template<class charT, class traits>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os, const year_month_weekday_last& ymwdl);
// Effects: Equivalent to:
return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{:L}/{:L}"), ymwdl.year(), ymwdl.month(), ymwdl.weekday_last());
// Returns: {y, m}.
constexpr year_month
operator/(const year& y, int m) noexcept;
// 29.8.18 Conventional syntax operators [time.cal.operators]
//  A set of overloaded operator/ functions provides a conventional syntax for the creation of civil calendar dates.
//  [Note 1: The year, month, and day are accepted in any of the following 3 orders: year /month /day month /day /year day /month /year Anywhere a day is required, any of the following can also be specified: last weekday [i ] weekday [last]
//  [Note 2: Partial-date types such as year_month and month_day can be created by not applying the second division operator for any of the three orders. For example:
year_month ym = 2015y/April;
month_day md1 = April/4;
month_day md2 = 4d/April;
//  [Example 1 :
auto a = 2015/4/4;
auto b = 2015y/4/4;
auto c = 2015y/4d/April;
auto d = 2015/April/4;
// a == int(125)
// b == year_month_day{year(2015), month(4), day(4)}
// error: no viable operator/ for first /
// error: no viable operator/ for first /
constexpr year_month
operator/(const year& y, const month& m) noexcept;
// Returns: y / month(m).
constexpr month_day
operator/(const month& m, const day& d) noexcept;
// Returns: {m, d}.
constexpr month_day
operator/(const month& m, int d) noexcept;
// Returns: m / day(d).
constexpr month_day
operator/(int m, const day& d) noexcept;
// Returns: month(m) / d.
constexpr month_day
operator/(const day& d, const month& m) noexcept;
// Returns: m / d.
constexpr month_day
operator/(const day& d, int m) noexcept;
// Returns: month(m) / d.
constexpr month_day_last
operator/(const month& m, last_spec) noexcept;
// Returns: month_day_last{m}.
constexpr month_day_last
operator/(int m, last_spec) noexcept;
// Returns: month(m) / last.
constexpr month_day_last
operator/(last_spec, const month& m) noexcept;
// Returns: m / last.
constexpr month_day_last
operator/(last_spec, int m) noexcept;
// Returns: month(m) / last.
constexpr month_weekday
operator/(const month& m, const weekday_indexed& wdi) noexcept;
// Returns: {m, wdi}.
constexpr month_weekday
operator/(int m, const weekday_indexed& wdi) noexcept;
// Returns: month(m) / wdi.
constexpr month_weekday
operator/(const weekday_indexed& wdi, const month& m) noexcept;
// Returns: m / wdi.
constexpr month_weekday
operator/(const weekday_indexed& wdi, int m) noexcept;
// Returns: month(m) / wdi.
constexpr month_weekday_last
operator/(const month& m, const weekday_last& wdl) noexcept;
// Returns: {m, wdl}.
constexpr month_weekday_last
operator/(int m, const weekday_last& wdl) noexcept;
// Returns: month(m) / wdl.
constexpr month_weekday_last
operator/(const weekday_last& wdl, const month& m) noexcept;
// Returns: m / wdl.
constexpr month_weekday_last
operator/(const weekday_last& wdl, int m) noexcept;
// Returns: month(m) / wdl.
constexpr year_month_day
operator/(const year_month& ym, const day& d) noexcept;
// Returns: {ym.year(), ym.month(), d}.
constexpr year_month_day
operator/(const year_month& ym, int d) noexcept;
// Returns: ym / day(d).
constexpr year_month_day
operator/(const year& y, const month_day& md) noexcept;
// Returns: y / md.month() / md.day().
constexpr year_month_day
operator/(int y, const month_day& md) noexcept;
// Returns: year(y) / md.
constexpr year_month_day
operator/(const month_day& md, const year& y) noexcept;
// Returns: y / md.
constexpr year_month_day
operator/(const month_day& md, int y) noexcept;
// Returns: year(y) / md.
constexpr year_month_day_last
operator/(const year_month& ym, last_spec) noexcept;
// Returns: {ym.year(), month_day_last{ym.month()}}.
constexpr year_month_day_last
operator/(const year& y, const month_day_last& mdl) noexcept;
// Returns: {y, mdl}.
constexpr year_month_day_last
operator/(int y, const month_day_last& mdl) noexcept;
// Returns: year(y) / mdl.
constexpr year_month_day_last
operator/(const month_day_last& mdl, const year& y) noexcept;
// Returns: y / mdl.
constexpr year_month_day_last
operator/(const month_day_last& mdl, int y) noexcept;
// Returns: year(y) / mdl.
constexpr year_month_weekday
operator/(const year_month& ym, const weekday_indexed& wdi) noexcept;
// Returns: {ym.year(), ym.month(), wdi}.
constexpr year_month_weekday
operator/(const year& y, const month_weekday& mwd) noexcept;
// Returns: {y, mwd.month(), mwd.weekday_indexed()}.
constexpr year_month_weekday
operator/(int y, const month_weekday& mwd) noexcept;
// Returns: year(y) / mwd.
constexpr year_month_weekday
operator/(const month_weekday& mwd, const year& y) noexcept;
// Returns: y / mwd.
constexpr year_month_weekday
operator/(const month_weekday& mwd, int y) noexcept;
// Returns: year(y) / mwd.
constexpr year_month_weekday_last
operator/(const year_month& ym, const weekday_last& wdl) noexcept;
// Returns: {ym.year(), ym.month(), wdl}.
constexpr year_month_weekday_last
operator/(const year& y, const month_weekday_last& mwdl) noexcept;
// Returns: {y, mwdl.month(), mwdl.weekday_last()}.
constexpr year_month_weekday_last
operator/(int y, const month_weekday_last& mwdl) noexcept;
// Returns: year(y) / mwdl.
constexpr year_month_weekday_last
operator/(const month_weekday_last& mwdl, const year& y) noexcept;
// Returns: y / mwdl.
constexpr year_month_weekday_last
operator/(const month_weekday_last& mwdl, int y) noexcept;
// Returns: year(y) / mwdl.
int main() {
    cout  <<  n4910 << endl;
    return EXIT_SUCCESS;
}
```

## 編纂・実行結果(compile and go)

```ubuntu:bash
$ clang++ p1393.cpp -std=03 -o p1393l -I. -Wall
In file included from p1393.cpp:10:
In file included from ./N4910.h:11:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/atomic:38:
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/c++0x_warning.h:32:2: error: This file requires compiler and library support for the ISO C++ 2011 standard. This support must be enabled with the -std=c++11 or -std=gnu++11 compiler options.
#error This file requires compiler and library support \
 ^
p1393.cpp:17:16: warning: nested namespace definition is a C++17 extension; define each namespace separately [-Wc++17-extensions]
  namespace std::chrono {
               ^~~~~~~~
                { namespace chrono
p1393.cpp:19:30: warning: defaulted function definitions are a C++11 extension [-Wc++11-extensions]
      explicit last_spec() = default;
                             ^
p1393.cpp:25:16: warning: nested namespace definition is a C++17 extension; define each namespace separately [-Wc++17-extensions]
  namespace std::chrono {
               ^~~~~~~~
                { namespace chrono
p1393.cpp:29:13: warning: defaulted function definitions are a C++11 extension [-Wc++11-extensions]
    day() = default;
            ^
p1393.cpp:30:5: error: unknown type name 'constexpr'
    constexpr explicit day(unsigned d) noexcept;
    ^
p1393.cpp:30:24: error: constructor cannot have a return type
    constexpr explicit day(unsigned d) noexcept;
                       ^~~
p1393.cpp:30:39: error: expected ';' at end of declaration list
    constexpr explicit day(unsigned d) noexcept;
                                      ^
                                      ;
p1393.cpp:31:5: error: unknown type name 'constexpr'
    constexpr day& operator++()    noexcept;
    ^
p1393.cpp:31:18: error: expected ';' at end of declaration list
    constexpr day& operator++()    noexcept;
                 ^
                 ;
p1393.cpp:32:5: error: unknown type name 'constexpr'
    constexpr day  operator++(int) noexcept;
    ^
p1393.cpp:32:18: error: expected ';' at end of declaration list
    constexpr day  operator++(int) noexcept;
                 ^
                 ;
p1393.cpp:33:5: error: unknown type name 'constexpr'
    constexpr day& operator--()    noexcept;
    ^
p1393.cpp:33:18: error: expected ';' at end of declaration list
    constexpr day& operator--()    noexcept;
                 ^
                 ;
p1393.cpp:34:5: error: unknown type name 'constexpr'
    constexpr day  operator--(int) noexcept;
    ^
p1393.cpp:34:18: error: expected ';' at end of declaration list
    constexpr day  operator--(int) noexcept;
                 ^
                 ;
p1393.cpp:35:5: error: unknown type name 'constexpr'
    constexpr day& operator+=(const days& d) noexcept;
    ^
p1393.cpp:35:18: error: expected ';' at end of declaration list
    constexpr day& operator+=(const days& d) noexcept;
                 ^
                 ;
p1393.cpp:36:5: error: unknown type name 'constexpr'
    constexpr day& operator-=(const days& d) noexcept;
    ^
p1393.cpp:36:18: error: expected ';' at end of declaration list
    constexpr day& operator-=(const days& d) noexcept;
                 ^
                 ;
p1393.cpp:37:5: error: unknown type name 'constexpr'
    constexpr explicit operator unsigned() const noexcept;
    ^
p1393.cpp:37:15: warning: explicit conversion functions are a C++11 extension [-Wc++11-extensions]
    constexpr explicit operator unsigned() const noexcept;
              ^~~~~~~~
p1393.cpp:37:49: error: expected ';' at end of declaration list
    constexpr explicit operator unsigned() const noexcept;
                                                ^
                                                ;
p1393.cpp:38:5: error: unknown type name 'constexpr'
    constexpr bool ok() const noexcept;
    ^
fatal error: too many errors emitted, stopping now [-ferror-limit=]
5 warnings and 20 errors generated.
$ clang++ p1393.cpp -std=2b -o p1393l -I. -Wall
p1393.cpp:35:37: error: unknown type name 'days'; did you mean 'day'?
    constexpr day& operator+=(const days& d) noexcept;
                                    ^~~~
                                    day
p1393.cpp:26:11: note: 'day' declared here
    class day {
          ^
p1393.cpp:36:37: error: unknown type name 'days'; did you mean 'day'?
    constexpr day& operator-=(const days& d) noexcept;
                                    ^~~~
                                    day
p1393.cpp:26:11: note: 'day' declared here
    class day {
          ^
p1393.cpp:41:11: error: unknown type name 'day'
constexpr day& operator++() noexcept;
          ^
p1393.cpp:47:23: error: C++ requires a type specifier for all declarations
   constexpr explicit day(unsigned d) noexcept;
   ~~~~~~~~~~~~~~~~~~ ^
p1393.cpp:48:14: error: unknown type name 'day'
   constexpr day operator++(int) noexcept;
             ^
p1393.cpp:51:11: error: unknown type name 'day'
constexpr day& operator--() noexcept;
          ^
p1393.cpp:53:11: error: unknown type name 'day'
constexpr day operator--(int) noexcept;
          ^
p1393.cpp:56:11: error: unknown type name 'day'
constexpr day& operator+=(const days& d) noexcept;
          ^
p1393.cpp:56:33: error: unknown type name 'days'
constexpr day& operator+=(const days& d) noexcept;
                                ^
p1393.cpp:58:11: error: unknown type name 'day'
constexpr day& operator-=(const days& d) noexcept;
          ^
p1393.cpp:58:33: error: unknown type name 'days'
constexpr day& operator-=(const days& d) noexcept;
                                ^
p1393.cpp:60:40: error: non-member function cannot have 'const' qualifier
constexpr explicit operator unsigned() const noexcept;
                                       ^~~~~~
p1393.cpp:60:20: error: conversion function must be a non-static member function
constexpr explicit operator unsigned() const noexcept;
                   ^
p1393.cpp:62:21: error: non-member function cannot have 'const' qualifier
constexpr bool ok() const noexcept;
                    ^~~~~~
p1393.cpp:65:33: error: unknown type name 'day'
constexpr bool operator==(const day& x, const day& y) noexcept;
                                ^
p1393.cpp:65:47: error: unknown type name 'day'
constexpr bool operator==(const day& x, const day& y) noexcept;
                                              ^
p1393.cpp:67:45: error: unknown type name 'day'
constexpr strong_ordering operator<=>(const day& x, const day& y) noexcept;
                                            ^
p1393.cpp:67:59: error: unknown type name 'day'
constexpr strong_ordering operator<=>(const day& x, const day& y) noexcept;
                                                          ^
p1393.cpp:69:11: error: unknown type name 'day'
constexpr day operator+(const day& x, const days& y) noexcept;
          ^
fatal error: too many errors emitted, stopping now [-ferror-limit=]
20 errors generated.

$ g++ p1393.cpp -std=03 -o p1393g -I. -Wall
In file included from /usr/local/include/c++/12.1.0/atomic:38,
                 from N4910.h:11,
                 from p1393.cpp:10:
/usr/local/include/c++/12.1.0/bits/c++0x_warning.h:32:2: error: #error This file requires compiler and library support for the ISO C++ 2011 standard. This support must be enabled with the -std=c++11 or -std=gnu++11 compiler options.
   32 | #error This file requires compiler and library support \
      |  ^~~~~
p1393.cpp:30:5: warning: identifier 'constexpr' is a keyword in C++11 [-Wc++11-compat]
   30 |     constexpr explicit day(unsigned d) noexcept;
      |     ^~~~~~~~~
p1393.cpp:30:40: warning: identifier 'noexcept' is a keyword in C++11 [-Wc++11-compat]
   30 |     constexpr explicit day(unsigned d) noexcept;
      |                                        ^~~~~~~~
p1393.cpp:86:70: warning: identifier 'nullptr' is a keyword in C++11 [-Wc++11-compat]
   86 |                 day& d, basic_string<charT, traits, Alloc>* abbrev = nullptr,
      |                                                                      ^~~~~~~
p1393.cpp:356:1: warning: identifier 'static_assert' is a keyword in C++11 [-Wc++11-compat]
  356 | static_assert(wdi.weekday() == Sunday);
      | ^~~~~~~~~~~~~
p1393.cpp:701:46: error: invalid suffix "y" on integer constant
  701 |        static_assert(year_month_day{sys_days{2017y/January/0}}  == 2016y/December/31);
      |                                              ^~~~~
p1393.cpp:701:68: error: invalid suffix "y" on integer constant
  701 |        static_assert(year_month_day{sys_days{2017y/January/0}}  == 2016y/December/31);
      |                                                                    ^~~~~
p1393.cpp:702:46: error: invalid suffix "y" on integer constant
  702 |        static_assert(year_month_day{sys_days{2017y/January/31}} == 2017y/January/31);
      |                                              ^~~~~
p1393.cpp:702:68: error: invalid suffix "y" on integer constant
  702 |        static_assert(year_month_day{sys_days{2017y/January/31}} == 2017y/January/31);
      |                                                                    ^~~~~
p1393.cpp:703:46: error: invalid suffix "y" on integer constant
  703 |        static_assert(year_month_day{sys_days{2017y/January/32}} == 2017y/February/1);
      |                                              ^~~~~
p1393.cpp:703:68: error: invalid suffix "y" on integer constant
  703 |        static_assert(year_month_day{sys_days{2017y/January/32}} == 2017y/February/1);
      |                                                                    ^~~~~
p1393.cpp:1014:22: error: invalid suffix "y" on integer constant
 1014 |      year_month ym = 2015y/April;
      |                      ^~~~~
p1393.cpp:1016:22: error: invalid suffix "d" on integer constant
 1016 |      month_day md2 = 4d/April;
      |                      ^~
p1393.cpp:1019:10: error: invalid suffix "y" on integer constant
 1019 | auto b = 2015y/4/4;
      |          ^~~~~
p1393.cpp:1020:10: error: invalid suffix "y" on integer constant
 1020 | auto c = 2015y/4d/April;
      |          ^~~~~
p1393.cpp:1020:16: error: invalid suffix "d" on integer constant
 1020 | auto c = 2015y/4d/April;
      |                ^~
p1393.cpp:19:30: warning: defaulted and deleted functions only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
   19 |       explicit last_spec() = default;
      |                              ^~~~~~~
p1393.cpp:29:13: warning: defaulted and deleted functions only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
   29 |     day() = default;
      |             ^~~~~~~
p1393.cpp:30:5: error: 'constexpr' does not name a type
   30 |     constexpr explicit day(unsigned d) noexcept;
      |     ^~~~~~~~~
p1393.cpp:30:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:31:5: error: 'constexpr' does not name a type
   31 |     constexpr day& operator++()    noexcept;
      |     ^~~~~~~~~
p1393.cpp:31:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:32:5: error: 'constexpr' does not name a type
   32 |     constexpr day  operator++(int) noexcept;
      |     ^~~~~~~~~
p1393.cpp:32:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:33:5: error: 'constexpr' does not name a type
   33 |     constexpr day& operator--()    noexcept;
      |     ^~~~~~~~~
p1393.cpp:33:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:34:5: error: 'constexpr' does not name a type
   34 |     constexpr day  operator--(int) noexcept;
      |     ^~~~~~~~~
p1393.cpp:34:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:35:5: error: 'constexpr' does not name a type
   35 |     constexpr day& operator+=(const days& d) noexcept;
      |     ^~~~~~~~~
p1393.cpp:35:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:36:5: error: 'constexpr' does not name a type
   36 |     constexpr day& operator-=(const days& d) noexcept;
      |     ^~~~~~~~~
p1393.cpp:36:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:37:5: error: 'constexpr' does not name a type
   37 |     constexpr explicit operator unsigned() const noexcept;
      |     ^~~~~~~~~
p1393.cpp:37:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:38:5: error: 'constexpr' does not name a type
   38 |     constexpr bool ok() const noexcept;
      |     ^~~~~~~~~
p1393.cpp:38:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:41:1: error: 'constexpr' does not name a type
   41 | constexpr day& operator++() noexcept;
      | ^~~~~~~~~
p1393.cpp:41:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:47:4: error: 'constexpr' does not name a type
   47 |    constexpr explicit day(unsigned d) noexcept;
      |    ^~~~~~~~~
p1393.cpp:47:4: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:48:4: error: 'constexpr' does not name a type
   48 |    constexpr day operator++(int) noexcept;
      |    ^~~~~~~~~
p1393.cpp:48:4: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:51:1: error: 'constexpr' does not name a type
   51 | constexpr day& operator--() noexcept;
      | ^~~~~~~~~
p1393.cpp:51:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:53:1: error: 'constexpr' does not name a type
   53 | constexpr day operator--(int) noexcept;
      | ^~~~~~~~~
p1393.cpp:53:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:56:1: error: 'constexpr' does not name a type
   56 | constexpr day& operator+=(const days& d) noexcept;
      | ^~~~~~~~~
p1393.cpp:56:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:58:1: error: 'constexpr' does not name a type
   58 | constexpr day& operator-=(const days& d) noexcept;
      | ^~~~~~~~~
p1393.cpp:58:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:60:1: error: 'constexpr' does not name a type
   60 | constexpr explicit operator unsigned() const noexcept;
      | ^~~~~~~~~
p1393.cpp:60:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:62:1: error: 'constexpr' does not name a type
   62 | constexpr bool ok() const noexcept;
      | ^~~~~~~~~
p1393.cpp:62:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:65:1: error: 'constexpr' does not name a type
   65 | constexpr bool operator==(const day& x, const day& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:65:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:67:1: error: 'constexpr' does not name a type
   67 | constexpr strong_ordering operator<=>(const day& x, const day& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:67:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:69:1: error: 'constexpr' does not name a type
   69 | constexpr day operator+(const day& x, const days& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:69:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:71:1: error: 'constexpr' does not name a type
   71 | constexpr day operator+(const days& x, const day& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:71:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:73:1: error: 'constexpr' does not name a type
   73 | constexpr day operator-(const day& x, const days& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:73:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:75:1: error: 'constexpr' does not name a type
   75 | constexpr days operator-(const day& x, const day& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:75:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:79:56: error: 'day' does not name a type
   79 |     operator<<(basic_ostream<charT, traits>& os, const day& d);
      |                                                        ^~~
p1393.cpp:81:1: error: expected unqualified-id before 'return'
   81 | return os << (d.ok() ?
      | ^~~~~~
p1393.cpp:83:66: error: spurious '>>', use '>' to terminate a template argument list
   83 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                                                  ^~
p1393.cpp:83:51: error: two or more data types in declaration of 'type name'
   83 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                                   ^~~~~~~~~~~~~~~~~
p1393.cpp:85:5: error: expected '>' before 'from_stream'
   85 |     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
      |     ^~~~~~~~~~~
p1393.cpp:87:38: error: expected unqualified-id before ';' token
   87 |            minutes* offset = nullptr);
      |                                      ^
p1393.cpp:90:1: error: 'constexpr' does not name a type
   90 | constexpr chrono::day operator""d(unsigned long long d) noexcept;
      | ^~~~~~~~~
p1393.cpp:90:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:99:9: error: expected unqualified-id before ')' token
   99 |   month() = default;
      |         ^
p1393.cpp:100:3: error: 'constexpr' does not name a type
  100 |   constexpr explicit month(unsigned m) noexcept;
      |   ^~~~~~~~~
p1393.cpp:100:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:101:3: error: 'constexpr' does not name a type
  101 |   constexpr month& operator++()    noexcept;
      |   ^~~~~~~~~
p1393.cpp:101:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:102:3: error: 'constexpr' does not name a type
  102 |   constexpr month  operator++(int) noexcept;
      |   ^~~~~~~~~
p1393.cpp:102:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:103:3: error: 'constexpr' does not name a type
  103 |   constexpr month& operator--()    noexcept;
      |   ^~~~~~~~~
p1393.cpp:103:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:104:3: error: 'constexpr' does not name a type
  104 |   constexpr month  operator--(int) noexcept;
      |   ^~~~~~~~~
p1393.cpp:104:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:105:3: error: 'constexpr' does not name a type
  105 |   constexpr month& operator+=(const months& m) noexcept;
      |   ^~~~~~~~~
p1393.cpp:105:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:106:3: error: 'constexpr' does not name a type
  106 |   constexpr month& operator-=(const months& m) noexcept;
      |   ^~~~~~~~~
p1393.cpp:106:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:107:3: error: 'constexpr' does not name a type
  107 |   constexpr explicit operator unsigned() const noexcept;
      |   ^~~~~~~~~
p1393.cpp:107:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:108:3: error: 'constexpr' does not name a type
  108 |   constexpr bool ok() const noexcept;
      |   ^~~~~~~~~
p1393.cpp:108:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:114:4: error: 'constexpr' does not name a type
  114 |    constexpr explicit month(unsigned m) noexcept;
      |    ^~~~~~~~~
p1393.cpp:114:4: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:116:1: error: 'constexpr' does not name a type
  116 | constexpr month& operator++() noexcept;
      | ^~~~~~~~~
p1393.cpp:116:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:118:1: error: 'constexpr' does not name a type
  118 | constexpr month operator++(int) noexcept;
      | ^~~~~~~~~
p1393.cpp:118:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:121:1: error: 'constexpr' does not name a type
  121 | constexpr month& operator--() noexcept;
      | ^~~~~~~~~
p1393.cpp:121:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:123:4: error: 'constexpr' does not name a type
  123 |    constexpr month operator--(int) noexcept;
      |    ^~~~~~~~~
p1393.cpp:123:4: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:126:1: error: 'constexpr' does not name a type
  126 | constexpr month& operator+=(const months& m) noexcept;
      | ^~~~~~~~~
p1393.cpp:126:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:128:1: error: 'constexpr' does not name a type
  128 | constexpr month& operator-=(const months& m) noexcept;
      | ^~~~~~~~~
p1393.cpp:128:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:130:1: error: 'constexpr' does not name a type
  130 | constexpr explicit operator unsigned() const noexcept;
      | ^~~~~~~~~
p1393.cpp:130:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:132:1: error: 'constexpr' does not name a type
  132 | constexpr bool ok() const noexcept;
      | ^~~~~~~~~
p1393.cpp:132:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:135:1: error: 'constexpr' does not name a type
  135 | constexpr bool operator==(const month& x, const month& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:135:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:137:1: error: 'constexpr' does not name a type
  137 | constexpr strong_ordering operator<=>(const month& x, const month& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:137:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:139:1: error: 'constexpr' does not name a type
  139 | constexpr month operator+(const month& x, const months& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:139:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:144:1: error: 'constexpr' does not name a type
  144 | constexpr month operator-(const month& x, const months& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:144:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:146:1: error: 'constexpr' does not name a type
  146 | constexpr months operator-(const month& x, const month& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:146:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:151:52: error: 'month' does not name a type
  151 | operator<<(basic_ostream<charT, traits>& os, const month& m);
      |                                                    ^~~~~
p1393.cpp:153:1: error: expected unqualified-id before 'return'
  153 | return os << (m.ok() ?
      | ^~~~~~
p1393.cpp:156:66: error: spurious '>>', use '>' to terminate a template argument list
  156 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                                                  ^~
p1393.cpp:156:51: error: two or more data types in declaration of 'type name'
  156 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                                   ^~~~~~~~~~~~~~~~~
p1393.cpp:158:5: error: expected '>' before 'from_stream'
  158 |     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
      |     ^~~~~~~~~~~
p1393.cpp:160:43: error: expected unqualified-id before ';' token
  160 |                 minutes* offset = nullptr);
      |                                           ^
p1393.cpp:170:8: error: expected unqualified-id before ')' token
  170 |   year() = default;
      |        ^
p1393.cpp:171:3: error: 'constexpr' does not name a type
  171 |   constexpr explicit year(int y) noexcept;
      |   ^~~~~~~~~
p1393.cpp:171:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:172:3: error: 'constexpr' does not name a type
  172 |   constexpr year& operator++()    noexcept;
      |   ^~~~~~~~~
p1393.cpp:172:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:173:3: error: 'constexpr' does not name a type
  173 |   constexpr year  operator++(int) noexcept;
      |   ^~~~~~~~~
p1393.cpp:173:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:174:3: error: 'constexpr' does not name a type
  174 |   constexpr year& operator--()    noexcept;
      |   ^~~~~~~~~
p1393.cpp:174:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:175:3: error: 'constexpr' does not name a type
  175 |   constexpr year  operator--(int) noexcept;
      |   ^~~~~~~~~
p1393.cpp:175:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:176:3: error: 'constexpr' does not name a type
  176 |   constexpr year& operator+=(const years& y) noexcept;
      |   ^~~~~~~~~
p1393.cpp:176:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:177:3: error: 'constexpr' does not name a type
  177 |   constexpr year& operator-=(const years& y) noexcept;
      |   ^~~~~~~~~
p1393.cpp:177:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:178:3: error: 'constexpr' does not name a type
  178 |   constexpr year operator+() const noexcept;
      |   ^~~~~~~~~
p1393.cpp:178:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:179:3: error: 'constexpr' does not name a type
  179 |   constexpr year operator-() const noexcept;
      |   ^~~~~~~~~
p1393.cpp:179:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:180:3: error: 'constexpr' does not name a type
  180 |   constexpr bool is_leap() const noexcept;
      |   ^~~~~~~~~
p1393.cpp:180:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:181:3: error: 'constexpr' does not name a type
  181 |   constexpr explicit operator int() const noexcept;
      |   ^~~~~~~~~
p1393.cpp:181:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:182:3: error: 'constexpr' does not name a type
  182 |   constexpr bool ok() const noexcept;
      |   ^~~~~~~~~
p1393.cpp:182:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:183:10: error: 'constexpr' does not name a type
  183 |   static constexpr year min() noexcept;
      |          ^~~~~~~~~
p1393.cpp:183:10: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:184:10: error: 'constexpr' does not name a type
  184 |   static constexpr year max() noexcept;
      |          ^~~~~~~~~
p1393.cpp:184:10: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:190:4: error: 'constexpr' does not name a type
  190 |    constexpr explicit year(int y) noexcept;
      |    ^~~~~~~~~
p1393.cpp:190:4: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:192:1: error: 'constexpr' does not name a type
  192 | constexpr year& operator++() noexcept;
      | ^~~~~~~~~
p1393.cpp:192:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:194:1: error: 'constexpr' does not name a type
  194 | constexpr year operator++(int) noexcept;
      | ^~~~~~~~~
p1393.cpp:194:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:198:1: error: 'constexpr' does not name a type
  198 | constexpr year& operator--() noexcept;
      | ^~~~~~~~~
p1393.cpp:198:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:199:1: error: 'constexpr' does not name a type
  199 | constexpr year operator--(int) noexcept;
      | ^~~~~~~~~
p1393.cpp:199:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:202:1: error: 'constexpr' does not name a type
  202 | constexpr year& operator+=(const years& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:202:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:204:1: error: 'constexpr' does not name a type
  204 | constexpr year& operator-=(const years& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:204:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:206:1: error: 'constexpr' does not name a type
  206 | constexpr year operator+() const noexcept;
      | ^~~~~~~~~
p1393.cpp:206:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:208:1: error: 'constexpr' does not name a type
  208 | constexpr year year::operator-() const noexcept;
      | ^~~~~~~~~
p1393.cpp:208:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:210:1: error: 'constexpr' does not name a type
  210 | constexpr bool is_leap() const noexcept;
      | ^~~~~~~~~
p1393.cpp:210:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:212:1: error: 'constexpr' does not name a type
  212 | constexpr explicit operator int() const noexcept;
      | ^~~~~~~~~
p1393.cpp:212:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:214:1: error: 'constexpr' does not name a type
  214 | constexpr bool ok() const noexcept;
      | ^~~~~~~~~
p1393.cpp:214:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:216:8: error: 'constexpr' does not name a type
  216 | static constexpr year min() noexcept;
      |        ^~~~~~~~~
p1393.cpp:216:8: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:218:8: error: 'constexpr' does not name a type
  218 | static constexpr year max() noexcept;
      |        ^~~~~~~~~
p1393.cpp:218:8: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:221:1: error: 'constexpr' does not name a type
  221 | constexpr bool operator==(const year& x, const year& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:221:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:223:1: error: 'constexpr' does not name a type
  223 | constexpr strong_ordering operator<=>(const year& x, const year& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:223:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:225:1: error: 'constexpr' does not name a type
  225 | constexpr year operator+(const year& x, const years& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:225:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:228:1: error: 'constexpr' does not name a type
  228 | constexpr year operator-(const year& x, const years& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:228:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:230:1: error: 'constexpr' does not name a type
  230 | constexpr years operator-(const year& x, const year& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:230:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:234:56: error: 'year' does not name a type
  234 |     operator<<(basic_ostream<charT, traits>& os, const year& y);
      |                                                        ^~~~
p1393.cpp:236:1: error: expected unqualified-id before 'return'
  236 | return os << (y.ok() ?
      | ^~~~~~
p1393.cpp:238:66: error: spurious '>>', use '>' to terminate a template argument list
  238 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                                                  ^~
p1393.cpp:238:51: error: two or more data types in declaration of 'type name'
  238 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                                   ^~~~~~~~~~~~~~~~~
p1393.cpp:240:1: error: expected '>' before 'from_stream'
  240 | from_stream(basic_istream<charT, traits>& is, const charT* fmt,
      | ^~~~~~~~~~~
p1393.cpp:242:39: error: expected unqualified-id before ';' token
  242 |             minutes* offset = nullptr);
      |                                       ^
p1393.cpp:245:1: error: 'constexpr' does not name a type
  245 | constexpr chrono::year operator""y(unsigned long long y) noexcept;
      | ^~~~~~~~~
p1393.cpp:245:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:255:11: error: expected unqualified-id before ')' token
  255 |   weekday() = default;
      |           ^
p1393.cpp:256:3: error: 'constexpr' does not name a type
  256 |   constexpr explicit weekday(unsigned wd) noexcept;
      |   ^~~~~~~~~
p1393.cpp:256:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:257:3: error: 'constexpr' does not name a type
  257 |   constexpr weekday(const sys_days& dp) noexcept;
      |   ^~~~~~~~~
p1393.cpp:257:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:258:3: error: 'constexpr' does not name a type
  258 |   constexpr explicit weekday(const local_days& dp) noexcept;
      |   ^~~~~~~~~
p1393.cpp:258:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:259:3: error: 'constexpr' does not name a type
  259 |   constexpr weekday& operator++()    noexcept;
      |   ^~~~~~~~~
p1393.cpp:259:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:260:3: error: 'constexpr' does not name a type
  260 |   constexpr weekday  operator++(int) noexcept;
      |   ^~~~~~~~~
p1393.cpp:260:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:261:3: error: 'constexpr' does not name a type
  261 |   constexpr weekday& operator--()    noexcept;
      |   ^~~~~~~~~
p1393.cpp:261:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:262:3: error: 'constexpr' does not name a type
  262 |   constexpr weekday  operator--(int) noexcept;
      |   ^~~~~~~~~
p1393.cpp:262:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:263:3: error: 'constexpr' does not name a type
  263 |   constexpr weekday& operator+=(const days& d) noexcept;
      |   ^~~~~~~~~
p1393.cpp:263:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:264:3: error: 'constexpr' does not name a type
  264 |   constexpr weekday& operator-=(const days& d) noexcept;
      |   ^~~~~~~~~
p1393.cpp:264:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:265:3: error: 'constexpr' does not name a type
  265 |   constexpr unsigned c_encoding() const noexcept;
      |   ^~~~~~~~~
p1393.cpp:265:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:266:3: error: 'constexpr' does not name a type
  266 |   constexpr unsigned iso_encoding() const noexcept;
      |   ^~~~~~~~~
p1393.cpp:266:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:267:3: error: 'constexpr' does not name a type
  267 |   constexpr bool ok() const noexcept;
      |   ^~~~~~~~~
p1393.cpp:267:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:268:3: error: 'constexpr' does not name a type
  268 |   constexpr weekday_indexed operator[](unsigned index) const noexcept;
      |   ^~~~~~~~~
p1393.cpp:268:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:269:3: error: 'constexpr' does not name a type
  269 |   constexpr weekday_last    operator[](last_spec) const noexcept;
      |   ^~~~~~~~~
p1393.cpp:269:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:275:1: error: 'constexpr' does not name a type
  275 | constexpr explicit weekday(unsigned wd) noexcept;
      | ^~~~~~~~~
p1393.cpp:275:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:277:1: error: 'constexpr' does not name a type
  277 | constexpr weekday(const sys_days& dp) noexcept;
      | ^~~~~~~~~
p1393.cpp:277:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:280:1: error: 'constexpr' does not name a type
  280 | constexpr explicit weekday(const local_days& dp) noexcept;
      | ^~~~~~~~~
p1393.cpp:280:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:283:1: error: 'constexpr' does not name a type
  283 | constexpr weekday& operator++() noexcept;
      | ^~~~~~~~~
p1393.cpp:283:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:285:1: error: 'constexpr' does not name a type
  285 | constexpr weekday operator++(int) noexcept;
      | ^~~~~~~~~
p1393.cpp:285:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:288:1: error: 'constexpr' does not name a type
  288 | constexpr weekday& operator--() noexcept;
      | ^~~~~~~~~
p1393.cpp:288:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:290:1: error: 'constexpr' does not name a type
  290 | constexpr weekday operator--(int) noexcept;
      | ^~~~~~~~~
p1393.cpp:290:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:293:1: error: 'constexpr' does not name a type
  293 | constexpr weekday& operator+=(const days& d) noexcept;
      | ^~~~~~~~~
p1393.cpp:293:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:295:1: error: 'constexpr' does not name a type
  295 | constexpr weekday& operator-=(const days& d) noexcept;
      | ^~~~~~~~~
p1393.cpp:295:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:297:1: error: 'constexpr' does not name a type
  297 | constexpr unsigned c_encoding() const noexcept;
      | ^~~~~~~~~
p1393.cpp:297:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:299:1: error: 'constexpr' does not name a type
  299 | constexpr unsigned iso_encoding() const noexcept;
      | ^~~~~~~~~
p1393.cpp:299:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:301:1: error: 'constexpr' does not name a type
  301 | constexpr bool ok() const noexcept;
      | ^~~~~~~~~
p1393.cpp:301:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:303:1: error: 'constexpr' does not name a type
  303 | constexpr weekday_indexed operator[](unsigned index) const noexcept;
      | ^~~~~~~~~
p1393.cpp:303:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:305:1: error: 'constexpr' does not name a type
  305 | constexpr weekday_last operator[](last_spec) const noexcept;
      | ^~~~~~~~~
p1393.cpp:305:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:307:1: error: 'constexpr' does not name a type
  307 | constexpr weekday operator+(const weekday& x, const days& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:307:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:309:1: error: 'constexpr' does not name a type
  309 | constexpr bool operator==(const weekday& x, const weekday& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:309:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:312:1: error: 'weekday' does not name a type
  312 | weekday{modulo(static_cast<long long>(x.wd_) + y.count(), 7)}
      | ^~~~~~~
p1393.cpp:316:1: error: 'constexpr' does not name a type
  316 | constexpr weekday operator+(const days& x, const weekday& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:316:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:318:1: error: 'constexpr' does not name a type
  318 | constexpr weekday operator-(const weekday& x, const days& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:318:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:320:1: error: 'constexpr' does not name a type
  320 | constexpr days operator-(const weekday& x, const weekday& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:320:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:325:52: error: 'weekday' does not name a type
  325 | operator<<(basic_ostream<charT, traits>& os, const weekday& wd);
      |                                                    ^~~~~~~
p1393.cpp:327:1: error: expected unqualified-id before 'return'
  327 | return os << (wd.ok() ?
      | ^~~~~~
p1393.cpp:330:66: error: spurious '>>', use '>' to terminate a template argument list
  330 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                                                  ^~
p1393.cpp:330:51: error: two or more data types in declaration of 'type name'
  330 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                                   ^~~~~~~~~~~~~~~~~
p1393.cpp:332:1: error: expected '>' before 'from_stream'
  332 | from_stream(basic_istream<charT, traits>& is, const charT* fmt,
      | ^~~~~~~~~~~
p1393.cpp:334:39: error: expected unqualified-id before ';' token
  334 |             minutes* offset = nullptr);
      |                                       ^
p1393.cpp:345:23: warning: defaulted and deleted functions only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
  345 |   weekday_indexed() = default;
      |                       ^~~~~~~
p1393.cpp:346:3: error: 'constexpr' does not name a type
  346 |   constexpr weekday_indexed(const chrono::weekday& wd, unsigned index) noexcept;
      |   ^~~~~~~~~
p1393.cpp:346:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:348:10: error: 'constexpr' does not name a type
  348 |          constexpr chrono::weekday weekday() const noexcept;
      |          ^~~~~~~~~
p1393.cpp:348:10: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:349:10: error: 'constexpr' does not name a type
  349 |          constexpr unsigned        index()   const noexcept;
      |          ^~~~~~~~~
p1393.cpp:349:10: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:350:10: error: 'constexpr' does not name a type
  350 |          constexpr bool ok() const noexcept;
      |          ^~~~~~~~~
p1393.cpp:350:10: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:355:1: error: 'constexpr' does not name a type
  355 | constexpr auto wdi = Sunday[2]; // wdi is the second Sunday of an as yet unspecified month
      | ^~~~~~~~~
p1393.cpp:355:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:356:14: error: expected constructor, destructor, or type conversion before '(' token
  356 | static_assert(wdi.weekday() == Sunday);
      |              ^
p1393.cpp:357:14: error: expected constructor, destructor, or type conversion before '(' token
  357 | static_assert(wdi.index() == 2);
      |              ^
p1393.cpp:360:4: error: 'constexpr' does not name a type
  360 |    constexpr weekday_indexed(const chrono::weekday& wd, unsigned index) noexcept;
      |    ^~~~~~~~~
p1393.cpp:360:4: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:361:1: error: 'constexpr' does not name a type
  361 | constexpr chrono::weekday weekday() const noexcept;
      | ^~~~~~~~~
p1393.cpp:361:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:363:1: error: 'constexpr' does not name a type
  363 | constexpr unsigned index() const noexcept;
      | ^~~~~~~~~
p1393.cpp:363:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:365:1: error: 'constexpr' does not name a type
  365 | constexpr bool ok() const noexcept;
      | ^~~~~~~~~
p1393.cpp:365:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:368:1: error: 'constexpr' does not name a type
  368 | constexpr bool operator==(const weekday_indexed& x, const weekday_indexed& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:368:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:372:52: error: 'weekday_indexed' does not name a type
  372 | operator<<(basic_ostream<charT, traits>& os, const weekday_indexed& wdi);
      |                                                    ^~~~~~~~~~~~~~~
p1393.cpp:374:4: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
  374 |    auto i = wdi.index();
      |    ^~~~
      |    ----
p1393.cpp:374:9: error: 'i' does not name a type
  374 |    auto i = wdi.index();
      |         ^
p1393.cpp:375:4: error: expected unqualified-id before 'return'
  375 |    return os << (i >= 1 && i <= 5 ?
      |    ^~~~~~
p1393.cpp:395:1: error: 'constexpr' does not name a type
  395 | constexpr auto wdl = Sunday[last]; // wdl is the last Sunday of an as yet unspecified month
      | ^~~~~~~~~
p1393.cpp:395:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:396:19: error: expected constructor, destructor, or type conversion before '(' token
  396 |      static_assert(wdl.weekday() == Sunday);
      |                   ^
p1393.cpp:399:4: error: 'constexpr' does not name a type
  399 |    constexpr explicit weekday_last(const chrono::weekday& wd) noexcept;
      |    ^~~~~~~~~
p1393.cpp:399:4: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:401:1: error: 'constexpr' does not name a type
  401 | constexpr chrono::weekday weekday() const noexcept;
      | ^~~~~~~~~
p1393.cpp:401:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:403:1: error: 'constexpr' does not name a type
  403 | constexpr bool ok() const noexcept;
      | ^~~~~~~~~
p1393.cpp:403:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:406:1: error: 'constexpr' does not name a type
  406 | constexpr bool operator==(const weekday_last& x, const weekday_last& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:406:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:410:52: error: 'weekday_last' does not name a type
  410 | operator<<(basic_ostream<charT, traits>& os, const weekday_last& wdl);
      |                                                    ^~~~~~~~~~~~
p1393.cpp:412:1: error: expected unqualified-id before 'return'
  412 | return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}[last]"), wdl.weekday());
      | ^~~~~~
p1393.cpp:421:19: warning: defaulted and deleted functions only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
  421 |     month_day() = default;
      |                   ^~~~~~~
p1393.cpp:422:5: error: 'constexpr' does not name a type
  422 |     constexpr month_day(const chrono::month& m, const chrono::day& d) noexcept;
      |     ^~~~~~~~~
p1393.cpp:422:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:423:5: error: 'constexpr' does not name a type
  423 |     constexpr chrono::month month() const noexcept;
      |     ^~~~~~~~~
p1393.cpp:423:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:424:5: error: 'constexpr' does not name a type
  424 |     constexpr chrono::day   day()   const noexcept;
      |     ^~~~~~~~~
p1393.cpp:424:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:425:5: error: 'constexpr' does not name a type
  425 |     constexpr bool ok() const noexcept;
      |     ^~~~~~~~~
p1393.cpp:425:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:430:4: error: 'constexpr' does not name a type
  430 |    constexpr month_day(const chrono::month& m, const chrono::day& d) noexcept;
      |    ^~~~~~~~~
p1393.cpp:430:4: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:432:1: error: 'constexpr' does not name a type
  432 | constexpr chrono::month month() const noexcept;
      | ^~~~~~~~~
p1393.cpp:432:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:433:1: error: 'constexpr' does not name a type
  433 | constexpr chrono::day day() const noexcept;
      | ^~~~~~~~~
p1393.cpp:433:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:435:1: error: 'constexpr' does not name a type
  435 | constexpr bool ok() const noexcept;
      | ^~~~~~~~~
p1393.cpp:435:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:438:1: error: 'constexpr' does not name a type
  438 | constexpr bool operator==(const month_day& x, const month_day& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:438:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:440:1: error: 'constexpr' does not name a type
  440 | constexpr strong_ordering operator<=>(const month_day& x, const month_day& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:440:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:442:1: error: expected unqualified-id before 'if'
  442 | if (auto c = x.month() <=> y.month(); c != 0) return c;
      | ^~
p1393.cpp:442:39: error: 'c' does not name a type
  442 | if (auto c = x.month() <=> y.month(); c != 0) return c;
      |                                       ^
p1393.cpp:443:3: error: expected unqualified-id before 'return'
  443 |   return x.day() <=> y.day();
      |   ^~~~~~
p1393.cpp:446:1: error: expected unqualified-id before '}' token
  446 | }
      | ^
p1393.cpp:446:1: error: expected declaration before '}' token
p1393.cpp:447:26: error: 'charT' was not declared in this scope; did you mean 'char'?
  447 | operator<<(basic_ostream<charT, traits>& os, const month_day& md);
      |                          ^~~~~
      |                          char
p1393.cpp:447:33: error: 'traits' was not declared in this scope
  447 | operator<<(basic_ostream<charT, traits>& os, const month_day& md);
      |                                 ^~~~~~
p1393.cpp:447:39: error: template argument 1 is invalid
  447 | operator<<(basic_ostream<charT, traits>& os, const month_day& md);
      |                                       ^
p1393.cpp:447:39: error: template argument 2 is invalid
p1393.cpp:447:52: error: 'month_day' does not name a type
  447 | operator<<(basic_ostream<charT, traits>& os, const month_day& md);
      |                                                    ^~~~~~~~~
p1393.cpp:447:66: error: expected constructor, destructor, or type conversion before ';' token
  447 | operator<<(basic_ostream<charT, traits>& os, const month_day& md);
      |                                                                  ^
p1393.cpp:449:1: error: expected unqualified-id before 'return'
  449 | return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}/{}"),
      | ^~~~~~
p1393.cpp:451:66: error: spurious '>>', use '>' to terminate a template argument list
  451 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                                                  ^~
p1393.cpp:451:51: error: two or more data types in declaration of 'type name'
  451 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                                   ^~~~~~~~~~~~~~~~~
p1393.cpp:453:1: error: expected '>' before 'from_stream'
  453 | from_stream(basic_istream<charT, traits>& is, const charT* fmt,
      | ^~~~~~~~~~~
p1393.cpp:455:39: error: expected unqualified-id before ';' token
  455 |             minutes* offset = nullptr);
      |                                       ^
p1393.cpp:463:3: error: 'constexpr' does not name a type
  463 |   constexpr explicit month_day_last(const chrono::month& m) noexcept;
      |   ^~~~~~~~~
p1393.cpp:463:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:464:3: error: 'constexpr' does not name a type
  464 |   constexpr chrono::month month() const noexcept;
      |   ^~~~~~~~~
p1393.cpp:464:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:465:3: error: 'constexpr' does not name a type
  465 |   constexpr bool ok() const noexcept;
      |   ^~~~~~~~~
p1393.cpp:465:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:471:1: error: 'constexpr' does not name a type
  471 | constexpr auto mdl = February/last; // mdl is the last day of February of an as yet unspecified year
      | ^~~~~~~~~
p1393.cpp:471:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:472:14: error: expected constructor, destructor, or type conversion before '(' token
  472 | static_assert(mdl.month() == February);
      |              ^
p1393.cpp:474:1: error: 'constexpr' does not name a type
  474 | constexpr explicit month_day_last(const chrono::month& m) noexcept;
      | ^~~~~~~~~
p1393.cpp:474:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:476:1: error: 'constexpr' does not name a type
  476 | constexpr month month() const noexcept;
      | ^~~~~~~~~
p1393.cpp:476:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:478:1: error: 'constexpr' does not name a type
  478 | constexpr bool ok() const noexcept;
      | ^~~~~~~~~
p1393.cpp:478:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:480:1: error: 'constexpr' does not name a type
  480 | constexpr bool operator==(const month_day_last& x, const month_day_last& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:480:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:482:1: error: 'constexpr' does not name a type
  482 | constexpr strong_ordering operator<=>(const month_day_last& x, const month_day_last& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:482:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:488:1: error: expected unqualified-id before 'return'
  488 | return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}/last"), mdl.month());
      | ^~~~~~
p1393.cpp:498:5: error: 'constexpr' does not name a type
  498 |     constexpr month_weekday(const chrono::month& m, const chrono::weekday_indexed& wdi) noexcept;
      |     ^~~~~~~~~
p1393.cpp:498:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:499:5: error: 'constexpr' does not name a type
  499 |     constexpr chrono::month           month()           const noexcept;
      |     ^~~~~~~~~
p1393.cpp:499:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:500:5: error: 'constexpr' does not name a type
  500 |     constexpr chrono::weekday_indexed weekday_indexed() const noexcept;
      |     ^~~~~~~~~
p1393.cpp:500:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:501:5: error: 'constexpr' does not name a type
  501 |     constexpr bool ok() const noexcept;
      |     ^~~~~~~~~
p1393.cpp:501:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:505:1: error: 'constexpr' does not name a type
  505 | constexpr auto mwd
      | ^~~~~~~~~
p1393.cpp:505:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:507:19: error: expected constructor, destructor, or type conversion before '(' token
  507 |      static_assert(mwd.month() == February);
      |                   ^
p1393.cpp:508:19: error: expected constructor, destructor, or type conversion before '(' token
  508 |      static_assert(mwd.weekday_indexed() == Tuesday[3]);
      |                   ^
p1393.cpp:511:4: error: 'constexpr' does not name a type
  511 |    constexpr month_weekday(const chrono::month& m, const chrono::weekday_indexed& wdi) noexcept;
      |    ^~~~~~~~~
p1393.cpp:511:4: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:514:1: error: 'constexpr' does not name a type
  514 | constexpr chrono::weekday_indexed weekday_indexed() const noexcept;
      | ^~~~~~~~~
p1393.cpp:514:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:516:1: error: 'constexpr' does not name a type
  516 | constexpr bool ok() const noexcept;
      | ^~~~~~~~~
p1393.cpp:516:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:519:1: error: 'constexpr' does not name a type
  519 | constexpr bool operator==(const month_weekday& x, const month_weekday& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:519:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:523:52: error: 'month_weekday' does not name a type
  523 | operator<<(basic_ostream<charT, traits>& os, const month_weekday& mwd);
      |                                                    ^~~~~~~~~~~~~
p1393.cpp:525:1: error: expected unqualified-id before 'return'
  525 | return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}/{:L}"),
      | ^~~~~~
p1393.cpp:532:13: error: 'weekday_last' in namespace 'std::chrono' does not name a type
  532 |     chrono::weekday_last wdl_;
      |             ^~~~~~~~~~~~
p1393.cpp:535:5: error: 'constexpr' does not name a type
  535 |     constexpr month_weekday_last(const chrono::month& m,
      |     ^~~~~~~~~
p1393.cpp:535:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:537:5: error: 'constexpr' does not name a type
  537 |     constexpr chrono::month        month()        const noexcept;
      |     ^~~~~~~~~
p1393.cpp:537:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:538:5: error: 'constexpr' does not name a type
  538 |     constexpr chrono::weekday_last weekday_last() const noexcept;
      |     ^~~~~~~~~
p1393.cpp:538:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:539:5: error: 'constexpr' does not name a type
  539 |     constexpr bool ok() const noexcept;
      |     ^~~~~~~~~
p1393.cpp:539:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:543:1: error: 'constexpr' does not name a type
  543 | constexpr auto mwd
      | ^~~~~~~~~
p1393.cpp:543:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:545:19: error: expected constructor, destructor, or type conversion before '(' token
  545 |      static_assert(mwd.month() == February);
      |                   ^
p1393.cpp:546:19: error: expected constructor, destructor, or type conversion before '(' token
  546 |      static_assert(mwd.weekday_last() == Tuesday[last]);
      |                   ^
p1393.cpp:549:4: error: 'constexpr' does not name a type
  549 |    constexpr month_weekday_last(const chrono::month& m,
      |    ^~~~~~~~~
p1393.cpp:549:4: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:553:1: error: 'constexpr' does not name a type
  553 | constexpr chrono::weekday_last weekday_last() const noexcept;
      | ^~~~~~~~~
p1393.cpp:553:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:555:1: error: 'constexpr' does not name a type
  555 | constexpr bool ok() const noexcept;
      | ^~~~~~~~~
p1393.cpp:555:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:558:1: error: 'constexpr' does not name a type
  558 | constexpr bool operator==(const month_weekday_last& x, const month_weekday_last& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:558:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:559:8: error: found ':' in nested-name-specifier, expected '::'
  559 | Returns: x.month() == y.month() && x.weekday_last() == y.weekday_last().
      |        ^
      |        ::
p1393.cpp:559:1: error: 'Returns' does not name a type
  559 | Returns: x.month() == y.month() && x.weekday_last() == y.weekday_last().
      | ^~~~~~~
p1393.cpp:564:1: error: expected unqualified-id before 'return'
  564 | return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}/{:L}"),
      | ^~~~~~
p1393.cpp:574:18: warning: defaulted and deleted functions only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
  574 |   year_month() = default;
      |                  ^~~~~~~
p1393.cpp:575:3: error: 'constexpr' does not name a type
  575 |   constexpr year_month(const chrono::year& y, const chrono::month& m) noexcept;
      |   ^~~~~~~~~
p1393.cpp:575:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:576:3: error: 'constexpr' does not name a type
  576 |   constexpr chrono::year  year()  const noexcept;
      |   ^~~~~~~~~
p1393.cpp:576:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:577:3: error: 'constexpr' does not name a type
  577 |   constexpr chrono::month month() const noexcept;
      |   ^~~~~~~~~
p1393.cpp:577:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:578:3: error: 'constexpr' does not name a type
  578 |   constexpr year_month& operator+=(const months& dm) noexcept;
      |   ^~~~~~~~~
p1393.cpp:578:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:579:3: error: 'constexpr' does not name a type
  579 |   constexpr year_month& operator-=(const months& dm) noexcept;
      |   ^~~~~~~~~
p1393.cpp:579:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:580:3: error: 'constexpr' does not name a type
  580 |   constexpr year_month& operator+=(const years& dy)  noexcept;
      |   ^~~~~~~~~
p1393.cpp:580:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:581:3: error: 'constexpr' does not name a type
  581 |   constexpr year_month& operator-=(const years& dy)  noexcept;
      |   ^~~~~~~~~
p1393.cpp:581:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:582:3: error: 'constexpr' does not name a type
  582 |   constexpr bool ok() const noexcept;
      |   ^~~~~~~~~
p1393.cpp:582:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:588:4: error: 'constexpr' does not name a type
  588 |    constexpr year_month(const chrono::year& y, const chrono::month& m) noexcept;
      |    ^~~~~~~~~
p1393.cpp:588:4: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:591:1: error: 'constexpr' does not name a type
  591 | constexpr chrono::month month() const noexcept;
      | ^~~~~~~~~
p1393.cpp:591:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:593:1: error: 'constexpr' does not name a type
  593 | constexpr year_month& operator+=(const months& dm) noexcept;
      | ^~~~~~~~~
p1393.cpp:593:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:596:1: error: 'constexpr' does not name a type
  596 | constexpr year_month& operator-=(const months& dm) noexcept;
      | ^~~~~~~~~
p1393.cpp:596:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:599:1: error: 'constexpr' does not name a type
  599 | constexpr year_month& operator+=(const years& dy) noexcept;
      | ^~~~~~~~~
p1393.cpp:599:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:601:1: error: 'constexpr' does not name a type
  601 | constexpr year_month& operator-=(const years& dy) noexcept;
      | ^~~~~~~~~
p1393.cpp:601:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:603:1: error: 'constexpr' does not name a type
  603 | constexpr bool ok() const noexcept;
      | ^~~~~~~~~
p1393.cpp:603:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:606:1: error: 'constexpr' does not name a type
  606 | constexpr bool operator==(const year_month& x, const year_month& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:606:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:608:1: error: 'constexpr' does not name a type
  608 | constexpr strong_ordering operator<=>(const year_month& x, const year_month& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:608:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:610:1: error: expected unqualified-id before 'if'
  610 | if (auto c = x.year() <=> y.year(); c != 0) return c;
      | ^~
p1393.cpp:610:37: error: 'c' does not name a type
  610 | if (auto c = x.year() <=> y.year(); c != 0) return c;
      |                                     ^
p1393.cpp:611:8: error: expected unqualified-id before 'return'
  611 |        return x.month() <=> y.month();
      |        ^~~~~~
p1393.cpp:612:1: error: 'constexpr' does not name a type
  612 | constexpr year_month operator+(const year_month& ym, const months& dm) noexcept;
      | ^~~~~~~~~
p1393.cpp:612:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:615:1: error: 'constexpr' does not name a type
  615 | constexpr year_month operator+(const months& dm, const year_month& ym) noexcept;
      | ^~~~~~~~~
p1393.cpp:615:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:618:1: error: 'constexpr' does not name a type
  618 | constexpr year_month operator-(const year_month& ym, const months& dm) noexcept;
      | ^~~~~~~~~
p1393.cpp:618:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:621:1: error: 'constexpr' does not name a type
  621 | constexpr months operator-(const year_month& x, const year_month& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:621:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:623:1: error: 'x' does not name a type
  623 | x.year() - y.year() + months{static_cast<int>(unsigned{x.month()}) -
      | ^
p1393.cpp:625:1: error: 'constexpr' does not name a type
  625 | constexpr year_month operator+(const year_month& ym, const years& dy) noexcept;
      | ^~~~~~~~~
p1393.cpp:625:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:627:1: error: 'constexpr' does not name a type
  627 | constexpr year_month operator+(const years& dy, const year_month& ym) noexcept;
      | ^~~~~~~~~
p1393.cpp:627:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:629:1: error: 'constexpr' does not name a type
  629 | constexpr year_month operator-(const year_month& ym, const years& dy) noexcept;
      | ^~~~~~~~~
p1393.cpp:629:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:633:52: error: 'year_month' does not name a type
  633 | operator<<(basic_ostream<charT, traits>& os, const year_month& ym);
      |                                                    ^~~~~~~~~~
p1393.cpp:635:1: error: expected unqualified-id before 'return'
  635 | return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{:L}"), ym.year(), ym.month());
      | ^~~~~~
p1393.cpp:636:66: error: spurious '>>', use '>' to terminate a template argument list
  636 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                                                  ^~
p1393.cpp:636:51: error: two or more data types in declaration of 'type name'
  636 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                                   ^~~~~~~~~~~~~~~~~
p1393.cpp:638:5: error: expected '>' before 'from_stream'
  638 |     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
      |     ^~~~~~~~~~~
p1393.cpp:640:43: error: expected unqualified-id before ';' token
  640 |                 minutes* offset = nullptr);
      |                                           ^
p1393.cpp:642:41: error: expected initializer before ')' token
  642 |                     const chrono::day& d) noexcept;
      |                                         ^
p1393.cpp:654:24: warning: defaulted and deleted functions only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
  654 |     year_month_day() = default;
      |                        ^~~~~~~
p1393.cpp:655:5: error: 'constexpr' does not name a type
  655 |     constexpr year_month_day(const chrono::year& y, const chrono::month& m,
      |     ^~~~~~~~~
p1393.cpp:655:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:657:5: error: 'constexpr' does not name a type
  657 |     constexpr year_month_day(const year_month_day_last& ymdl) noexcept;
      |     ^~~~~~~~~
p1393.cpp:657:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:658:5: error: 'constexpr' does not name a type
  658 |     constexpr year_month_day(const sys_days& dp) noexcept;
      |     ^~~~~~~~~
p1393.cpp:658:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:659:5: error: 'constexpr' does not name a type
  659 |     constexpr explicit year_month_day(const local_days& dp) noexcept;
      |     ^~~~~~~~~
p1393.cpp:659:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:660:5: error: 'constexpr' does not name a type
  660 |     constexpr year_month_day& operator+=(const months& m) noexcept;
      |     ^~~~~~~~~
p1393.cpp:660:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:661:5: error: 'constexpr' does not name a type
  661 |     constexpr year_month_day& operator-=(const months& m) noexcept;
      |     ^~~~~~~~~
p1393.cpp:661:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:662:5: error: 'constexpr' does not name a type
  662 |     constexpr year_month_day& operator+=(const years& y)  noexcept;
      |     ^~~~~~~~~
p1393.cpp:662:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:663:5: error: 'constexpr' does not name a type
  663 |     constexpr year_month_day& operator-=(const years& y)  noexcept;
      |     ^~~~~~~~~
p1393.cpp:663:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:664:5: error: 'constexpr' does not name a type
  664 |     constexpr chrono::year  year()  const noexcept;
      |     ^~~~~~~~~
p1393.cpp:664:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:665:5: error: 'constexpr' does not name a type
  665 |     constexpr chrono::month month() const noexcept;
      |     ^~~~~~~~~
p1393.cpp:665:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:666:5: error: 'constexpr' does not name a type
  666 |     constexpr chrono::day   day()   const noexcept;
      |     ^~~~~~~~~
p1393.cpp:666:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:667:5: error: 'constexpr' does not name a type
  667 |     constexpr          operator sys_days()   const noexcept;
      |     ^~~~~~~~~
p1393.cpp:667:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:668:5: error: 'constexpr' does not name a type
  668 |     constexpr explicit operator local_days() const noexcept;
      |     ^~~~~~~~~
p1393.cpp:668:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:669:5: error: 'constexpr' does not name a type
  669 |     constexpr bool ok() const noexcept;
      |     ^~~~~~~~~
p1393.cpp:669:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:675:1: error: 'constexpr' does not name a type
  675 | constexpr year_month_day(const chrono::year& y, const chrono::month& m,
      | ^~~~~~~~~
p1393.cpp:675:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:679:1: error: 'constexpr' does not name a type
  679 | constexpr year_month_day(const sys_days& dp) noexcept;
      | ^~~~~~~~~
p1393.cpp:679:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:681:1: error: 'constexpr' does not name a type
  681 | constexpr explicit year_month_day(const local_days& dp) noexcept;
      | ^~~~~~~~~
p1393.cpp:681:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:685:1: error: 'constexpr' does not name a type
  685 | constexpr year_month_day& operator-=(const months& m) noexcept;
      | ^~~~~~~~~
p1393.cpp:685:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:688:1: error: 'constexpr' does not name a type
  688 | constexpr year_month_day& year_month_day::operator+=(const years& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:688:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:690:1: error: 'constexpr' does not name a type
  690 | constexpr year_month_day& year_month_day::operator-=(const years& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:690:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:692:1: error: 'constexpr' does not name a type
  692 | constexpr chrono::year year() const noexcept;
      | ^~~~~~~~~
p1393.cpp:692:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:694:1: error: 'constexpr' does not name a type
  694 | constexpr chrono::month month() const noexcept;
      | ^~~~~~~~~
p1393.cpp:694:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:696:1: error: 'constexpr' does not name a type
  696 | constexpr chrono::day day() const noexcept;
      | ^~~~~~~~~
p1393.cpp:696:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:698:1: error: 'constexpr' does not name a type
  698 | constexpr operator sys_days() const noexcept;
      | ^~~~~~~~~
p1393.cpp:698:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:701:21: error: expected constructor, destructor, or type conversion before '(' token
  701 |        static_assert(year_month_day{sys_days{2017y/January/0}}  == 2016y/December/31);
      |                     ^
p1393.cpp:701:65: error: expected unqualified-id before '==' token
  701 |        static_assert(year_month_day{sys_days{2017y/January/0}}  == 2016y/December/31);
      |                                                                 ^~
p1393.cpp:702:21: error: expected constructor, destructor, or type conversion before '(' token
  702 |        static_assert(year_month_day{sys_days{2017y/January/31}} == 2017y/January/31);
      |                     ^
p1393.cpp:702:65: error: expected unqualified-id before '==' token
  702 |        static_assert(year_month_day{sys_days{2017y/January/31}} == 2017y/January/31);
      |                                                                 ^~
p1393.cpp:703:21: error: expected constructor, destructor, or type conversion before '(' token
  703 |        static_assert(year_month_day{sys_days{2017y/January/32}} == 2017y/February/1);
      |                     ^
p1393.cpp:703:65: error: expected unqualified-id before '==' token
  703 |        static_assert(year_month_day{sys_days{2017y/January/32}} == 2017y/February/1);
      |                                                                 ^~
p1393.cpp:704:1: error: 'constexpr' does not name a type
  704 | constexpr explicit operator local_days() const noexcept;
      | ^~~~~~~~~
p1393.cpp:704:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:708:1: error: 'constexpr' does not name a type
  708 | constexpr bool operator==(const year_month_day& x, const year_month_day& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:708:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:710:1: error: 'constexpr' does not name a type
  710 | constexpr strong_ordering operator<=>(const year_month_day& x, const year_month_day& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:710:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:712:3: error: expected unqualified-id before 'if'
  712 |   if (auto c = x.year() <=> y.year(); c != 0) return c;
      |   ^~
p1393.cpp:712:39: error: 'c' does not name a type
  712 |   if (auto c = x.year() <=> y.year(); c != 0) return c;
      |                                       ^
p1393.cpp:713:3: error: expected unqualified-id before 'if'
  713 |   if (auto c = x.month() <=> y.month(); c != 0) return c;
      |   ^~
p1393.cpp:713:41: error: 'c' does not name a type
  713 |   if (auto c = x.month() <=> y.month(); c != 0) return c;
      |                                         ^
p1393.cpp:714:3: error: expected unqualified-id before 'return'
  714 |   return x.day() <=> y.day();
      |   ^~~~~~
p1393.cpp:715:1: error: 'constexpr' does not name a type
  715 | constexpr year_month_day operator+(const year_month_day& ymd, const months& dm) noexcept;
      | ^~~~~~~~~
p1393.cpp:715:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:719:1: error: 'constexpr' does not name a type
  719 | constexpr year_month_day operator+(const months& dm, const year_month_day& ymd) noexcept;
      | ^~~~~~~~~
p1393.cpp:719:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:722:1: error: 'constexpr' does not name a type
  722 | constexpr year_month_day operator-(const year_month_day& ymd, const months& dm) noexcept;
      | ^~~~~~~~~
p1393.cpp:722:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:725:1: error: 'constexpr' does not name a type
  725 | constexpr year_month_day operator+(const year_month_day& ymd, const years& dy) noexcept;
      | ^~~~~~~~~
p1393.cpp:725:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:728:1: error: 'constexpr' does not name a type
  728 | constexpr year_month_day operator+(const years& dy, const year_month_day& ymd) noexcept;
      | ^~~~~~~~~
p1393.cpp:728:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:730:1: error: 'constexpr' does not name a type
  730 | constexpr year_month_day operator-(const year_month_day& ymd, const years& dy) noexcept;
      | ^~~~~~~~~
p1393.cpp:730:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:734:56: error: 'year_month_day' does not name a type
  734 |     operator<<(basic_ostream<charT, traits>& os, const year_month_day& ymd);
      |                                                        ^~~~~~~~~~~~~~
p1393.cpp:736:1: error: expected unqualified-id before 'return'
  736 | return os << (ymd.ok() ?
      | ^~~~~~
p1393.cpp:738:66: error: spurious '>>', use '>' to terminate a template argument list
  738 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                                                  ^~
p1393.cpp:738:51: error: two or more data types in declaration of 'type name'
  738 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                                   ^~~~~~~~~~~~~~~~~
p1393.cpp:740:5: error: expected '>' before 'from_stream'
  740 |     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
      |     ^~~~~~~~~~~
p1393.cpp:742:38: error: expected unqualified-id before ';' token
  742 |            minutes* offset = nullptr);
      |                                      ^
p1393.cpp:752:3: error: 'constexpr' does not name a type
  752 |   constexpr year_month_day_last(const chrono::year& y,
      |   ^~~~~~~~~
p1393.cpp:752:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:754:5: error: 'constexpr' does not name a type
  754 |     constexpr year_month_day_last& operator+=(const months& m) noexcept;
      |     ^~~~~~~~~
p1393.cpp:754:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:755:5: error: 'constexpr' does not name a type
  755 |     constexpr year_month_day_last& operator-=(const months& m) noexcept;
      |     ^~~~~~~~~
p1393.cpp:755:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:756:5: error: 'constexpr' does not name a type
  756 |     constexpr year_month_day_last& operator+=(const years& y)  noexcept;
      |     ^~~~~~~~~
p1393.cpp:756:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:757:5: error: 'constexpr' does not name a type
  757 |     constexpr year_month_day_last& operator-=(const years& y)  noexcept;
      |     ^~~~~~~~~
p1393.cpp:757:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:758:5: error: 'constexpr' does not name a type
  758 |     constexpr chrono::year           year()           const noexcept;
      |     ^~~~~~~~~
p1393.cpp:758:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:759:5: error: 'constexpr' does not name a type
  759 |     constexpr chrono::month          month()          const noexcept;
      |     ^~~~~~~~~
p1393.cpp:759:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:760:5: error: 'constexpr' does not name a type
  760 |     constexpr chrono::month_day_last month_day_last() const noexcept;
      |     ^~~~~~~~~
p1393.cpp:760:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:761:5: error: 'constexpr' does not name a type
  761 |     constexpr chrono::day            day()            const noexcept;
      |     ^~~~~~~~~
p1393.cpp:761:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:762:5: error: 'constexpr' does not name a type
  762 |     constexpr          operator sys_days()   const noexcept;
      |     ^~~~~~~~~
p1393.cpp:762:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:763:5: error: 'constexpr' does not name a type
  763 |     constexpr explicit operator local_days() const noexcept;
      |     ^~~~~~~~~
p1393.cpp:763:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:764:5: error: 'constexpr' does not name a type
  764 |     constexpr bool ok() const noexcept;
      |     ^~~~~~~~~
p1393.cpp:764:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:771:1: error: 'constexpr' does not name a type
  771 | constexpr year_month_day_last(const chrono::year& y,
      | ^~~~~~~~~
p1393.cpp:771:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:774:1: error: 'constexpr' does not name a type
  774 | constexpr year_month_day_last& operator+=(const months& m) noexcept;
      | ^~~~~~~~~
p1393.cpp:774:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:777:1: error: 'constexpr' does not name a type
  777 | constexpr year_month_day_last& operator-=(const months& m) noexcept;
      | ^~~~~~~~~
p1393.cpp:777:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:780:1: error: 'constexpr' does not name a type
  780 | constexpr year_month_day_last& operator+=(const years& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:780:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:782:1: error: 'constexpr' does not name a type
  782 | constexpr year_month_day_last& operator-=(const years& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:782:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:784:1: error: 'constexpr' does not name a type
  784 | constexpr chrono::year year() const noexcept;
      | ^~~~~~~~~
p1393.cpp:784:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:786:1: error: 'constexpr' does not name a type
  786 | constexpr chrono::month month() const noexcept;
      | ^~~~~~~~~
p1393.cpp:786:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:788:1: error: 'constexpr' does not name a type
  788 | constexpr chrono::month_day_last month_day_last() const noexcept;
      | ^~~~~~~~~
p1393.cpp:788:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:790:1: error: 'constexpr' does not name a type
  790 | constexpr chrono::day day() const noexcept;
      | ^~~~~~~~~
p1393.cpp:790:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:793:1: error: 'constexpr' does not name a type
  793 | constexpr operator sys_days() const noexcept;
      | ^~~~~~~~~
p1393.cpp:793:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:795:1: error: 'constexpr' does not name a type
  795 | constexpr explicit operator local_days() const noexcept;
      | ^~~~~~~~~
p1393.cpp:795:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:797:1: error: 'constexpr' does not name a type
  797 | constexpr bool ok() const noexcept;
      | ^~~~~~~~~
p1393.cpp:797:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:800:1: error: 'constexpr' does not name a type
  800 | constexpr bool operator==(const year_month_day_last& x, const year_month_day_last& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:800:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:802:40: error: 'year_month_day_last' does not name a type
  802 |                                  const year_month_day_last& y) noexcept;
      |                                        ^~~~~~~~~~~~~~~~~~~
p1393.cpp:804:1: error: expected unqualified-id before 'if'
  804 | if (auto c = x.year() <=> y.year(); c != 0) return c;
      | ^~
p1393.cpp:804:37: error: 'c' does not name a type
  804 | if (auto c = x.year() <=> y.year(); c != 0) return c;
      |                                     ^
p1393.cpp:805:3: error: expected unqualified-id before 'return'
  805 |   return x.month_day_last() <=> y.month_day_last();
      |   ^~~~~~
p1393.cpp:806:1: error: 'constexpr' does not name a type
  806 | constexpr year_month_day_last
      | ^~~~~~~~~
p1393.cpp:806:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:810:17: error: 'months' does not name a type
  810 | operator+(const months& dm, const year_month_day_last& ymdl) noexcept;
      |                 ^~~~~~
p1393.cpp:810:35: error: 'year_month_day_last' does not name a type
  810 | operator+(const months& dm, const year_month_day_last& ymdl) noexcept;
      |                                   ^~~~~~~~~~~~~~~~~~~
p1393.cpp:810:62: error: expected constructor, destructor, or type conversion before 'noexcept'
  810 | operator+(const months& dm, const year_month_day_last& ymdl) noexcept;
      |                                                              ^~~~~~~~
p1393.cpp:813:4: error: 'constexpr' does not name a type
  813 |    constexpr year_month_day_last
      |    ^~~~~~~~~
p1393.cpp:813:4: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:817:1: error: 'constexpr' does not name a type
  817 | constexpr year_month_day_last
      | ^~~~~~~~~
p1393.cpp:817:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:820:19: error: 'years' does not name a type
  820 |   operator+(const years& dy, const year_month_day_last& ymdl) noexcept;
      |                   ^~~~~
p1393.cpp:820:36: error: 'year_month_day_last' does not name a type
  820 |   operator+(const years& dy, const year_month_day_last& ymdl) noexcept;
      |                                    ^~~~~~~~~~~~~~~~~~~
p1393.cpp:820:63: error: expected constructor, destructor, or type conversion before 'noexcept'
  820 |   operator+(const years& dy, const year_month_day_last& ymdl) noexcept;
      |                                                               ^~~~~~~~
p1393.cpp:822:1: error: 'constexpr' does not name a type
  822 | constexpr year_month_day_last
      | ^~~~~~~~~
p1393.cpp:822:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:827:52: error: 'year_month_day_last' does not name a type
  827 | operator<<(basic_ostream<charT, traits>& os, const year_month_day_last& ymdl);
      |                                                    ^~~~~~~~~~~~~~~~~~~
p1393.cpp:829:1: error: expected unqualified-id before 'return'
  829 | return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{:L}"),
      | ^~~~~~
p1393.cpp:859:25: error: expected constructor, destructor, or type conversion before 'noexcept'
  859 | year()            const noexcept;
      |                         ^~~~~~~~
p1393.cpp:860:25: error: expected constructor, destructor, or type conversion before 'noexcept'
  860 | month()           const noexcept;
      |                         ^~~~~~~~
p1393.cpp:861:25: error: expected constructor, destructor, or type conversion before 'noexcept'
  861 | weekday()         const noexcept;
      |                         ^~~~~~~~
p1393.cpp:862:25: error: expected constructor, destructor, or type conversion before 'noexcept'
  862 | index()           const noexcept;
      |                         ^~~~~~~~
p1393.cpp:868:4: error: 'constexpr' does not name a type
  868 |    constexpr year_month_weekday(const chrono::year& y, const chrono::month& m,
      |    ^~~~~~~~~
p1393.cpp:868:4: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:871:1: error: 'constexpr' does not name a type
  871 | constexpr year_month_weekday(const sys_days& dp) noexcept;
      | ^~~~~~~~~
p1393.cpp:871:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:872:1: error: 'constexpr' does not name a type
  872 | constexpr explicit year_month_weekday(const local_days& dp) noexcept;
      | ^~~~~~~~~
p1393.cpp:872:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:874:1: error: 'constexpr' does not name a type
  874 | constexpr year_month_weekday& operator+=(const months& m) noexcept;
      | ^~~~~~~~~
p1393.cpp:874:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:877:1: error: 'constexpr' does not name a type
  877 | constexpr year_month_weekday& operator-=(const months& m) noexcept;
      | ^~~~~~~~~
p1393.cpp:877:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:880:1: error: 'constexpr' does not name a type
  880 | constexpr year_month_weekday& operator+=(const years& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:880:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:882:1: error: 'constexpr' does not name a type
  882 | constexpr year_month_weekday& operator-=(const years& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:882:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:884:1: error: 'constexpr' does not name a type
  884 | constexpr chrono::year year() const noexcept;
      | ^~~~~~~~~
p1393.cpp:884:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:886:1: error: 'constexpr' does not name a type
  886 | constexpr chrono::month month() const noexcept;
      | ^~~~~~~~~
p1393.cpp:886:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:888:1: error: 'constexpr' does not name a type
  888 | constexpr chrono::weekday weekday() const noexcept;
      | ^~~~~~~~~
p1393.cpp:888:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:890:1: error: 'constexpr' does not name a type
  890 | constexpr unsigned index() const noexcept;
      | ^~~~~~~~~
p1393.cpp:890:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:892:1: error: 'constexpr' does not name a type
  892 | constexpr chrono::weekday_indexed weekday_indexed() const noexcept;
      | ^~~~~~~~~
p1393.cpp:892:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:894:1: error: 'constexpr' does not name a type
  894 | constexpr operator sys_days() const noexcept;
      | ^~~~~~~~~
p1393.cpp:894:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:896:1: error: 'constexpr' does not name a type
  896 | constexpr explicit operator local_days() const noexcept;
      | ^~~~~~~~~
p1393.cpp:896:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:900:1: error: 'constexpr' does not name a type
  900 | constexpr bool operator==(const year_month_weekday& x, const year_month_weekday& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:900:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:902:1: error: 'constexpr' does not name a type
  902 | constexpr year_month_weekday operator+(const year_month_weekday& ymwd, const months& dm) noexcept;
      | ^~~~~~~~~
p1393.cpp:902:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:905:1: error: 'constexpr' does not name a type
  905 | constexpr year_month_weekday operator+(const months& dm, const year_month_weekday& ymwd) noexcept;
      | ^~~~~~~~~
p1393.cpp:905:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:908:1: error: 'constexpr' does not name a type
  908 | constexpr year_month_weekday operator-(const year_month_weekday& ymwd, const months& dm) noexcept;
      | ^~~~~~~~~
p1393.cpp:908:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:911:1: error: 'constexpr' does not name a type
  911 | constexpr year_month_weekday operator+(const year_month_weekday& ymwd, const years& dy) noexcept;
      | ^~~~~~~~~
p1393.cpp:911:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:913:1: error: 'constexpr' does not name a type
  913 | constexpr year_month_weekday operator+(const years& dy, const year_month_weekday& ymwd) noexcept;
      | ^~~~~~~~~
p1393.cpp:913:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:915:1: error: 'constexpr' does not name a type
  915 | constexpr year_month_weekday operator-(const year_month_weekday& ymwd, const years& dy) noexcept;
      | ^~~~~~~~~
p1393.cpp:915:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:919:52: error: 'year_month_weekday' does not name a type
  919 | operator<<(basic_ostream<charT, traits>& os, const year_month_weekday& ymwd);
      |                                                    ^~~~~~~~~~~~~~~~~~
p1393.cpp:921:1: error: expected unqualified-id before 'return'
  921 | return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{:L}/{:L}"), ymwd.year(), ymwd.month(), ymwd.weekday_indexed());
      | ^~~~~~
p1393.cpp:928:9: error: 'weekday_last' in namespace 'std::chrono' does not name a type
  928 | chrono::weekday_last wdl_;
      |         ^~~~~~~~~~~~
p1393.cpp:931:3: error: 'constexpr' does not name a type
  931 |   constexpr year_month_weekday_last(const chrono::year& y, const chrono::month& m,
      |   ^~~~~~~~~
p1393.cpp:931:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:935:1: error: 'constexpr' does not name a type
  935 | constexpr year_month_weekday_last& operator+=(const months& m) noexcept;
      | ^~~~~~~~~
p1393.cpp:935:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:936:1: error: 'constexpr' does not name a type
  936 | constexpr year_month_weekday_last& operator-=(const months& m) noexcept;
      | ^~~~~~~~~
p1393.cpp:936:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:937:1: error: 'constexpr' does not name a type
  937 | constexpr year_month_weekday_last& operator+=(const years& y)  noexcept;
      | ^~~~~~~~~
p1393.cpp:937:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:938:1: error: 'constexpr' does not name a type
  938 | constexpr year_month_weekday_last& operator-=(const years& y)  noexcept;
      | ^~~~~~~~~
p1393.cpp:938:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:939:10: error: 'constexpr' does not name a type
  939 |          constexpr chrono::year         year()
      |          ^~~~~~~~~
p1393.cpp:939:10: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:943:10: error: 'constexpr' does not name a type
  943 |          constexpr          operator sys_days()   const noexcept;
      |          ^~~~~~~~~
p1393.cpp:943:10: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:944:10: error: 'constexpr' does not name a type
  944 |          constexpr explicit operator local_days() const noexcept;
      |          ^~~~~~~~~
p1393.cpp:944:10: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:945:10: error: 'constexpr' does not name a type
  945 |          constexpr bool ok() const noexcept;
      |          ^~~~~~~~~
p1393.cpp:945:10: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:951:4: error: 'constexpr' does not name a type
  951 |    constexpr year_month_weekday_last(const chrono::year& y, const chrono::month& m,
      |    ^~~~~~~~~
p1393.cpp:951:4: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:954:1: error: 'constexpr' does not name a type
  954 | constexpr year_month_weekday_last& operator+=(const months& m) noexcept;
      | ^~~~~~~~~
p1393.cpp:954:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:955:1: error: 'constexpr' does not name a type
  955 | constexpr year_month_weekday_last& operator-=(const months& m) noexcept;
      | ^~~~~~~~~
p1393.cpp:955:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:956:7: error: 'noexcept' does not name a type
  956 | const noexcept;
      |       ^~~~~~~~
p1393.cpp:956:7: note: C++11 'noexcept' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:957:7: error: 'noexcept' does not name a type
  957 | const noexcept;
      |       ^~~~~~~~
p1393.cpp:957:7: note: C++11 'noexcept' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:958:7: error: 'noexcept' does not name a type
  958 | const noexcept;
      |       ^~~~~~~~
p1393.cpp:958:7: note: C++11 'noexcept' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:961:1: error: 'constexpr' does not name a type
  961 | constexpr year_month_weekday_last& operator+=(const years& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:961:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:963:1: error: 'constexpr' does not name a type
  963 | constexpr year_month_weekday_last& operator-=(const years& y) noexcept;
      | ^~~~~~~~~
p1393.cpp:963:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:965:1: error: 'constexpr' does not name a type
  965 | constexpr chrono::year year() const noexcept;
      | ^~~~~~~~~
p1393.cpp:965:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:967:1: error: 'constexpr' does not name a type
  967 | constexpr chrono::month month() const noexcept;
      | ^~~~~~~~~
p1393.cpp:967:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:969:1: error: 'constexpr' does not name a type
  969 | constexpr chrono::weekday weekday() const noexcept;
      | ^~~~~~~~~
p1393.cpp:969:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:971:1: error: 'constexpr' does not name a type
  971 | constexpr chrono::weekday_last weekday_last() const noexcept;
      | ^~~~~~~~~
p1393.cpp:971:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:973:1: error: 'constexpr' does not name a type
  973 | constexpr operator sys_days() const noexcept;
      | ^~~~~~~~~
p1393.cpp:973:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:975:1: error: 'constexpr' does not name a type
  975 | constexpr explicit operator local_days() const noexcept;
      | ^~~~~~~~~
p1393.cpp:975:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:979:28: error: 'year_month_weekday_last' does not name a type
  979 |                      const year_month_weekday_last& y) noexcept;
      |                            ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:981:1: error: 'constexpr' does not name a type
  981 | constexpr year_month_weekday_last
      | ^~~~~~~~~
p1393.cpp:981:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:985:1: error: 'constexpr' does not name a type
  985 | constexpr year_month_weekday_last
      | ^~~~~~~~~
p1393.cpp:985:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:989:1: error: 'constexpr' does not name a type
  989 | constexpr year_month_weekday_last
      | ^~~~~~~~~
p1393.cpp:989:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:993:1: error: 'constexpr' does not name a type
  993 | constexpr year_month_weekday_last
      | ^~~~~~~~~
p1393.cpp:993:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:996:1: error: 'constexpr' does not name a type
  996 | constexpr year_month_weekday_last
      | ^~~~~~~~~
p1393.cpp:996:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:999:1: error: 'constexpr' does not name a type
  999 | constexpr year_month_weekday_last
      | ^~~~~~~~~
p1393.cpp:999:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1004:52: error: 'year_month_weekday_last' does not name a type
 1004 | operator<<(basic_ostream<charT, traits>& os, const year_month_weekday_last& ymwdl);
      |                                                    ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:1006:1: error: expected unqualified-id before 'return'
 1006 | return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{:L}/{:L}"), ymwdl.year(), ymwdl.month(), ymwdl.weekday_last());
      | ^~~~~~
p1393.cpp:1008:1: error: 'constexpr' does not name a type
 1008 | constexpr year_month
      | ^~~~~~~~~
p1393.cpp:1008:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1014:6: error: 'year_month' does not name a type
 1014 |      year_month ym = 2015y/April;
      |      ^~~~~~~~~~
p1393.cpp:1015:6: error: 'month_day' does not name a type
 1015 |      month_day md1 = April/4;
      |      ^~~~~~~~~
p1393.cpp:1016:6: error: 'month_day' does not name a type
 1016 |      month_day md2 = 4d/April;
      |      ^~~~~~~~~
p1393.cpp:1018:1: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
 1018 | auto a = 2015/4/4;
      | ^~~~
      | ----
p1393.cpp:1018:6: error: 'a' does not name a type
 1018 | auto a = 2015/4/4;
      |      ^
p1393.cpp:1019:1: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
 1019 | auto b = 2015y/4/4;
      | ^~~~
      | ----
p1393.cpp:1019:6: error: 'b' does not name a type
 1019 | auto b = 2015y/4/4;
      |      ^
p1393.cpp:1020:1: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
 1020 | auto c = 2015y/4d/April;
      | ^~~~
      | ----
p1393.cpp:1020:6: error: 'c' does not name a type
 1020 | auto c = 2015y/4d/April;
      |      ^
p1393.cpp:1021:1: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
 1021 | auto d = 2015/April/4;
      | ^~~~
      | ----
p1393.cpp:1021:6: error: 'd' does not name a type
 1021 | auto d = 2015/April/4;
      |      ^
p1393.cpp:1026:1: error: 'constexpr' does not name a type
 1026 | constexpr year_month
      | ^~~~~~~~~
p1393.cpp:1026:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1029:1: error: 'constexpr' does not name a type
 1029 | constexpr month_day
      | ^~~~~~~~~
p1393.cpp:1029:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1032:1: error: 'constexpr' does not name a type
 1032 | constexpr month_day
      | ^~~~~~~~~
p1393.cpp:1032:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1035:1: error: 'constexpr' does not name a type
 1035 | constexpr month_day
      | ^~~~~~~~~
p1393.cpp:1035:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1038:1: error: 'constexpr' does not name a type
 1038 | constexpr month_day
      | ^~~~~~~~~
p1393.cpp:1038:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1041:1: error: 'constexpr' does not name a type
 1041 | constexpr month_day
      | ^~~~~~~~~
p1393.cpp:1041:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1044:1: error: 'constexpr' does not name a type
 1044 | constexpr month_day_last
      | ^~~~~~~~~
p1393.cpp:1044:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1047:1: error: 'constexpr' does not name a type
 1047 | constexpr month_day_last
      | ^~~~~~~~~
p1393.cpp:1047:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1050:1: error: 'constexpr' does not name a type
 1050 | constexpr month_day_last
      | ^~~~~~~~~
p1393.cpp:1050:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1053:1: error: 'constexpr' does not name a type
 1053 | constexpr month_day_last
      | ^~~~~~~~~
p1393.cpp:1053:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1056:1: error: 'constexpr' does not name a type
 1056 | constexpr month_weekday
      | ^~~~~~~~~
p1393.cpp:1056:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1059:1: error: 'constexpr' does not name a type
 1059 | constexpr month_weekday
      | ^~~~~~~~~
p1393.cpp:1059:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1062:1: error: 'constexpr' does not name a type
 1062 | constexpr month_weekday
      | ^~~~~~~~~
p1393.cpp:1062:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1065:1: error: 'constexpr' does not name a type
 1065 | constexpr month_weekday
      | ^~~~~~~~~
p1393.cpp:1065:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1068:1: error: 'constexpr' does not name a type
 1068 | constexpr month_weekday_last
      | ^~~~~~~~~
p1393.cpp:1068:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1071:1: error: 'constexpr' does not name a type
 1071 | constexpr month_weekday_last
      | ^~~~~~~~~
p1393.cpp:1071:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1074:1: error: 'constexpr' does not name a type
 1074 | constexpr month_weekday_last
      | ^~~~~~~~~
p1393.cpp:1074:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1077:1: error: 'constexpr' does not name a type
 1077 | constexpr month_weekday_last
      | ^~~~~~~~~
p1393.cpp:1077:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1080:1: error: 'constexpr' does not name a type
 1080 | constexpr year_month_day
      | ^~~~~~~~~
p1393.cpp:1080:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1083:1: error: 'constexpr' does not name a type
 1083 | constexpr year_month_day
      | ^~~~~~~~~
p1393.cpp:1083:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1086:1: error: 'constexpr' does not name a type
 1086 | constexpr year_month_day
      | ^~~~~~~~~
p1393.cpp:1086:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1089:1: error: 'constexpr' does not name a type
 1089 | constexpr year_month_day
      | ^~~~~~~~~
p1393.cpp:1089:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1092:1: error: 'constexpr' does not name a type
 1092 | constexpr year_month_day
      | ^~~~~~~~~
p1393.cpp:1092:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1095:1: error: 'constexpr' does not name a type
 1095 | constexpr year_month_day
      | ^~~~~~~~~
p1393.cpp:1095:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1098:1: error: 'constexpr' does not name a type
 1098 | constexpr year_month_day_last
      | ^~~~~~~~~
p1393.cpp:1098:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1101:1: error: 'constexpr' does not name a type
 1101 | constexpr year_month_day_last
      | ^~~~~~~~~
p1393.cpp:1101:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1104:1: error: 'constexpr' does not name a type
 1104 | constexpr year_month_day_last
      | ^~~~~~~~~
p1393.cpp:1104:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1107:1: error: 'constexpr' does not name a type
 1107 | constexpr year_month_day_last
      | ^~~~~~~~~
p1393.cpp:1107:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1110:1: error: 'constexpr' does not name a type
 1110 | constexpr year_month_day_last
      | ^~~~~~~~~
p1393.cpp:1110:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1113:1: error: 'constexpr' does not name a type
 1113 | constexpr year_month_weekday
      | ^~~~~~~~~
p1393.cpp:1113:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1116:1: error: 'constexpr' does not name a type
 1116 | constexpr year_month_weekday
      | ^~~~~~~~~
p1393.cpp:1116:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1119:1: error: 'constexpr' does not name a type
 1119 | constexpr year_month_weekday
      | ^~~~~~~~~
p1393.cpp:1119:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1122:1: error: 'constexpr' does not name a type
 1122 | constexpr year_month_weekday
      | ^~~~~~~~~
p1393.cpp:1122:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1125:1: error: 'constexpr' does not name a type
 1125 | constexpr year_month_weekday
      | ^~~~~~~~~
p1393.cpp:1125:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1128:1: error: 'constexpr' does not name a type
 1128 | constexpr year_month_weekday_last
      | ^~~~~~~~~
p1393.cpp:1128:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1131:1: error: 'constexpr' does not name a type
 1131 | constexpr year_month_weekday_last
      | ^~~~~~~~~
p1393.cpp:1131:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1134:1: error: 'constexpr' does not name a type
 1134 | constexpr year_month_weekday_last
      | ^~~~~~~~~
p1393.cpp:1134:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1137:1: error: 'constexpr' does not name a type
 1137 | constexpr year_month_weekday_last
      | ^~~~~~~~~
p1393.cpp:1137:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1393.cpp:1140:1: error: 'constexpr' does not name a type
 1140 | constexpr year_month_weekday_last
      | ^~~~~~~~~
p1393.cpp:1140:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'

$ g++ p1393.cpp -std=2b -o p1393g -I. -Wall
p1393.cpp:35:37: error: 'days' does not name a type; did you mean 'day'?
   35 |     constexpr day& operator+=(const days& d) noexcept;
      |                                     ^~~~
      |                                     day
p1393.cpp:36:37: error: 'days' does not name a type; did you mean 'day'?
   36 |     constexpr day& operator-=(const days& d) noexcept;
      |                                     ^~~~
      |                                     day
p1393.cpp:41:11: error: 'day' does not name a type
   41 | constexpr day& operator++() noexcept;
      |           ^~~
p1393.cpp:47:23: error: ISO C++ forbids declaration of 'day' with no type [-fpermissive]
   47 |    constexpr explicit day(unsigned d) noexcept;
      |                       ^~~
p1393.cpp:47:14: error: 'explicit' outside class declaration
   47 |    constexpr explicit day(unsigned d) noexcept;
      |              ^~~~~~~~
p1393.cpp:48:14: error: 'day' does not name a type
   48 |    constexpr day operator++(int) noexcept;
      |              ^~~
p1393.cpp:51:11: error: 'day' does not name a type
   51 | constexpr day& operator--() noexcept;
      |           ^~~
p1393.cpp:53:11: error: 'day' does not name a type
   53 | constexpr day operator--(int) noexcept;
      |           ^~~
p1393.cpp:56:11: error: 'day' does not name a type
   56 | constexpr day& operator+=(const days& d) noexcept;
      |           ^~~
p1393.cpp:58:11: error: 'day' does not name a type
   58 | constexpr day& operator-=(const days& d) noexcept;
      |           ^~~
p1393.cpp:60:11: error: 'explicit' outside class declaration
   60 | constexpr explicit operator unsigned() const noexcept;
      |           ^~~~~~~~
p1393.cpp:60:46: error: non-member function 'constexpr operator unsigned int()' cannot have cv-qualifier
   60 | constexpr explicit operator unsigned() const noexcept;
      |                                              ^~~~~~~~
p1393.cpp:60:20: error: 'constexpr operator unsigned int()' must be a non-static member function
   60 | constexpr explicit operator unsigned() const noexcept;
      |                    ^~~~~~~~
p1393.cpp:62:27: error: non-member function 'constexpr bool ok()' cannot have cv-qualifier
   62 | constexpr bool ok() const noexcept;
      |                           ^~~~~~~~
p1393.cpp:65:33: error: 'day' does not name a type
   65 | constexpr bool operator==(const day& x, const day& y) noexcept;
      |                                 ^~~
p1393.cpp:65:47: error: 'day' does not name a type
   65 | constexpr bool operator==(const day& x, const day& y) noexcept;
      |                                               ^~~
p1393.cpp:65:16: error: 'constexpr bool operator==(const int&, const int&)' must have an argument of class or enumerated type
   65 | constexpr bool operator==(const day& x, const day& y) noexcept;
      |                ^~~~~~~~
p1393.cpp:67:45: error: 'day' does not name a type
   67 | constexpr strong_ordering operator<=>(const day& x, const day& y) noexcept;
      |                                             ^~~
p1393.cpp:67:59: error: 'day' does not name a type
   67 | constexpr strong_ordering operator<=>(const day& x, const day& y) noexcept;
      |                                                           ^~~
p1393.cpp:67:27: error: 'constexpr std::strong_ordering operator<=>(const int&, const int&)' must have an argument of class or enumerated type
   67 | constexpr strong_ordering operator<=>(const day& x, const day& y) noexcept;
      |                           ^~~~~~~~
p1393.cpp:69:11: error: 'day' does not name a type
   69 | constexpr day operator+(const day& x, const days& y) noexcept;
      |           ^~~
p1393.cpp:71:11: error: 'day' does not name a type
   71 | constexpr day operator+(const days& x, const day& y) noexcept;
      |           ^~~
p1393.cpp:73:11: error: 'day' does not name a type
   73 | constexpr day operator-(const day& x, const days& y) noexcept;
      |           ^~~
p1393.cpp:75:11: error: 'days' does not name a type
   75 | constexpr days operator-(const day& x, const day& y) noexcept;
      |           ^~~~
p1393.cpp:79:56: error: 'day' does not name a type
   79 |     operator<<(basic_ostream<charT, traits>& os, const day& d);
      |                                                        ^~~
p1393.cpp:81:1: error: expected unqualified-id before 'return'
   81 | return os << (d.ok() ?
      | ^~~~~~
p1393.cpp:86:17: error: 'day' is not a type
   86 |                 day& d, basic_string<charT, traits, Alloc>* abbrev = nullptr,
      |                 ^~~
p1393.cpp:87:12: error: 'minutes' has not been declared
   87 |            minutes* offset = nullptr);
      |            ^~~~~~~
p1393.cpp:90:23: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
   90 | constexpr chrono::day operator""d(unsigned long long d) noexcept;
      |                       ^~~~~~~~
p1393.cpp:99:11: error: expected constructor, destructor, or type conversion before '=' token
   99 |   month() = default;
      |           ^
p1393.cpp:100:22: error: ISO C++ forbids declaration of 'month' with no type [-fpermissive]
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:100:13: error: 'explicit' outside class declaration
  100 |   constexpr explicit month(unsigned m) noexcept;
      |             ^~~~~~~~
p1393.cpp:101:13: error: 'month' does not name a type
  101 |   constexpr month& operator++()    noexcept;
      |             ^~~~~
p1393.cpp:102:13: error: 'month' does not name a type
  102 |   constexpr month  operator++(int) noexcept;
      |             ^~~~~
p1393.cpp:103:13: error: 'month' does not name a type
  103 |   constexpr month& operator--()    noexcept;
      |             ^~~~~
p1393.cpp:104:13: error: 'month' does not name a type
  104 |   constexpr month  operator--(int) noexcept;
      |             ^~~~~
p1393.cpp:105:13: error: 'month' does not name a type
  105 |   constexpr month& operator+=(const months& m) noexcept;
      |             ^~~~~
p1393.cpp:106:13: error: 'month' does not name a type
  106 |   constexpr month& operator-=(const months& m) noexcept;
      |             ^~~~~
p1393.cpp:107:13: error: 'explicit' outside class declaration
  107 |   constexpr explicit operator unsigned() const noexcept;
      |             ^~~~~~~~
p1393.cpp:107:48: error: non-member function 'constexpr std::chrono::operator unsigned int()' cannot have cv-qualifier
  107 |   constexpr explicit operator unsigned() const noexcept;
      |                                                ^~~~~~~~
p1393.cpp:107:22: error: 'constexpr std::chrono::operator unsigned int()' must be a non-static member function
  107 |   constexpr explicit operator unsigned() const noexcept;
      |                      ^~~~~~~~
p1393.cpp:108:29: error: non-member function 'constexpr bool std::chrono::ok()' cannot have cv-qualifier
  108 |   constexpr bool ok() const noexcept;
      |                             ^~~~~~~~
p1393.cpp:114:23: error: ISO C++ forbids declaration of 'month' with no type [-fpermissive]
  114 |    constexpr explicit month(unsigned m) noexcept;
      |                       ^~~~~
p1393.cpp:114:14: error: 'explicit' outside class declaration
  114 |    constexpr explicit month(unsigned m) noexcept;
      |              ^~~~~~~~
p1393.cpp:116:11: error: 'month' does not name a type
  116 | constexpr month& operator++() noexcept;
      |           ^~~~~
p1393.cpp:118:11: error: 'month' does not name a type
  118 | constexpr month operator++(int) noexcept;
      |           ^~~~~
p1393.cpp:121:11: error: 'month' does not name a type
  121 | constexpr month& operator--() noexcept;
      |           ^~~~~
p1393.cpp:123:14: error: 'month' does not name a type
  123 |    constexpr month operator--(int) noexcept;
      |              ^~~~~
p1393.cpp:126:11: error: 'month' does not name a type
  126 | constexpr month& operator+=(const months& m) noexcept;
      |           ^~~~~
p1393.cpp:128:11: error: 'month' does not name a type
  128 | constexpr month& operator-=(const months& m) noexcept;
      |           ^~~~~
p1393.cpp:130:11: error: 'explicit' outside class declaration
  130 | constexpr explicit operator unsigned() const noexcept;
      |           ^~~~~~~~
p1393.cpp:130:46: error: non-member function 'constexpr operator unsigned int()' cannot have cv-qualifier
  130 | constexpr explicit operator unsigned() const noexcept;
      |                                              ^~~~~~~~
p1393.cpp:130:20: error: 'constexpr operator unsigned int()' must be a non-static member function
  130 | constexpr explicit operator unsigned() const noexcept;
      |                    ^~~~~~~~
p1393.cpp:132:27: error: non-member function 'constexpr bool ok()' cannot have cv-qualifier
  132 | constexpr bool ok() const noexcept;
      |                           ^~~~~~~~
p1393.cpp:135:33: error: 'month' does not name a type
  135 | constexpr bool operator==(const month& x, const month& y) noexcept;
      |                                 ^~~~~
p1393.cpp:135:49: error: 'month' does not name a type
  135 | constexpr bool operator==(const month& x, const month& y) noexcept;
      |                                                 ^~~~~
p1393.cpp:135:16: error: 'constexpr bool operator==(const int&, const int&)' must have an argument of class or enumerated type
  135 | constexpr bool operator==(const month& x, const month& y) noexcept;
      |                ^~~~~~~~
p1393.cpp:137:45: error: 'month' does not name a type
  137 | constexpr strong_ordering operator<=>(const month& x, const month& y) noexcept;
      |                                             ^~~~~
p1393.cpp:137:61: error: 'month' does not name a type
  137 | constexpr strong_ordering operator<=>(const month& x, const month& y) noexcept;
      |                                                             ^~~~~
p1393.cpp:137:27: error: 'constexpr std::strong_ordering operator<=>(const int&, const int&)' must have an argument of class or enumerated type
  137 | constexpr strong_ordering operator<=>(const month& x, const month& y) noexcept;
      |                           ^~~~~~~~
p1393.cpp:139:11: error: 'month' does not name a type
  139 | constexpr month operator+(const month& x, const months& y) noexcept;
      |           ^~~~~
p1393.cpp:144:11: error: 'month' does not name a type
  144 | constexpr month operator-(const month& x, const months& y) noexcept;
      |           ^~~~~
p1393.cpp:146:11: error: 'months' does not name a type
  146 | constexpr months operator-(const month& x, const month& y) noexcept;
      |           ^~~~~~
p1393.cpp:151:52: error: 'month' does not name a type
  151 | operator<<(basic_ostream<charT, traits>& os, const month& m);
      |                                                    ^~~~~
p1393.cpp:153:1: error: expected unqualified-id before 'return'
  153 | return os << (m.ok() ?
      | ^~~~~~
p1393.cpp:159:17: error: 'month' is not a type
  159 |                 month& m, basic_string<charT, traits, Alloc>* abbrev = nullptr,
      |                 ^~~~~
p1393.cpp:160:17: error: 'minutes' has not been declared
  160 |                 minutes* offset = nullptr);
      |                 ^~~~~~~
p1393.cpp:158:5: error: redeclaration of 'template<class charT, class traits, class Alloc> std::basic_istream<_CharT, _Traits>& from_stream(std::basic_istream<_CharT, _Traits>&, const charT*, int&, std::__cxx11::basic_string<_CharT, _Traits, _Allocator>*, int*)' may not have default arguments [-fpermissive]
  158 |     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
      |     ^~~~~~~~~~~
p1393.cpp:156:37: error: redefinition of default argument for 'class Alloc'
  156 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                     ^~~~~
p1393.cpp:83:37: note: original definition appeared here
   83 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                     ^~~~~
p1393.cpp:170:10: error: expected constructor, destructor, or type conversion before '=' token
  170 |   year() = default;
      |          ^
p1393.cpp:171:22: error: ISO C++ forbids declaration of 'year' with no type [-fpermissive]
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:171:13: error: 'explicit' outside class declaration
  171 |   constexpr explicit year(int y) noexcept;
      |             ^~~~~~~~
p1393.cpp:172:13: error: 'year' does not name a type
  172 |   constexpr year& operator++()    noexcept;
      |             ^~~~
p1393.cpp:173:13: error: 'year' does not name a type
  173 |   constexpr year  operator++(int) noexcept;
      |             ^~~~
p1393.cpp:174:13: error: 'year' does not name a type
  174 |   constexpr year& operator--()    noexcept;
      |             ^~~~
p1393.cpp:175:13: error: 'year' does not name a type
  175 |   constexpr year  operator--(int) noexcept;
      |             ^~~~
p1393.cpp:176:13: error: 'year' does not name a type
  176 |   constexpr year& operator+=(const years& y) noexcept;
      |             ^~~~
p1393.cpp:177:13: error: 'year' does not name a type
  177 |   constexpr year& operator-=(const years& y) noexcept;
      |             ^~~~
p1393.cpp:178:13: error: 'year' does not name a type
  178 |   constexpr year operator+() const noexcept;
      |             ^~~~
p1393.cpp:179:13: error: 'year' does not name a type
  179 |   constexpr year operator-() const noexcept;
      |             ^~~~
p1393.cpp:180:34: error: non-member function 'constexpr bool std::chrono::is_leap()' cannot have cv-qualifier
  180 |   constexpr bool is_leap() const noexcept;
      |                                  ^~~~~~~~
p1393.cpp:181:13: error: 'explicit' outside class declaration
  181 |   constexpr explicit operator int() const noexcept;
      |             ^~~~~~~~
p1393.cpp:181:43: error: non-member function 'constexpr std::chrono::operator int()' cannot have cv-qualifier
  181 |   constexpr explicit operator int() const noexcept;
      |                                           ^~~~~~~~
p1393.cpp:181:22: error: 'constexpr std::chrono::operator int()' must be a non-static member function
  181 |   constexpr explicit operator int() const noexcept;
      |                      ^~~~~~~~
p1393.cpp:182:29: error: non-member function 'constexpr bool std::chrono::ok()' cannot have cv-qualifier
  182 |   constexpr bool ok() const noexcept;
      |                             ^~~~~~~~
p1393.cpp:183:20: error: 'year' does not name a type
  183 |   static constexpr year min() noexcept;
      |                    ^~~~
p1393.cpp:184:20: error: 'year' does not name a type
  184 |   static constexpr year max() noexcept;
      |                    ^~~~
p1393.cpp:190:23: error: ISO C++ forbids declaration of 'year' with no type [-fpermissive]
  190 |    constexpr explicit year(int y) noexcept;
      |                       ^~~~
p1393.cpp:190:14: error: 'explicit' outside class declaration
  190 |    constexpr explicit year(int y) noexcept;
      |              ^~~~~~~~
p1393.cpp:192:11: error: 'year' does not name a type
  192 | constexpr year& operator++() noexcept;
      |           ^~~~
p1393.cpp:194:11: error: 'year' does not name a type
  194 | constexpr year operator++(int) noexcept;
      |           ^~~~
p1393.cpp:198:11: error: 'year' does not name a type
  198 | constexpr year& operator--() noexcept;
      |           ^~~~
p1393.cpp:199:11: error: 'year' does not name a type
  199 | constexpr year operator--(int) noexcept;
      |           ^~~~
p1393.cpp:202:11: error: 'year' does not name a type
  202 | constexpr year& operator+=(const years& y) noexcept;
      |           ^~~~
p1393.cpp:204:11: error: 'year' does not name a type
  204 | constexpr year& operator-=(const years& y) noexcept;
      |           ^~~~
p1393.cpp:206:11: error: 'year' does not name a type
  206 | constexpr year operator+() const noexcept;
      |           ^~~~
p1393.cpp:208:11: error: 'year' does not name a type
  208 | constexpr year year::operator-() const noexcept;
      |           ^~~~
p1393.cpp:210:32: error: non-member function 'constexpr bool is_leap()' cannot have cv-qualifier
  210 | constexpr bool is_leap() const noexcept;
      |                                ^~~~~~~~
p1393.cpp:212:11: error: 'explicit' outside class declaration
  212 | constexpr explicit operator int() const noexcept;
      |           ^~~~~~~~
p1393.cpp:212:41: error: non-member function 'constexpr operator int()' cannot have cv-qualifier
  212 | constexpr explicit operator int() const noexcept;
      |                                         ^~~~~~~~
p1393.cpp:212:20: error: 'constexpr operator int()' must be a non-static member function
  212 | constexpr explicit operator int() const noexcept;
      |                    ^~~~~~~~
p1393.cpp:214:27: error: non-member function 'constexpr bool ok()' cannot have cv-qualifier
  214 | constexpr bool ok() const noexcept;
      |                           ^~~~~~~~
p1393.cpp:216:18: error: 'year' does not name a type
  216 | static constexpr year min() noexcept;
      |                  ^~~~
p1393.cpp:218:18: error: 'year' does not name a type
  218 | static constexpr year max() noexcept;
      |                  ^~~~
p1393.cpp:221:33: error: 'year' does not name a type
  221 | constexpr bool operator==(const year& x, const year& y) noexcept;
      |                                 ^~~~
p1393.cpp:221:48: error: 'year' does not name a type
  221 | constexpr bool operator==(const year& x, const year& y) noexcept;
      |                                                ^~~~
p1393.cpp:221:16: error: 'constexpr bool operator==(const int&, const int&)' must have an argument of class or enumerated type
  221 | constexpr bool operator==(const year& x, const year& y) noexcept;
      |                ^~~~~~~~
p1393.cpp:223:45: error: 'year' does not name a type
  223 | constexpr strong_ordering operator<=>(const year& x, const year& y) noexcept;
      |                                             ^~~~
p1393.cpp:223:60: error: 'year' does not name a type
  223 | constexpr strong_ordering operator<=>(const year& x, const year& y) noexcept;
      |                                                            ^~~~
p1393.cpp:223:27: error: 'constexpr std::strong_ordering operator<=>(const int&, const int&)' must have an argument of class or enumerated type
  223 | constexpr strong_ordering operator<=>(const year& x, const year& y) noexcept;
      |                           ^~~~~~~~
p1393.cpp:225:11: error: 'year' does not name a type
  225 | constexpr year operator+(const year& x, const years& y) noexcept;
      |           ^~~~
p1393.cpp:228:11: error: 'year' does not name a type
  228 | constexpr year operator-(const year& x, const years& y) noexcept;
      |           ^~~~
p1393.cpp:230:11: error: 'years' does not name a type
  230 | constexpr years operator-(const year& x, const year& y) noexcept;
      |           ^~~~~
p1393.cpp:234:56: error: 'year' does not name a type
  234 |     operator<<(basic_ostream<charT, traits>& os, const year& y);
      |                                                        ^~~~
p1393.cpp:236:1: error: expected unqualified-id before 'return'
  236 | return os << (y.ok() ?
      | ^~~~~~
p1393.cpp:241:13: error: 'year' is not a type
  241 |             year& y, basic_string<charT, traits, Alloc>* abbrev = nullptr,
      |             ^~~~
p1393.cpp:242:13: error: 'minutes' has not been declared
  242 |             minutes* offset = nullptr);
      |             ^~~~~~~
p1393.cpp:240:1: error: redeclaration of 'template<class charT, class traits, class Alloc> std::basic_istream<_CharT, _Traits>& from_stream(std::basic_istream<_CharT, _Traits>&, const charT*, int&, std::__cxx11::basic_string<_CharT, _Traits, _Allocator>*, int*)' may not have default arguments [-fpermissive]
  240 | from_stream(basic_istream<charT, traits>& is, const charT* fmt,
      | ^~~~~~~~~~~
p1393.cpp:238:37: error: redefinition of default argument for 'class Alloc'
  238 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                     ^~~~~
p1393.cpp:83:37: note: original definition appeared here
   83 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                     ^~~~~
p1393.cpp:245:19: error: 'year' in namespace 'std::chrono' does not name a type
  245 | constexpr chrono::year operator""y(unsigned long long y) noexcept;
      |                   ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:255:13: error: expected constructor, destructor, or type conversion before '=' token
  255 |   weekday() = default;
      |             ^
p1393.cpp:256:22: error: ISO C++ forbids declaration of 'weekday' with no type [-fpermissive]
  256 |   constexpr explicit weekday(unsigned wd) noexcept;
      |                      ^~~~~~~
p1393.cpp:256:13: error: 'explicit' outside class declaration
  256 |   constexpr explicit weekday(unsigned wd) noexcept;
      |             ^~~~~~~~
p1393.cpp:257:27: error: 'sys_days' does not name a type
  257 |   constexpr weekday(const sys_days& dp) noexcept;
      |                           ^~~~~~~~
p1393.cpp:257:13: error: ISO C++ forbids declaration of 'weekday' with no type [-fpermissive]
  257 |   constexpr weekday(const sys_days& dp) noexcept;
      |             ^~~~~~~
p1393.cpp:258:36: error: 'local_days' does not name a type
  258 |   constexpr explicit weekday(const local_days& dp) noexcept;
      |                                    ^~~~~~~~~~
p1393.cpp:258:22: error: ISO C++ forbids declaration of 'weekday' with no type [-fpermissive]
  258 |   constexpr explicit weekday(const local_days& dp) noexcept;
      |                      ^~~~~~~
p1393.cpp:258:13: error: 'explicit' outside class declaration
  258 |   constexpr explicit weekday(const local_days& dp) noexcept;
      |             ^~~~~~~~
p1393.cpp:259:13: error: 'weekday' does not name a type
  259 |   constexpr weekday& operator++()    noexcept;
      |             ^~~~~~~
p1393.cpp:260:13: error: 'weekday' does not name a type
  260 |   constexpr weekday  operator++(int) noexcept;
      |             ^~~~~~~
p1393.cpp:261:13: error: 'weekday' does not name a type
  261 |   constexpr weekday& operator--()    noexcept;
      |             ^~~~~~~
p1393.cpp:262:13: error: 'weekday' does not name a type
  262 |   constexpr weekday  operator--(int) noexcept;
      |             ^~~~~~~
p1393.cpp:263:13: error: 'weekday' does not name a type
  263 |   constexpr weekday& operator+=(const days& d) noexcept;
      |             ^~~~~~~
p1393.cpp:264:13: error: 'weekday' does not name a type
  264 |   constexpr weekday& operator-=(const days& d) noexcept;
      |             ^~~~~~~
p1393.cpp:265:41: error: non-member function 'constexpr unsigned int std::chrono::c_encoding()' cannot have cv-qualifier
  265 |   constexpr unsigned c_encoding() const noexcept;
      |                                         ^~~~~~~~
p1393.cpp:266:43: error: non-member function 'constexpr unsigned int std::chrono::iso_encoding()' cannot have cv-qualifier
  266 |   constexpr unsigned iso_encoding() const noexcept;
      |                                           ^~~~~~~~
p1393.cpp:267:29: error: non-member function 'constexpr bool std::chrono::ok()' cannot have cv-qualifier
  267 |   constexpr bool ok() const noexcept;
      |                             ^~~~~~~~
p1393.cpp:268:13: error: 'weekday_indexed' does not name a type
  268 |   constexpr weekday_indexed operator[](unsigned index) const noexcept;
      |             ^~~~~~~~~~~~~~~
p1393.cpp:269:13: error: 'weekday_last' does not name a type
  269 |   constexpr weekday_last    operator[](last_spec) const noexcept;
      |             ^~~~~~~~~~~~
p1393.cpp:275:20: error: ISO C++ forbids declaration of 'weekday' with no type [-fpermissive]
  275 | constexpr explicit weekday(unsigned wd) noexcept;
      |                    ^~~~~~~
p1393.cpp:275:11: error: 'explicit' outside class declaration
  275 | constexpr explicit weekday(unsigned wd) noexcept;
      |           ^~~~~~~~
p1393.cpp:277:25: error: 'sys_days' does not name a type
  277 | constexpr weekday(const sys_days& dp) noexcept;
      |                         ^~~~~~~~
p1393.cpp:277:11: error: ISO C++ forbids declaration of 'weekday' with no type [-fpermissive]
  277 | constexpr weekday(const sys_days& dp) noexcept;
      |           ^~~~~~~
p1393.cpp:280:34: error: 'local_days' does not name a type
  280 | constexpr explicit weekday(const local_days& dp) noexcept;
      |                                  ^~~~~~~~~~
p1393.cpp:280:20: error: ISO C++ forbids declaration of 'weekday' with no type [-fpermissive]
  280 | constexpr explicit weekday(const local_days& dp) noexcept;
      |                    ^~~~~~~
p1393.cpp:280:11: error: 'explicit' outside class declaration
  280 | constexpr explicit weekday(const local_days& dp) noexcept;
      |           ^~~~~~~~
p1393.cpp:283:11: error: 'weekday' does not name a type
  283 | constexpr weekday& operator++() noexcept;
      |           ^~~~~~~
p1393.cpp:285:11: error: 'weekday' does not name a type
  285 | constexpr weekday operator++(int) noexcept;
      |           ^~~~~~~
p1393.cpp:288:11: error: 'weekday' does not name a type
  288 | constexpr weekday& operator--() noexcept;
      |           ^~~~~~~
p1393.cpp:290:11: error: 'weekday' does not name a type
  290 | constexpr weekday operator--(int) noexcept;
      |           ^~~~~~~
p1393.cpp:293:11: error: 'weekday' does not name a type
  293 | constexpr weekday& operator+=(const days& d) noexcept;
      |           ^~~~~~~
p1393.cpp:295:11: error: 'weekday' does not name a type
  295 | constexpr weekday& operator-=(const days& d) noexcept;
      |           ^~~~~~~
p1393.cpp:297:39: error: non-member function 'constexpr unsigned int c_encoding()' cannot have cv-qualifier
  297 | constexpr unsigned c_encoding() const noexcept;
      |                                       ^~~~~~~~
p1393.cpp:299:41: error: non-member function 'constexpr unsigned int iso_encoding()' cannot have cv-qualifier
  299 | constexpr unsigned iso_encoding() const noexcept;
      |                                         ^~~~~~~~
p1393.cpp:301:27: error: non-member function 'constexpr bool ok()' cannot have cv-qualifier
  301 | constexpr bool ok() const noexcept;
      |                           ^~~~~~~~
p1393.cpp:303:11: error: 'weekday_indexed' does not name a type
  303 | constexpr weekday_indexed operator[](unsigned index) const noexcept;
      |           ^~~~~~~~~~~~~~~
p1393.cpp:305:11: error: 'weekday_last' does not name a type
  305 | constexpr weekday_last operator[](last_spec) const noexcept;
      |           ^~~~~~~~~~~~
p1393.cpp:307:11: error: 'weekday' does not name a type
  307 | constexpr weekday operator+(const weekday& x, const days& y) noexcept;
      |           ^~~~~~~
p1393.cpp:309:33: error: 'weekday' does not name a type
  309 | constexpr bool operator==(const weekday& x, const weekday& y) noexcept;
      |                                 ^~~~~~~
p1393.cpp:309:51: error: 'weekday' does not name a type
  309 | constexpr bool operator==(const weekday& x, const weekday& y) noexcept;
      |                                                   ^~~~~~~
p1393.cpp:309:16: error: 'constexpr bool operator==(const int&, const int&)' must have an argument of class or enumerated type
  309 | constexpr bool operator==(const weekday& x, const weekday& y) noexcept;
      |                ^~~~~~~~
p1393.cpp:312:1: error: 'weekday' does not name a type
  312 | weekday{modulo(static_cast<long long>(x.wd_) + y.count(), 7)}
      | ^~~~~~~
p1393.cpp:316:11: error: 'weekday' does not name a type
  316 | constexpr weekday operator+(const days& x, const weekday& y) noexcept;
      |           ^~~~~~~
p1393.cpp:318:11: error: 'weekday' does not name a type
  318 | constexpr weekday operator-(const weekday& x, const days& y) noexcept;
      |           ^~~~~~~
p1393.cpp:320:11: error: 'days' does not name a type
  320 | constexpr days operator-(const weekday& x, const weekday& y) noexcept;
      |           ^~~~
p1393.cpp:325:52: error: 'weekday' does not name a type
  325 | operator<<(basic_ostream<charT, traits>& os, const weekday& wd);
      |                                                    ^~~~~~~
p1393.cpp:327:1: error: expected unqualified-id before 'return'
  327 | return os << (wd.ok() ?
      | ^~~~~~
p1393.cpp:333:13: error: 'weekday' is not a type
  333 |             weekday& wd, basic_string<charT, traits, Alloc>* abbrev = nullptr,
      |             ^~~~~~~
p1393.cpp:334:13: error: 'minutes' has not been declared
  334 |             minutes* offset = nullptr);
      |             ^~~~~~~
p1393.cpp:332:1: error: redeclaration of 'template<class charT, class traits, class Alloc> std::basic_istream<_CharT, _Traits>& from_stream(std::basic_istream<_CharT, _Traits>&, const charT*, int&, std::__cxx11::basic_string<_CharT, _Traits, _Allocator>*, int*)' may not have default arguments [-fpermissive]
  332 | from_stream(basic_istream<charT, traits>& is, const charT* fmt,
      | ^~~~~~~~~~~
p1393.cpp:330:37: error: redefinition of default argument for 'class Alloc'
  330 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                     ^~~~~
p1393.cpp:83:37: note: original definition appeared here
   83 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                     ^~~~~
p1393.cpp:341:13: error: 'weekday' in namespace 'std::chrono' does not name a type
  341 |     chrono::weekday  wd_;
      |             ^~~~~~~
p1393.cpp:346:43: error: 'weekday' in namespace 'std::chrono' does not name a type
  346 |   constexpr weekday_indexed(const chrono::weekday& wd, unsigned index) noexcept;
      |                                           ^~~~~~~
p1393.cpp:348:28: error: 'weekday' in namespace 'std::chrono' does not name a type
  348 |          constexpr chrono::weekday weekday() const noexcept;
      |                            ^~~~~~~
p1393.cpp:355:22: error: 'Sunday' was not declared in this scope
  355 | constexpr auto wdi = Sunday[2]; // wdi is the second Sunday of an as yet unspecified month
      |                      ^~~~~~
p1393.cpp:356:32: error: 'Sunday' was not declared in this scope
  356 | static_assert(wdi.weekday() == Sunday);
      |                                ^~~~~~
p1393.cpp:360:44: error: 'weekday' in namespace 'std::chrono' does not name a type
  360 |    constexpr weekday_indexed(const chrono::weekday& wd, unsigned index) noexcept;
      |                                            ^~~~~~~
p1393.cpp:360:14: error: ISO C++ forbids declaration of 'weekday_indexed' with no type [-fpermissive]
  360 |    constexpr weekday_indexed(const chrono::weekday& wd, unsigned index) noexcept;
      |              ^~~~~~~~~~~~~~~
p1393.cpp:361:19: error: 'weekday' in namespace 'std::chrono' does not name a type
  361 | constexpr chrono::weekday weekday() const noexcept;
      |                   ^~~~~~~
p1393.cpp:363:34: error: non-member function 'constexpr unsigned int index()' cannot have cv-qualifier
  363 | constexpr unsigned index() const noexcept;
      |                                  ^~~~~~~~
p1393.cpp:365:27: error: non-member function 'constexpr bool ok()' cannot have cv-qualifier
  365 | constexpr bool ok() const noexcept;
      |                           ^~~~~~~~
p1393.cpp:368:33: error: 'weekday_indexed' does not name a type
  368 | constexpr bool operator==(const weekday_indexed& x, const weekday_indexed& y) noexcept;
      |                                 ^~~~~~~~~~~~~~~
p1393.cpp:368:59: error: 'weekday_indexed' does not name a type
  368 | constexpr bool operator==(const weekday_indexed& x, const weekday_indexed& y) noexcept;
      |                                                           ^~~~~~~~~~~~~~~
p1393.cpp:368:16: error: 'constexpr bool operator==(const int&, const int&)' must have an argument of class or enumerated type
  368 | constexpr bool operator==(const weekday_indexed& x, const weekday_indexed& y) noexcept;
      |                ^~~~~~~~
p1393.cpp:372:52: error: 'weekday_indexed' does not name a type
  372 | operator<<(basic_ostream<charT, traits>& os, const weekday_indexed& wdi);
      |                                                    ^~~~~~~~~~~~~~~
p1393.cpp:375:4: error: expected unqualified-id before 'return'
  375 |    return os << (i >= 1 && i <= 5 ?
      |    ^~~~~~
p1393.cpp:395:22: error: 'Sunday' was not declared in this scope
  395 | constexpr auto wdl = Sunday[last]; // wdl is the last Sunday of an as yet unspecified month
      |                      ^~~~~~
p1393.cpp:395:29: error: 'last' was not declared in this scope
  395 | constexpr auto wdl = Sunday[last]; // wdl is the last Sunday of an as yet unspecified month
      |                             ^~~~
p1393.cpp:396:37: error: 'Sunday' was not declared in this scope
  396 |      static_assert(wdl.weekday() == Sunday);
      |                                     ^~~~~~
p1393.cpp:399:50: error: 'weekday' in namespace 'std::chrono' does not name a type
  399 |    constexpr explicit weekday_last(const chrono::weekday& wd) noexcept;
      |                                                  ^~~~~~~
p1393.cpp:399:23: error: ISO C++ forbids declaration of 'weekday_last' with no type [-fpermissive]
  399 |    constexpr explicit weekday_last(const chrono::weekday& wd) noexcept;
      |                       ^~~~~~~~~~~~
p1393.cpp:399:14: error: 'explicit' outside class declaration
  399 |    constexpr explicit weekday_last(const chrono::weekday& wd) noexcept;
      |              ^~~~~~~~
p1393.cpp:401:19: error: 'weekday' in namespace 'std::chrono' does not name a type
  401 | constexpr chrono::weekday weekday() const noexcept;
      |                   ^~~~~~~
p1393.cpp:403:27: error: non-member function 'constexpr bool ok()' cannot have cv-qualifier
  403 | constexpr bool ok() const noexcept;
      |                           ^~~~~~~~
p1393.cpp:406:33: error: 'weekday_last' does not name a type
  406 | constexpr bool operator==(const weekday_last& x, const weekday_last& y) noexcept;
      |                                 ^~~~~~~~~~~~
p1393.cpp:406:56: error: 'weekday_last' does not name a type
  406 | constexpr bool operator==(const weekday_last& x, const weekday_last& y) noexcept;
      |                                                        ^~~~~~~~~~~~
p1393.cpp:406:16: error: 'constexpr bool operator==(const int&, const int&)' must have an argument of class or enumerated type
  406 | constexpr bool operator==(const weekday_last& x, const weekday_last& y) noexcept;
      |                ^~~~~~~~
p1393.cpp:410:52: error: 'weekday_last' does not name a type
  410 | operator<<(basic_ostream<charT, traits>& os, const weekday_last& wdl);
      |                                                    ^~~~~~~~~~~~
p1393.cpp:412:1: error: expected unqualified-id before 'return'
  412 | return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}[last]"), wdl.weekday());
      | ^~~~~~
p1393.cpp:417:15: error: 'month' in namespace 'std::chrono' does not name a type
  417 |       chrono::month m_;
      |               ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:422:39: error: 'month' in namespace 'std::chrono' does not name a type
  422 |     constexpr month_day(const chrono::month& m, const chrono::day& d) noexcept;
      |                                       ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:423:23: error: 'month' in namespace 'std::chrono' does not name a type
  423 |     constexpr chrono::month month() const noexcept;
      |                       ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:430:38: error: 'month' in namespace 'std::chrono' does not name a type
  430 |    constexpr month_day(const chrono::month& m, const chrono::day& d) noexcept;
      |                                      ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:430:14: error: ISO C++ forbids declaration of 'month_day' with no type [-fpermissive]
  430 |    constexpr month_day(const chrono::month& m, const chrono::day& d) noexcept;
      |              ^~~~~~~~~
p1393.cpp:432:19: error: 'month' in namespace 'std::chrono' does not name a type
  432 | constexpr chrono::month month() const noexcept;
      |                   ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:433:35: error: non-member function 'constexpr std::chrono::day day()' cannot have cv-qualifier
  433 | constexpr chrono::day day() const noexcept;
      |                                   ^~~~~~~~
p1393.cpp:435:27: error: non-member function 'constexpr bool ok()' cannot have cv-qualifier
  435 | constexpr bool ok() const noexcept;
      |                           ^~~~~~~~
p1393.cpp:438:33: error: 'month_day' does not name a type
  438 | constexpr bool operator==(const month_day& x, const month_day& y) noexcept;
      |                                 ^~~~~~~~~
p1393.cpp:438:53: error: 'month_day' does not name a type
  438 | constexpr bool operator==(const month_day& x, const month_day& y) noexcept;
      |                                                     ^~~~~~~~~
p1393.cpp:438:16: error: 'constexpr bool operator==(const int&, const int&)' must have an argument of class or enumerated type
  438 | constexpr bool operator==(const month_day& x, const month_day& y) noexcept;
      |                ^~~~~~~~
p1393.cpp:440:45: error: 'month_day' does not name a type
  440 | constexpr strong_ordering operator<=>(const month_day& x, const month_day& y) noexcept;
      |                                             ^~~~~~~~~
p1393.cpp:440:65: error: 'month_day' does not name a type
  440 | constexpr strong_ordering operator<=>(const month_day& x, const month_day& y) noexcept;
      |                                                                 ^~~~~~~~~
p1393.cpp:440:27: error: 'constexpr std::strong_ordering operator<=>(const int&, const int&)' must have an argument of class or enumerated type
  440 | constexpr strong_ordering operator<=>(const month_day& x, const month_day& y) noexcept;
      |                           ^~~~~~~~
p1393.cpp:442:1: error: expected unqualified-id before 'if'
  442 | if (auto c = x.month() <=> y.month(); c != 0) return c;
      | ^~
p1393.cpp:442:39: error: 'c' does not name a type
  442 | if (auto c = x.month() <=> y.month(); c != 0) return c;
      |                                       ^
p1393.cpp:443:3: error: expected unqualified-id before 'return'
  443 |   return x.day() <=> y.day();
      |   ^~~~~~
p1393.cpp:446:1: error: expected unqualified-id before '}' token
  446 | }
      | ^
p1393.cpp:446:1: error: expected declaration before '}' token
p1393.cpp:447:26: error: 'charT' was not declared in this scope; did you mean 'char'?
  447 | operator<<(basic_ostream<charT, traits>& os, const month_day& md);
      |                          ^~~~~
      |                          char
p1393.cpp:447:33: error: 'traits' was not declared in this scope
  447 | operator<<(basic_ostream<charT, traits>& os, const month_day& md);
      |                                 ^~~~~~
p1393.cpp:447:39: error: template argument 1 is invalid
  447 | operator<<(basic_ostream<charT, traits>& os, const month_day& md);
      |                                       ^
p1393.cpp:447:39: error: template argument 2 is invalid
p1393.cpp:447:52: error: 'month_day' does not name a type
  447 | operator<<(basic_ostream<charT, traits>& os, const month_day& md);
      |                                                    ^~~~~~~~~
p1393.cpp:447:66: error: expected constructor, destructor, or type conversion before ';' token
  447 | operator<<(basic_ostream<charT, traits>& os, const month_day& md);
      |                                                                  ^
p1393.cpp:449:1: error: expected unqualified-id before 'return'
  449 | return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}/{}"),
      | ^~~~~~
p1393.cpp:454:13: error: 'month_day' is not a type
  454 |             month_day& md, basic_string<charT, traits, Alloc>* abbrev = nullptr,
      |             ^~~~~~~~~
p1393.cpp:455:13: error: 'minutes' has not been declared
  455 |             minutes* offset = nullptr);
      |             ^~~~~~~
p1393.cpp:453:1: error: redeclaration of 'template<class charT, class traits, class Alloc> std::basic_istream<_CharT, _Traits>& from_stream(std::basic_istream<_CharT, _Traits>&, const charT*, int&, std::__cxx11::basic_string<_CharT, _Traits, _Allocator>*, int*)' may not have default arguments [-fpermissive]
  453 | from_stream(basic_istream<charT, traits>& is, const charT* fmt,
      | ^~~~~~~~~~~
p1393.cpp:451:37: error: redefinition of default argument for 'class Alloc'
  451 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                     ^~~~~
p1393.cpp:83:37: note: original definition appeared here
   83 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                     ^~~~~
p1393.cpp:461:15: error: 'month' in namespace 'std::chrono' does not name a type
  461 |       chrono::month m_;
      |               ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:463:51: error: 'month' in namespace 'std::chrono' does not name a type
  463 |   constexpr explicit month_day_last(const chrono::month& m) noexcept;
      |                                                   ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:464:21: error: 'month' in namespace 'std::chrono' does not name a type
  464 |   constexpr chrono::month month() const noexcept;
      |                     ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:471:22: error: 'February' was not declared in this scope
  471 | constexpr auto mdl = February/last; // mdl is the last day of February of an as yet unspecified year
      |                      ^~~~~~~~
p1393.cpp:471:31: error: 'last' was not declared in this scope
  471 | constexpr auto mdl = February/last; // mdl is the last day of February of an as yet unspecified year
      |                               ^~~~
p1393.cpp:472:30: error: 'February' was not declared in this scope
  472 | static_assert(mdl.month() == February);
      |                              ^~~~~~~~
p1393.cpp:474:49: error: 'month' in namespace 'std::chrono' does not name a type
  474 | constexpr explicit month_day_last(const chrono::month& m) noexcept;
      |                                                 ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:474:20: error: ISO C++ forbids declaration of 'month_day_last' with no type [-fpermissive]
  474 | constexpr explicit month_day_last(const chrono::month& m) noexcept;
      |                    ^~~~~~~~~~~~~~
p1393.cpp:474:11: error: 'explicit' outside class declaration
  474 | constexpr explicit month_day_last(const chrono::month& m) noexcept;
      |           ^~~~~~~~
p1393.cpp:476:11: error: 'month' does not name a type
  476 | constexpr month month() const noexcept;
      |           ^~~~~
p1393.cpp:478:27: error: non-member function 'constexpr bool std::chrono::ok()' cannot have cv-qualifier
  478 | constexpr bool ok() const noexcept;
      |                           ^~~~~~~~
p1393.cpp:480:33: error: 'month_day_last' does not name a type
  480 | constexpr bool operator==(const month_day_last& x, const month_day_last& y) noexcept;
      |                                 ^~~~~~~~~~~~~~
p1393.cpp:480:58: error: 'month_day_last' does not name a type
  480 | constexpr bool operator==(const month_day_last& x, const month_day_last& y) noexcept;
      |                                                          ^~~~~~~~~~~~~~
p1393.cpp:480:16: error: 'constexpr bool std::chrono::operator==(const int&, const int&)' must have an argument of class or enumerated type
  480 | constexpr bool operator==(const month_day_last& x, const month_day_last& y) noexcept;
      |                ^~~~~~~~
p1393.cpp:482:45: error: 'month_day_last' does not name a type
  482 | constexpr strong_ordering operator<=>(const month_day_last& x, const month_day_last& y) noexcept;
      |                                             ^~~~~~~~~~~~~~
p1393.cpp:482:70: error: 'month_day_last' does not name a type
  482 | constexpr strong_ordering operator<=>(const month_day_last& x, const month_day_last& y) noexcept;
      |                                                                      ^~~~~~~~~~~~~~
p1393.cpp:482:27: error: 'constexpr std::strong_ordering std::chrono::operator<=>(const int&, const int&)' must have an argument of class or enumerated type
  482 | constexpr strong_ordering operator<=>(const month_day_last& x, const month_day_last& y) noexcept;
      |                           ^~~~~~~~
p1393.cpp:486:52: error: 'month_day_last' does not name a type
  486 | operator<<(basic_ostream<charT, traits>& os, const month_day_last& mdl);
      |                                                    ^~~~~~~~~~~~~~
p1393.cpp:488:1: error: expected unqualified-id before 'return'
  488 | return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}/last"), mdl.month());
      | ^~~~~~
p1393.cpp:494:15: error: 'month' in namespace 'std::chrono' does not name a type
  494 |       chrono::month           m_;
      |               ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:498:43: error: 'month' in namespace 'std::chrono' does not name a type
  498 |     constexpr month_weekday(const chrono::month& m, const chrono::weekday_indexed& wdi) noexcept;
      |                                           ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:499:23: error: 'month' in namespace 'std::chrono' does not name a type
  499 |     constexpr chrono::month           month()           const noexcept;
      |                       ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:506:3: error: 'February' was not declared in this scope
  506 | = February/Tuesday[3]; // mwd is the third Tuesday of February of an as yet unspecified year
      |   ^~~~~~~~
p1393.cpp:506:12: error: 'Tuesday' was not declared in this scope
  506 | = February/Tuesday[3]; // mwd is the third Tuesday of February of an as yet unspecified year
      |            ^~~~~~~
p1393.cpp:507:35: error: 'February' was not declared in this scope
  507 |      static_assert(mwd.month() == February);
      |                                   ^~~~~~~~
p1393.cpp:508:45: error: 'Tuesday' was not declared in this scope
  508 |      static_assert(mwd.weekday_indexed() == Tuesday[3]);
      |                                             ^~~~~~~
p1393.cpp:511:42: error: 'month' in namespace 'std::chrono' does not name a type
  511 |    constexpr month_weekday(const chrono::month& m, const chrono::weekday_indexed& wdi) noexcept;
      |                                          ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:511:14: error: ISO C++ forbids declaration of 'month_weekday' with no type [-fpermissive]
  511 |    constexpr month_weekday(const chrono::month& m, const chrono::weekday_indexed& wdi) noexcept;
      |              ^~~~~~~~~~~~~
p1393.cpp:514:59: error: non-member function 'constexpr std::chrono::weekday_indexed weekday_indexed()' cannot have cv-qualifier
  514 | constexpr chrono::weekday_indexed weekday_indexed() const noexcept;
      |                                                           ^~~~~~~~
p1393.cpp:516:27: error: non-member function 'constexpr bool ok()' cannot have cv-qualifier
  516 | constexpr bool ok() const noexcept;
      |                           ^~~~~~~~
p1393.cpp:519:33: error: 'month_weekday' does not name a type
  519 | constexpr bool operator==(const month_weekday& x, const month_weekday& y) noexcept;
      |                                 ^~~~~~~~~~~~~
p1393.cpp:519:57: error: 'month_weekday' does not name a type
  519 | constexpr bool operator==(const month_weekday& x, const month_weekday& y) noexcept;
      |                                                         ^~~~~~~~~~~~~
p1393.cpp:519:16: error: 'constexpr bool operator==(const int&, const int&)' must have an argument of class or enumerated type
  519 | constexpr bool operator==(const month_weekday& x, const month_weekday& y) noexcept;
      |                ^~~~~~~~
p1393.cpp:523:52: error: 'month_weekday' does not name a type
  523 | operator<<(basic_ostream<charT, traits>& os, const month_weekday& mwd);
      |                                                    ^~~~~~~~~~~~~
p1393.cpp:525:1: error: expected unqualified-id before 'return'
  525 | return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}/{:L}"),
      | ^~~~~~
p1393.cpp:531:13: error: 'month' in namespace 'std::chrono' does not name a type
  531 |     chrono::month        m_;
      |             ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:532:13: error: 'weekday_last' in namespace 'std::chrono' does not name a type
  532 |     chrono::weekday_last wdl_;
      |             ^~~~~~~~~~~~
p1393.cpp:535:48: error: 'month' in namespace 'std::chrono' does not name a type
  535 |     constexpr month_weekday_last(const chrono::month& m,
      |                                                ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:536:48: error: 'weekday_last' in namespace 'std::chrono' does not name a type
  536 |                                  const chrono::weekday_last& wdl) noexcept;
      |                                                ^~~~~~~~~~~~
p1393.cpp:537:23: error: 'month' in namespace 'std::chrono' does not name a type
  537 |     constexpr chrono::month        month()        const noexcept;
      |                       ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:538:23: error: 'weekday_last' in namespace 'std::chrono' does not name a type
  538 |     constexpr chrono::weekday_last weekday_last() const noexcept;
      |                       ^~~~~~~~~~~~
p1393.cpp:544:3: error: 'February' was not declared in this scope
  544 | = February/Tuesday[last]; // mwd is the last Tuesday of February of an as yet unspecified year
      |   ^~~~~~~~
p1393.cpp:544:12: error: 'Tuesday' was not declared in this scope
  544 | = February/Tuesday[last]; // mwd is the last Tuesday of February of an as yet unspecified year
      |            ^~~~~~~
p1393.cpp:544:20: error: 'last' was not declared in this scope
  544 | = February/Tuesday[last]; // mwd is the last Tuesday of February of an as yet unspecified year
      |                    ^~~~
p1393.cpp:545:35: error: 'February' was not declared in this scope
  545 |      static_assert(mwd.month() == February);
      |                                   ^~~~~~~~
p1393.cpp:546:42: error: 'Tuesday' was not declared in this scope
  546 |      static_assert(mwd.weekday_last() == Tuesday[last]);
      |                                          ^~~~~~~
p1393.cpp:546:50: error: 'last' was not declared in this scope
  546 |      static_assert(mwd.weekday_last() == Tuesday[last]);
      |                                                  ^~~~
p1393.cpp:549:47: error: 'month' in namespace 'std::chrono' does not name a type
  549 |    constexpr month_weekday_last(const chrono::month& m,
      |                                               ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:550:47: error: 'weekday_last' in namespace 'std::chrono' does not name a type
  550 |                                 const chrono::weekday_last& wdl) noexcept;
      |                                               ^~~~~~~~~~~~
p1393.cpp:549:14: error: ISO C++ forbids declaration of 'month_weekday_last' with no type [-fpermissive]
  549 |    constexpr month_weekday_last(const chrono::month& m,
      |              ^~~~~~~~~~~~~~~~~~
p1393.cpp:553:19: error: 'weekday_last' in namespace 'std::chrono' does not name a type
  553 | constexpr chrono::weekday_last weekday_last() const noexcept;
      |                   ^~~~~~~~~~~~
p1393.cpp:555:27: error: non-member function 'constexpr bool ok()' cannot have cv-qualifier
  555 | constexpr bool ok() const noexcept;
      |                           ^~~~~~~~
p1393.cpp:558:33: error: 'month_weekday_last' does not name a type
  558 | constexpr bool operator==(const month_weekday_last& x, const month_weekday_last& y) noexcept;
      |                                 ^~~~~~~~~~~~~~~~~~
p1393.cpp:558:62: error: 'month_weekday_last' does not name a type
  558 | constexpr bool operator==(const month_weekday_last& x, const month_weekday_last& y) noexcept;
      |                                                              ^~~~~~~~~~~~~~~~~~
p1393.cpp:558:16: error: 'constexpr bool operator==(const int&, const int&)' must have an argument of class or enumerated type
  558 | constexpr bool operator==(const month_weekday_last& x, const month_weekday_last& y) noexcept;
      |                ^~~~~~~~
p1393.cpp:559:8: error: found ':' in nested-name-specifier, expected '::'
  559 | Returns: x.month() == y.month() && x.weekday_last() == y.weekday_last().
      |        ^
      |        ::
p1393.cpp:559:1: error: 'Returns' does not name a type
  559 | Returns: x.month() == y.month() && x.weekday_last() == y.weekday_last().
      | ^~~~~~~
p1393.cpp:564:1: error: expected unqualified-id before 'return'
  564 | return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}/{:L}"),
      | ^~~~~~
p1393.cpp:570:15: error: 'year' in namespace 'std::chrono' does not name a type
  570 |       chrono::year  y_;
      |               ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:571:15: error: 'month' in namespace 'std::chrono' does not name a type
  571 |       chrono::month m_;
      |               ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:575:38: error: 'year' in namespace 'std::chrono' does not name a type
  575 |   constexpr year_month(const chrono::year& y, const chrono::month& m) noexcept;
      |                                      ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:575:61: error: 'month' in namespace 'std::chrono' does not name a type
  575 |   constexpr year_month(const chrono::year& y, const chrono::month& m) noexcept;
      |                                                             ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:576:21: error: 'year' in namespace 'std::chrono' does not name a type
  576 |   constexpr chrono::year  year()  const noexcept;
      |                     ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:577:21: error: 'month' in namespace 'std::chrono' does not name a type
  577 |   constexpr chrono::month month() const noexcept;
      |                     ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:578:42: error: 'months' does not name a type; did you mean 'month'?
  578 |   constexpr year_month& operator+=(const months& dm) noexcept;
      |                                          ^~~~~~
      |                                          month
p1393.cpp:579:42: error: 'months' does not name a type; did you mean 'month'?
  579 |   constexpr year_month& operator-=(const months& dm) noexcept;
      |                                          ^~~~~~
      |                                          month
p1393.cpp:580:42: error: 'years' does not name a type; did you mean 'year'?
  580 |   constexpr year_month& operator+=(const years& dy)  noexcept;
      |                                          ^~~~~
      |                                          year
p1393.cpp:580:25: error: 'constexpr std::chrono::year_month& std::chrono::year_month::operator+=(const int&)' cannot be overloaded with 'constexpr std::chrono::year_month& std::chrono::year_month::operator+=(const int&)'
  580 |   constexpr year_month& operator+=(const years& dy)  noexcept;
      |                         ^~~~~~~~
p1393.cpp:578:25: note: previous declaration 'constexpr std::chrono::year_month& std::chrono::year_month::operator+=(const int&)'
  578 |   constexpr year_month& operator+=(const months& dm) noexcept;
      |                         ^~~~~~~~
p1393.cpp:581:42: error: 'years' does not name a type; did you mean 'year'?
  581 |   constexpr year_month& operator-=(const years& dy)  noexcept;
      |                                          ^~~~~
      |                                          year
p1393.cpp:581:25: error: 'constexpr std::chrono::year_month& std::chrono::year_month::operator-=(const int&)' cannot be overloaded with 'constexpr std::chrono::year_month& std::chrono::year_month::operator-=(const int&)'
  581 |   constexpr year_month& operator-=(const years& dy)  noexcept;
      |                         ^~~~~~~~
p1393.cpp:579:25: note: previous declaration 'constexpr std::chrono::year_month& std::chrono::year_month::operator-=(const int&)'
  579 |   constexpr year_month& operator-=(const months& dm) noexcept;
      |                         ^~~~~~~~
p1393.cpp:588:39: error: 'year' in namespace 'std::chrono' does not name a type
  588 |    constexpr year_month(const chrono::year& y, const chrono::month& m) noexcept;
      |                                       ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:588:62: error: 'month' in namespace 'std::chrono' does not name a type
  588 |    constexpr year_month(const chrono::year& y, const chrono::month& m) noexcept;
      |                                                              ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:588:14: error: ISO C++ forbids declaration of 'year_month' with no type [-fpermissive]
  588 |    constexpr year_month(const chrono::year& y, const chrono::month& m) noexcept;
      |              ^~~~~~~~~~
p1393.cpp:591:19: error: 'month' in namespace 'std::chrono' does not name a type
  591 | constexpr chrono::month month() const noexcept;
      |                   ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:593:11: error: 'year_month' does not name a type
  593 | constexpr year_month& operator+=(const months& dm) noexcept;
      |           ^~~~~~~~~~
p1393.cpp:596:11: error: 'year_month' does not name a type
  596 | constexpr year_month& operator-=(const months& dm) noexcept;
      |           ^~~~~~~~~~
p1393.cpp:599:11: error: 'year_month' does not name a type
  599 | constexpr year_month& operator+=(const years& dy) noexcept;
      |           ^~~~~~~~~~
p1393.cpp:601:11: error: 'year_month' does not name a type
  601 | constexpr year_month& operator-=(const years& dy) noexcept;
      |           ^~~~~~~~~~
p1393.cpp:603:27: error: non-member function 'constexpr bool ok()' cannot have cv-qualifier
  603 | constexpr bool ok() const noexcept;
      |                           ^~~~~~~~
p1393.cpp:606:33: error: 'year_month' does not name a type
  606 | constexpr bool operator==(const year_month& x, const year_month& y) noexcept;
      |                                 ^~~~~~~~~~
p1393.cpp:606:54: error: 'year_month' does not name a type
  606 | constexpr bool operator==(const year_month& x, const year_month& y) noexcept;
      |                                                      ^~~~~~~~~~
p1393.cpp:606:16: error: 'constexpr bool operator==(const int&, const int&)' must have an argument of class or enumerated type
  606 | constexpr bool operator==(const year_month& x, const year_month& y) noexcept;
      |                ^~~~~~~~
p1393.cpp:608:45: error: 'year_month' does not name a type
  608 | constexpr strong_ordering operator<=>(const year_month& x, const year_month& y) noexcept;
      |                                             ^~~~~~~~~~
p1393.cpp:608:66: error: 'year_month' does not name a type
  608 | constexpr strong_ordering operator<=>(const year_month& x, const year_month& y) noexcept;
      |                                                                  ^~~~~~~~~~
p1393.cpp:608:27: error: 'constexpr std::strong_ordering operator<=>(const int&, const int&)' must have an argument of class or enumerated type
  608 | constexpr strong_ordering operator<=>(const year_month& x, const year_month& y) noexcept;
      |                           ^~~~~~~~
p1393.cpp:610:1: error: expected unqualified-id before 'if'
  610 | if (auto c = x.year() <=> y.year(); c != 0) return c;
      | ^~
p1393.cpp:610:37: error: 'c' does not name a type
  610 | if (auto c = x.year() <=> y.year(); c != 0) return c;
      |                                     ^
p1393.cpp:611:8: error: expected unqualified-id before 'return'
  611 |        return x.month() <=> y.month();
      |        ^~~~~~
p1393.cpp:612:11: error: 'year_month' does not name a type
  612 | constexpr year_month operator+(const year_month& ym, const months& dm) noexcept;
      |           ^~~~~~~~~~
p1393.cpp:615:11: error: 'year_month' does not name a type
  615 | constexpr year_month operator+(const months& dm, const year_month& ym) noexcept;
      |           ^~~~~~~~~~
p1393.cpp:618:11: error: 'year_month' does not name a type
  618 | constexpr year_month operator-(const year_month& ym, const months& dm) noexcept;
      |           ^~~~~~~~~~
p1393.cpp:621:11: error: 'months' does not name a type
  621 | constexpr months operator-(const year_month& x, const year_month& y) noexcept;
      |           ^~~~~~
p1393.cpp:623:1: error: 'x' does not name a type
  623 | x.year() - y.year() + months{static_cast<int>(unsigned{x.month()}) -
      | ^
p1393.cpp:625:11: error: 'year_month' does not name a type
  625 | constexpr year_month operator+(const year_month& ym, const years& dy) noexcept;
      |           ^~~~~~~~~~
p1393.cpp:627:11: error: 'year_month' does not name a type
  627 | constexpr year_month operator+(const years& dy, const year_month& ym) noexcept;
      |           ^~~~~~~~~~
p1393.cpp:629:11: error: 'year_month' does not name a type
  629 | constexpr year_month operator-(const year_month& ym, const years& dy) noexcept;
      |           ^~~~~~~~~~
p1393.cpp:633:52: error: 'year_month' does not name a type
  633 | operator<<(basic_ostream<charT, traits>& os, const year_month& ym);
      |                                                    ^~~~~~~~~~
p1393.cpp:635:1: error: expected unqualified-id before 'return'
  635 | return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{:L}"), ym.year(), ym.month());
      | ^~~~~~
p1393.cpp:639:17: error: 'year_month' is not a type
  639 |                 year_month& ym, basic_string<charT, traits, Alloc>* abbrev = nullptr,
      |                 ^~~~~~~~~~
p1393.cpp:640:17: error: 'minutes' has not been declared
  640 |                 minutes* offset = nullptr);
      |                 ^~~~~~~
p1393.cpp:638:5: error: redeclaration of 'template<class charT, class traits, class Alloc> std::basic_istream<_CharT, _Traits>& from_stream(std::basic_istream<_CharT, _Traits>&, const charT*, int&, std::__cxx11::basic_string<_CharT, _Traits, _Allocator>*, int*)' may not have default arguments [-fpermissive]
  638 |     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
      |     ^~~~~~~~~~~
p1393.cpp:636:37: error: redefinition of default argument for 'class Alloc'
  636 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                     ^~~~~
p1393.cpp:83:37: note: original definition appeared here
   83 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                     ^~~~~
p1393.cpp:642:41: error: expected initializer before ')' token
  642 |                     const chrono::day& d) noexcept;
      |                                         ^
p1393.cpp:649:13: error: 'year' in namespace 'std::chrono' does not name a type
  649 |     chrono::year  y_;
      |             ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:650:13: error: 'month' in namespace 'std::chrono' does not name a type
  650 |     chrono::month m_;
      |             ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:655:44: error: 'year' in namespace 'std::chrono' does not name a type
  655 |     constexpr year_month_day(const chrono::year& y, const chrono::month& m,
      |                                            ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:655:67: error: 'month' in namespace 'std::chrono' does not name a type
  655 |     constexpr year_month_day(const chrono::year& y, const chrono::month& m,
      |                                                                   ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:657:36: error: 'year_month_day_last' does not name a type; did you mean 'year_month_day'?
  657 |     constexpr year_month_day(const year_month_day_last& ymdl) noexcept;
      |                                    ^~~~~~~~~~~~~~~~~~~
      |                                    year_month_day
p1393.cpp:658:36: error: 'sys_days' does not name a type
  658 |     constexpr year_month_day(const sys_days& dp) noexcept;
      |                                    ^~~~~~~~
p1393.cpp:658:15: error: 'constexpr std::chrono::year_month_day::year_month_day(const int&)' cannot be overloaded with 'constexpr std::chrono::year_month_day::year_month_day(const int&)'
  658 |     constexpr year_month_day(const sys_days& dp) noexcept;
      |               ^~~~~~~~~~~~~~
p1393.cpp:657:15: note: previous declaration 'constexpr std::chrono::year_month_day::year_month_day(const int&)'
  657 |     constexpr year_month_day(const year_month_day_last& ymdl) noexcept;
      |               ^~~~~~~~~~~~~~
p1393.cpp:659:45: error: 'local_days' does not name a type
  659 |     constexpr explicit year_month_day(const local_days& dp) noexcept;
      |                                             ^~~~~~~~~~
p1393.cpp:659:24: error: 'constexpr std::chrono::year_month_day::year_month_day(const int&)' cannot be overloaded with 'constexpr std::chrono::year_month_day::year_month_day(const int&)'
  659 |     constexpr explicit year_month_day(const local_days& dp) noexcept;
      |                        ^~~~~~~~~~~~~~
p1393.cpp:657:15: note: previous declaration 'constexpr std::chrono::year_month_day::year_month_day(const int&)'
  657 |     constexpr year_month_day(const year_month_day_last& ymdl) noexcept;
      |               ^~~~~~~~~~~~~~
p1393.cpp:660:48: error: 'months' does not name a type; did you mean 'month'?
  660 |     constexpr year_month_day& operator+=(const months& m) noexcept;
      |                                                ^~~~~~
      |                                                month
p1393.cpp:661:48: error: 'months' does not name a type; did you mean 'month'?
  661 |     constexpr year_month_day& operator-=(const months& m) noexcept;
      |                                                ^~~~~~
      |                                                month
p1393.cpp:662:48: error: 'years' does not name a type; did you mean 'year'?
  662 |     constexpr year_month_day& operator+=(const years& y)  noexcept;
      |                                                ^~~~~
      |                                                year
p1393.cpp:662:31: error: 'constexpr std::chrono::year_month_day& std::chrono::year_month_day::operator+=(const int&)' cannot be overloaded with 'constexpr std::chrono::year_month_day& std::chrono::year_month_day::operator+=(const int&)'
  662 |     constexpr year_month_day& operator+=(const years& y)  noexcept;
      |                               ^~~~~~~~
p1393.cpp:660:31: note: previous declaration 'constexpr std::chrono::year_month_day& std::chrono::year_month_day::operator+=(const int&)'
  660 |     constexpr year_month_day& operator+=(const months& m) noexcept;
      |                               ^~~~~~~~
p1393.cpp:663:48: error: 'years' does not name a type; did you mean 'year'?
  663 |     constexpr year_month_day& operator-=(const years& y)  noexcept;
      |                                                ^~~~~
      |                                                year
p1393.cpp:663:31: error: 'constexpr std::chrono::year_month_day& std::chrono::year_month_day::operator-=(const int&)' cannot be overloaded with 'constexpr std::chrono::year_month_day& std::chrono::year_month_day::operator-=(const int&)'
  663 |     constexpr year_month_day& operator-=(const years& y)  noexcept;
      |                               ^~~~~~~~
p1393.cpp:661:31: note: previous declaration 'constexpr std::chrono::year_month_day& std::chrono::year_month_day::operator-=(const int&)'
  661 |     constexpr year_month_day& operator-=(const months& m) noexcept;
      |                               ^~~~~~~~
p1393.cpp:664:23: error: 'year' in namespace 'std::chrono' does not name a type
  664 |     constexpr chrono::year  year()  const noexcept;
      |                       ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:665:23: error: 'month' in namespace 'std::chrono' does not name a type
  665 |     constexpr chrono::month month() const noexcept;
      |                       ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:667:33: error: expected type-specifier before 'sys_days'
  667 |     constexpr          operator sys_days()   const noexcept;
      |                                 ^~~~~~~~
p1393.cpp:668:33: error: expected type-specifier before 'local_days'
  668 |     constexpr explicit operator local_days() const noexcept;
      |                                 ^~~~~~~~~~
p1393.cpp:675:40: error: 'year' in namespace 'std::chrono' does not name a type
  675 | constexpr year_month_day(const chrono::year& y, const chrono::month& m,
      |                                        ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:675:63: error: 'month' in namespace 'std::chrono' does not name a type
  675 | constexpr year_month_day(const chrono::year& y, const chrono::month& m,
      |                                                               ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:676:35: error: 'year_month_day_last' does not name a type
  676 |    constexpr year_month_day(const year_month_day_last& ymdl) noexcept;
      |                                   ^~~~~~~~~~~~~~~~~~~
p1393.cpp:676:14: error: ISO C++ forbids declaration of 'year_month_day' with no type [-fpermissive]
  676 |    constexpr year_month_day(const year_month_day_last& ymdl) noexcept;
      |              ^~~~~~~~~~~~~~
p1393.cpp:676:4: error: a parameter cannot be declared 'constexpr'
  676 |    constexpr year_month_day(const year_month_day_last& ymdl) noexcept;
      |    ^~~~~~~~~
p1393.cpp:676:70: error: expected ')' before ';' token
  676 |    constexpr year_month_day(const year_month_day_last& ymdl) noexcept;
      |                                                                      ^
      |                                                                      )
p1393.cpp:675:25: note: to match this '('
  675 | constexpr year_month_day(const chrono::year& y, const chrono::month& m,
      |                         ^
p1393.cpp:675:11: error: ISO C++ forbids declaration of 'year_month_day' with no type [-fpermissive]
  675 | constexpr year_month_day(const chrono::year& y, const chrono::month& m,
      |           ^~~~~~~~~~~~~~
p1393.cpp:679:32: error: 'sys_days' does not name a type
  679 | constexpr year_month_day(const sys_days& dp) noexcept;
      |                                ^~~~~~~~
p1393.cpp:679:11: error: ISO C++ forbids declaration of 'year_month_day' with no type [-fpermissive]
  679 | constexpr year_month_day(const sys_days& dp) noexcept;
      |           ^~~~~~~~~~~~~~
p1393.cpp:681:41: error: 'local_days' does not name a type
  681 | constexpr explicit year_month_day(const local_days& dp) noexcept;
      |                                         ^~~~~~~~~~
p1393.cpp:681:20: error: ISO C++ forbids declaration of 'year_month_day' with no type [-fpermissive]
  681 | constexpr explicit year_month_day(const local_days& dp) noexcept;
      |                    ^~~~~~~~~~~~~~
p1393.cpp:681:11: error: 'explicit' outside class declaration
  681 | constexpr explicit year_month_day(const local_days& dp) noexcept;
      |           ^~~~~~~~
p1393.cpp:685:11: error: 'year_month_day' does not name a type
  685 | constexpr year_month_day& operator-=(const months& m) noexcept;
      |           ^~~~~~~~~~~~~~
p1393.cpp:688:11: error: 'year_month_day' does not name a type
  688 | constexpr year_month_day& year_month_day::operator+=(const years& y) noexcept;
      |           ^~~~~~~~~~~~~~
p1393.cpp:690:11: error: 'year_month_day' does not name a type
  690 | constexpr year_month_day& year_month_day::operator-=(const years& y) noexcept;
      |           ^~~~~~~~~~~~~~
p1393.cpp:692:19: error: 'year' in namespace 'std::chrono' does not name a type
  692 | constexpr chrono::year year() const noexcept;
      |                   ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:694:19: error: 'month' in namespace 'std::chrono' does not name a type
  694 | constexpr chrono::month month() const noexcept;
      |                   ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:696:35: error: non-member function 'constexpr std::chrono::day day()' cannot have cv-qualifier
  696 | constexpr chrono::day day() const noexcept;
      |                                   ^~~~~~~~
p1393.cpp:698:20: error: expected type-specifier before 'sys_days'
  698 | constexpr operator sys_days() const noexcept;
      |                    ^~~~~~~~
p1393.cpp:701:36: error: expected ',' before '{' token
  701 |        static_assert(year_month_day{sys_days{2017y/January/0}}  == 2016y/December/31);
      |                                    ^
      |                                    ,
p1393.cpp:701:36: error: expected string-literal before '{' token
p1393.cpp:701:36: error: expected ')' before '{' token
  701 |        static_assert(year_month_day{sys_days{2017y/January/0}}  == 2016y/December/31);
      |                     ~              ^
      |                                    )
p1393.cpp:702:36: error: expected ',' before '{' token
  702 |        static_assert(year_month_day{sys_days{2017y/January/31}} == 2017y/January/31);
      |                                    ^
      |                                    ,
p1393.cpp:702:36: error: expected string-literal before '{' token
p1393.cpp:702:36: error: expected ')' before '{' token
  702 |        static_assert(year_month_day{sys_days{2017y/January/31}} == 2017y/January/31);
      |                     ~              ^
      |                                    )
p1393.cpp:703:36: error: expected ',' before '{' token
  703 |        static_assert(year_month_day{sys_days{2017y/January/32}} == 2017y/February/1);
      |                                    ^
      |                                    ,
p1393.cpp:703:36: error: expected string-literal before '{' token
p1393.cpp:703:36: error: expected ')' before '{' token
  703 |        static_assert(year_month_day{sys_days{2017y/January/32}} == 2017y/February/1);
      |                     ~              ^
      |                                    )
p1393.cpp:704:29: error: expected type-specifier before 'local_days'
  704 | constexpr explicit operator local_days() const noexcept;
      |                             ^~~~~~~~~~
p1393.cpp:708:33: error: 'year_month_day' does not name a type
  708 | constexpr bool operator==(const year_month_day& x, const year_month_day& y) noexcept;
      |                                 ^~~~~~~~~~~~~~
p1393.cpp:708:58: error: 'year_month_day' does not name a type
  708 | constexpr bool operator==(const year_month_day& x, const year_month_day& y) noexcept;
      |                                                          ^~~~~~~~~~~~~~
p1393.cpp:708:16: error: 'constexpr bool operator==(const int&, const int&)' must have an argument of class or enumerated type
  708 | constexpr bool operator==(const year_month_day& x, const year_month_day& y) noexcept;
      |                ^~~~~~~~
p1393.cpp:710:45: error: 'year_month_day' does not name a type
  710 | constexpr strong_ordering operator<=>(const year_month_day& x, const year_month_day& y) noexcept;
      |                                             ^~~~~~~~~~~~~~
p1393.cpp:710:70: error: 'year_month_day' does not name a type
  710 | constexpr strong_ordering operator<=>(const year_month_day& x, const year_month_day& y) noexcept;
      |                                                                      ^~~~~~~~~~~~~~
p1393.cpp:710:27: error: 'constexpr std::strong_ordering operator<=>(const int&, const int&)' must have an argument of class or enumerated type
  710 | constexpr strong_ordering operator<=>(const year_month_day& x, const year_month_day& y) noexcept;
      |                           ^~~~~~~~
p1393.cpp:712:3: error: expected unqualified-id before 'if'
  712 |   if (auto c = x.year() <=> y.year(); c != 0) return c;
      |   ^~
p1393.cpp:712:39: error: 'c' does not name a type
  712 |   if (auto c = x.year() <=> y.year(); c != 0) return c;
      |                                       ^
p1393.cpp:713:3: error: expected unqualified-id before 'if'
  713 |   if (auto c = x.month() <=> y.month(); c != 0) return c;
      |   ^~
p1393.cpp:713:41: error: 'c' does not name a type
  713 |   if (auto c = x.month() <=> y.month(); c != 0) return c;
      |                                         ^
p1393.cpp:714:3: error: expected unqualified-id before 'return'
  714 |   return x.day() <=> y.day();
      |   ^~~~~~
p1393.cpp:715:11: error: 'year_month_day' does not name a type
  715 | constexpr year_month_day operator+(const year_month_day& ymd, const months& dm) noexcept;
      |           ^~~~~~~~~~~~~~
p1393.cpp:719:11: error: 'year_month_day' does not name a type
  719 | constexpr year_month_day operator+(const months& dm, const year_month_day& ymd) noexcept;
      |           ^~~~~~~~~~~~~~
p1393.cpp:722:11: error: 'year_month_day' does not name a type
  722 | constexpr year_month_day operator-(const year_month_day& ymd, const months& dm) noexcept;
      |           ^~~~~~~~~~~~~~
p1393.cpp:725:11: error: 'year_month_day' does not name a type
  725 | constexpr year_month_day operator+(const year_month_day& ymd, const years& dy) noexcept;
      |           ^~~~~~~~~~~~~~
p1393.cpp:728:11: error: 'year_month_day' does not name a type
  728 | constexpr year_month_day operator+(const years& dy, const year_month_day& ymd) noexcept;
      |           ^~~~~~~~~~~~~~
p1393.cpp:730:11: error: 'year_month_day' does not name a type
  730 | constexpr year_month_day operator-(const year_month_day& ymd, const years& dy) noexcept;
      |           ^~~~~~~~~~~~~~
p1393.cpp:734:56: error: 'year_month_day' does not name a type
  734 |     operator<<(basic_ostream<charT, traits>& os, const year_month_day& ymd);
      |                                                        ^~~~~~~~~~~~~~
p1393.cpp:736:1: error: expected unqualified-id before 'return'
  736 | return os << (ymd.ok() ?
      | ^~~~~~
p1393.cpp:741:17: error: 'year_month_day' is not a type
  741 |                 year_month_day& ymd, basic_string<charT, traits, Alloc>* abbrev = nullptr,
      |                 ^~~~~~~~~~~~~~
p1393.cpp:742:12: error: 'minutes' has not been declared
  742 |            minutes* offset = nullptr);
      |            ^~~~~~~
p1393.cpp:740:5: error: redeclaration of 'template<class charT, class traits, class Alloc> std::basic_istream<_CharT, _Traits>& from_stream(std::basic_istream<_CharT, _Traits>&, const charT*, int&, std::__cxx11::basic_string<_CharT, _Traits, _Allocator>*, int*)' may not have default arguments [-fpermissive]
  740 |     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
      |     ^~~~~~~~~~~
p1393.cpp:738:37: error: redefinition of default argument for 'class Alloc'
  738 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                     ^~~~~
p1393.cpp:83:37: note: original definition appeared here
   83 | template<class charT, class traits, class Alloc = allocator<charT>>
      |                                     ^~~~~
p1393.cpp:749:15: error: 'year' in namespace 'std::chrono' does not name a type
  749 |       chrono::year           y_;
      |               ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:750:15: error: 'month_day_last' in namespace 'std::chrono' does not name a type
  750 |       chrono::month_day_last mdl_;
      |               ^~~~~~~~~~~~~~
p1393.cpp:474:20: note: 'constexpr int std::chrono::month_day_last(const int&)' declared here
  474 | constexpr explicit month_day_last(const chrono::month& m) noexcept;
      |                    ^~~~~~~~~~~~~~
p1393.cpp:752:47: error: 'year' in namespace 'std::chrono' does not name a type
  752 |   constexpr year_month_day_last(const chrono::year& y,
      |                                               ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:753:49: error: 'month_day_last' in namespace 'std::chrono' does not name a type
  753 |                                   const chrono::month_day_last& mdl) noexcept;
      |                                                 ^~~~~~~~~~~~~~
p1393.cpp:474:20: note: 'constexpr int std::chrono::month_day_last(const int&)' declared here
  474 | constexpr explicit month_day_last(const chrono::month& m) noexcept;
      |                    ^~~~~~~~~~~~~~
p1393.cpp:754:53: error: 'months' does not name a type; did you mean 'month'?
  754 |     constexpr year_month_day_last& operator+=(const months& m) noexcept;
      |                                                     ^~~~~~
      |                                                     month
p1393.cpp:755:53: error: 'months' does not name a type; did you mean 'month'?
  755 |     constexpr year_month_day_last& operator-=(const months& m) noexcept;
      |                                                     ^~~~~~
      |                                                     month
p1393.cpp:756:53: error: 'years' does not name a type; did you mean 'year'?
  756 |     constexpr year_month_day_last& operator+=(const years& y)  noexcept;
      |                                                     ^~~~~
      |                                                     year
p1393.cpp:756:36: error: 'constexpr std::chrono::year_month_day_last& std::chrono::year_month_day_last::operator+=(const int&)' cannot be overloaded with 'constexpr std::chrono::year_month_day_last& std::chrono::year_month_day_last::operator+=(const int&)'
  756 |     constexpr year_month_day_last& operator+=(const years& y)  noexcept;
      |                                    ^~~~~~~~
p1393.cpp:754:36: note: previous declaration 'constexpr std::chrono::year_month_day_last& std::chrono::year_month_day_last::operator+=(const int&)'
  754 |     constexpr year_month_day_last& operator+=(const months& m) noexcept;
      |                                    ^~~~~~~~
p1393.cpp:757:53: error: 'years' does not name a type; did you mean 'year'?
  757 |     constexpr year_month_day_last& operator-=(const years& y)  noexcept;
      |                                                     ^~~~~
      |                                                     year
p1393.cpp:757:36: error: 'constexpr std::chrono::year_month_day_last& std::chrono::year_month_day_last::operator-=(const int&)' cannot be overloaded with 'constexpr std::chrono::year_month_day_last& std::chrono::year_month_day_last::operator-=(const int&)'
  757 |     constexpr year_month_day_last& operator-=(const years& y)  noexcept;
      |                                    ^~~~~~~~
p1393.cpp:755:36: note: previous declaration 'constexpr std::chrono::year_month_day_last& std::chrono::year_month_day_last::operator-=(const int&)'
  755 |     constexpr year_month_day_last& operator-=(const months& m) noexcept;
      |                                    ^~~~~~~~
p1393.cpp:758:23: error: 'year' in namespace 'std::chrono' does not name a type
  758 |     constexpr chrono::year           year()           const noexcept;
      |                       ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:759:23: error: 'month' in namespace 'std::chrono' does not name a type
  759 |     constexpr chrono::month          month()          const noexcept;
      |                       ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:760:23: error: 'month_day_last' in namespace 'std::chrono' does not name a type
  760 |     constexpr chrono::month_day_last month_day_last() const noexcept;
      |                       ^~~~~~~~~~~~~~
p1393.cpp:474:20: note: 'constexpr int std::chrono::month_day_last(const int&)' declared here
  474 | constexpr explicit month_day_last(const chrono::month& m) noexcept;
      |                    ^~~~~~~~~~~~~~
p1393.cpp:762:33: error: expected type-specifier before 'sys_days'
  762 |     constexpr          operator sys_days()   const noexcept;
      |                                 ^~~~~~~~
p1393.cpp:763:33: error: expected type-specifier before 'local_days'
  763 |     constexpr explicit operator local_days() const noexcept;
      |                                 ^~~~~~~~~~
p1393.cpp:771:45: error: 'year' in namespace 'std::chrono' does not name a type
  771 | constexpr year_month_day_last(const chrono::year& y,
      |                                             ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:772:48: error: 'month_day_last' in namespace 'std::chrono' does not name a type
  772 |                                  const chrono::month_day_last& mdl) noexcept;
      |                                                ^~~~~~~~~~~~~~
p1393.cpp:474:20: note: 'constexpr int std::chrono::month_day_last(const int&)' declared here
  474 | constexpr explicit month_day_last(const chrono::month& m) noexcept;
      |                    ^~~~~~~~~~~~~~
p1393.cpp:771:11: error: ISO C++ forbids declaration of 'year_month_day_last' with no type [-fpermissive]
  771 | constexpr year_month_day_last(const chrono::year& y,
      |           ^~~~~~~~~~~~~~~~~~~
p1393.cpp:774:11: error: 'year_month_day_last' does not name a type
  774 | constexpr year_month_day_last& operator+=(const months& m) noexcept;
      |           ^~~~~~~~~~~~~~~~~~~
p1393.cpp:777:11: error: 'year_month_day_last' does not name a type
  777 | constexpr year_month_day_last& operator-=(const months& m) noexcept;
      |           ^~~~~~~~~~~~~~~~~~~
p1393.cpp:780:11: error: 'year_month_day_last' does not name a type
  780 | constexpr year_month_day_last& operator+=(const years& y) noexcept;
      |           ^~~~~~~~~~~~~~~~~~~
p1393.cpp:782:11: error: 'year_month_day_last' does not name a type
  782 | constexpr year_month_day_last& operator-=(const years& y) noexcept;
      |           ^~~~~~~~~~~~~~~~~~~
p1393.cpp:784:19: error: 'year' in namespace 'std::chrono' does not name a type
  784 | constexpr chrono::year year() const noexcept;
      |                   ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:786:19: error: 'month' in namespace 'std::chrono' does not name a type
  786 | constexpr chrono::month month() const noexcept;
      |                   ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:788:19: error: 'month_day_last' in namespace 'std::chrono' does not name a type
  788 | constexpr chrono::month_day_last month_day_last() const noexcept;
      |                   ^~~~~~~~~~~~~~
p1393.cpp:474:20: note: 'constexpr int std::chrono::month_day_last(const int&)' declared here
  474 | constexpr explicit month_day_last(const chrono::month& m) noexcept;
      |                    ^~~~~~~~~~~~~~
p1393.cpp:790:35: error: non-member function 'constexpr std::chrono::day day()' cannot have cv-qualifier
  790 | constexpr chrono::day day() const noexcept;
      |                                   ^~~~~~~~
p1393.cpp:793:20: error: expected type-specifier before 'sys_days'
  793 | constexpr operator sys_days() const noexcept;
      |                    ^~~~~~~~
p1393.cpp:795:29: error: expected type-specifier before 'local_days'
  795 | constexpr explicit operator local_days() const noexcept;
      |                             ^~~~~~~~~~
p1393.cpp:797:27: error: non-member function 'constexpr bool ok()' cannot have cv-qualifier
  797 | constexpr bool ok() const noexcept;
      |                           ^~~~~~~~
p1393.cpp:800:33: error: 'year_month_day_last' does not name a type
  800 | constexpr bool operator==(const year_month_day_last& x, const year_month_day_last& y) noexcept;
      |                                 ^~~~~~~~~~~~~~~~~~~
p1393.cpp:800:63: error: 'year_month_day_last' does not name a type
  800 | constexpr bool operator==(const year_month_day_last& x, const year_month_day_last& y) noexcept;
      |                                                               ^~~~~~~~~~~~~~~~~~~
p1393.cpp:800:16: error: 'constexpr bool operator==(const int&, const int&)' must have an argument of class or enumerated type
  800 | constexpr bool operator==(const year_month_day_last& x, const year_month_day_last& y) noexcept;
      |                ^~~~~~~~
p1393.cpp:802:40: error: 'year_month_day_last' does not name a type
  802 |                                  const year_month_day_last& y) noexcept;
      |                                        ^~~~~~~~~~~~~~~~~~~
p1393.cpp:804:1: error: expected unqualified-id before 'if'
  804 | if (auto c = x.year() <=> y.year(); c != 0) return c;
      | ^~
p1393.cpp:804:37: error: 'c' does not name a type
  804 | if (auto c = x.year() <=> y.year(); c != 0) return c;
      |                                     ^
p1393.cpp:805:3: error: expected unqualified-id before 'return'
  805 |   return x.month_day_last() <=> y.month_day_last();
      |   ^~~~~~
p1393.cpp:806:11: error: 'year_month_day_last' does not name a type
  806 | constexpr year_month_day_last
      |           ^~~~~~~~~~~~~~~~~~~
p1393.cpp:810:17: error: 'months' does not name a type
  810 | operator+(const months& dm, const year_month_day_last& ymdl) noexcept;
      |                 ^~~~~~
p1393.cpp:810:35: error: 'year_month_day_last' does not name a type
  810 | operator+(const months& dm, const year_month_day_last& ymdl) noexcept;
      |                                   ^~~~~~~~~~~~~~~~~~~
p1393.cpp:810:70: error: expected constructor, destructor, or type conversion before ';' token
  810 | operator+(const months& dm, const year_month_day_last& ymdl) noexcept;
      |                                                                      ^
p1393.cpp:813:14: error: 'year_month_day_last' does not name a type
  813 |    constexpr year_month_day_last
      |              ^~~~~~~~~~~~~~~~~~~
p1393.cpp:817:11: error: 'year_month_day_last' does not name a type
  817 | constexpr year_month_day_last
      |           ^~~~~~~~~~~~~~~~~~~
p1393.cpp:820:19: error: 'years' does not name a type
  820 |   operator+(const years& dy, const year_month_day_last& ymdl) noexcept;
      |                   ^~~~~
p1393.cpp:820:36: error: 'year_month_day_last' does not name a type
  820 |   operator+(const years& dy, const year_month_day_last& ymdl) noexcept;
      |                                    ^~~~~~~~~~~~~~~~~~~
p1393.cpp:820:71: error: expected constructor, destructor, or type conversion before ';' token
  820 |   operator+(const years& dy, const year_month_day_last& ymdl) noexcept;
      |                                                                       ^
p1393.cpp:822:11: error: 'year_month_day_last' does not name a type
  822 | constexpr year_month_day_last
      |           ^~~~~~~~~~~~~~~~~~~
p1393.cpp:827:52: error: 'year_month_day_last' does not name a type
  827 | operator<<(basic_ostream<charT, traits>& os, const year_month_day_last& ymdl);
      |                                                    ^~~~~~~~~~~~~~~~~~~
p1393.cpp:829:1: error: expected unqualified-id before 'return'
  829 | return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{:L}"),
      | ^~~~~~
p1393.cpp:859:33: error: expected constructor, destructor, or type conversion before ';' token
  859 | year()            const noexcept;
      |                                 ^
p1393.cpp:860:33: error: expected constructor, destructor, or type conversion before ';' token
  860 | month()           const noexcept;
      |                                 ^
p1393.cpp:861:33: error: expected constructor, destructor, or type conversion before ';' token
  861 | weekday()         const noexcept;
      |                                 ^
p1393.cpp:862:33: error: expected constructor, destructor, or type conversion before ';' token
  862 | index()           const noexcept;
      |                                 ^
p1393.cpp:868:47: error: 'year' in namespace 'std::chrono' does not name a type
  868 |    constexpr year_month_weekday(const chrono::year& y, const chrono::month& m,
      |                                               ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:868:70: error: 'month' in namespace 'std::chrono' does not name a type
  868 |    constexpr year_month_weekday(const chrono::year& y, const chrono::month& m,
      |                                                                      ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:868:14: error: ISO C++ forbids declaration of 'year_month_weekday' with no type [-fpermissive]
  868 |    constexpr year_month_weekday(const chrono::year& y, const chrono::month& m,
      |              ^~~~~~~~~~~~~~~~~~
p1393.cpp:871:36: error: 'sys_days' does not name a type
  871 | constexpr year_month_weekday(const sys_days& dp) noexcept;
      |                                    ^~~~~~~~
p1393.cpp:871:11: error: ISO C++ forbids declaration of 'year_month_weekday' with no type [-fpermissive]
  871 | constexpr year_month_weekday(const sys_days& dp) noexcept;
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:872:45: error: 'local_days' does not name a type
  872 | constexpr explicit year_month_weekday(const local_days& dp) noexcept;
      |                                             ^~~~~~~~~~
p1393.cpp:872:20: error: ISO C++ forbids declaration of 'year_month_weekday' with no type [-fpermissive]
  872 | constexpr explicit year_month_weekday(const local_days& dp) noexcept;
      |                    ^~~~~~~~~~~~~~~~~~
p1393.cpp:872:11: error: 'explicit' outside class declaration
  872 | constexpr explicit year_month_weekday(const local_days& dp) noexcept;
      |           ^~~~~~~~
p1393.cpp:874:11: error: 'year_month_weekday' does not name a type
  874 | constexpr year_month_weekday& operator+=(const months& m) noexcept;
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:877:11: error: 'year_month_weekday' does not name a type
  877 | constexpr year_month_weekday& operator-=(const months& m) noexcept;
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:880:11: error: 'year_month_weekday' does not name a type
  880 | constexpr year_month_weekday& operator+=(const years& y) noexcept;
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:882:11: error: 'year_month_weekday' does not name a type
  882 | constexpr year_month_weekday& operator-=(const years& y) noexcept;
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:884:19: error: 'year' in namespace 'std::chrono' does not name a type
  884 | constexpr chrono::year year() const noexcept;
      |                   ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:886:19: error: 'month' in namespace 'std::chrono' does not name a type
  886 | constexpr chrono::month month() const noexcept;
      |                   ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:888:19: error: 'weekday' in namespace 'std::chrono' does not name a type
  888 | constexpr chrono::weekday weekday() const noexcept;
      |                   ^~~~~~~
p1393.cpp:890:34: error: non-member function 'constexpr unsigned int index()' cannot have cv-qualifier
  890 | constexpr unsigned index() const noexcept;
      |                                  ^~~~~~~~
p1393.cpp:892:59: error: non-member function 'constexpr std::chrono::weekday_indexed weekday_indexed()' cannot have cv-qualifier
  892 | constexpr chrono::weekday_indexed weekday_indexed() const noexcept;
      |                                                           ^~~~~~~~
p1393.cpp:894:20: error: expected type-specifier before 'sys_days'
  894 | constexpr operator sys_days() const noexcept;
      |                    ^~~~~~~~
p1393.cpp:896:29: error: expected type-specifier before 'local_days'
  896 | constexpr explicit operator local_days() const noexcept;
      |                             ^~~~~~~~~~
p1393.cpp:900:33: error: 'year_month_weekday' does not name a type
  900 | constexpr bool operator==(const year_month_weekday& x, const year_month_weekday& y) noexcept;
      |                                 ^~~~~~~~~~~~~~~~~~
p1393.cpp:900:62: error: 'year_month_weekday' does not name a type
  900 | constexpr bool operator==(const year_month_weekday& x, const year_month_weekday& y) noexcept;
      |                                                              ^~~~~~~~~~~~~~~~~~
p1393.cpp:900:16: error: 'constexpr bool operator==(const int&, const int&)' must have an argument of class or enumerated type
  900 | constexpr bool operator==(const year_month_weekday& x, const year_month_weekday& y) noexcept;
      |                ^~~~~~~~
p1393.cpp:902:11: error: 'year_month_weekday' does not name a type
  902 | constexpr year_month_weekday operator+(const year_month_weekday& ymwd, const months& dm) noexcept;
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:905:11: error: 'year_month_weekday' does not name a type
  905 | constexpr year_month_weekday operator+(const months& dm, const year_month_weekday& ymwd) noexcept;
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:908:11: error: 'year_month_weekday' does not name a type
  908 | constexpr year_month_weekday operator-(const year_month_weekday& ymwd, const months& dm) noexcept;
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:911:11: error: 'year_month_weekday' does not name a type
  911 | constexpr year_month_weekday operator+(const year_month_weekday& ymwd, const years& dy) noexcept;
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:913:11: error: 'year_month_weekday' does not name a type
  913 | constexpr year_month_weekday operator+(const years& dy, const year_month_weekday& ymwd) noexcept;
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:915:11: error: 'year_month_weekday' does not name a type
  915 | constexpr year_month_weekday operator-(const year_month_weekday& ymwd, const years& dy) noexcept;
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:919:52: error: 'year_month_weekday' does not name a type
  919 | operator<<(basic_ostream<charT, traits>& os, const year_month_weekday& ymwd);
      |                                                    ^~~~~~~~~~~~~~~~~~
p1393.cpp:921:1: error: expected unqualified-id before 'return'
  921 | return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{:L}/{:L}"), ymwd.year(), ymwd.month(), ymwd.weekday_indexed());
      | ^~~~~~
p1393.cpp:926:9: error: 'year' in namespace 'std::chrono' does not name a type
  926 | chrono::year         y_;
      |         ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:927:9: error: 'month' in namespace 'std::chrono' does not name a type
  927 | chrono::month        m_;
      |         ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:928:9: error: 'weekday_last' in namespace 'std::chrono' does not name a type
  928 | chrono::weekday_last wdl_;
      |         ^~~~~~~~~~~~
p1393.cpp:931:51: error: 'year' in namespace 'std::chrono' does not name a type
  931 |   constexpr year_month_weekday_last(const chrono::year& y, const chrono::month& m,
      |                                                   ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:931:74: error: 'month' in namespace 'std::chrono' does not name a type
  931 |   constexpr year_month_weekday_last(const chrono::year& y, const chrono::month& m,
      |                                                                          ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:932:15: error: 'weekday_last' in namespace 'std::chrono' does not name a type
  932 | const chrono::weekday_last& wdl) noexcept;
      |               ^~~~~~~~~~~~
p1393.cpp:935:53: error: 'months' does not name a type; did you mean 'month'?
  935 | constexpr year_month_weekday_last& operator+=(const months& m) noexcept;
      |                                                     ^~~~~~
      |                                                     month
p1393.cpp:936:53: error: 'months' does not name a type; did you mean 'month'?
  936 | constexpr year_month_weekday_last& operator-=(const months& m) noexcept;
      |                                                     ^~~~~~
      |                                                     month
p1393.cpp:937:53: error: 'years' does not name a type; did you mean 'year'?
  937 | constexpr year_month_weekday_last& operator+=(const years& y)  noexcept;
      |                                                     ^~~~~
      |                                                     year
p1393.cpp:937:36: error: 'constexpr std::chrono::year_month_weekday_last& std::chrono::year_month_weekday_last::operator+=(const int&)' cannot be overloaded with 'constexpr std::chrono::year_month_weekday_last& std::chrono::year_month_weekday_last::operator+=(const int&)'
  937 | constexpr year_month_weekday_last& operator+=(const years& y)  noexcept;
      |                                    ^~~~~~~~
p1393.cpp:935:36: note: previous declaration 'constexpr std::chrono::year_month_weekday_last& std::chrono::year_month_weekday_last::operator+=(const int&)'
  935 | constexpr year_month_weekday_last& operator+=(const months& m) noexcept;
      |                                    ^~~~~~~~
p1393.cpp:938:53: error: 'years' does not name a type; did you mean 'year'?
  938 | constexpr year_month_weekday_last& operator-=(const years& y)  noexcept;
      |                                                     ^~~~~
      |                                                     year
p1393.cpp:938:36: error: 'constexpr std::chrono::year_month_weekday_last& std::chrono::year_month_weekday_last::operator-=(const int&)' cannot be overloaded with 'constexpr std::chrono::year_month_weekday_last& std::chrono::year_month_weekday_last::operator-=(const int&)'
  938 | constexpr year_month_weekday_last& operator-=(const years& y)  noexcept;
      |                                    ^~~~~~~~
p1393.cpp:936:36: note: previous declaration 'constexpr std::chrono::year_month_weekday_last& std::chrono::year_month_weekday_last::operator-=(const int&)'
  936 | constexpr year_month_weekday_last& operator-=(const months& m) noexcept;
      |                                    ^~~~~~~~
p1393.cpp:939:28: error: 'year' in namespace 'std::chrono' does not name a type
  939 |          constexpr chrono::year         year()
      |                            ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:943:38: error: expected type-specifier before 'sys_days'
  943 |          constexpr          operator sys_days()   const noexcept;
      |                                      ^~~~~~~~
p1393.cpp:944:38: error: expected type-specifier before 'local_days'
  944 |          constexpr explicit operator local_days() const noexcept;
      |                                      ^~~~~~~~~~
p1393.cpp:951:52: error: 'year' in namespace 'std::chrono' does not name a type
  951 |    constexpr year_month_weekday_last(const chrono::year& y, const chrono::month& m,
      |                                                    ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:951:75: error: 'month' in namespace 'std::chrono' does not name a type
  951 |    constexpr year_month_weekday_last(const chrono::year& y, const chrono::month& m,
      |                                                                           ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:952:52: error: 'weekday_last' in namespace 'std::chrono' does not name a type
  952 |                                      const chrono::weekday_last& wdl) noexcept;
      |                                                    ^~~~~~~~~~~~
p1393.cpp:951:14: error: ISO C++ forbids declaration of 'year_month_weekday_last' with no type [-fpermissive]
  951 |    constexpr year_month_weekday_last(const chrono::year& y, const chrono::month& m,
      |              ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:954:11: error: 'year_month_weekday_last' does not name a type
  954 | constexpr year_month_weekday_last& operator+=(const months& m) noexcept;
      |           ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:955:11: error: 'year_month_weekday_last' does not name a type
  955 | constexpr year_month_weekday_last& operator-=(const months& m) noexcept;
      |           ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:956:7: error: expected unqualified-id before 'noexcept'
  956 | const noexcept;
      |       ^~~~~~~~
p1393.cpp:957:7: error: expected unqualified-id before 'noexcept'
  957 | const noexcept;
      |       ^~~~~~~~
p1393.cpp:958:7: error: expected unqualified-id before 'noexcept'
  958 | const noexcept;
      |       ^~~~~~~~
p1393.cpp:961:11: error: 'year_month_weekday_last' does not name a type
  961 | constexpr year_month_weekday_last& operator+=(const years& y) noexcept;
      |           ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:963:11: error: 'year_month_weekday_last' does not name a type
  963 | constexpr year_month_weekday_last& operator-=(const years& y) noexcept;
      |           ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:965:19: error: 'year' in namespace 'std::chrono' does not name a type
  965 | constexpr chrono::year year() const noexcept;
      |                   ^~~~
p1393.cpp:171:22: note: 'constexpr int std::chrono::year(int)' declared here
  171 |   constexpr explicit year(int y) noexcept;
      |                      ^~~~
p1393.cpp:967:19: error: 'month' in namespace 'std::chrono' does not name a type
  967 | constexpr chrono::month month() const noexcept;
      |                   ^~~~~
p1393.cpp:100:22: note: 'constexpr int std::chrono::month(unsigned int)' declared here
  100 |   constexpr explicit month(unsigned m) noexcept;
      |                      ^~~~~
p1393.cpp:969:19: error: 'weekday' in namespace 'std::chrono' does not name a type
  969 | constexpr chrono::weekday weekday() const noexcept;
      |                   ^~~~~~~
p1393.cpp:971:19: error: 'weekday_last' in namespace 'std::chrono' does not name a type
  971 | constexpr chrono::weekday_last weekday_last() const noexcept;
      |                   ^~~~~~~~~~~~
p1393.cpp:973:20: error: expected type-specifier before 'sys_days'
  973 | constexpr operator sys_days() const noexcept;
      |                    ^~~~~~~~
p1393.cpp:975:29: error: expected type-specifier before 'local_days'
  975 | constexpr explicit operator local_days() const noexcept;
      |                             ^~~~~~~~~~
p1393.cpp:979:28: error: 'year_month_weekday_last' does not name a type
  979 |                      const year_month_weekday_last& y) noexcept;
      |                            ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:981:11: error: 'year_month_weekday_last' does not name a type
  981 | constexpr year_month_weekday_last
      |           ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:985:11: error: 'year_month_weekday_last' does not name a type
  985 | constexpr year_month_weekday_last
      |           ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:989:11: error: 'year_month_weekday_last' does not name a type
  989 | constexpr year_month_weekday_last
      |           ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:993:11: error: 'year_month_weekday_last' does not name a type
  993 | constexpr year_month_weekday_last
      |           ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:996:11: error: 'year_month_weekday_last' does not name a type
  996 | constexpr year_month_weekday_last
      |           ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:999:11: error: 'year_month_weekday_last' does not name a type
  999 | constexpr year_month_weekday_last
      |           ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:1004:52: error: 'year_month_weekday_last' does not name a type
 1004 | operator<<(basic_ostream<charT, traits>& os, const year_month_weekday_last& ymwdl);
      |                                                    ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:1006:1: error: expected unqualified-id before 'return'
 1006 | return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{:L}/{:L}"), ymwdl.year(), ymwdl.month(), ymwdl.weekday_last());
      | ^~~~~~
p1393.cpp:1008:11: error: 'year_month' does not name a type
 1008 | constexpr year_month
      |           ^~~~~~~~~~
p1393.cpp:1014:6: error: 'year_month' does not name a type
 1014 |      year_month ym = 2015y/April;
      |      ^~~~~~~~~~
p1393.cpp:1015:6: error: 'month_day' does not name a type
 1015 |      month_day md1 = April/4;
      |      ^~~~~~~~~
p1393.cpp:1016:6: error: 'month_day' does not name a type
 1016 |      month_day md2 = 4d/April;
      |      ^~~~~~~~~
p1393.cpp:1019:10: error: unable to find numeric literal operator 'operator""y'
 1019 | auto b = 2015y/4/4;
      |          ^~~~~
p1393.cpp:1019:10: note: use '-fext-numeric-literals' to enable more built-in suffixes
p1393.cpp:1020:10: error: unable to find numeric literal operator 'operator""y'
 1020 | auto c = 2015y/4d/April;
      |          ^~~~~
p1393.cpp:1020:10: note: use '-fext-numeric-literals' to enable more built-in suffixes
p1393.cpp:1020:19: error: 'April' was not declared in this scope
 1020 | auto c = 2015y/4d/April;
      |                   ^~~~~
p1393.cpp:1021:15: error: 'April' was not declared in this scope
 1021 | auto d = 2015/April/4;
      |               ^~~~~
p1393.cpp:1026:11: error: 'year_month' does not name a type
 1026 | constexpr year_month
      |           ^~~~~~~~~~
p1393.cpp:1029:11: error: 'month_day' does not name a type
 1029 | constexpr month_day
      |           ^~~~~~~~~
p1393.cpp:1032:11: error: 'month_day' does not name a type
 1032 | constexpr month_day
      |           ^~~~~~~~~
p1393.cpp:1035:11: error: 'month_day' does not name a type
 1035 | constexpr month_day
      |           ^~~~~~~~~
p1393.cpp:1038:11: error: 'month_day' does not name a type
 1038 | constexpr month_day
      |           ^~~~~~~~~
p1393.cpp:1041:11: error: 'month_day' does not name a type
 1041 | constexpr month_day
      |           ^~~~~~~~~
p1393.cpp:1044:11: error: 'month_day_last' does not name a type
 1044 | constexpr month_day_last
      |           ^~~~~~~~~~~~~~
p1393.cpp:1047:11: error: 'month_day_last' does not name a type
 1047 | constexpr month_day_last
      |           ^~~~~~~~~~~~~~
p1393.cpp:1050:11: error: 'month_day_last' does not name a type
 1050 | constexpr month_day_last
      |           ^~~~~~~~~~~~~~
p1393.cpp:1053:11: error: 'month_day_last' does not name a type
 1053 | constexpr month_day_last
      |           ^~~~~~~~~~~~~~
p1393.cpp:1056:11: error: 'month_weekday' does not name a type
 1056 | constexpr month_weekday
      |           ^~~~~~~~~~~~~
p1393.cpp:1059:11: error: 'month_weekday' does not name a type
 1059 | constexpr month_weekday
      |           ^~~~~~~~~~~~~
p1393.cpp:1062:11: error: 'month_weekday' does not name a type
 1062 | constexpr month_weekday
      |           ^~~~~~~~~~~~~
p1393.cpp:1065:11: error: 'month_weekday' does not name a type
 1065 | constexpr month_weekday
      |           ^~~~~~~~~~~~~
p1393.cpp:1068:11: error: 'month_weekday_last' does not name a type
 1068 | constexpr month_weekday_last
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:1071:11: error: 'month_weekday_last' does not name a type
 1071 | constexpr month_weekday_last
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:1074:11: error: 'month_weekday_last' does not name a type
 1074 | constexpr month_weekday_last
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:1077:11: error: 'month_weekday_last' does not name a type
 1077 | constexpr month_weekday_last
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:1080:11: error: 'year_month_day' does not name a type
 1080 | constexpr year_month_day
      |           ^~~~~~~~~~~~~~
p1393.cpp:1083:11: error: 'year_month_day' does not name a type
 1083 | constexpr year_month_day
      |           ^~~~~~~~~~~~~~
p1393.cpp:1086:11: error: 'year_month_day' does not name a type
 1086 | constexpr year_month_day
      |           ^~~~~~~~~~~~~~
p1393.cpp:1089:11: error: 'year_month_day' does not name a type
 1089 | constexpr year_month_day
      |           ^~~~~~~~~~~~~~
p1393.cpp:1092:11: error: 'year_month_day' does not name a type
 1092 | constexpr year_month_day
      |           ^~~~~~~~~~~~~~
p1393.cpp:1095:11: error: 'year_month_day' does not name a type
 1095 | constexpr year_month_day
      |           ^~~~~~~~~~~~~~
p1393.cpp:1098:11: error: 'year_month_day_last' does not name a type
 1098 | constexpr year_month_day_last
      |           ^~~~~~~~~~~~~~~~~~~
p1393.cpp:1101:11: error: 'year_month_day_last' does not name a type
 1101 | constexpr year_month_day_last
      |           ^~~~~~~~~~~~~~~~~~~
p1393.cpp:1104:11: error: 'year_month_day_last' does not name a type
 1104 | constexpr year_month_day_last
      |           ^~~~~~~~~~~~~~~~~~~
p1393.cpp:1107:11: error: 'year_month_day_last' does not name a type
 1107 | constexpr year_month_day_last
      |           ^~~~~~~~~~~~~~~~~~~
p1393.cpp:1110:11: error: 'year_month_day_last' does not name a type
 1110 | constexpr year_month_day_last
      |           ^~~~~~~~~~~~~~~~~~~
p1393.cpp:1113:11: error: 'year_month_weekday' does not name a type
 1113 | constexpr year_month_weekday
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:1116:11: error: 'year_month_weekday' does not name a type
 1116 | constexpr year_month_weekday
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:1119:11: error: 'year_month_weekday' does not name a type
 1119 | constexpr year_month_weekday
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:1122:11: error: 'year_month_weekday' does not name a type
 1122 | constexpr year_month_weekday
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:1125:11: error: 'year_month_weekday' does not name a type
 1125 | constexpr year_month_weekday
      |           ^~~~~~~~~~~~~~~~~~
p1393.cpp:1128:11: error: 'year_month_weekday_last' does not name a type
 1128 | constexpr year_month_weekday_last
      |           ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:1131:11: error: 'year_month_weekday_last' does not name a type
 1131 | constexpr year_month_weekday_last
      |           ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:1134:11: error: 'year_month_weekday_last' does not name a type
 1134 | constexpr year_month_weekday_last
      |           ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:1137:11: error: 'year_month_weekday_last' does not name a type
 1137 | constexpr year_month_weekday_last
      |           ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:1140:11: error: 'year_month_weekday_last' does not name a type
 1140 | constexpr year_month_weekday_last
      |           ^~~~~~~~~~~~~~~~~~~~~~~
p1393.cpp:90:23: warning: inline function 'constexpr std::chrono::day operator""d(long long unsigned int)' used but never defined
   90 | constexpr chrono::day operator""d(unsigned long long d) noexcept;
      |                       ^~~~~~~~

```

# 検討事項(agenda)
コンパイルエラーを取るか、コンパイルエラーの理由を解説する。

<!-- リンクエラーの解説をする。clang++とg++の比較。意味のある出力。
コンパイルエラーを取るか、コンパイルエラーの理由を解説する。-->

## 応用例1　AUTOSAR C++

AUTOSARでC++のコーディング標準を作っている。　
MISRA-C++コーディング標準の改訂をまたずに、C++14に対応したかったためかもしれない。　


Autosar Guidelines C++14 example code compile list


https://qiita.com/kaizen_nagoya/items/8ccbf6675c3494d57a76

MISRA C++, AUTOSAR C++について

https://qiita.com/kaizen_nagoya/items/3436fbd49865e0da7d35

## 応用例2　MISRA C/C++

MISRA C まとめ #include <misra_c.h>

https://qiita.com/kaizen_nagoya/items/f1a79a7cbd281607c7c9

MISRA C++ 5-0-16

https://qiita.com/kaizen_nagoya/items/7df2d4e05db724752a74

## 応用例3 CERT C/C++

SEI CERT C++ Coding Standard AA. Bibliography 確認中。

https://qiita.com/kaizen_nagoya/items/fe06719aef10f3f985ae

MISRA C/C++, AUTOSAR C++, CERT C/C++とC/C++工業標準をコンパイルする

https://qiita.com/kaizen_nagoya/items/8dff19511e42b2593db1

## 応用例4 箱庭　

箱庭ではUnityをはじめC++を使っているらしい。　

ここでコンパイルしたコードと同じようなコードを使っているか、
ここで出たコンパイルエラーと同じようなエラーがでたかを
いろいろな版のコンパイラでコンパイルして確認していく。

仮想戦略会議「箱庭」

https://qiita.com/kaizen_nagoya/items/73cb132707653176a461

お盆には「箱庭」記事を書きましょう「もくもく会」の題材になる（１）

https://qiita.com/kaizen_nagoya/items/a22bf2b1dab0ad3258d4

お盆には「箱庭」記事を書きましょう「もくもく会」の題材になる（2）

https://qiita.com/kaizen_nagoya/items/e3c0ceb2dcc9cf3f3fac


# 参考資料(reference)

エンジニア夏休み企画 個人開発

https://qiita.com/official-events/6d31965c499a69377c0b


## 自己参考資料(self reference)

関連する自己参照以外は、こちらの先頭に移転。

C言語（C++)に対する誤解、曲解、無理解、爽快。

https://qiita.com/kaizen_nagoya/items/3f3992c9722c1cee2e3a

#include "N4910.h"

https://qiita.com/kaizen_nagoya/items/163a47cef7d6bb1c33a8

C++N4910資料の改善点

https://qiita.com/kaizen_nagoya/items/fb4ceb5d117a54641af3

dockerにclang

https://qiita.com/kaizen_nagoya/items/8829ffeee397eda50e80

docker gnu(gcc/g++) and llvm(clang/clang++)

https://qiita.com/kaizen_nagoya/items/059874ea39c4de64c0f7

コンパイル用shell script C版(clangとgcc)とC++版(clang++とg++)

https://qiita.com/kaizen_nagoya/items/74220c0577a512c2d7da


C++N4910:2022 tag follower 300人超えました。ありがとうございます。

https://qiita.com/kaizen_nagoya/items/a63fb96d351ac5c16ff7

astyle 使ってみた

https://qiita.com/kaizen_nagoya/items/3c9a87a781d53a1a23f3

【個人開発】　効率的な背景　＜エンジニア夏休み企画＞

https://qiita.com/kaizen_nagoya/items/3ebab436e63731e4b885

 ＜この記事は個人の過去の経験に基づく個人の感想です。現在所属する組織、業務とは関係がありません。＞

# 文書履歴(document history)
ver. 0.01 初稿 　20220820