# Symbol

UnqualifiedName: __FIIterable_1_Windows__CWeb__CHttp__CHeaders__CHttpExpectationHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIIterable_1_Windows__CWeb__CHttp__CHeaders__CHttpExpectationHeaderValue_t


UnqualifiedName: __FIIterator_1_Windows__CWeb__CHttp__CHeaders__CHttpLanguageRangeWithQualityHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIIterator_1_Windows__CWeb__CHttp__CHeaders__CHttpLanguageRangeWithQualityHeaderValue_t


UnqualifiedName: __FIIterable_1_Windows__CWeb__CHttp__CHeaders__CHttpLanguageRangeWithQualityHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIIterable_1_Windows__CWeb__CHttp__CHeaders__CHttpLanguageRangeWithQualityHeaderValue_t


UnqualifiedName: __FIIterator_1_Windows__CWeb__CHttp__CHeaders__CHttpMediaTypeWithQualityHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIIterator_1_Windows__CWeb__CHttp__CHeaders__CHttpMediaTypeWithQualityHeaderValue_t


UnqualifiedName: __FIIterable_1_Windows__CWeb__CHttp__CHeaders__CHttpMediaTypeWithQualityHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIIterable_1_Windows__CWeb__CHttp__CHeaders__CHttpMediaTypeWithQualityHeaderValue_t


UnqualifiedName: __FIIterator_1_Windows__CWeb__CHttp__CHeaders__CHttpNameValueHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIIterator_1_Windows__CWeb__CHttp__CHeaders__CHttpNameValueHeaderValue_t


UnqualifiedName: __FIIterable_1_Windows__CWeb__CHttp__CHeaders__CHttpNameValueHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIIterable_1_Windows__CWeb__CHttp__CHeaders__CHttpNameValueHeaderValue_t


UnqualifiedName: __FIIterator_1_Windows__CWeb__CHttp__CHeaders__CHttpProductInfoHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIIterator_1_Windows__CWeb__CHttp__CHeaders__CHttpProductInfoHeaderValue_t


UnqualifiedName: __FIIterable_1_Windows__CWeb__CHttp__CHeaders__CHttpProductInfoHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIIterable_1_Windows__CWeb__CHttp__CHeaders__CHttpProductInfoHeaderValue_t


UnqualifiedName: __FIIterator_1_Windows__CWeb__CHttp__CHeaders__CHttpTransferCodingHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIIterator_1_Windows__CWeb__CHttp__CHeaders__CHttpTransferCodingHeaderValue_t


UnqualifiedName: __FIIterable_1_Windows__CWeb__CHttp__CHeaders__CHttpTransferCodingHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIIterable_1_Windows__CWeb__CHttp__CHeaders__CHttpTransferCodingHeaderValue_t


UnqualifiedName: __FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpChallengeHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpChallengeHeaderValue_t


UnqualifiedName: __FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpConnectionOptionHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpConnectionOptionHeaderValue_t


UnqualifiedName: __FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpContentCodingHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpContentCodingHeaderValue_t


UnqualifiedName: __FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpContentCodingWithQualityHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpContentCodingWithQualityHeaderValue_t


UnqualifiedName: __FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpCookiePairHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpCookiePairHeaderValue_t


UnqualifiedName: __FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpExpectationHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpExpectationHeaderValue_t


UnqualifiedName: __FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpLanguageRangeWithQualityHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpLanguageRangeWithQualityHeaderValue_t


UnqualifiedName: __FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpMediaTypeWithQualityHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpMediaTypeWithQualityHeaderValue_t


UnqualifiedName: __FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpNameValueHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpNameValueHeaderValue_t


UnqualifiedName: __FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpProductInfoHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpProductInfoHeaderValue_t


UnqualifiedName: __FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpTransferCodingHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVectorView_1_Windows__CWeb__CHttp__CHeaders__CHttpTransferCodingHeaderValue_t


UnqualifiedName: __FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpChallengeHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpChallengeHeaderValue_t


UnqualifiedName: __FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpConnectionOptionHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpConnectionOptionHeaderValue_t


UnqualifiedName: __FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpContentCodingHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpContentCodingHeaderValue_t


UnqualifiedName: __FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpContentCodingWithQualityHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpContentCodingWithQualityHeaderValue_t


UnqualifiedName: __FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpCookiePairHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpCookiePairHeaderValue_t


UnqualifiedName: __FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpExpectationHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpExpectationHeaderValue_t


UnqualifiedName: __FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpLanguageRangeWithQualityHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpLanguageRangeWithQualityHeaderValue_t


UnqualifiedName: __FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpMediaTypeWithQualityHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpMediaTypeWithQualityHeaderValue_t


UnqualifiedName: __FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpNameValueHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpNameValueHeaderValue_t


UnqualifiedName: __FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpProductInfoHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpProductInfoHeaderValue_t


UnqualifiedName: __FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpTransferCodingHeaderValue_t
FullyQualifiedName:
ABI::Windows::Foundation::Collections::__FIVector_1_Windows__CWeb__CHttp__CHeaders__CHttpTransferCodingHeaderValue_t


UnqualifiedName: is_detected_impl<typename VoidTImpl<Op<Args...>>::type, Op, Args...>
FullyQualifiedName:
absl::namespace type_traits_internal::is_detected_impl<typename VoidTImpl<Op<Args...>>::type, Op, Args...>


UnqualifiedName: type
FullyQualifiedName:
absl::namespace type_traits_internal::is_detected_impl<typename VoidTImpl<Op<Args...>>::type, Op, Args...>::type


FullyQualifiedName:
absl::namespace type_traits_internal::is_detected_convertible_impl<
    typename std::enable_if<std::is_convertible<Op<Args...>, To>::value>::type,
    To, Op, Args...>

UnqualifiedName:
is_detected_convertible_impl<
    typename std::enable_if<std::is_convertible<Op<Args...>, To>::value>::type,
    To, Op, Args...>


UnqualifiedName: type
FullyQualifiedName:
absl::namespace type_traits_internal::is_detected_convertible_impl<
    typename std::enable_if<std::is_convertible<Op<Args...>, To>::value>::type,
    To, Op, Args...>::type


FullyQualifiedName:
absl::type_traits_internal::IsHashable<
    Key,
    absl::enable_if_t<std::is_convertible<
        decltype(std::declval<std::hash<Key>&>()(std::declval<Key const&>())),
        std::size_t>::value>>

UnqualifiedName:
IsHashable<
    Key,
    absl::enable_if_t<std::is_convertible<
        decltype(std::declval<std::hash<Key>&>()(std::declval<Key const&>())),
        std::size_t>::value>>


UnqualifiedName: IsOwnerImpl< T, std::enable_if_t<std::is_class<typename T::absl_internal_is_view>::value>>
FullyQualifiedName:
absl::type_traits_internal::IsOwnerImpl<
    T,
    std::enable_if_t<std::is_class<typename T::absl_internal_is_view>::value>>


UnqualifiedName: IsViewImpl< T, std::enable_if_t<std::is_class<typename T::absl_internal_is_view>::value>>
FullyQualifiedName:
absl::type_traits_internal::IsViewImpl<
    T,
    std::enable_if_t<std::is_class<typename T::absl_internal_is_view>::value>>


FullyQualifiedName:
template <typename H>
  friend H AbslHashValue(H h, Time t) {
    return H::combine(std::move(h), t.rep_);
  }

 private:
  friend constexpr Time time_internal::FromUnixDuration(Duration d);
  friend constexpr Duration time_internal::ToUnixDuration(Time t);

#ifdef ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON
  friend constexpr std::strong_ordering operator<=>(Time lhs, Time rhs);
#endif  // ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON

  friend constexpr bool operator<(Time lhs, Time rhs);
  friend constexpr bool operator==(Time lhs, Time rhs);
  friend Duration operator-(Time lhs, Time rhs);
  friend constexpr Time UniversalEpoch();
  friend constexpr Time InfiniteFuture();
  friend constexpr Time InfinitePast();
  constexpr explicit Time(Duration rep) : rep_(rep) {}
  Duration rep_;
};

// Relational Operators
#ifdef ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON

ABSL_ATTRIBUTE_CONST_FUNCTION constexpr std::strong_ordering operator<=>(
    Time lhs, Time rhs) {
  return lhs.rep_ <=> rhs.rep_;
}

#endif  // ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON

ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool operator<(Time lhs, Time rhs) {
  return lhs.rep_ < rhs.rep_;
}
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool operator>(Time lhs, Time rhs) {
  return rhs < lhs;
}
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool operator>=(Time lhs, Time rhs) {
  return !(lhs < rhs);
}
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool operator<=(Time lhs, Time rhs) {
  return !(rhs < lhs);
}
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool operator==(Time lhs, Time rhs) {
  return lhs.rep_ == rhs.rep_;
}
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool operator!=(Time lhs, Time rhs) {
  return !(lhs == rhs);
}

// Additive Operators
ABSL_ATTRIBUTE_CONST_FUNCTION inline Time operator+(Time lhs, Duration rhs) {
  return lhs += rhs;
}
ABSL_ATTRIBUTE_CONST_FUNCTION inline Time operator+(Duration lhs, Time rhs) {
  return rhs += lhs;
}
ABSL_ATTRIBUTE_CONST_FUNCTION inline Time operator-(Time lhs, Duration rhs) {
  return lhs -= rhs;
}
ABSL_ATTRIBUTE_CONST_FUNCTION inline Duration operator-(Time lhs, Time rhs) {
  return lhs.rep_ - rhs.rep_;
}

// UnixEpoch()
//
// Returns the `absl::Time` representing "1970-01-01 00:00:00.0 +0000".
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time UnixEpoch() { return Time(); }

// UniversalEpoch()
//
// Returns the `absl::Time` representing "0001-01-01 00:00:00.0 +0000", the
// epoch of the ICU Universal Time Scale.
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time UniversalEpoch() {
  // 719162 is the number of days from 0001-01-01 to 1970-01-01,
  // assuming the Gregorian calendar.
  return Time(
      time_internal::MakeDuration(-24 * 719162 * int64_t{3600}, uint32_t{0}));
}

// InfiniteFuture()
//
// Returns an `absl::Time` that is infinitely far in the future.
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time InfiniteFuture() {
  return Time(time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(),
                                          ~uint32_t{0}));
}

// InfinitePast()
//
// Returns an `absl::Time` that is infinitely far in the past.
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time InfinitePast() {
  return Time(time_internal::MakeDuration((std::numeric_limits<int64_t>::min)(),
                                          ~uint32_t{0}));
}

// FromUnixNanos()
// FromUnixMicros()
// FromUnixMillis()
// FromUnixSeconds()
// FromTimeT()
// FromUDate()
// FromUniversal()
//
// Creates an `absl::Time` from a variety of other representations.  See
// https://unicode-org.github.io/icu/userguide/datetime/universaltimescale.html
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time FromUnixNanos(int64_t ns);
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time FromUnixMicros(int64_t us);
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time FromUnixMillis(int64_t ms);
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time FromUnixSeconds(int64_t s);
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time FromTimeT(time_t t);
ABSL_ATTRIBUTE_CONST_FUNCTION Time FromUDate(double udate);
ABSL_ATTRIBUTE_CONST_FUNCTION Time FromUniversal(int64_t universal);

// ToUnixNanos()
// ToUnixMicros()
// ToUnixMillis()
// ToUnixSeconds()
// ToTimeT()
// ToUDate()
// ToUniversal()
//
// Converts an `absl::Time` to a variety of other representations.  See
// https://unicode-org.github.io/icu/userguide/datetime/universaltimescale.html
//
// Note that these operations round down toward negative infinity where
// necessary to adjust to the resolution of the result type.  Beware of
// possible time_t over/underflow in ToTime{T,val,spec}() on 32-bit platforms.
ABSL_ATTRIBUTE_CONST_FUNCTION int64_t ToUnixNanos(Time t);
ABSL_ATTRIBUTE_CONST_FUNCTION int64_t ToUnixMicros(Time t);
ABSL_ATTRIBUTE_CONST_FUNCTION int64_t ToUnixMillis(Time t);
ABSL_ATTRIBUTE_CONST_FUNCTION int64_t ToUnixSeconds(Time t);
ABSL_ATTRIBUTE_CONST_FUNCTION time_t ToTimeT(Time t);
ABSL_ATTRIBUTE_CONST_FUNCTION double ToUDate(Time t);
ABSL_ATTRIBUTE_CONST_FUNCTION int64_t ToUniversal(Time t);

// DurationFromTimespec()
// DurationFromTimeval()
// ToTimespec()
// ToTimeval()
// TimeFromTimespec()
// TimeFromTimeval()
// ToTimespec()
// ToTimeval()
//
// Some APIs use a timespec or a timeval as a Duration (e.g., nanosleep(2)
// and select(2)), while others use them as a Time (e.g. clock_gettime(2)
// and gettimeofday(2)), so conversion functions are provided for both cases.
// The "to timespec/val" direction is easily handled via overloading, but
// for "from timespec/val" the desired type is part of the function name.
ABSL_ATTRIBUTE_CONST_FUNCTION Duration DurationFromTimespec(timespec ts);
ABSL_ATTRIBUTE_CONST_FUNCTION Duration DurationFromTimeval(timeval tv);
ABSL_ATTRIBUTE_CONST_FUNCTION timespec ToTimespec(Duration d);
ABSL_ATTRIBUTE_CONST_FUNCTION timeval ToTimeval(Duration d);
ABSL_ATTRIBUTE_CONST_FUNCTION Time TimeFromTimespec(timespec ts);
ABSL_ATTRIBUTE_CONST_FUNCTION Time TimeFromTimeval(timeval tv);
ABSL_ATTRIBUTE_CONST_FUNCTION timespec ToTimespec(Time t);
ABSL_ATTRIBUTE_CONST_FUNCTION timeval ToTimeval(Time t);

// FromChrono()
//
// Converts a std::chrono::system_clock::time_point to an absl::Time.
//
// Example:
//
//   auto tp = std::chrono::system_clock::from_time_t(123);
//   absl::Time t = absl::FromChrono(tp);
//   // t == absl::FromTimeT(123)
ABSL_ATTRIBUTE_PURE_FUNCTION Time
FromChrono(const std::chrono::system_clock::time_point& tp);

// ToChronoTime()
//
// Converts an absl::Time to a std::chrono::system_clock::time_point. If
// overflow would occur, the returned value will saturate at the min/max time
// point value instead.
//
// Example:
//
//   absl::Time t = absl::FromTimeT(123);
//   auto tp = absl::ToChronoTime(t);
//   // tp == std::chrono::system_clock::from_time_t(123);
ABSL_ATTRIBUTE_CONST_FUNCTION std::chrono::system_clock::time_point
    ToChronoTime(Time);

// AbslParseFlag()
//
// Parses the command-line flag string representation `text` into a Time value.
// Time flags must be specified in a format that matches absl::RFC3339_full.
//
// For example:
//
//   --start_time=2016-01-02T03:04:05.678+08:00
//
// Note: A UTC offset (or 'Z' indicating a zero-offset from UTC) is required.
//
// Additionally, if you'd like to specify a time as a count of
// seconds/milliseconds/etc from the Unix epoch, use an absl::Duration flag
// and add that duration to absl::UnixEpoch() to get an absl::Time.
bool AbslParseFlag(absl::string_view text, Time* t, std::string* error);

// AbslUnparseFlag()
//
// Unparses a Time value into a command-line string representation using
// the format specified by `absl::ParseTime()`.
std::string AbslUnparseFlag(Time t);

ABSL_DEPRECATED("Use AbslParseFlag() instead.")
bool ParseFlag(const std::string& text, Time* t, std::string* error);
ABSL_DEPRECATED("Use AbslUnparseFlag() instead.")
std::string UnparseFlag(Time t);

// TimeZone
//
// The `absl::TimeZone` is an opaque, small, value-type class representing a
// geo-political region within which particular rules are used for converting
// between absolute and civil times (see https://git.io/v59Ly). `absl::TimeZone`
// values are named using the TZ identifiers from the IANA Time Zone Database,
// such as "America/Los_Angeles" or "Australia/Sydney". `absl::TimeZone` values
// are created from factory functions such as `absl::LoadTimeZone()`. Note:
// strings like "PST" and "EDT" are not valid TZ identifiers. Prefer to pass by
// value rather than const reference.
//
// For more on the fundamental concepts of time zones, absolute times, and civil
// times, see https://github.com/google/cctz#fundamental-concepts
//
// Examples:
//
//   absl::TimeZone utc = absl::UTCTimeZone();
//   absl::TimeZone pst = absl::FixedTimeZone(-8 * 60 * 60);
//   absl::TimeZone loc = absl::LocalTimeZone();
//   absl::TimeZone lax;
//   if (!absl::LoadTimeZone("America/Los_Angeles", &lax)) {
//     // handle error case
//   }
//
// See also:
// - https://github.com/google/cctz
// - https://www.iana.org/time-zones
// - https://en.wikipedia.org/wiki/Zoneinfo
class TimeZone {
 public:
  explicit TimeZone(time_internal::cctz::time_zone tz) : cz_(tz) {}
  TimeZone() = default;  // UTC, but prefer UTCTimeZone() to be explicit.

  // Copyable.
  TimeZone(const TimeZone&) = default;
  TimeZone& operator=(const TimeZone&) = default;

  explicit operator time_internal::cctz::time_zone() const { return cz_; }

  std::string name() const { return cz_.name(); }

  // TimeZone::CivilInfo
  //
  // Information about the civil time corresponding to an absolute time.
  // This struct is not intended to represent an instant in time. So, rather
  // than passing a `TimeZone::CivilInfo` to a function, pass an `absl::Time`
  // and an `absl::TimeZone`.
  struct CivilInfo {
    CivilSecond cs;
    Duration subsecond;

    // Note: The following fields exist for backward compatibility
    // with older APIs.  Accessing these fields directly is a sign of
    // imprudent logic in the calling code.  Modern time-related code
    // should only access this data indirectly by way of FormatTime().
    // These fields are undefined for InfiniteFuture() and InfinitePast().
    int offset;             // seconds east of UTC
    bool is_dst;            // is offset non-standard?
    const char* zone_abbr;  // time-zone abbreviation (e.g., "PST")
  };

  // TimeZone::At(Time)
  //
  // Returns the civil time for this TimeZone at a certain `absl::Time`.
  // If the input time is infinite, the output civil second will be set to
  // CivilSecond::max() or min(), and the subsecond will be infinite.
  //
  // Example:
  //
  //   const auto epoch = lax.At(absl::UnixEpoch());
  //   // epoch.cs == 1969-12-31 16:00:00
  //   // epoch.subsecond == absl::ZeroDuration()
  //   // epoch.offset == -28800
  //   // epoch.is_dst == false
  //   // epoch.abbr == "PST"
  CivilInfo At(Time t) const;

  // TimeZone::TimeInfo
  //
  // Information about the absolute times corresponding to a civil time.
  // (Subseconds must be handled separately.)
  //
  // It is possible for a caller to pass a civil-time value that does
  // not represent an actual or unique instant in time (due to a shift
  // in UTC offset in the TimeZone, which results in a discontinuity in
  // the civil-time components). For example, a daylight-saving-time
  // transition skips or repeats civil times---in the United States,
  // March 13, 2011 02:15 never occurred, while November 6, 2011 01:15
  // occurred twice---so requests for such times are not well-defined.
  // To account for these possibilities, `absl::TimeZone::TimeInfo` is
  // richer than just a single `absl::Time`.
  struct TimeInfo {
    enum CivilKind {
      UNIQUE,    // the civil time was singular (pre == trans == post)
      SKIPPED,   // the civil time did not exist (pre >= trans > post)
      REPEATED,  // the civil time was ambiguous (pre < trans <= post)
    } kind;
    Time pre;    // time calculated using the pre-transition offset
    Time trans;  // when the civil-time discontinuity occurred
    Time post;   // time calculated using the post-transition offset
  };

  // TimeZone::At(CivilSecond)
  //
  // Returns an `absl::TimeInfo` containing the absolute time(s) for this
  // TimeZone at an `absl::CivilSecond`. When the civil time is skipped or
  // repeated, returns times calculated using the pre-transition and post-
  // transition UTC offsets, plus the transition time itself.
  //
  // Examples:
  //
  //   // A unique civil time
  //   const auto jan01 = lax.At(absl::CivilSecond(2011, 1, 1, 0, 0, 0));
  //   // jan01.kind == TimeZone::TimeInfo::UNIQUE
  //   // jan01.pre    is 2011-01-01 00:00:00 -0800
  //   // jan01.trans  is 2011-01-01 00:00:00 -0800
  //   // jan01.post   is 2011-01-01 00:00:00 -0800
  //
  //   // A Spring DST transition, when there is a gap in civil time
  //   const auto mar13 = lax.At(absl::CivilSecond(2011, 3, 13, 2, 15, 0));
  //   // mar13.kind == TimeZone::TimeInfo::SKIPPED
  //   // mar13.pre   is 2011-03-13 03:15:00 -0700
  //   // mar13.trans is 2011-03-13 03:00:00 -0700
  //   // mar13.post  is 2011-03-13 01:15:00 -0800
  //
  //   // A Fall DST transition, when civil times are repeated
  //   const auto nov06 = lax.At(absl::CivilSecond(2011, 11, 6, 1, 15, 0));
  //   // nov06.kind == TimeZone::TimeInfo::REPEATED
  //   // nov06.pre   is 2011-11-06 01:15:00 -0700
  //   // nov06.trans is 2011-11-06 01:00:00 -0800
  //   // nov06.post  is 2011-11-06 01:15:00 -0800
  TimeInfo At(CivilSecond ct) const;

  // TimeZone::NextTransition()
  // TimeZone::PrevTransition()
  //
  // Finds the time of the next/previous offset change in this time zone.
  //
  // By definition, `NextTransition(t, &trans)` returns false when `t` is
  // `InfiniteFuture()`, and `PrevTransition(t, &trans)` returns false
  // when `t` is `InfinitePast()`. If the zone has no transitions, the
  // result will also be false no matter what the argument.
  //
  // Otherwise, when `t` is `InfinitePast()`, `NextTransition(t, &trans)`
  // returns true and sets `trans` to the first recorded transition. Chains
  // of calls to `NextTransition()/PrevTransition()` will eventually return
  // false, but it is unspecified exactly when `NextTransition(t, &trans)`
  // jumps to false, or what time is set by `PrevTransition(t, &trans)` for
  // a very distant `t`.
  //
  // Note: Enumeration of time-zone transitions is for informational purposes
  // only. Modern time-related code should not care about when offset changes
  // occur.
  //
  // Example:
  //   absl::TimeZone nyc;
  //   if (!absl::LoadTimeZone("America/New_York", &nyc)) { ... }
  //   const auto now = absl::Now();
  //   auto t = absl::InfinitePast();
  //   absl::TimeZone::CivilTransition trans;
  //   while (t <= now && nyc.NextTransition(t, &trans)) {
  //     // transition: trans.from -> trans.to
  //     t = nyc.At(trans.to).trans;
  //   }
  struct CivilTransition {
    CivilSecond from;  // the civil time we jump from
    CivilSecond to;    // the civil time we jump to
  };
  bool NextTransition(Time t, CivilTransition* trans) const;
  bool PrevTransition(Time t, CivilTransition* trans) const;

  template <typename H>
  friend H AbslHashValue(H h, TimeZone tz) {
    return H::combine(std::move(h), tz.cz_);
  }

 private:
  friend bool operator==(TimeZone a, TimeZone b) { return a.cz_ == b.cz_; }
  friend bool operator!=(TimeZone a, TimeZone b) { return a.cz_ != b.cz_; }
  friend std::ostream& operator<<(std::ostream& os, TimeZone tz) {
    return os << tz.name();
  }

  time_internal::cctz::time_zone cz_;
};

// LoadTimeZone()
//
// Loads the named zone. May perform I/O on the initial load of the named
// zone. If the name is invalid, or some other kind of error occurs, returns
// `false` and `*tz` is set to the UTC time zone.
inline bool LoadTimeZone(absl::string_view name, TimeZone* tz) {
  if (name == "localtime") {
    *tz = TimeZone(time_internal::cctz::local_time_zone());
    return true;
  }
  time_internal::cctz::time_zone cz;
  const bool b = time_internal::cctz::load_time_zone(std::string(name), &cz);
  *tz = TimeZone(cz);
  return b;
}

// FixedTimeZone()
//
// Returns a TimeZone that is a fixed offset (seconds east) from UTC.
// Note: If the absolute value of the offset is greater than 24 hours
// you'll get UTC (i.e., no offset) instead.
inline TimeZone FixedTimeZone(int seconds) {
  return TimeZone(
      time_internal::cctz::fixed_time_zone(std::chrono::seconds(seconds)));
}

// UTCTimeZone()
//
// Convenience method returning the UTC time zone.
inline TimeZone UTCTimeZone() {
  return TimeZone(time_internal::cctz::utc_time_zone());
}

// LocalTimeZone()
//
// Convenience method returning the local time zone, or UTC if there is
// no configured local zone.  Warning: Be wary of using LocalTimeZone(),
// and particularly so in a server process, as the zone configured for the
// local machine should be irrelevant.  Prefer an explicit zone name.
inline TimeZone LocalTimeZone() {
  return TimeZone(time_internal::cctz::local_time_zone());
}

// ToCivilSecond()
// ToCivilMinute()
// ToCivilHour()
// ToCivilDay()
// ToCivilMonth()
// ToCivilYear()
//
// Helpers for TimeZone::At(Time) to return particularly aligned civil times.
//
// Example:
//
//   absl::Time t = ...;
//   absl::TimeZone tz = ...;
//   const auto cd = absl::ToCivilDay(t, tz);
ABSL_ATTRIBUTE_PURE_FUNCTION inline CivilSecond ToCivilSecond(Time t,
                                                              TimeZone tz) {
  return tz.At(t).cs;  // already a CivilSecond
}
ABSL_ATTRIBUTE_PURE_FUNCTION inline CivilMinute ToCivilMinute(Time t,
                                                              TimeZone tz) {
  return CivilMinute(tz.At(t).cs);
}
ABSL_ATTRIBUTE_PURE_FUNCTION inline CivilHour ToCivilHour(Time t, TimeZone tz) {
  return CivilHour(tz.At(t).cs);
}
ABSL_ATTRIBUTE_PURE_FUNCTION inline CivilDay ToCivilDay(Time t, TimeZone tz) {
  return CivilDay(tz.At(t).cs);
}
ABSL_ATTRIBUTE_PURE_FUNCTION inline CivilMonth ToCivilMonth(Time t,
                                                            TimeZone tz) {
  return CivilMonth(tz.At(t).cs);
}
ABSL_ATTRIBUTE_PURE_FUNCTION inline CivilYear ToCivilYear(Time t, TimeZone tz) {
  return CivilYear(tz.At(t).cs);
}

// FromCivil()
//
// Helper for TimeZone::At(CivilSecond) that provides "order-preserving
// semantics." If the civil time maps to a unique time, that time is
// returned. If the civil time is repeated in the given time zone, the
// time using the pre-transition offset is returned. Otherwise, the
// civil time is skipped in the given time zone, and the transition time
// is returned. This means that for any two civil times, ct1 and ct2,
// (ct1 < ct2) => (FromCivil(ct1) <= FromCivil(ct2)), the equal case
// being when two non-existent civil times map to the same transition time.
//
// Note: Accepts civil times of any alignment.
ABSL_ATTRIBUTE_PURE_FUNCTION inline Time FromCivil(CivilSecond ct,
                                                   TimeZone tz) {
  const auto ti = tz.At(ct);
  if (ti.kind == TimeZone::TimeInfo::SKIPPED) return ti.trans;
  return ti.pre;
}

// TimeConversion
//
// An `absl::TimeConversion` represents the conversion of year, month, day,
// hour, minute, and second values (i.e., a civil time), in a particular
// `absl::TimeZone`, to a time instant (an absolute time), as returned by
// `absl::ConvertDateTime()`. Legacy version of `absl::TimeZone::TimeInfo`.
//
// Deprecated. Use `absl::TimeZone::TimeInfo`.
struct ABSL_DEPRECATED("Use `absl::TimeZone::TimeInfo`.") TimeConversion {
  Time pre;    // time calculated using the pre-transition offset
  Time trans;  // when the civil-time discontinuity occurred
  Time post;   // time calculated using the post-transition offset

  enum Kind {
    UNIQUE,    // the civil time was singular (pre == trans == post)
    SKIPPED,   // the civil time did not exist
    REPEATED,  // the civil time was ambiguous
  };
  Kind kind;

  bool normalized;  // input values were outside their valid ranges
};

// ConvertDateTime()
//
// Legacy version of `absl::TimeZone::At(absl::CivilSecond)` that takes
// the civil time as six, separate values (YMDHMS).
//
// The input month, day, hour, minute, and second values can be outside
// of their valid ranges, in which case they will be "normalized" during
// the conversion.
//
// Example:
//
//   // "October 32" normalizes to "November 1".
//   absl::TimeConversion tc =
//       absl::ConvertDateTime(2013, 10, 32, 8, 30, 0, lax);
//   // tc.kind == TimeConversion::UNIQUE && tc.normalized == true
//   // absl::ToCivilDay(tc.pre, tz).month() == 11
//   // absl::ToCivilDay(tc.pre, tz).day() == 1
//
// Deprecated. Use `absl::TimeZone::At(CivilSecond)`.
ABSL_INTERNAL_DISABLE_DEPRECATED_DECLARATION_WARNING
ABSL_DEPRECATED("Use `absl::TimeZone::At(CivilSecond)`.")
TimeConversion ConvertDateTime(int64_t year, int mon, int day, int hour,
                               int min, int sec, TimeZone tz);
ABSL_INTERNAL_RESTORE_DEPRECATED_DECLARATION_WARNING

// FromDateTime()
//
// A convenience wrapper for `absl::ConvertDateTime()` that simply returns
// the "pre" `absl::Time`.  That is, the unique result, or the instant that
// is correct using the pre-transition offset (as if the transition never
// happened).
//
// Example:
//
//   absl::Time t = absl::FromDateTime(2017, 9, 26, 9, 30, 0, lax);
//   // t = 2017-09-26 09:30:00 -0700
//
// Deprecated. Use `absl::FromCivil(CivilSecond, TimeZone)`. Note that the
// behavior of `FromCivil()` differs from `FromDateTime()` for skipped civil
// times. If you care about that see `absl::TimeZone::At(absl::CivilSecond)`.
ABSL_DEPRECATED("Use `absl::FromCivil(CivilSecond, TimeZone)`.")
inline Time FromDateTime(int64_t year, int mon, int day, int hour, int min,
                         int sec, TimeZone tz) {
  ABSL_INTERNAL_DISABLE_DEPRECATED_DECLARATION_WARNING
  return ConvertDateTime(year, mon, day, hour, min, sec, tz).pre;
  ABSL_INTERNAL_RESTORE_DEPRECATED_DECLARATION_WARNING
}

// FromTM()
//
// Converts the `tm_year`, `tm_mon`, `tm_mday`, `tm_hour`, `tm_min`, and
// `tm_sec` fields to an `absl::Time` using the given time zone. See ctime(3)
// for a description of the expected values of the tm fields. If the civil time
// is unique (see `absl::TimeZone::At(absl::CivilSecond)` above), the matching
// time instant is returned.  Otherwise, the `tm_isdst` field is consulted to
// choose between the possible results.  For a repeated civil time, `tm_isdst !=
// 0` returns the matching DST instant, while `tm_isdst == 0` returns the
// matching non-DST instant.  For a skipped civil time there is no matching
// instant, so `tm_isdst != 0` returns the DST instant, and `tm_isdst == 0`
// returns the non-DST instant, that would have matched if the transition never
// happened.
ABSL_ATTRIBUTE_PURE_FUNCTION Time FromTM(const struct tm& tm, TimeZone tz);

// ToTM()
//
// Converts the given `absl::Time` to a struct tm using the given time zone.
// See ctime(3) for a description of the values of the tm fields.
ABSL_ATTRIBUTE_PURE_FUNCTION struct tm ToTM(Time t, TimeZone tz);

// RFC3339_full
// RFC3339_sec
//
// FormatTime()/ParseTime() format specifiers for RFC3339 date/time strings,
// with trailing zeros trimmed or with fractional seconds omitted altogether.
//
// Note that RFC3339_sec[] matches an ISO 8601 extended format for date and
// time with UTC offset.  Also note the use of "%Y": RFC3339 mandates that
// years have exactly four digits, but we allow them to take their natural
// width.
ABSL_DLL extern const char RFC3339_full[];  // %Y-%m-%d%ET%H:%M:%E*S%Ez
ABSL_DLL extern const char RFC3339_sec[];   // %Y-%m-%d%ET%H:%M:%S%Ez

// RFC1123_full
// RFC1123_no_wday
//
// FormatTime()/ParseTime() format specifiers for RFC1123 date/time strings.
ABSL_DLL extern const char RFC1123_full[];     // %a, %d %b %E4Y %H:%M:%S %z
ABSL_DLL extern const char RFC1123_no_wday[];  // %d %b %E4Y %H:%M:%S %z

// FormatTime()
//
// Formats the given `absl::Time` in the `absl::TimeZone` according to the
// provided format string. Uses strftime()-like formatting options, with
// the following extensions:
//
//   - %Ez  - RFC3339-compatible numeric UTC offset (+hh:mm or -hh:mm)
//   - %E*z - Full-resolution numeric UTC offset (+hh:mm:ss or -hh:mm:ss)
//   - %E#S - Seconds with # digits of fractional precision
//   - %E*S - Seconds with full fractional precision (a literal '*')
//   - %E#f - Fractional seconds with # digits of precision
//   - %E*f - Fractional seconds with full precision (a literal '*')
//   - %E4Y - Four-character years (-999 ... -001, 0000, 0001 ... 9999)
//   - %ET  - The RFC3339 "date-time" separator "T"
//
// Note that %E0S behaves like %S, and %E0f produces no characters.  In
// contrast %E*f always produces at least one digit, which may be '0'.
//
// Note that %Y produces as many characters as it takes to fully render the
// year.  A year outside of [-999:9999] when formatted with %E4Y will produce
// more than four characters, just like %Y.
//
// We recommend that format strings include the UTC offset (%z, %Ez, or %E*z)
// so that the result uniquely identifies a time instant.
//
// Example:
//
//   absl::CivilSecond cs(2013, 1, 2, 3, 4, 5);
//   absl::Time t = absl::FromCivil(cs, lax);
//   std::string f = absl::FormatTime("%H:%M:%S", t, lax);  // "03:04:05"
//   f = absl::FormatTime("%H:%M:%E3S", t, lax);  // "03:04:05.000"
//
// Note: If the given `absl::Time` is `absl::InfiniteFuture()`, the returned
// string will be exactly "infinite-future". If the given `absl::Time` is
// `absl::InfinitePast()`, the returned string will be exactly "infinite-past".
// In both cases the given format string and `absl::TimeZone` are ignored.
//
ABSL_ATTRIBUTE_PURE_FUNCTION std::string FormatTime(absl::string_view format,
                                                    Time t, TimeZone tz);

// Convenience functions that format the given time using the RFC3339_full
// format.  The first overload uses the provided TimeZone, while the second
// uses LocalTimeZone().
ABSL_ATTRIBUTE_PURE_FUNCTION std::string FormatTime(Time t, TimeZone tz);
ABSL_ATTRIBUTE_PURE_FUNCTION std::string FormatTime(Time t);

// Output stream operator.
inline std::ostream& operator<<(std::ostream& os, Time t) {
  return os << FormatTime(t);
}

// Support for StrFormat(), StrCat() etc.
template <typename Sink>
void AbslStringify(Sink& sink, Time t) {
  sink.Append(FormatTime(t));
}

// ParseTime()
//
// Parses an input string according to the provided format string and
// returns the corresponding `absl::Time`. Uses strftime()-like formatting
// options, with the same extensions as FormatTime(), but with the
// exceptions that %E#S is interpreted as %E*S, and %E#f as %E*f.  %Ez
// and %E*z also accept the same inputs, which (along with %z) includes
// 'z' and 'Z' as synonyms for +00:00.  %ET accepts either 'T' or 't'.
//
// %Y consumes as many numeric characters as it can, so the matching data
// should always be terminated with a non-numeric.  %E4Y always consumes
// exactly four characters, including any sign.
//
// Unspecified fields are taken from the default date and time of ...
//
//   "1970-01-01 00:00:00.0 +0000"
//
// For example, parsing a string of "15:45" (%H:%M) will return an absl::Time
// that represents "1970-01-01 15:45:00.0 +0000".
//
// Note that since ParseTime() returns time instants, it makes the most sense
// to parse fully-specified date/time strings that include a UTC offset (%z,
// %Ez, or %E*z).
//
// Note also that `absl::ParseTime()` only heeds the fields year, month, day,
// hour, minute, (fractional) second, and UTC offset.  Other fields, like
// weekday (%a or %A), while parsed for syntactic validity, are ignored
// in the conversion.
//
// Date and time fields that are out-of-range will be treated as errors
// rather than normalizing them like `absl::CivilSecond` does.  For example,
// it is an error to parse the date "Oct 32, 2013" because 32 is out of range.
//
// A leap second of ":60" is normalized to ":00" of the following minute
// with fractional seconds discarded.  The following table shows how the
// given seconds and subseconds will be parsed:
//
//   "59.x" -> 59.x  // exact
//   "60.x" -> 00.0  // normalized
//   "00.x" -> 00.x  // exact
//
// Errors are indicated by returning false and assigning an error message
// to the "err" out param if it is non-null.
//
// Note: If the input string is exactly "infinite-future", the returned
// `absl::Time` will be `absl::InfiniteFuture()` and `true` will be returned.
// If the input string is "infinite-past", the returned `absl::Time` will be
// `absl::InfinitePast()` and `true` will be returned.
//
bool ParseTime(absl::string_view format, absl::string_view input, Time* time,
               std::string* err);

// Like ParseTime() above, but if the format string does not contain a UTC
// offset specification (%z/%Ez/%E*z) then the input is interpreted in the
// given TimeZone.  This means that the input, by itself, does not identify a
// unique instant.  Being time-zone dependent, it also admits the possibility
// of ambiguity or non-existence, in which case the "pre" time (as defined
// by TimeZone::TimeInfo) is returned.  For these reasons we recommend that
// all date/time strings include a UTC offset so they're context independent.
bool ParseTime(absl::string_view format, absl::string_view input, TimeZone tz,
               Time* time, std::string* err);

// ============================================================================
// Implementation Details Follow
// ============================================================================

namespace time_internal {

// Creates a Duration with a given representation.
// REQUIRES: hi,lo is a valid representation of a Duration as specified
// in time/duration.cc.
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration MakeDuration(int64_t hi,
                                                              uint32_t lo = 0) {
  return Duration(hi, lo);
}

ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration MakeDuration(int64_t hi,
                                                              int64_t lo) {
  return MakeDuration(hi, static_cast<uint32_t>(lo));
}

// Make a Duration value from a floating-point number, as long as that number
// is in the range [ 0 .. numeric_limits<int64_t>::max ), that is, as long as
// it's positive and can be converted to int64_t without risk of UB.
ABSL_ATTRIBUTE_CONST_FUNCTION inline Duration MakePosDoubleDuration(double n) {
  const int64_t int_secs = static_cast<int64_t>(n);
  const uint32_t ticks = static_cast<uint32_t>(
      std::round((n - static_cast<double>(int_secs)) * kTicksPerSecond));
  return ticks < kTicksPerSecond
             ? MakeDuration(int_secs, ticks)
             : MakeDuration(int_secs + 1, ticks - kTicksPerSecond);
}

// Creates a normalized Duration from an almost-normalized (sec,ticks)
// pair. sec may be positive or negative.  ticks must be in the range
// -kTicksPerSecond < *ticks < kTicksPerSecond.  If ticks is negative it
// will be normalized to a positive value in the resulting Duration.
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration MakeNormalizedDuration(
    int64_t sec, int64_t ticks) {
  return (ticks < 0) ? MakeDuration(sec - 1, ticks + kTicksPerSecond)
                     : MakeDuration(sec, ticks);
}

// Provide access to the Duration representation.
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr int64_t GetRepHi(Duration d) {
  return d.rep_hi_.Get();
}
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr uint32_t GetRepLo(Duration d) {
  return d.rep_lo_;
}

// Returns true iff d is positive or negative infinity.
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool IsInfiniteDuration(Duration d) {
  return GetRepLo(d) == ~uint32_t{0};
}

// Returns an infinite Duration with the opposite sign.
// REQUIRES: IsInfiniteDuration(d)
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration OppositeInfinity(Duration d) {
  return GetRepHi(d) < 0
             ? MakeDuration((std::numeric_limits<int64_t>::max)(), ~uint32_t{0})
             : MakeDuration((std::numeric_limits<int64_t>::min)(),
                            ~uint32_t{0});
}

// Returns (-n)-1 (equivalently -(n+1)) without avoidable overflow.
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr int64_t NegateAndSubtractOne(
    int64_t n) {
  // Note: Good compilers will optimize this expression to ~n when using
  // a two's-complement representation (which is required for int64_t).
  return (n < 0) ? -(n + 1) : (-n) - 1;
}

// Map between a Time and a Duration since the Unix epoch.  Note that these
// functions depend on the above mentioned choice of the Unix epoch for the
// Time representation (and both need to be Time friends).  Without this
// knowledge, we would need to add-in/subtract-out UnixEpoch() respectively.
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time FromUnixDuration(Duration d) {
  return Time(d);
}
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration ToUnixDuration(Time t) {
  return t.rep_;
}

template <std::intmax_t N>
ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration FromInt64(int64_t v,
                                                           std::ratio<1, N>

UnqualifiedName:
strong_ordering operator<=>(Time lhs, Time rhs);
#endif  // ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON

  friend constexpr bool operator


FullyQualifiedName:
absl::variant_internal::MakeVisitationMatrix<ReturnType, FunctionObject, index_sequence<>,
                            index_sequence<BoundIndices...>>

UnqualifiedName:
MakeVisitationMatrix<ReturnType, FunctionObject, index_sequence<>,
                            index_sequence<BoundIndices...>>


UnqualifiedName: ResultType
FullyQualifiedName:
absl::variant_internal::MakeVisitationMatrix<ReturnType, FunctionObject, index_sequence<>,
                            index_sequence<BoundIndices...>>::ResultType


UnqualifiedName: Run
FullyQualifiedName:
absl::variant_internal::MakeVisitationMatrix<ReturnType, FunctionObject, index_sequence<>,
                            index_sequence<BoundIndices...>>::Run


FullyQualifiedName:
absl::variant_internal::MakeVisitationMatrixImpl<ReturnType, FunctionObject, EndIndices,
                                index_sequence<CurrIndices...>, BoundIndices>

UnqualifiedName:
MakeVisitationMatrixImpl<ReturnType, FunctionObject, EndIndices,
                                index_sequence<CurrIndices...>, BoundIndices>


UnqualifiedName: ResultType
FullyQualifiedName:
absl::variant_internal::MakeVisitationMatrixImpl<ReturnType, FunctionObject, EndIndices,
                                index_sequence<CurrIndices...>, BoundIndices>::ResultType


UnqualifiedName: Run
FullyQualifiedName:
absl::variant_internal::MakeVisitationMatrixImpl<ReturnType, FunctionObject, EndIndices,
                                index_sequence<CurrIndices...>, BoundIndices>::Run


FullyQualifiedName:
absl::variant_internal::MakeVisitationMatrix<ReturnType, FunctionObject,
                            index_sequence<HeadEndIndex, TailEndIndices...>,
                            index_sequence<BoundIndices...>>

UnqualifiedName:
MakeVisitationMatrix<ReturnType, FunctionObject,
                            index_sequence<HeadEndIndex, TailEndIndices...>,
                            index_sequence<BoundIndices...>>


UnqualifiedName: FlattenedOp
FullyQualifiedName:
absl::variant_internal::VisitIndicesVariadicImpl<absl::index_sequence<N...>, EndIndices...>::FlattenedOp


UnqualifiedName: operator()
FullyQualifiedName:
absl::variant_internal::VisitIndicesVariadicImpl<absl::index_sequence<N...>, EndIndices...>::FlattenedOp::operator()


FullyQualifiedName:
absl::variant_internal::IndexOfConstructedType<
    Variant, T,
    void_t<decltype(ImaginaryFun<Variant>::Run(std::declval<T>(), {}))>>

UnqualifiedName:
IndexOfConstructedType<
    Variant, T,
    void_t<decltype(ImaginaryFun<Variant>::Run(std::declval<T>(), {}))>>


FullyQualifiedName:
absl::variant_internal::VariantHashBase<Variant,
                       absl::enable_if_t<absl::conjunction<
                           type_traits_internal::IsHashable<Ts>...>::value>,
                       Ts...>

UnqualifiedName:
VariantHashBase<Variant,
                       absl::enable_if_t<absl::conjunction<
                           type_traits_internal::IsHashable<Ts>...>::value>,
                       Ts...>


UnqualifiedName: argument_type
FullyQualifiedName:
absl::variant_internal::VariantHashBase<Variant,
                       absl::enable_if_t<absl::conjunction<
                           type_traits_internal::IsHashable<Ts>...>::value>,
                       Ts...>::argument_type


UnqualifiedName: result_type
FullyQualifiedName:
absl::variant_internal::VariantHashBase<Variant,
                       absl::enable_if_t<absl::conjunction<
                           type_traits_internal::IsHashable<Ts>...>::value>,
                       Ts...>::result_type


UnqualifiedName: operator()
FullyQualifiedName:
absl::variant_internal::VariantHashBase<Variant,
                       absl::enable_if_t<absl::conjunction<
                           type_traits_internal::IsHashable<Ts>...>::value>,
                       Ts...>::operator()


UnqualifiedName: BOOST_STATIC_CONSTANT
FullyQualifiedName:
boost::algorithm::has_native_replace< std::basic_string<T, TraitsT, AllocT> >::BOOST_STATIC_CONSTANT


UnqualifiedName: safe_cancellation_thread_id_
FullyQualifiedName:
boost::asio::detail::win_iocp_socket_service_base::base_implementation_type::safe_cancellation_thread_id_


FullyQualifiedName:
boost::asio::detail::is_work_dispatcher_required<Handler, Executor,
    enable_if_t<
      is_same<
        typename associated_executor<Handler,
          Executor>::asio_associated_executor_is_unspecialised,
        void
      >::value
    >>

UnqualifiedName:
is_work_dispatcher_required<Handler, Executor,
    enable_if_t<
      is_same<
        typename associated_executor<Handler,
          Executor>::asio_associated_executor_is_unspecialised,
        void
      >::value
    >>


UnqualifiedName: work_dispatcher<Handler, Executor, enable_if_t<!execution::is_executor<Executor>::value>>
FullyQualifiedName:
boost::asio::detail::work_dispatcher<Handler, Executor,
    enable_if_t<!execution::is_executor<Executor>::value>>


UnqualifiedName: work_dispatcher
FullyQualifiedName:
boost::asio::detail::work_dispatcher<Handler, Executor,
    enable_if_t<!execution::is_executor<Executor>::value>>::work_dispatcher


UnqualifiedName: operator()
FullyQualifiedName:
boost::asio::detail::work_dispatcher<Handler, Executor,
    enable_if_t<!execution::is_executor<Executor>::value>>::operator()


UnqualifiedName: work_
FullyQualifiedName:
boost::asio::detail::work_dispatcher<Handler, Executor,
    enable_if_t<!execution::is_executor<Executor>::value>>::work_


UnqualifiedName: handler_
FullyQualifiedName:
boost::asio::detail::work_dispatcher<Handler, Executor,
    enable_if_t<!execution::is_executor<Executor>::value>>::handler_


UnqualifiedName: wrapped_executor<Dispatcher, void_type<typename Dispatcher::executor_type>>
FullyQualifiedName:
boost::asio::detail::wrapped_executor<Dispatcher,
    void_type<typename Dispatcher::executor_type>>


UnqualifiedName: executor_type
FullyQualifiedName:
boost::asio::detail::wrapped_executor<Dispatcher,
    void_type<typename Dispatcher::executor_type>>::executor_type


UnqualifiedName: get
FullyQualifiedName:
boost::asio::detail::wrapped_executor<Dispatcher,
    void_type<typename Dispatcher::executor_type>>::get


FullyQualifiedName:
boost::asio::associator<Associator,
    detail::write_op<AsyncWriteStream, ConstBufferSequence,
      ConstBufferIterator, CompletionCondition, WriteHandler>,
    DefaultCandidate>

UnqualifiedName:
associator<Associator,
    detail::write_op<AsyncWriteStream, ConstBufferSequence,
      ConstBufferIterator, CompletionCondition, WriteHandler>,
    DefaultCandidate>


UnqualifiedName: get
FullyQualifiedName:
boost::asio::associator<Associator,
    detail::write_op<AsyncWriteStream, ConstBufferSequence,
      ConstBufferIterator, CompletionCondition, WriteHandler>,
    DefaultCandidate>::get


FullyQualifiedName:
boost::asio::associator<Associator,
    detail::write_dynbuf_v1_op<AsyncWriteStream,
      DynamicBuffer_v1, CompletionCondition, WriteHandler>,
    DefaultCandidate>

UnqualifiedName:
associator<Associator,
    detail::write_dynbuf_v1_op<AsyncWriteStream,
      DynamicBuffer_v1, CompletionCondition, WriteHandler>,
    DefaultCandidate>


UnqualifiedName: get
FullyQualifiedName:
boost::asio::associator<Associator,
    detail::write_dynbuf_v1_op<AsyncWriteStream,
      DynamicBuffer_v1, CompletionCondition, WriteHandler>,
    DefaultCandidate>::get


FullyQualifiedName:
boost::asio::associator<Associator,
    detail::write_dynbuf_v2_op<AsyncWriteStream,
      DynamicBuffer_v2, CompletionCondition, WriteHandler>,
    DefaultCandidate>

UnqualifiedName:
associator<Associator,
    detail::write_dynbuf_v2_op<AsyncWriteStream,
      DynamicBuffer_v2, CompletionCondition, WriteHandler>,
    DefaultCandidate>


UnqualifiedName: get
FullyQualifiedName:
boost::asio::associator<Associator,
    detail::write_dynbuf_v2_op<AsyncWriteStream,
      DynamicBuffer_v2, CompletionCondition, WriteHandler>,
    DefaultCandidate>::get


UnqualifiedName: equality_comparable< boost::asio::basic_system_executor<Blocking, Relationship, Allocator> >
FullyQualifiedName:
boost::asio::traits::equality_comparable<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>
  >


UnqualifiedName: is_valid
FullyQualifiedName:
boost::asio::traits::equality_comparable<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>
  >::is_valid


UnqualifiedName: is_noexcept
FullyQualifiedName:
boost::asio::traits::equality_comparable<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>
  >::is_noexcept


FullyQualifiedName:
boost::asio::traits::execute_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Function
  >

UnqualifiedName:
execute_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Function
  >


UnqualifiedName: is_valid
FullyQualifiedName:
boost::asio::traits::execute_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Function
  >::is_valid


UnqualifiedName: is_noexcept
FullyQualifiedName:
boost::asio::traits::execute_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Function
  >::is_noexcept


UnqualifiedName: result_type
FullyQualifiedName:
boost::asio::traits::execute_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Function
  >::result_type


FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::blocking_t::possibly_t
  >

UnqualifiedName:
require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::blocking_t::possibly_t
  >


UnqualifiedName: is_valid
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::blocking_t::possibly_t
  >::is_valid


UnqualifiedName: is_noexcept
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::blocking_t::possibly_t
  >::is_noexcept


UnqualifiedName: result_type
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::blocking_t::possibly_t
  >::result_type


FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::blocking_t::always_t
  >

UnqualifiedName:
require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::blocking_t::always_t
  >


UnqualifiedName: is_valid
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::blocking_t::always_t
  >::is_valid


UnqualifiedName: is_noexcept
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::blocking_t::always_t
  >::is_noexcept


UnqualifiedName: result_type
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::blocking_t::always_t
  >::result_type


FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::blocking_t::never_t
  >

UnqualifiedName:
require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::blocking_t::never_t
  >


UnqualifiedName: is_valid
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::blocking_t::never_t
  >::is_valid


UnqualifiedName: is_noexcept
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::blocking_t::never_t
  >::is_noexcept


UnqualifiedName: result_type
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::blocking_t::never_t
  >::result_type


FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::relationship_t::fork_t
  >

UnqualifiedName:
require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::relationship_t::fork_t
  >


UnqualifiedName: is_valid
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::relationship_t::fork_t
  >::is_valid


UnqualifiedName: is_noexcept
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::relationship_t::fork_t
  >::is_noexcept


UnqualifiedName: result_type
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::relationship_t::fork_t
  >::result_type


FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::relationship_t::continuation_t
  >

UnqualifiedName:
require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::relationship_t::continuation_t
  >


UnqualifiedName: is_valid
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::relationship_t::continuation_t
  >::is_valid


UnqualifiedName: is_noexcept
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::relationship_t::continuation_t
  >::is_noexcept


UnqualifiedName: result_type
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::relationship_t::continuation_t
  >::result_type


FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<void>
  >

UnqualifiedName:
require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<void>
  >


UnqualifiedName: is_valid
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<void>
  >::is_valid


UnqualifiedName: is_noexcept
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<void>
  >::is_noexcept


UnqualifiedName: result_type
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<void>
  >::result_type


FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<OtherAllocator>
  >

UnqualifiedName:
require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<OtherAllocator>
  >


UnqualifiedName: is_valid
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<OtherAllocator>
  >::is_valid


UnqualifiedName: is_noexcept
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<OtherAllocator>
  >::is_noexcept


UnqualifiedName: result_type
FullyQualifiedName:
boost::asio::traits::require_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<OtherAllocator>
  >::result_type


FullyQualifiedName:
boost::asio::traits::query_static_constexpr_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Property,
    typename boost::asio::enable_if<
      boost::asio::is_convertible<
        Property,
        boost::asio::execution::mapping_t
      >::value
    >::type
  >

UnqualifiedName:
query_static_constexpr_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Property,
    typename boost::asio::enable_if<
      boost::asio::is_convertible<
        Property,
        boost::asio::execution::mapping_t
      >::value
    >::type
  >


UnqualifiedName: is_valid
FullyQualifiedName:
boost::asio::traits::query_static_constexpr_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Property,
    typename boost::asio::enable_if<
      boost::asio::is_convertible<
        Property,
        boost::asio::execution::mapping_t
      >::value
    >::type
  >::is_valid


UnqualifiedName: is_noexcept
FullyQualifiedName:
boost::asio::traits::query_static_constexpr_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Property,
    typename boost::asio::enable_if<
      boost::asio::is_convertible<
        Property,
        boost::asio::execution::mapping_t
      >::value
    >::type
  >::is_noexcept


UnqualifiedName: result_type
FullyQualifiedName:
boost::asio::traits::query_static_constexpr_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Property,
    typename boost::asio::enable_if<
      boost::asio::is_convertible<
        Property,
        boost::asio::execution::mapping_t
      >::value
    >::type
  >::result_type


UnqualifiedName: value
FullyQualifiedName:
boost::asio::traits::query_static_constexpr_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Property,
    typename boost::asio::enable_if<
      boost::asio::is_convertible<
        Property,
        boost::asio::execution::mapping_t
      >::value
    >::type
  >::value


FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Property,
    typename boost::asio::enable_if<
      boost::asio::is_convertible<
        Property,
        boost::asio::execution::blocking_t
      >::value
    >::type
  >

UnqualifiedName:
query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Property,
    typename boost::asio::enable_if<
      boost::asio::is_convertible<
        Property,
        boost::asio::execution::blocking_t
      >::value
    >::type
  >


UnqualifiedName: is_valid
FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Property,
    typename boost::asio::enable_if<
      boost::asio::is_convertible<
        Property,
        boost::asio::execution::blocking_t
      >::value
    >::type
  >::is_valid


UnqualifiedName: is_noexcept
FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Property,
    typename boost::asio::enable_if<
      boost::asio::is_convertible<
        Property,
        boost::asio::execution::blocking_t
      >::value
    >::type
  >::is_noexcept


UnqualifiedName: result_type
FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Property,
    typename boost::asio::enable_if<
      boost::asio::is_convertible<
        Property,
        boost::asio::execution::blocking_t
      >::value
    >::type
  >::result_type


FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Property,
    typename boost::asio::enable_if<
      boost::asio::is_convertible<
        Property,
        boost::asio::execution::relationship_t
      >::value
    >::type
  >

UnqualifiedName:
query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Property,
    typename boost::asio::enable_if<
      boost::asio::is_convertible<
        Property,
        boost::asio::execution::relationship_t
      >::value
    >::type
  >


UnqualifiedName: is_valid
FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Property,
    typename boost::asio::enable_if<
      boost::asio::is_convertible<
        Property,
        boost::asio::execution::relationship_t
      >::value
    >::type
  >::is_valid


UnqualifiedName: is_noexcept
FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Property,
    typename boost::asio::enable_if<
      boost::asio::is_convertible<
        Property,
        boost::asio::execution::relationship_t
      >::value
    >::type
  >::is_noexcept


UnqualifiedName: result_type
FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    Property,
    typename boost::asio::enable_if<
      boost::asio::is_convertible<
        Property,
        boost::asio::execution::relationship_t
      >::value
    >::type
  >::result_type


FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::context_t
  >

UnqualifiedName:
query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::context_t
  >


UnqualifiedName: is_valid
FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::context_t
  >::is_valid


UnqualifiedName: is_noexcept
FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::context_t
  >::is_noexcept


UnqualifiedName: result_type
FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::context_t
  >::result_type


FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<void>
  >

UnqualifiedName:
query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<void>
  >


UnqualifiedName: is_valid
FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<void>
  >::is_valid


UnqualifiedName: is_noexcept
FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<void>
  >::is_noexcept


UnqualifiedName: result_type
FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<void>
  >::result_type


FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<Allocator>
  >

UnqualifiedName:
query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<Allocator>
  >


UnqualifiedName: is_valid
FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<Allocator>
  >::is_valid


UnqualifiedName: is_noexcept
FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<Allocator>
  >::is_noexcept


UnqualifiedName: result_type
FullyQualifiedName:
boost::asio::traits::query_member<
    boost::asio::basic_system_executor<Blocking, Relationship, Allocator>,
    boost::asio::execution::allocator_t<Allocator>
  >::result_type


FullyQualifiedName:
boost::asio::detail::static_query_trait<T, Property,
  void_t<
    decltype(decay_t<Property>::template static_query_v<T>)
  >>

UnqualifiedName:
static_query_trait<T, Property,
  void_t<
    decltype(decay_t<Property>::template static_query_v<T>)
  >>


UnqualifiedName: is_valid
FullyQualifiedName:
boost::asio::detail::static_query_trait<T, Property,
  void_t<
    decltype(decay_t<Property>::template static_query_v<T>)
  >>::is_valid


UnqualifiedName: result_type
FullyQualifiedName:
boost::asio::detail::static_query_trait<T, Property,
  void_t<
    decltype(decay_t<Property>::template static_query_v<T>)
  >>::result_type


UnqualifiedName: is_noexcept
FullyQualifiedName:
boost::asio::detail::static_query_trait<T, Property,
  void_t<
    decltype(decay_t<Property>::template static_query_v<T>)
  >>::is_noexcept


UnqualifiedName: value
FullyQualifiedName:
boost::asio::detail::static_query_trait<T, Property,
  void_t<
    decltype(decay_t<Property>::template static_query_v<T>)
  >>::value


FullyQualifiedName:
boost::asio::detail::static_require_trait<T, Property,
  enable_if_t<
    decay_t<Property>::value() == traits::static_query<T, Property>::value()
  >>

UnqualifiedName:
static_require_trait<T, Property,
  enable_if_t<
    decay_t<Property>::value() == traits::static_query<T, Property>::value()
  >>


UnqualifiedName: is_valid
FullyQualifiedName:
boost::asio::detail::static_require_trait<T, Property,
  enable_if_t<
    decay_t<Property>::value() == traits::static_query<T, Property>::value()
  >>::is_valid


FullyQualifiedName:
boost::asio::detail::static_require_trait<T, Property,
  enable_if_t<
    has_static_require<decay_t<T>,
      decay_t<Property>>::value
  >>

UnqualifiedName:
static_require_trait<T, Property,
  enable_if_t<
    has_static_require<decay_t<T>,
      decay_t<Property>>::value
  >>


UnqualifiedName: is_valid
FullyQualifiedName:
boost::asio::detail::static_require_trait<T, Property,
  enable_if_t<
    has_static_require<decay_t<T>,
      decay_t<Property>>::value
  >>::is_valid


UnqualifiedName: duration_type
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::duration_type


UnqualifiedName: traits_type
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::traits_type


UnqualifiedName: day_type
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::day_type


UnqualifiedName: hour_type
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::hour_type


UnqualifiedName: min_type
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::min_type


UnqualifiedName: sec_type
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::sec_type


UnqualifiedName: fractional_seconds_type
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::fractional_seconds_type


UnqualifiedName: tick_type
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::tick_type


UnqualifiedName: impl_type
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::impl_type


UnqualifiedName: ticks_per_second
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::ticks_per_second


UnqualifiedName: resolution
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::resolution


UnqualifiedName: total_seconds
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::total_seconds


UnqualifiedName: total_milliseconds
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::total_milliseconds


UnqualifiedName: total_nanoseconds
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::total_nanoseconds


UnqualifiedName: total_microseconds
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::total_microseconds


UnqualifiedName: fractional_seconds
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::fractional_seconds


UnqualifiedName: num_fractional_digits
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::num_fractional_digits


UnqualifiedName: invert_sign
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::invert_sign


UnqualifiedName: is_negative
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::is_negative


UnqualifiedName: is_positive
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::is_positive


UnqualifiedName: operator<
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::operator<


UnqualifiedName: operator==
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::operator==


UnqualifiedName: operator-
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::operator-


UnqualifiedName: operator+
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::operator+


UnqualifiedName: operator/
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::operator/


UnqualifiedName: operator-=
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::operator-=


UnqualifiedName: operator+=
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::operator+=


UnqualifiedName: operator/=
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::operator/=


UnqualifiedName: operator*
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::operator*


UnqualifiedName: operator*=
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::operator*=


UnqualifiedName: is_special
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::is_special


UnqualifiedName: is_pos_infinity
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::is_pos_infinity


UnqualifiedName: is_neg_infinity
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::is_neg_infinity


UnqualifiedName: is_not_a_date_time
FullyQualifiedName:
boost::date_time::boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >::is_not_a_date_time


UnqualifiedName: type
FullyQualifiedName:
common_type<_CHRONO time_point<_Clock, _Duration1>,
    _CHRONO time_point<_Clock, _Duration2>>::type


FullyQualifiedName:
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    _NODISCARD constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>> operator+

UnqualifiedName:
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    _NODISCARD constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>> operator+


UnqualifiedName: _CD
FullyQualifiedName:
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    _NODISCARD constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>> operator+::_CD


FullyQualifiedName:
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    _NODISCARD constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>> operator-

UnqualifiedName:
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    _NODISCARD constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>> operator-


UnqualifiedName: _CD
FullyQualifiedName:
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    _NODISCARD constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>> operator-::_CD


UnqualifiedName: type operator/
FullyQualifiedName:
template <class _Rep1, class _Period1, class _Rep2>
    _NODISCARD constexpr typename _Duration_div_mod<common_type_t<_Rep1, _Rep2>, _Period1, _Rep2>::type operator/


UnqualifiedName: _CR
FullyQualifiedName:
template <class _Rep1, class _Period1, class _Rep2>
    _NODISCARD constexpr typename _Duration_div_mod<common_type_t<_Rep1, _Rep2>, _Period1, _Rep2>::type operator/::_CR


UnqualifiedName: _CD
FullyQualifiedName:
template <class _Rep1, class _Period1, class _Rep2>
    _NODISCARD constexpr typename _Duration_div_mod<common_type_t<_Rep1, _Rep2>, _Period1, _Rep2>::type operator/::_CD


FullyQualifiedName:
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    _NODISCARD constexpr common_type_t<_Rep1, _Rep2> operator/

UnqualifiedName:
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    _NODISCARD constexpr common_type_t<_Rep1, _Rep2> operator/


UnqualifiedName: _CD
FullyQualifiedName:
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    _NODISCARD constexpr common_type_t<_Rep1, _Rep2> operator/::_CD


UnqualifiedName: type operator%
FullyQualifiedName:
template <class _Rep1, class _Period1, class _Rep2>
    _NODISCARD constexpr typename _Duration_div_mod<common_type_t<_Rep1, _Rep2>, _Period1, _Rep2>::type operator%


UnqualifiedName: _CR
FullyQualifiedName:
template <class _Rep1, class _Period1, class _Rep2>
    _NODISCARD constexpr typename _Duration_div_mod<common_type_t<_Rep1, _Rep2>, _Period1, _Rep2>::type operator%::_CR


UnqualifiedName: _CD
FullyQualifiedName:
template <class _Rep1, class _Period1, class _Rep2>
    _NODISCARD constexpr typename _Duration_div_mod<common_type_t<_Rep1, _Rep2>, _Period1, _Rep2>::type operator%::_CD


FullyQualifiedName:
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    _NODISCARD constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>> operator%

UnqualifiedName:
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    _NODISCARD constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>> operator%


UnqualifiedName: _CD
FullyQualifiedName:
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    _NODISCARD constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>> operator%::_CD


FullyQualifiedName:
round::template <class _Clock, class _Duration, class _Rep, class _Period>
    _NODISCARD constexpr time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>> operator+

UnqualifiedName:
template <class _Clock, class _Duration, class _Rep, class _Period>
    _NODISCARD constexpr time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>> operator+


UnqualifiedName: _RT
FullyQualifiedName:
round::template <class _Clock, class _Duration, class _Rep, class _Period>
    _NODISCARD constexpr time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>> operator+::_RT


FullyQualifiedName:
round::template <class _Rep, class _Period, class _Clock, class _Duration>
    _NODISCARD constexpr time_point<_Clock, common_type_t<duration<_Rep, _Period>, _Duration>> operator+

UnqualifiedName:
template <class _Rep, class _Period, class _Clock, class _Duration>
    _NODISCARD constexpr time_point<_Clock, common_type_t<duration<_Rep, _Period>, _Duration>> operator+


FullyQualifiedName:
round::template <class _Clock, class _Duration, class _Rep, class _Period>
    _NODISCARD constexpr time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>> operator-

UnqualifiedName:
template <class _Clock, class _Duration, class _Rep, class _Period>
    _NODISCARD constexpr time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>> operator-


UnqualifiedName: _RT
FullyQualifiedName:
round::template <class _Clock, class _Duration, class _Rep, class _Period>
    _NODISCARD constexpr time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>> operator-::_RT


FullyQualifiedName:
round::template <class _Clock, class _Duration1, class _Duration2>
    _NODISCARD constexpr common_type_t<_Duration1, _Duration2> operator-

UnqualifiedName:
template <class _Clock, class _Duration1, class _Duration2>
    _NODISCARD constexpr common_type_t<_Duration1, _Duration2> operator-


FullyQualifiedName:
_Iterator_traits_base<_Iter,
    void_t<typename _Iter::iterator_category, typename _Iter::value_type, typename _Iter::difference_type,
        typename _Iter::pointer, typename _Iter::reference>>

UnqualifiedName:
_Iterator_traits_base<_Iter,
    void_t<typename _Iter::iterator_category, typename _Iter::value_type, typename _Iter::difference_type,
        typename _Iter::pointer, typename _Iter::reference>>


UnqualifiedName: iterator_category
FullyQualifiedName:
_Iterator_traits_base<_Iter,
    void_t<typename _Iter::iterator_category, typename _Iter::value_type, typename _Iter::difference_type,
        typename _Iter::pointer, typename _Iter::reference>>::iterator_category


UnqualifiedName: value_type
FullyQualifiedName:
_Iterator_traits_base<_Iter,
    void_t<typename _Iter::iterator_category, typename _Iter::value_type, typename _Iter::difference_type,
        typename _Iter::pointer, typename _Iter::reference>>::value_type


UnqualifiedName: difference_type
FullyQualifiedName:
_Iterator_traits_base<_Iter,
    void_t<typename _Iter::iterator_category, typename _Iter::value_type, typename _Iter::difference_type,
        typename _Iter::pointer, typename _Iter::reference>>::difference_type


UnqualifiedName: pointer
FullyQualifiedName:
_Iterator_traits_base<_Iter,
    void_t<typename _Iter::iterator_category, typename _Iter::value_type, typename _Iter::difference_type,
        typename _Iter::pointer, typename _Iter::reference>>::pointer


UnqualifiedName: reference
FullyQualifiedName:
_Iterator_traits_base<_Iter,
    void_t<typename _Iter::iterator_category, typename _Iter::value_type, typename _Iter::difference_type,
        typename _Iter::pointer, typename _Iter::reference>>::reference


UnqualifiedName: _Traits
FullyQualifiedName:
__CLR_OR_THIS_CALL basic_ostream<unsigned short,
    char_traits<unsigned short>>::operator<<::_Traits


FullyQualifiedName:
template <class _Elem, class _Traits>
_NODISCARD constexpr _Get_comparison_category_t<_Traits> operator<=>

UnqualifiedName:
template <class _Elem, class _Traits>
_NODISCARD constexpr _Get_comparison_category_t<_Traits> operator<=>


UnqualifiedName: _Construct_from
FullyQualifiedName:
template <class _Base>
struct _Non_trivial_copy : _Base { // non-trivial copy construction facade
    using _Base::_Base;

    _Non_trivial_copy() = default;
    _CONSTEXPR20 _Non_trivial_copy(const _Non_trivial_copy& _That)
        noexcept(noexcept(_Base::_Construct_from(static_cast<const _Base&>(_That)))) {
        _Base::_Construct_from


