Compiler Explorer

Source code

// Formatting library for C++ - chrono support
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#ifndef FMT_CHRONO_H_
#define FMT_CHRONO_H_

#ifndef FMT_MODULE
# include <algorithm>
# include <chrono>
# include <cmath> // std::isfinite
# include <cstring> // std::memcpy
# include <ctime>
# include <iterator>
# include <locale>
# include <ostream>
# include <type_traits>
#endif

/*
  Formatting library for C++

Permission is hereby granted, free of charge, to any person obtaining
  a copy of this software and associated documentation files (the
  "Software"), to deal in the Software without restriction, including
  without limitation the rights to use, copy, modify, merge, publish,
  distribute, sublicense, and/or sell copies of the Software, and to
  permit persons to whom the Software is furnished to do so, subject to
  the following conditions:

The above copyright notice and this permission notice shall be
  included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

--- Optional exception to the license ---

As an exception, if, as a result of your compiling your source code, portions
  of this Software are embedded into a machine-executable object form of such
  source code, you may redistribute such embedded portions in such object form
  without including the above copyright and permission notices.
 */

#ifndef FMT_FORMAT_H_
#define FMT_FORMAT_H_

#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
#  define _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
#  define FMT_REMOVE_TRANSITIVE_INCLUDES
#endif

// Formatting library for C++ - the base API for char/UTF-8
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.

#ifndef FMT_BASE_H_
#define FMT_BASE_H_

#if defined(FMT_IMPORT_STD) && !defined(FMT_MODULE)
#  define FMT_MODULE
#endif

#ifndef FMT_MODULE
# include <limits.h> // CHAR_BIT
# include <stdio.h> // FILE
# include <string.h> // memcmp

// <cstddef> is also included transitively from <type_traits>.
# include <cstddef> // std::byte
# include <type_traits> // std::enable_if
#endif

// The fmt library version in the form major * 10000 + minor * 100 + patch.
#define FMT_VERSION 110002

// Detect compiler versions.
#if defined(__clang__) && !defined(__ibmxl__)
#  define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
#else
#  define FMT_CLANG_VERSION 0
#endif
#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
#  define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
#else
#  define FMT_GCC_VERSION 0
#endif
#if defined(__ICL)
#  define FMT_ICC_VERSION __ICL
#elif defined(__INTEL_COMPILER)
#  define FMT_ICC_VERSION __INTEL_COMPILER
#else
#  define FMT_ICC_VERSION 0
#endif
#if defined(_MSC_VER)
#  define FMT_MSC_VERSION _MSC_VER
#else
#  define FMT_MSC_VERSION 0
#endif

// Detect standard library versions.
#ifdef _GLIBCXX_RELEASE
#  define FMT_GLIBCXX_RELEASE _GLIBCXX_RELEASE
#else
#  define FMT_GLIBCXX_RELEASE 0
#endif
#ifdef _LIBCPP_VERSION
#  define FMT_LIBCPP_VERSION _LIBCPP_VERSION
#else
#  define FMT_LIBCPP_VERSION 0
#endif

#ifdef _MSVC_LANG
#  define FMT_CPLUSPLUS _MSVC_LANG
#else
#  define FMT_CPLUSPLUS __cplusplus
#endif

// Detect __has_*.
#ifdef __has_feature
#  define FMT_HAS_FEATURE(x) __has_feature(x)
#else
#  define FMT_HAS_FEATURE(x) 0
#endif
#ifdef __has_include
#  define FMT_HAS_INCLUDE(x) __has_include(x)
#else
#  define FMT_HAS_INCLUDE(x) 0
#endif
#ifdef __has_builtin
#  define FMT_HAS_BUILTIN(x) __has_builtin(x)
#else
#  define FMT_HAS_BUILTIN(x) 0
#endif
#ifdef __has_cpp_attribute
#  define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
#else
#  define FMT_HAS_CPP_ATTRIBUTE(x) 0
#endif

#define FMT_HAS_CPP14_ATTRIBUTE(attribute) \
  (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))

#define FMT_HAS_CPP17_ATTRIBUTE(attribute) \
  (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))

// Detect C++14 relaxed constexpr.
#ifdef FMT_USE_CONSTEXPR
// Use the provided definition.
#elif FMT_GCC_VERSION >= 600 && FMT_CPLUSPLUS >= 201402L
// GCC only allows throw in constexpr since version 6:
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67371.
#  define FMT_USE_CONSTEXPR 1
#elif FMT_ICC_VERSION
#  define FMT_USE_CONSTEXPR 0  // https://github.com/fmtlib/fmt/issues/1628
#elif FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912
#  define FMT_USE_CONSTEXPR 1
#else
#  define FMT_USE_CONSTEXPR 0
#endif
#if FMT_USE_CONSTEXPR
#  define FMT_CONSTEXPR constexpr
#else
#  define FMT_CONSTEXPR
#endif

// Detect consteval, C++20 constexpr extensions and std::is_constant_evaluated.
#if !defined(__cpp_lib_is_constant_evaluated)
# define FMT_USE_CONSTEVAL 0
#elif FMT_CPLUSPLUS < 201709L
# define FMT_USE_CONSTEVAL 0
#elif FMT_GLIBCXX_RELEASE && FMT_GLIBCXX_RELEASE < 10
# define FMT_USE_CONSTEVAL 0
#elif FMT_LIBCPP_VERSION && FMT_LIBCPP_VERSION < 10000
# define FMT_USE_CONSTEVAL 0
#elif defined(__apple_build_version__) && __apple_build_version__ < 14000029L
# define FMT_USE_CONSTEVAL 0 // consteval is broken in Apple clang < 14.
#elif FMT_MSC_VERSION && FMT_MSC_VERSION < 1929
# define FMT_USE_CONSTEVAL 0 // consteval is broken in MSVC VS2019 < 16.10.
#elif defined(__cpp_consteval)
# define FMT_USE_CONSTEVAL 1
#elif FMT_GCC_VERSION >= 1002 || FMT_CLANG_VERSION >= 1101
# define FMT_USE_CONSTEVAL 1
#else
# define FMT_USE_CONSTEVAL 0
#endif
#if FMT_USE_CONSTEVAL
# define FMT_CONSTEVAL consteval
# define FMT_CONSTEXPR20 constexpr
#else
# define FMT_CONSTEVAL
# define FMT_CONSTEXPR20
#endif

// Check if exceptions are disabled.
#ifdef FMT_USE_EXCEPTIONS
// Use the provided definition.
#elif defined(__GNUC__) && !defined(__EXCEPTIONS)
#  define FMT_USE_EXCEPTIONS 0
#elif FMT_MSC_VERSION && !_HAS_EXCEPTIONS
#  define FMT_USE_EXCEPTIONS 0
#else
#  define FMT_USE_EXCEPTIONS 1
#endif
#if FMT_USE_EXCEPTIONS
#  define FMT_TRY try
#  define FMT_CATCH(x) catch (x)
#else
#  define FMT_TRY if (true)
#  define FMT_CATCH(x) if (false)
#endif

#if FMT_HAS_CPP17_ATTRIBUTE(fallthrough)
#  define FMT_FALLTHROUGH [[fallthrough]]
#elif defined(__clang__)
#  define FMT_FALLTHROUGH [[clang::fallthrough]]
#elif FMT_GCC_VERSION >= 700 && \
    (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520)
#  define FMT_FALLTHROUGH [[gnu::fallthrough]]
#else
#  define FMT_FALLTHROUGH
#endif

// Disable [[noreturn]] on MSVC/NVCC because of bogus unreachable code warnings.
#if FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VERSION && !defined(__NVCC__)
#  define FMT_NORETURN [[noreturn]]
#else
#  define FMT_NORETURN
#endif

#ifdef FMT_NODISCARD
// Use the provided definition.
#elif FMT_HAS_CPP17_ATTRIBUTE(nodiscard)
#  define FMT_NODISCARD [[nodiscard]]
#else
#  define FMT_NODISCARD
#endif

#ifdef FMT_DEPRECATED
// Use the provided definition.
#elif FMT_HAS_CPP14_ATTRIBUTE(deprecated)
#  define FMT_DEPRECATED [[deprecated]]
#else
#  define FMT_DEPRECATED /* deprecated */
#endif

#ifdef FMT_ALWAYS_INLINE
// Use the provided definition.
#elif FMT_GCC_VERSION || FMT_CLANG_VERSION
#  define FMT_ALWAYS_INLINE inline __attribute__((always_inline))
#else
#  define FMT_ALWAYS_INLINE inline
#endif
// A version of FMT_ALWAYS_INLINE to prevent code bloat in debug mode.
#ifdef NDEBUG
#  define FMT_INLINE FMT_ALWAYS_INLINE
#else
#  define FMT_INLINE inline
#endif

#if FMT_GCC_VERSION || FMT_CLANG_VERSION
#  define FMT_VISIBILITY(value) __attribute__((visibility(value)))
#else
#  define FMT_VISIBILITY(value)
#endif

#define FMT_PRAGMA_IMPL(x) _Pragma(#x)
#ifdef FMT_PRAGMA_GCC
// Use the provided definition.
#elif FMT_GCC_VERSION >= 504 && !defined(__NVCOMPILER)
// Workaround a _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884
// and an nvhpc warning: https://github.com/fmtlib/fmt/pull/2582.
#  define FMT_PRAGMA_GCC(x) FMT_PRAGMA_IMPL(GCC x)
#else
#  define FMT_PRAGMA_GCC(x)
#endif

#ifdef FMT_PRAGMA_CLANG
// Use the provided definition.
#elif FMT_CLANG_VERSION
#  define FMT_PRAGMA_CLANG(x) FMT_PRAGMA_IMPL(clang x)
#else
#  define FMT_PRAGMA_CLANG(x)
#endif

#if FMT_MSC_VERSION
#  define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__))
#  define FMT_UNCHECKED_ITERATOR(It) \
    using _Unchecked_type = It  // Mark iterator as checked.
#else
#  define FMT_MSC_WARNING(...)
#  define FMT_UNCHECKED_ITERATOR(It) using unchecked_type = It
#endif

#ifndef FMT_BEGIN_NAMESPACE
#  define FMT_BEGIN_NAMESPACE \
    namespace fmt {           \
    inline namespace v11 {
#  define FMT_END_NAMESPACE \
    }                       \
    }
#endif

#ifndef FMT_EXPORT
#  define FMT_EXPORT
#  define FMT_BEGIN_EXPORT
#  define FMT_END_EXPORT
#endif

#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
#  if defined(FMT_LIB_EXPORT)
#    define FMT_API __declspec(dllexport)
#  elif defined(FMT_SHARED)
#    define FMT_API __declspec(dllimport)
#  endif
#elif defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)
#  define FMT_API FMT_VISIBILITY("default")
#endif
#ifndef FMT_API
#  define FMT_API
#endif

#ifndef FMT_OPTIMIZE_SIZE
#  define FMT_OPTIMIZE_SIZE 0
#endif

// FMT_BUILTIN_TYPE=0 may result in smaller library size at the cost of higher
// per-call binary size by passing built-in types through the extension API.
#ifndef FMT_BUILTIN_TYPES
#  define FMT_BUILTIN_TYPES 1
#endif

#define FMT_APPLY_VARIADIC(expr) \
  using ignore = int[];          \
  (void)ignore { 0, (expr, 0)... }

// Enable minimal optimizations for more compact code in debug mode.
FMT_PRAGMA_GCC(push_options)
#if !defined(__OPTIMIZE__) && !defined(__CUDACC__)
FMT_PRAGMA_GCC(optimize("Og"))
#endif
FMT_PRAGMA_CLANG(diagnostic push)

FMT_BEGIN_NAMESPACE

// Implementations of enable_if_t and other metafunctions for older systems.
template <bool B, typename T = void>
using enable_if_t = typename std::enable_if<B, T>::type;
template <bool B, typename T, typename F>
using conditional_t = typename std::conditional<B, T, F>::type;
template <bool B> using bool_constant = std::integral_constant<bool, B>;
template <typename T>
using remove_reference_t = typename std::remove_reference<T>::type;
template <typename T>
using remove_const_t = typename std::remove_const<T>::type;
template <typename T>
using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
template <typename T>
using make_unsigned_t = typename std::make_unsigned<T>::type;
template <typename T>
using underlying_t = typename std::underlying_type<T>::type;
template <typename T> using decay_t = typename std::decay<T>::type;

#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500
// A workaround for gcc 4.9 to make void_t work in a SFINAE context.
template <typename...> struct void_t_impl {
 using type = void;
};
template <typename... T> using void_t = typename void_t_impl<T...>::type;
#else
template <typename...> using void_t = void;
#endif

struct monostate {
  constexpr monostate() {}
};

// An enable_if helper to be used in template parameters which results in much
// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed
// to workaround a bug in MSVC 2019 (see #1140 and #1186).
#ifdef FMT_DOC
# define FMT_ENABLE_IF(...)
#else
# define FMT_ENABLE_IF(...) fmt::enable_if_t<(__VA_ARGS__), int> = 0
#endif

namespace detail {
// Suppresses "unused variable" warnings with the method described in
// https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/.
// (void)var does not work on many Intel compilers.
template <typename... T> FMT_CONSTEXPR void ignore_unused(const T&...) {}

constexpr auto is_constant_evaluated(bool default_value = false) noexcept
 -> bool {
// Workaround for incompatibility between clang 14 and libstdc++ consteval-based
// std::is_constant_evaluated: https://github.com/fmtlib/fmt/issues/3247.
#if FMT_CPLUSPLUS >= 202002L && FMT_GLIBCXX_RELEASE >= 12 && \
 (FMT_CLANG_VERSION >= 1400 && FMT_CLANG_VERSION < 1500)
 ignore_unused(default_value);
 return __builtin_is_constant_evaluated();
#elif defined(__cpp_lib_is_constant_evaluated)
 ignore_unused(default_value);
 return std::is_constant_evaluated();
#else
 return default_value;
#endif
}

// Suppresses "conditional expression is constant" warnings.
template <typename T> constexpr auto const_check(T value) -> T { return value; }

FMT_NORETURN FMT_API void assert_fail(const char* file, int line,
                                      const char* message);

#if defined(FMT_ASSERT)
// Use the provided definition.
#elif defined(NDEBUG)
// FMT_ASSERT is not empty to avoid -Wempty-body.
#  define FMT_ASSERT(condition, message) \
    fmt::detail::ignore_unused((condition), (message))
#else
#  define FMT_ASSERT(condition, message)                                    \
    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
         ? (void)0                                                          \
         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
#endif

#ifdef FMT_USE_INT128
// Use the provided definition.
#elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && \
    !(FMT_CLANG_VERSION && FMT_MSC_VERSION)
#  define FMT_USE_INT128 1
using int128_opt = __int128_t;  // An optional native 128-bit integer.
using uint128_opt = __uint128_t;
inline auto map(int128_opt x) -> int128_opt { return x; }
inline auto map(uint128_opt x) -> uint128_opt { return x; }
#else
#  define FMT_USE_INT128 0
#endif
#if !FMT_USE_INT128
enum class int128_opt {};
enum class uint128_opt {};
// Reduce template instantiations.
inline auto map(int128_opt) -> monostate { return {}; }
inline auto map(uint128_opt) -> monostate { return {}; }
#endif

#ifndef FMT_USE_BITINT
#  define FMT_USE_BITINT (FMT_CLANG_VERSION >= 1400)
#endif

#if FMT_USE_BITINT
FMT_PRAGMA_CLANG(diagnostic ignored "-Wbit-int-extension")
template <int N> using bitint = _BitInt(N);
template <int N> using ubitint = unsigned _BitInt(N);
#else
template <int N> struct bitint {};
template <int N> struct ubitint {};
#endif // FMT_USE_BITINT

// Casts a nonnegative integer to unsigned.
template <typename Int>
FMT_CONSTEXPR auto to_unsigned(Int value) -> make_unsigned_t<Int> {
 FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value");
 return static_cast<make_unsigned_t<Int>>(value);
}

template <typename Char>
using unsigned_char = conditional_t<sizeof(Char) == 1, unsigned char, unsigned>;

// A heuristic to detect std::string and std::[experimental::]string_view.
// It is mainly used to avoid dependency on <[experimental/]string_view>.
template <typename T, typename Enable = void>
struct is_std_string_like : std::false_type {};
template <typename T>
struct is_std_string_like<T, void_t<decltype(std::declval<T>().find_first_of(
 typename T::value_type(), 0))>>
 : std::is_convertible<decltype(std::declval<T>().data()),
 const typename T::value_type*> {};

// Check if the literal encoding is UTF-8.
enum { is_utf8_enabled = "\u00A7"[1] == '\xA7' };
enum { use_utf8 = !FMT_MSC_VERSION || is_utf8_enabled };

#ifndef FMT_UNICODE
#  define FMT_UNICODE 1
#endif

static_assert(!FMT_UNICODE || use_utf8,
              "Unicode support requires compiling with /utf-8");

template <typename T> constexpr const char* narrow(const T*) { return nullptr; }
constexpr FMT_ALWAYS_INLINE const char* narrow(const char* s) { return s; }

template <typename Char>
FMT_CONSTEXPR auto compare(const Char* s1, const Char* s2, std::size_t n)
 -> int {
 if (!is_constant_evaluated() && sizeof(Char) == 1) return memcmp(s1, s2, n);
 for (; n != 0; ++s1, ++s2, --n) {
 if (*s1 < *s2) return -1;
 if (*s1 > *s2) return 1;
 }
 return 0;
}

namespace adl {
using namespace std;

template <typename Container>
auto invoke_back_inserter()
 -> decltype(back_inserter(std::declval<Container&>()));
} // namespace adl

template <typename It, typename Enable = std::true_type>
struct is_back_insert_iterator : std::false_type {};

template <typename It>
struct is_back_insert_iterator<
 It, bool_constant<std::is_same<
 decltype(adl::invoke_back_inserter<typename It::container_type>()),
 It>::value>> : std::true_type {};

// Extracts a reference to the container from *insert_iterator.
template <typename OutputIt>
inline FMT_CONSTEXPR20 auto get_container(OutputIt it) ->
 typename OutputIt::container_type& {
 struct accessor : OutputIt {
 FMT_CONSTEXPR20 accessor(OutputIt base) : OutputIt(base) {}
 using OutputIt::container;
 };
 return *accessor(it).container;
}
} // namespace detail

// Parsing-related public API and forward declarations.
FMT_BEGIN_EXPORT

/**
 * An implementation of `std::basic_string_view` for pre-C++17. It provides a
 * subset of the API. `fmt::basic_string_view` is used for format strings even
 * if `std::basic_string_view` is available to prevent issues when a library is
 * compiled with a different `-std` option than the client code (which is not
 * recommended).
 */
template <typename Char> class basic_string_view {
 private:
 const Char* data_;
 size_t size_;

public:
  using value_type = Char;
  using iterator = const Char*;

constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {}

/// Constructs a string reference object from a C string and a size.
  constexpr basic_string_view(const Char* s, size_t count) noexcept
      : data_(s), size_(count) {}

constexpr basic_string_view(std::nullptr_t) = delete;

/// Constructs a string reference object from a C string.
#if FMT_GCC_VERSION
 FMT_ALWAYS_INLINE
#endif
 FMT_CONSTEXPR20 basic_string_view(const Char* s) : data_(s) {
#if FMT_HAS_BUILTIN(__buitin_strlen) || FMT_GCC_VERSION || FMT_CLANG_VERSION
 if (std::is_same<Char, char>::value) {
 size_ = __builtin_strlen(detail::narrow(s));
 return;
 }
#endif
 size_t len = 0;
 while (*s++) ++len;
 size_ = len;
 }

/// Constructs a string reference from a `std::basic_string` or a
 /// `std::basic_string_view` object.
 template <typename S,
 FMT_ENABLE_IF(detail::is_std_string_like<S>::value&& std::is_same<
 typename S::value_type, Char>::value)>
 FMT_CONSTEXPR basic_string_view(const S& s) noexcept
 : data_(s.data()), size_(s.size()) {}

/// Returns a pointer to the string data.
  constexpr auto data() const noexcept -> const Char* { return data_; }

/// Returns the string size.
  constexpr auto size() const noexcept -> size_t { return size_; }

constexpr auto begin() const noexcept -> iterator { return data_; }
  constexpr auto end() const noexcept -> iterator { return data_ + size_; }

constexpr auto operator[](size_t pos) const noexcept -> const Char& {
    return data_[pos];
  }

FMT_CONSTEXPR void remove_prefix(size_t n) noexcept {
    data_ += n;
    size_ -= n;
  }

FMT_CONSTEXPR auto starts_with(basic_string_view<Char> sv) const noexcept
 -> bool {
 return size_ >= sv.size_ && detail::compare(data_, sv.data_, sv.size_) == 0;
 }
 FMT_CONSTEXPR auto starts_with(Char c) const noexcept -> bool {
 return size_ >= 1 && *data_ == c;
 }
 FMT_CONSTEXPR auto starts_with(const Char* s) const -> bool {
 return starts_with(basic_string_view<Char>(s));
 }

// Lexicographically compare this string reference to other.
 FMT_CONSTEXPR auto compare(basic_string_view other) const -> int {
 size_t str_size = size_ < other.size_ ? size_ : other.size_;
 int result = detail::compare(data_, other.data_, str_size);
 if (result == 0)
 result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
 return result;
 }

FMT_CONSTEXPR friend auto operator==(basic_string_view lhs,
 basic_string_view rhs) -> bool {
 return lhs.compare(rhs) == 0;
 }
 friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool {
 return lhs.compare(rhs) != 0;
 }
 friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool {
 return lhs.compare(rhs) < 0;
 }
 friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool {
 return lhs.compare(rhs) <= 0;
 }
 friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool {
 return lhs.compare(rhs) > 0;
 }
 friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool {
 return lhs.compare(rhs) >= 0;
 }
};

using string_view = basic_string_view<char>;

/// Specifies if `T` is a character type. Can be specialized by users.
template <typename T> struct is_char : std::false_type {};
template <> struct is_char<char> : std::true_type {};

template <typename T> class basic_appender;
using appender = basic_appender<char>;

// Checks whether T is a container with contiguous storage.
template <typename T> struct is_contiguous : std::false_type {};

class context;
template <typename OutputIt, typename Char> class generic_context;
template <typename Char> class parse_context;

// Longer aliases for C++20 compatibility.
template <typename Char> using basic_format_parse_context = parse_context<Char>;
using format_parse_context = parse_context<char>;
template <typename OutputIt, typename Char>
using basic_format_context =
 conditional_t<std::is_same<OutputIt, appender>::value, context,
 generic_context<OutputIt, Char>>;
using format_context = context;

template <typename Char>
using buffered_context =
 conditional_t<std::is_same<Char, char>::value, context,
 generic_context<basic_appender<Char>, Char>>;

template <typename Context> class basic_format_arg;
template <typename Context> class basic_format_args;

// A separate type would result in shorter symbols but break ABI compatibility
// between clang and gcc on ARM (#1919).
using format_args = basic_format_args<context>;

// A formatter for objects of type T.
template <typename T, typename Char = char, typename Enable = void>
struct formatter {
 // A deleted default constructor indicates a disabled formatter.
 formatter() = delete;
};

// This is defined in base.h instead of format.h to avoid injecting in std.
// It is a template to avoid undesirable implicit conversions to std::byte.
#ifdef __cpp_lib_byte
template <typename T, FMT_ENABLE_IF(std::is_same<T, std::byte>::value)>
inline auto format_as(T b) -> unsigned char {
 return static_cast<unsigned char>(b);
}
#endif

/// Reports a format error at compile time or, via a `format_error` exception,
/// at runtime.
// This function is intentionally not constexpr to give a compile-time error.
FMT_NORETURN FMT_API void report_error(const char* message);

enum class presentation_type : unsigned char {
  // Common specifiers:
  none = 0,
  debug = 1,   // '?'
  string = 2,  // 's' (string, bool)

// Integral, bool and character specifiers:
  dec = 3,  // 'd'
  hex,      // 'x' or 'X'
  oct,      // 'o'
  bin,      // 'b' or 'B'
  chr,      // 'c'

// String and pointer specifiers:
  pointer = 3,  // 'p'

// Floating-point specifiers:
  exp = 1,  // 'e' or 'E' (1 since there is no FP debug presentation)
  fixed,    // 'f' or 'F'
  general,  // 'g' or 'G'
  hexfloat  // 'a' or 'A'
};

enum class align { none, left, right, center, numeric };
enum class sign { none, minus, plus, space };
enum class arg_id_kind { none, index, name };

// Basic format specifiers for built-in and string types.
class basic_specs {
 private:
  // Data is arranged as follows:
  //
  //  0                   1                   2                   3
  //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  // |type |align| w | p | s |u|#|L|  f  |          unused           |
  // +-----+-----+---+---+---+-+-+-+-----+---------------------------+
  //
  //   w - dynamic width info
  //   p - dynamic precision info
  //   s - sign
  //   u - uppercase (e.g. 'X' for 'x')
  //   # - alternate form ('#')
  //   L - localized
  //   f - fill size
  //
  // Bitfields are not used because of compiler bugs such as gcc bug 61414.
  enum : unsigned {
    type_mask = 0x00007,
    align_mask = 0x00038,
    width_mask = 0x000C0,
    precision_mask = 0x00300,
    sign_mask = 0x00C00,
    uppercase_mask = 0x01000,
    alternate_mask = 0x02000,
    localized_mask = 0x04000,
    fill_size_mask = 0x38000,

align_shift = 3,
    width_shift = 6,
    precision_shift = 8,
    sign_shift = 10,
    fill_size_shift = 15,

max_fill_size = 4
  };

unsigned long data_ = 1 << fill_size_shift;

// Character (code unit) type is erased to prevent template bloat.
  char fill_data_[max_fill_size] = {' '};

FMT_CONSTEXPR void set_fill_size(size_t size) {
 data_ = (data_ & ~fill_size_mask) | (size << fill_size_shift);
 }

public:
 constexpr auto type() const -> presentation_type {
 return static_cast<presentation_type>(data_ & type_mask);
 }
 FMT_CONSTEXPR void set_type(presentation_type t) {
 data_ = (data_ & ~type_mask) | static_cast<unsigned>(t);
 }

constexpr auto align() const -> align {
 return static_cast<fmt::align>((data_ & align_mask) >> align_shift);
 }
 FMT_CONSTEXPR void set_align(fmt::align a) {
 data_ = (data_ & ~align_mask) | (static_cast<unsigned>(a) << align_shift);
 }

constexpr auto dynamic_width() const -> arg_id_kind {
 return static_cast<arg_id_kind>((data_ & width_mask) >> width_shift);
 }
 FMT_CONSTEXPR void set_dynamic_width(arg_id_kind w) {
 data_ = (data_ & ~width_mask) | (static_cast<unsigned>(w) << width_shift);
 }

FMT_CONSTEXPR auto dynamic_precision() const -> arg_id_kind {
 return static_cast<arg_id_kind>((data_ & precision_mask) >>
 precision_shift);
 }
 FMT_CONSTEXPR void set_dynamic_precision(arg_id_kind p) {
 data_ = (data_ & ~precision_mask) |
 (static_cast<unsigned>(p) << precision_shift);
 }

constexpr bool dynamic() const {
    return (data_ & (width_mask | precision_mask)) != 0;
  }

constexpr auto sign() const -> sign {
 return static_cast<fmt::sign>((data_ & sign_mask) >> sign_shift);
 }
 FMT_CONSTEXPR void set_sign(fmt::sign s) {
 data_ = (data_ & ~sign_mask) | (static_cast<unsigned>(s) << sign_shift);
 }

constexpr auto upper() const -> bool { return (data_ & uppercase_mask) != 0; }
  FMT_CONSTEXPR void set_upper() { data_ |= uppercase_mask; }

constexpr auto alt() const -> bool { return (data_ & alternate_mask) != 0; }
  FMT_CONSTEXPR void set_alt() { data_ |= alternate_mask; }
  FMT_CONSTEXPR void clear_alt() { data_ &= ~alternate_mask; }

constexpr auto localized() const -> bool {
    return (data_ & localized_mask) != 0;
  }
  FMT_CONSTEXPR void set_localized() { data_ |= localized_mask; }

constexpr auto fill_size() const -> size_t {
    return (data_ & fill_size_mask) >> fill_size_shift;
  }

template <typename Char, FMT_ENABLE_IF(std::is_same<Char, char>::value)>
 constexpr auto fill() const -> const Char* {
 return fill_data_;
 }
 template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
 constexpr auto fill() const -> const Char* {
 return nullptr;
 }

template <typename Char> constexpr auto fill_unit() const -> Char {
 using uchar = unsigned char;
 return static_cast<Char>(static_cast<uchar>(fill_data_[0]) |
 (static_cast<uchar>(fill_data_[1]) << 8));
 }

FMT_CONSTEXPR void set_fill(char c) {
    fill_data_[0] = c;
    set_fill_size(1);
  }

template <typename Char>
 FMT_CONSTEXPR void set_fill(basic_string_view<Char> s) {
 auto size = s.size();
 set_fill_size(size);
 if (size == 1) {
 unsigned uchar = static_cast<detail::unsigned_char<Char>>(s[0]);
 fill_data_[0] = static_cast<char>(uchar);
 fill_data_[1] = static_cast<char>(uchar >> 8);
 return;
 }
 FMT_ASSERT(size <= max_fill_size, "invalid fill");
 for (size_t i = 0; i < size; ++i)
 fill_data_[i & 3] = static_cast<char>(s[i]);
 }
};

// Format specifiers for built-in and string types.
struct format_specs : basic_specs {
  int width;
  int precision;

constexpr format_specs() : width(0), precision(-1) {}
};

/**
 * Parsing context consisting of a format string range being parsed and an
 * argument counter for automatic indexing.
 */
template <typename Char = char> class parse_context {
 private:
 basic_string_view<Char> fmt_;
 int next_arg_id_;

enum { use_constexpr_cast = !FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200 };

FMT_CONSTEXPR void do_check_arg_id(int arg_id);

public:
  using char_type = Char;
  using iterator = const Char*;

explicit constexpr parse_context(basic_string_view<Char> fmt,
 int next_arg_id = 0)
 : fmt_(fmt), next_arg_id_(next_arg_id) {}

/// Returns an iterator to the beginning of the format string range being
  /// parsed.
  constexpr auto begin() const noexcept -> iterator { return fmt_.begin(); }

/// Returns an iterator past the end of the format string range being parsed.
  constexpr auto end() const noexcept -> iterator { return fmt_.end(); }

/// Advances the begin iterator to `it`.
  FMT_CONSTEXPR void advance_to(iterator it) {
    fmt_.remove_prefix(detail::to_unsigned(it - begin()));
  }

/// Reports an error if using the manual argument indexing; otherwise returns
 /// the next argument index and switches to the automatic indexing.
 FMT_CONSTEXPR auto next_arg_id() -> int {
 if (next_arg_id_ < 0) {
 report_error("cannot switch from manual to automatic argument indexing");
 return 0;
 }
 int id = next_arg_id_++;
 do_check_arg_id(id);
 return id;
 }

/// Reports an error if using the automatic argument indexing; otherwise
 /// switches to the manual indexing.
 FMT_CONSTEXPR void check_arg_id(int id) {
 if (next_arg_id_ > 0) {
 report_error("cannot switch from automatic to manual argument indexing");
 return;
 }
 next_arg_id_ = -1;
 do_check_arg_id(id);
 }
 FMT_CONSTEXPR void check_arg_id(basic_string_view<Char>) {
 next_arg_id_ = -1;
 }
 FMT_CONSTEXPR void check_dynamic_spec(int arg_id);
};

FMT_END_EXPORT

namespace detail {

// Constructs fmt::basic_string_view<Char> from types implicitly convertible
// to it, deducing Char. Explicitly convertible types such as the ones returned
// from FMT_STRING are intentionally excluded.
template <typename Char, FMT_ENABLE_IF(is_char<Char>::value)>
constexpr auto to_string_view(const Char* s) -> basic_string_view<Char> {
 return s;
}
template <typename T, FMT_ENABLE_IF(is_std_string_like<T>::value)>
constexpr auto to_string_view(const T& s)
 -> basic_string_view<typename T::value_type> {
 return s;
}
template <typename Char>
constexpr auto to_string_view(basic_string_view<Char> s)
 -> basic_string_view<Char> {
 return s;
}

template <typename T, typename Enable = void>
struct has_to_string_view : std::false_type {};
// detail:: is intentional since to_string_view is not an extension point.
template <typename T>
struct has_to_string_view<
 T, void_t<decltype(detail::to_string_view(std::declval<T>()))>>
 : std::true_type {};

/// String's character (code unit) type. detail:: is intentional to prevent ADL.
template <typename S,
 typename V = decltype(detail::to_string_view(std::declval<S>()))>
using char_t = typename V::value_type;

enum class type {
  none_type,
  // Integer types should go first,
  int_type,
  uint_type,
  long_long_type,
  ulong_long_type,
  int128_type,
  uint128_type,
  bool_type,
  char_type,
  last_integer_type = char_type,
  // followed by floating-point types.
  float_type,
  double_type,
  long_double_type,
  last_numeric_type = long_double_type,
  cstring_type,
  string_type,
  pointer_type,
  custom_type
};

// Maps core type T to the corresponding type enum constant.
template <typename T, typename Char>
struct type_constant : std::integral_constant<type, type::custom_type> {};

#define FMT_TYPE_CONSTANT(Type, constant) \
 template <typename Char> \
 struct type_constant<Type, Char> \
 : std::integral_constant<type, type::constant> {}

FMT_TYPE_CONSTANT(int, int_type);
FMT_TYPE_CONSTANT(unsigned, uint_type);
FMT_TYPE_CONSTANT(long long, long_long_type);
FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type);
FMT_TYPE_CONSTANT(int128_opt, int128_type);
FMT_TYPE_CONSTANT(uint128_opt, uint128_type);
FMT_TYPE_CONSTANT(bool, bool_type);
FMT_TYPE_CONSTANT(Char, char_type);
FMT_TYPE_CONSTANT(float, float_type);
FMT_TYPE_CONSTANT(double, double_type);
FMT_TYPE_CONSTANT(long double, long_double_type);
FMT_TYPE_CONSTANT(const Char*, cstring_type);
FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type);
FMT_TYPE_CONSTANT(const void*, pointer_type);

constexpr auto is_integral_type(type t) -> bool {
 return t > type::none_type && t <= type::last_integer_type;
}
constexpr auto is_arithmetic_type(type t) -> bool {
 return t > type::none_type && t <= type::last_numeric_type;
}

constexpr auto set(type rhs) -> int { return 1 << static_cast<int>(rhs); }
constexpr auto in(type t, int set) -> bool {
 return ((set >> static_cast<int>(t)) & 1) != 0;
}

// Bitsets of types.
enum {
  sint_set =
      set(type::int_type) | set(type::long_long_type) | set(type::int128_type),
  uint_set = set(type::uint_type) | set(type::ulong_long_type) |
             set(type::uint128_type),
  bool_set = set(type::bool_type),
  char_set = set(type::char_type),
  float_set = set(type::float_type) | set(type::double_type) |
              set(type::long_double_type),
  string_set = set(type::string_type),
  cstring_set = set(type::cstring_type),
  pointer_set = set(type::pointer_type)
};

struct view {};

template <typename Char, typename T> struct named_arg;
template <typename T> struct is_named_arg : std::false_type {};
template <typename T> struct is_static_named_arg : std::false_type {};

template <typename Char, typename T>
struct is_named_arg<named_arg<Char, T>> : std::true_type {};

template <typename Char, typename T> struct named_arg : view {
 const Char* name;
 const T& value;

named_arg(const Char* n, const T& v) : name(n), value(v) {}

static_assert(!is_named_arg<T>::value, "nested named arguments");
};

template <typename Char, typename T>
auto unwrap_named_arg(const named_arg<Char, T>& arg) -> const T& {
 return arg.value;
}
template <typename T,
 FMT_ENABLE_IF(!is_named_arg<remove_reference_t<T>>::value)>
auto unwrap_named_arg(T&& value) -> T&& {
 return value;
}

template <bool B = false> constexpr auto count() -> size_t { return B ? 1 : 0; }
template <bool B1, bool B2, bool... Tail> constexpr auto count() -> size_t {
 return (B1 ? 1 : 0) + count<B2, Tail...>();
}

template <typename... Args> constexpr auto count_named_args() -> size_t {
 return count<is_named_arg<Args>::value...>();
}
template <typename... Args> constexpr auto count_static_named_args() -> size_t {
 return count<is_static_named_arg<Args>::value...>();
}

template <typename Char> struct named_arg_info {
 const Char* name;
 int id;
};

template <typename Char, typename T, FMT_ENABLE_IF(!is_named_arg<T>::value)>
void init_named_arg(named_arg_info<Char>*, int& arg_index, int&, const T&) {
 ++arg_index;
}
template <typename Char, typename T, FMT_ENABLE_IF(is_named_arg<T>::value)>
void init_named_arg(named_arg_info<Char>* named_args, int& arg_index,
 int& named_arg_index, const T& arg) {
 named_args[named_arg_index++] = {arg.name, arg_index++};
}

template <typename T, typename Char,
 FMT_ENABLE_IF(!is_static_named_arg<T>::value)>
FMT_CONSTEXPR void init_static_named_arg(named_arg_info<Char>*, int& arg_index,
 int&) {
 ++arg_index;
}
template <typename T, typename Char,
 FMT_ENABLE_IF(is_static_named_arg<T>::value)>
FMT_CONSTEXPR void init_static_named_arg(named_arg_info<Char>* named_args,
 int& arg_index, int& named_arg_index) {
 named_args[named_arg_index++] = {T::name, arg_index++};
}

// To minimize the number of types we need to deal with, long is translated
// either to int or to long long depending on its size.
enum { long_short = sizeof(long) == sizeof(int) };
using long_type = conditional_t<long_short, int, long long>;
using ulong_type = conditional_t<long_short, unsigned, unsigned long long>;

template <typename T> struct format_as_result {
 template <typename U,
 FMT_ENABLE_IF(std::is_enum::value || std::is_class::value)>
 static auto map(U*) -> remove_cvref_t<decltype(format_as(std::declval()))>;
 static auto map(...) -> void;

using type = decltype(map(static_cast<T*>(nullptr)));
};
template <typename T> using format_as_t = typename format_as_result<T>::type;

template <typename Char, typename T>
constexpr auto has_const_formatter_impl(T*)
 -> decltype(formatter<T, Char>().format(
 std::declval<const T&>(),
 std::declval<buffered_context<Char>&>()),
 true) {
 return true;
}
template <typename Char> constexpr auto has_const_formatter_impl(...) -> bool {
 return false;
}
template <typename T, typename Char>
constexpr auto has_const_formatter() -> bool {
 return has_const_formatter_impl<Char>(static_cast<T*>(nullptr));
}

struct unformattable {};
struct unformattable_char : unformattable {};
struct unformattable_pointer : unformattable {};

#define FMT_MAP_API static FMT_CONSTEXPR FMT_ALWAYS_INLINE

// Maps formatting arguments to reduce the set of types we need to work with.
// Returns unformattable* on errors to be SFINAE-friendly.
template <typename Char> struct arg_mapper {
 FMT_MAP_API auto map(signed char x) -> int { return x; }
 FMT_MAP_API auto map(unsigned char x) -> unsigned { return x; }
 FMT_MAP_API auto map(short x) -> int { return x; }
 FMT_MAP_API auto map(unsigned short x) -> unsigned { return x; }
 FMT_MAP_API auto map(int x) -> int { return x; }
 FMT_MAP_API auto map(unsigned x) -> unsigned { return x; }
 FMT_MAP_API auto map(long x) -> long_type { return x; }
 FMT_MAP_API auto map(unsigned long x) -> ulong_type { return x; }
 FMT_MAP_API auto map(long long x) -> long long { return x; }
 FMT_MAP_API auto map(unsigned long long x) -> unsigned long long { return x; }
 FMT_MAP_API auto map(int128_opt x) -> int128_opt { return x; }
 FMT_MAP_API auto map(uint128_opt x) -> uint128_opt { return x; }
 FMT_MAP_API auto map(bool x) -> bool { return x; }

template <typename T, FMT_ENABLE_IF(std::is_same<T, char>::value ||
 std::is_same<T, Char>::value)>
 FMT_MAP_API auto map(T x) -> Char {
 return x;
 }
 template <typename T, enable_if_t<(std::is_same<T, wchar_t>::value ||
#ifdef __cpp_char8_t
 std::is_same<T, char8_t>::value ||
#endif
 std::is_same<T, char16_t>::value ||
 std::is_same<T, char32_t>::value) &&
 !std::is_same<T, Char>::value,
 int> = 0>
 FMT_MAP_API auto map(T) -> unformattable_char {
 return {};
 }

FMT_MAP_API auto map(float x) -> float { return x; }
  FMT_MAP_API auto map(double x) -> double { return x; }
  FMT_MAP_API auto map(long double x) -> long double { return x; }

template <int N, FMT_ENABLE_IF(N <= 64)>
 FMT_MAP_API auto map(bitint<N> x) -> long long {
 return x;
 }
 template <int N, FMT_ENABLE_IF(N <= 64)>
 FMT_MAP_API auto map(ubitint<N> x) -> unsigned long long {
 return x;
 }
 template <int N, FMT_ENABLE_IF(N > 64)>
 FMT_MAP_API auto map(bitint<N>) -> unformattable {
 return {};
 }
 template <int N, FMT_ENABLE_IF(N > 64)>
 FMT_MAP_API auto map(ubitint<N>) -> unformattable {
 return {};
 }

FMT_MAP_API auto map(Char* x) -> const Char* { return x; }
 FMT_MAP_API auto map(const Char* x) -> const Char* { return x; }
 template <typename T, typename C = char_t<T>,
 FMT_ENABLE_IF(std::is_same<C, Char>::value &&
 !std::is_pointer<T>::value)>
 FMT_MAP_API auto map(const T& x) -> basic_string_view<C> {
 return to_string_view(x);
 }
 template <typename T, typename C = char_t<T>,
 FMT_ENABLE_IF(!std::is_same<C, Char>::value &&
 !std::is_pointer<T>::value)>
 FMT_MAP_API auto map(const T&) -> unformattable_char {
 return {};
 }

FMT_MAP_API auto map(void* x) -> const void* { return x; }
 FMT_MAP_API auto map(const void* x) -> const void* { return x; }
 FMT_MAP_API auto map(volatile void* x) -> const void* {
 return const_cast<const void*>(x);
 }
 FMT_MAP_API auto map(const volatile void* x) -> const void* {
 return const_cast<const void*>(x);
 }
 FMT_MAP_API auto map(std::nullptr_t x) -> const void* { return x; }

// Use SFINAE instead of a const T* parameter to avoid a conflict with the
 // array overload.
 template <
 typename T,
 FMT_ENABLE_IF(
 std::is_pointer<T>::value || std::is_member_pointer<T>::value ||
 std::is_function<typename std::remove_pointer<T>::type>::value ||
 (std::is_array<T>::value &&
 !std::is_convertible<T, const Char*>::value))>
 FMT_MAP_API auto map(const T&) -> unformattable_pointer {
 return {};
 }

template <typename T, std::size_t N,
 FMT_ENABLE_IF(!std::is_same<T, wchar_t>::value)>
 FMT_MAP_API auto map(const T (&x)[N]) -> const T (&)[N] {
 return x;
 }

// Only map owning types because mapping views can be unsafe.
 template <typename T, typename U = format_as_t<T>,
 FMT_ENABLE_IF(std::is_arithmetic::value)>
 FMT_MAP_API auto map(const T& x) -> decltype(map(U())) {
 return map(format_as(x));
 }

template <typename T, typename U = remove_const_t<T>>
 struct formattable
 : bool_constant<has_const_formatter<U, Char>() ||
 (std::is_constructible<formatter<U, Char>>::value &&
 !std::is_const<T>::value)> {};

template <typename T, FMT_ENABLE_IF(formattable<T>::value)>
 FMT_MAP_API auto do_map(T& x) -> T& {
 return x;
 }
 template <typename T, FMT_ENABLE_IF(!formattable<T>::value)>
 FMT_MAP_API auto do_map(T&) -> unformattable {
 return {};
 }

// is_fundamental is used to allow formatters for extended FP types.
 template <typename T, typename U = remove_const_t<T>,
 FMT_ENABLE_IF(
 (std::is_class::value || std::is_enum::value ||
 std::is_union::value || std::is_fundamental::value) &&
 !has_to_string_view::value && !is_char::value &&
 !is_named_arg::value && !std::is_integral::value &&
 !std::is_arithmetic<format_as_t>::value)>
 FMT_MAP_API auto map(T& x) -> decltype(do_map(x)) {
 return do_map(x);
 }

template <typename T, FMT_ENABLE_IF(is_named_arg<T>::value)>
 FMT_MAP_API auto map(const T& named_arg) -> decltype(map(named_arg.value)) {
 return map(named_arg.value);
 }

FMT_MAP_API auto map(...) -> unformattable { return {}; }
};

// detail:: is used to workaround a bug in MSVC 2017.
template <typename T, typename Char>
using mapped_t = decltype(detail::arg_mapper<Char>::map(std::declval<T&>()));

// A type constant after applying arg_mapper.
template <typename T, typename Char = char>
using mapped_type_constant = type_constant<mapped_t<T, Char>, Char>;

template <typename T, typename Context,
 type TYPE =
 mapped_type_constant<T, typename Context::char_type>::value>
using stored_type_constant = std::integral_constant<
 type, Context::builtin_types || TYPE == type::int_type ? TYPE
 : type::custom_type>;
// A parse context with extra data used only in compile-time checks.
template <typename Char>
class compile_parse_context : public parse_context<Char> {
 private:
 int num_args_;
 const type* types_;
 using base = parse_context<Char>;

public:
 explicit FMT_CONSTEXPR compile_parse_context(basic_string_view<Char> fmt,
 int num_args, const type* types,
 int next_arg_id = 0)
 : base(fmt, next_arg_id), num_args_(num_args), types_(types) {}

constexpr auto num_args() const -> int { return num_args_; }
  constexpr auto arg_type(int id) const -> type { return types_[id]; }

FMT_CONSTEXPR auto next_arg_id() -> int {
    int id = base::next_arg_id();
    if (id >= num_args_) report_error("argument not found");
    return id;
  }

FMT_CONSTEXPR void check_arg_id(int id) {
    base::check_arg_id(id);
    if (id >= num_args_) report_error("argument not found");
  }
  using base::check_arg_id;

FMT_CONSTEXPR void check_dynamic_spec(int arg_id) {
 ignore_unused(arg_id);
 if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id]))
 report_error("width/precision is not integer");
 }
};

// An argument reference.
template <typename Char> union arg_ref {
 FMT_CONSTEXPR arg_ref(int idx = 0) : index(idx) {}
 FMT_CONSTEXPR arg_ref(basic_string_view<Char> n) : name(n) {}

int index;
 basic_string_view<Char> name;
};

// Format specifiers with width and precision resolved at formatting rather
// than parsing time to allow reusing the same parsed specifiers with
// different sets of arguments (precompilation of format strings).
template <typename Char = char> struct dynamic_format_specs : format_specs {
 arg_ref<Char> width_ref;
 arg_ref<Char> precision_ref;
};

// Converts a character to ASCII. Returns '\0' on conversion failure.
template <typename Char, FMT_ENABLE_IF(std::is_integral<Char>::value)>
constexpr auto to_ascii(Char c) -> char {
 return c <= 0xff ? static_cast<char>(c) : '\0';
}

// Returns the number of code units in a code point or 1 on error.
template <typename Char>
FMT_CONSTEXPR auto code_point_length(const Char* begin) -> int {
 if (const_check(sizeof(Char) != 1)) return 1;
 auto c = static_cast<unsigned char>(*begin);
 return static_cast<int>((0x3a55000000000000ull >> (2 * (c >> 3))) & 3) + 1;
}

// Parses the range [begin, end) as an unsigned integer. This function assumes
// that the range is non-empty and the first character is a digit.
template <typename Char>
FMT_CONSTEXPR auto parse_nonnegative_int(const Char*& begin, const Char* end,
 int error_value) noexcept -> int {
 FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
 unsigned value = 0, prev = 0;
 auto p = begin;
 do {
 prev = value;
 value = value * 10 + unsigned(*p - '0');
 ++p;
 } while (p != end && '0' <= *p && *p <= '9');
 auto num_digits = p - begin;
 begin = p;
 int digits10 = static_cast<int>(sizeof(int) * CHAR_BIT * 3 / 10);
 if (num_digits <= digits10) return static_cast<int>(value);
 // Check for overflow.
 unsigned max = INT_MAX;
 return num_digits == digits10 + 1 &&
 prev * 10ull + unsigned(p[-1] - '0') <= max
 ? static_cast<int>(value)
 : error_value;
}

FMT_CONSTEXPR inline auto parse_align(char c) -> align {
 switch (c) {
 case '<': return align::left;
 case '>': return align::right;
 case '^': return align::center;
 }
 return align::none;
}

template <typename Char> constexpr auto is_name_start(Char c) -> bool {
 return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_';
}

template <typename Char, typename Handler>
FMT_CONSTEXPR auto parse_arg_id(const Char* begin, const Char* end,
 Handler&& handler) -> const Char* {
 Char c = *begin;
 if (c >= '0' && c <= '9') {
 int index = 0;
 if (c != '0')
 index = parse_nonnegative_int(begin, end, INT_MAX);
 else
 ++begin;
 if (begin == end || (*begin != '}' && *begin != ':'))
 report_error("invalid format string");
 else
 handler.on_index(index);
 return begin;
 }
 if (FMT_OPTIMIZE_SIZE > 1 || !is_name_start(c)) {
 report_error("invalid format string");
 return begin;
 }
 auto it = begin;
 do {
 ++it;
 } while (it != end && (is_name_start(*it) || ('0' <= *it && *it <= '9')));
 handler.on_name({begin, to_unsigned(it - begin)});
 return it;
}

template <typename Char> struct dynamic_spec_handler {
 parse_context<Char>& ctx;
 arg_ref<Char>& ref;
 arg_id_kind& kind;

FMT_CONSTEXPR void on_index(int id) {
 ref = id;
 kind = arg_id_kind::index;
 ctx.check_arg_id(id);
 ctx.check_dynamic_spec(id);
 }
 FMT_CONSTEXPR void on_name(basic_string_view<Char> id) {
 ref = id;
 kind = arg_id_kind::name;
 ctx.check_arg_id(id);
 }
};

template <typename Char> struct parse_dynamic_spec_result {
 const Char* end;
 arg_id_kind kind;
};

// Parses integer | "{" [arg_id] "}".
template <typename Char>
FMT_CONSTEXPR auto parse_dynamic_spec(const Char* begin, const Char* end,
 int& value, arg_ref<Char>& ref,
 parse_context<Char>& ctx)
 -> parse_dynamic_spec_result<Char> {
 FMT_ASSERT(begin != end, "");
 auto kind = arg_id_kind::none;
 if ('0' <= *begin && *begin <= '9') {
 int val = parse_nonnegative_int(begin, end, -1);
 if (val == -1) report_error("number is too big");
 value = val;
 } else {
 if (*begin == '{') {
 ++begin;
 if (begin != end) {
 Char c = *begin;
 if (c == '}' || c == ':') {
 int id = ctx.next_arg_id();
 ref = id;
 kind = arg_id_kind::index;
 ctx.check_dynamic_spec(id);
 } else {
 begin = parse_arg_id(begin, end,
 dynamic_spec_handler<Char>{ctx, ref, kind});
 }
 }
 if (begin != end && *begin == '}') return {++begin, kind};
 }
 report_error("invalid format string");
 }
 return {begin, kind};
}

template <typename Char>
FMT_CONSTEXPR auto parse_width(const Char* begin, const Char* end,
 format_specs& specs, arg_ref<Char>& width_ref,
 parse_context<Char>& ctx) -> const Char* {
 auto result = parse_dynamic_spec(begin, end, specs.width, width_ref, ctx);
 specs.set_dynamic_width(result.kind);
 return result.end;
}

template <typename Char>
FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end,
 format_specs& specs,
 arg_ref<Char>& precision_ref,
 parse_context<Char>& ctx) -> const Char* {
 ++begin;
 if (begin == end) {
 report_error("invalid precision");
 return begin;
 }
 auto result =
 parse_dynamic_spec(begin, end, specs.precision, precision_ref, ctx);
 specs.set_dynamic_precision(result.kind);
 return result.end;
}

enum class state { start, align, sign, hash, zero, width, precision, locale };

// Parses standard format specifiers.
template <typename Char>
FMT_CONSTEXPR auto parse_format_specs(const Char* begin, const Char* end,
 dynamic_format_specs<Char>& specs,
 parse_context<Char>& ctx, type arg_type)
 -> const Char* {
 auto c = '\0';
 if (end - begin > 1) {
 auto next = to_ascii(begin[1]);
 c = parse_align(next) == align::none ? to_ascii(*begin) : '\0';
 } else {
 if (begin == end) return begin;
 c = to_ascii(*begin);
 }

struct {
    state current_state = state::start;
    FMT_CONSTEXPR void operator()(state s, bool valid = true) {
      if (current_state >= s || !valid)
        report_error("invalid format specifier");
      current_state = s;
    }
  } enter_state;

using pres = presentation_type;
  constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
  struct {
    const Char*& begin;
    format_specs& specs;
    type arg_type;

FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* {
      if (!in(arg_type, set)) report_error("invalid format specifier");
      specs.set_type(pres_type);
      return begin + 1;
    }
  } parse_presentation_type{begin, specs, arg_type};

for (;;) {
 switch (c) {
 case '<':
 case '>':
 case '^':
 enter_state(state::align);
 specs.set_align(parse_align(c));
 ++begin;
 break;
 case '+':
 case ' ':
 specs.set_sign(c == ' ' ? sign::space : sign::plus);
 FMT_FALLTHROUGH;
 case '-':
 enter_state(state::sign, in(arg_type, sint_set | float_set));
 ++begin;
 break;
 case '#':
 enter_state(state::hash, is_arithmetic_type(arg_type));
 specs.set_alt();
 ++begin;
 break;
 case '0':
 enter_state(state::zero);
 if (!is_arithmetic_type(arg_type))
 report_error("format specifier requires numeric argument");
 if (specs.align() == align::none) {
 // Ignore 0 if align is specified for compatibility with std::format.
 specs.set_align(align::numeric);
 specs.set_fill('0');
 }
 ++begin;
 break;
 case '1':
 case '2':
 case '3':
 case '4':
 case '5':
 case '6':
 case '7':
 case '8':
 case '9':
 case '{':
 enter_state(state::width);
 begin = parse_width(begin, end, specs, specs.width_ref, ctx);
 break;
 case '.':
 enter_state(state::precision,
 in(arg_type, float_set | string_set | cstring_set));
 begin = parse_precision(begin, end, specs, specs.precision_ref, ctx);
 break;
 case 'L':
 enter_state(state::locale, is_arithmetic_type(arg_type));
 specs.set_localized();
 ++begin;
 break;
 case 'd': return parse_presentation_type(pres::dec, integral_set);
 case 'X': specs.set_upper(); FMT_FALLTHROUGH;
 case 'x': return parse_presentation_type(pres::hex, integral_set);
 case 'o': return parse_presentation_type(pres::oct, integral_set);
 case 'B': specs.set_upper(); FMT_FALLTHROUGH;
 case 'b': return parse_presentation_type(pres::bin, integral_set);
 case 'E': specs.set_upper(); FMT_FALLTHROUGH;
 case 'e': return parse_presentation_type(pres::exp, float_set);
 case 'F': specs.set_upper(); FMT_FALLTHROUGH;
 case 'f': return parse_presentation_type(pres::fixed, float_set);
 case 'G': specs.set_upper(); FMT_FALLTHROUGH;
 case 'g': return parse_presentation_type(pres::general, float_set);
 case 'A': specs.set_upper(); FMT_FALLTHROUGH;
 case 'a': return parse_presentation_type(pres::hexfloat, float_set);
 case 'c':
 if (arg_type == type::bool_type) report_error("invalid format specifier");
 return parse_presentation_type(pres::chr, integral_set);
 case 's':
 return parse_presentation_type(pres::string,
 bool_set | string_set | cstring_set);
 case 'p':
 return parse_presentation_type(pres::pointer, pointer_set | cstring_set);
 case '?':
 return parse_presentation_type(pres::debug,
 char_set | string_set | cstring_set);
 case '}': return begin;
 default: {
 if (*begin == '}') return begin;
 // Parse fill and alignment.
 auto fill_end = begin + code_point_length(begin);
 if (end - fill_end <= 0) {
 report_error("invalid format specifier");
 return begin;
 }
 if (*begin == '{') {
 report_error("invalid fill character '{'");
 return begin;
 }
 auto alignment = parse_align(to_ascii(*fill_end));
 enter_state(state::align, alignment != align::none);
 specs.set_fill(
 basic_string_view<Char>(begin, to_unsigned(fill_end - begin)));
 specs.set_align(alignment);
 begin = fill_end + 1;
 }
 }
 if (begin == end) return begin;
 c = to_ascii(*begin);
 }
}

template <typename Char, typename Handler>
FMT_CONSTEXPR FMT_INLINE auto parse_replacement_field(const Char* begin,
 const Char* end,
 Handler&& handler)
 -> const Char* {
 ++begin;
 if (begin == end) {
 handler.on_error("invalid format string");
 return end;
 }
 int arg_id = 0;
 switch (*begin) {
 case '}':
 handler.on_replacement_field(handler.on_arg_id(), begin);
 return begin + 1;
 case '{': handler.on_text(begin, begin + 1); return begin + 1;
 case ':': arg_id = handler.on_arg_id(); break;
 default: {
 struct id_adapter {
 Handler& handler;
 int arg_id;

FMT_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); }
 FMT_CONSTEXPR void on_name(basic_string_view<Char> id) {
 arg_id = handler.on_arg_id(id);
 }
 } adapter = {handler, 0};
 begin = parse_arg_id(begin, end, adapter);
 arg_id = adapter.arg_id;
 Char c = begin != end ? *begin : Char();
 if (c == '}') {
 handler.on_replacement_field(arg_id, begin);
 return begin + 1;
 }
 if (c != ':') {
 handler.on_error("missing '}' in format string");
 return end;
 }
 break;
 }
 }
 begin = handler.on_format_specs(arg_id, begin + 1, end);
 if (begin == end || *begin != '}')
 return handler.on_error("unknown format specifier"), end;
 return begin + 1;
}

template <typename Char, typename Handler>
FMT_CONSTEXPR void parse_format_string(basic_string_view<Char> fmt,
 Handler&& handler) {
 auto begin = fmt.data(), end = begin + fmt.size();
 auto p = begin;
 while (p != end) {
 auto c = *p++;
 if (c == '{') {
 handler.on_text(begin, p - 1);
 begin = p = parse_replacement_field(p - 1, end, handler);
 } else if (c == '}') {
 if (p == end || *p != '}')
 return handler.on_error("unmatched '}' in format string");
 handler.on_text(begin, p);
 begin = ++p;
 }
 }
 handler.on_text(begin, end);
}

// Checks char specs and returns true iff the presentation type is char-like.
FMT_CONSTEXPR inline auto check_char_specs(const format_specs& specs) -> bool {
  auto type = specs.type();
  if (type != presentation_type::none && type != presentation_type::chr &&
      type != presentation_type::debug) {
    return false;
  }
  if (specs.align() == align::numeric || specs.sign() != sign::none ||
      specs.alt()) {
    report_error("invalid format specifier for char");
  }
  return true;
}

// A base class for compile-time strings.
struct compile_string {};

template <typename T, typename Char>
FMT_VISIBILITY("hidden") // Suppress an ld warning on macOS (#3769).
FMT_CONSTEXPR auto invoke_parse(parse_context<Char>& ctx) -> const Char* {
 using mapped_type = remove_cvref_t<mapped_t<T, Char>>;
#if defined(__cpp_if_constexpr)
 if constexpr (std::is_default_constructible<formatter<mapped_type, Char>>())
 return formatter<mapped_type, Char>().parse(ctx);
 return ctx.begin(); // Ignore the error - it is reported in the value ctor.
#else
 return formatter<mapped_type, Char>().parse(ctx);
#endif
}

template <typename... T> struct arg_pack {};

template <typename Char, int NUM_ARGS, int NUM_NAMED_ARGS, bool DYNAMIC_NAMES>
class format_string_checker {
 private:
 type types_[NUM_ARGS > 0 ? NUM_ARGS : 1];
 named_arg_info<Char> named_args_[NUM_NAMED_ARGS > 0 ? NUM_NAMED_ARGS : 1];
 compile_parse_context<Char> context_;

using parse_func = auto (*)(parse_context<Char>&) -> const Char*;
 parse_func parse_funcs_[NUM_ARGS > 0 ? NUM_ARGS : 1];

public:
 template <typename... T>
 explicit FMT_CONSTEXPR format_string_checker(basic_string_view<Char> fmt,
 arg_pack<T...>)
 : types_{mapped_type_constant<T, Char>::value...},
 named_args_{},
 context_(fmt, NUM_ARGS, types_),
 parse_funcs_{&invoke_parse<T, Char>...} {
 int arg_index = 0, named_arg_index = 0;
 FMT_APPLY_VARIADIC(
 init_static_named_arg<T>(named_args_, arg_index, named_arg_index));
 ignore_unused(arg_index, named_arg_index);
 }

FMT_CONSTEXPR void on_text(const Char*, const Char*) {}

FMT_CONSTEXPR auto on_arg_id() -> int { return context_.next_arg_id(); }
 FMT_CONSTEXPR auto on_arg_id(int id) -> int {
 context_.check_arg_id(id);
 return id;
 }
 FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int {
 for (int i = 0; i < NUM_NAMED_ARGS; ++i) {
 if (named_args_[i].name == id) return named_args_[i].id;
 }
 if (!DYNAMIC_NAMES) on_error("argument not found");
 return -1;
 }

FMT_CONSTEXPR void on_replacement_field(int id, const Char* begin) {
    on_format_specs(id, begin, begin);  // Call parse() on empty specs.
  }

FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char* end)
 -> const Char* {
 context_.advance_to(begin);
 if (id >= 0 && id < NUM_ARGS) return parse_funcs_[id](context_);
 while (begin != end && *begin != '}') ++begin;
 return begin;
 }

FMT_NORETURN FMT_CONSTEXPR void on_error(const char* message) {
    report_error(message);
  }
};

/// A contiguous memory buffer with an optional growing ability. It is an
/// internal class and shouldn't be used directly, only via `memory_buffer`.
template <typename T> class buffer {
 private:
 T* ptr_;
 size_t size_;
 size_t capacity_;

using grow_fun = void (*)(buffer& buf, size_t capacity);
  grow_fun grow_;

protected:
  // Don't initialize ptr_ since it is not accessed to save a few cycles.
  FMT_MSC_WARNING(suppress : 26495)
  FMT_CONSTEXPR20 buffer(grow_fun grow, size_t sz) noexcept
      : size_(sz), capacity_(sz), grow_(grow) {}

constexpr buffer(grow_fun grow, T* p = nullptr, size_t sz = 0,
                   size_t cap = 0) noexcept
      : ptr_(p), size_(sz), capacity_(cap), grow_(grow) {}

FMT_CONSTEXPR20 ~buffer() = default;
  buffer(buffer&&) = default;

/// Sets the buffer data and capacity.
  FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept {
    ptr_ = buf_data;
    capacity_ = buf_capacity;
  }

public:
  using value_type = T;
  using const_reference = const T&;

buffer(const buffer&) = delete;
  void operator=(const buffer&) = delete;

auto begin() noexcept -> T* { return ptr_; }
  auto end() noexcept -> T* { return ptr_ + size_; }

auto begin() const noexcept -> const T* { return ptr_; }
  auto end() const noexcept -> const T* { return ptr_ + size_; }

/// Returns the size of this buffer.
  constexpr auto size() const noexcept -> size_t { return size_; }

/// Returns the capacity of this buffer.
  constexpr auto capacity() const noexcept -> size_t { return capacity_; }

/// Returns a pointer to the buffer data (not null-terminated).
  FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; }
  FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; }

/// Clears this buffer.
  FMT_CONSTEXPR void clear() { size_ = 0; }

// Tries resizing the buffer to contain `count` elements. If T is a POD type
 // the new elements may not be initialized.
 FMT_CONSTEXPR void try_resize(size_t count) {
 try_reserve(count);
 size_ = count <= capacity_ ? count : capacity_;
 }

// Tries increasing the buffer capacity to `new_capacity`. It can increase the
  // capacity by a smaller amount than requested but guarantees there is space
  // for at least one additional element either by increasing the capacity or by
  // flushing the buffer if it is full.
  FMT_CONSTEXPR void try_reserve(size_t new_capacity) {
    if (new_capacity > capacity_) grow_(*this, new_capacity);
  }

FMT_CONSTEXPR void push_back(const T& value) {
    try_reserve(size_ + 1);
    ptr_[size_++] = value;
  }

/// Appends data to the end of the buffer.
 template <typename U>
// Workaround for MSVC2019 to fix error C2893: Failed to specialize function
// template 'void fmt::v11::detail::buffer<T>::append(const U *,const U *)'.
#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1940
 FMT_CONSTEXPR20
#endif
 void
 append(const U* begin, const U* end) {
 while (begin != end) {
 auto count = to_unsigned(end - begin);
 try_reserve(size_ + count);
 auto free_cap = capacity_ - size_;
 if (free_cap < count) count = free_cap;
 // A loop is faster than memcpy on small sizes.
 T* out = ptr_ + size_;
 for (size_t i = 0; i < count; ++i) out[i] = begin[i];
 size_ += count;
 begin += count;
 }
 }

template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& {
 return ptr_[index];
 }
 template <typename Idx>
 FMT_CONSTEXPR auto operator[](Idx index) const -> const T& {
 return ptr_[index];
 }
};

struct buffer_traits {
  explicit buffer_traits(size_t) {}
  auto count() const -> size_t { return 0; }
  auto limit(size_t size) -> size_t { return size; }
};

class fixed_buffer_traits {
 private:
  size_t count_ = 0;
  size_t limit_;

public:
 explicit fixed_buffer_traits(size_t limit) : limit_(limit) {}
 auto count() const -> size_t { return count_; }
 auto limit(size_t size) -> size_t {
 size_t n = limit_ > count_ ? limit_ - count_ : 0;
 count_ += size;
 return size < n ? size : n;
 }
};

// A buffer that writes to an output iterator when flushed.
template <typename OutputIt, typename T, typename Traits = buffer_traits>
class iterator_buffer : public Traits, public buffer<T> {
 private:
 OutputIt out_;
 enum { buffer_size = 256 };
 T data_[buffer_size];

static FMT_CONSTEXPR void grow(buffer<T>& buf, size_t) {
 if (buf.size() == buffer_size) static_cast<iterator_buffer&>(buf).flush();
 }

void flush() {
    auto size = this->size();
    this->clear();
    const T* begin = data_;
    const T* end = begin + this->limit(size);
    while (begin != end) *out_++ = *begin++;
  }

public:
 explicit iterator_buffer(OutputIt out, size_t n = buffer_size)
 : Traits(n), buffer<T>(grow, data_, 0, buffer_size), out_(out) {}
 iterator_buffer(iterator_buffer&& other) noexcept
 : Traits(other),
 buffer<T>(grow, data_, 0, buffer_size),
 out_(other.out_) {}
 ~iterator_buffer() {
 // Don't crash if flush fails during unwinding.
 FMT_TRY { flush(); }
 FMT_CATCH(...) {}
 }

auto out() -> OutputIt {
    flush();
    return out_;
  }
  auto count() const -> size_t { return Traits::count() + this->size(); }
};

template <typename T>
class iterator_buffer<T*, T, fixed_buffer_traits> : public fixed_buffer_traits,
 public buffer<T> {
 private:
 T* out_;
 enum { buffer_size = 256 };
 T data_[buffer_size];

static FMT_CONSTEXPR void grow(buffer<T>& buf, size_t) {
 if (buf.size() == buf.capacity())
 static_cast<iterator_buffer&>(buf).flush();
 }

void flush() {
    size_t n = this->limit(this->size());
    if (this->data() == out_) {
      out_ += n;
      this->set(data_, buffer_size);
    }
    this->clear();
  }

public:
 explicit iterator_buffer(T* out, size_t n = buffer_size)
 : fixed_buffer_traits(n), buffer<T>(grow, out, 0, n), out_(out) {}
 iterator_buffer(iterator_buffer&& other) noexcept
 : fixed_buffer_traits(other),
 buffer<T>(static_cast<iterator_buffer&&>(other)),
 out_(other.out_) {
 if (this->data() != out_) {
 this->set(data_, buffer_size);
 this->clear();
 }
 }
 ~iterator_buffer() { flush(); }

auto out() -> T* {
    flush();
    return out_;
  }
  auto count() const -> size_t {
    return fixed_buffer_traits::count() + this->size();
  }
};

template <typename T> class iterator_buffer<T*, T> : public buffer<T> {
 public:
 explicit iterator_buffer(T* out, size_t = 0)
 : buffer<T>([](buffer<T>&, size_t) {}, out, 0, ~size_t()) {}

auto out() -> T* { return &*this->end(); }
};

template <typename Container>
class container_buffer : public buffer<typename Container::value_type> {
 private:
 using value_type = typename Container::value_type;

static FMT_CONSTEXPR void grow(buffer<value_type>& buf, size_t capacity) {
 auto& self = static_cast<container_buffer&>(buf);
 self.container.resize(capacity);
 self.set(&self.container[0], capacity);
 }

public:
  Container& container;

explicit container_buffer(Container& c)
 : buffer<value_type>(grow, c.size()), container(c) {}
};

// A buffer that writes to a container with the contiguous storage.
template <typename OutputIt>
class iterator_buffer<
 OutputIt,
 enable_if_t<is_back_insert_iterator<OutputIt>::value &&
 is_contiguous<typename OutputIt::container_type>::value,
 typename OutputIt::container_type::value_type>>
 : public container_buffer<typename OutputIt::container_type> {
 private:
 using base = container_buffer<typename OutputIt::container_type>;

public:
  explicit iterator_buffer(typename OutputIt::container_type& c) : base(c) {}
  explicit iterator_buffer(OutputIt out, size_t = 0)
      : base(get_container(out)) {}

auto out() -> OutputIt { return OutputIt(this->container); }
};

// A buffer that counts the number of code units written discarding the output.
template <typename T = char> class counting_buffer : public buffer<T> {
 private:
 enum { buffer_size = 256 };
 T data_[buffer_size];
 size_t count_ = 0;

static FMT_CONSTEXPR void grow(buffer<T>& buf, size_t) {
 if (buf.size() != buffer_size) return;
 static_cast<counting_buffer&>(buf).count_ += buf.size();
 buf.clear();
 }

public:
 FMT_CONSTEXPR counting_buffer() : buffer<T>(grow, data_, 0, buffer_size) {}

constexpr auto count() const noexcept -> size_t {
    return count_ + this->size();
  }
};

template <typename T>
struct is_back_insert_iterator<basic_appender<T>> : std::true_type {};

// An optimized version of std::copy with the output value type (T).
template <typename T, typename InputIt, typename OutputIt,
 FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value)>
FMT_CONSTEXPR20 auto copy(InputIt begin, InputIt end, OutputIt out)
 -> OutputIt {
 get_container(out).append(begin, end);
 return out;
}

template <typename T, typename InputIt, typename OutputIt,
 FMT_ENABLE_IF(!is_back_insert_iterator<OutputIt>::value)>
FMT_CONSTEXPR auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt {
 while (begin != end) *out++ = static_cast<T>(*begin++);
 return out;
}

template <typename T, typename V, typename OutputIt>
FMT_CONSTEXPR auto copy(basic_string_view<V> s, OutputIt out) -> OutputIt {
 return copy<T>(s.begin(), s.end(), out);
}

template <typename It, typename Enable = std::true_type>
struct is_buffer_appender : std::false_type {};
template <typename It>
struct is_buffer_appender<
 It, bool_constant<
 is_back_insert_iterator<It>::value &&
 std::is_base_of<buffer<typename It::container_type::value_type>,
 typename It::container_type>::value>>
 : std::true_type {};

// Maps an output iterator to a buffer.
template <typename T, typename OutputIt,
 FMT_ENABLE_IF(!is_buffer_appender<OutputIt>::value)>
auto get_buffer(OutputIt out) -> iterator_buffer<OutputIt, T> {
 return iterator_buffer<OutputIt, T>(out);
}
template <typename T, typename OutputIt,
 FMT_ENABLE_IF(is_buffer_appender<OutputIt>::value)>
auto get_buffer(OutputIt out) -> buffer<T>& {
 return get_container(out);
}

template <typename Buf, typename OutputIt>
auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) {
 return buf.out();
}
template <typename T, typename OutputIt>
auto get_iterator(buffer<T>&, OutputIt out) -> OutputIt {
 return out;
}

// This type is intentionally undefined, only used for errors.
template <typename T, typename Char> struct type_is_unformattable_for;

template <typename Char> struct string_value {
 const Char* data;
 size_t size;
 auto str() const -> basic_string_view<Char> { return {data, size}; }
};

template <typename Char> struct named_arg_value {
 const named_arg_info<Char>* data;
 size_t size;
};

template <typename Context> struct custom_value {
 using char_type = typename Context::char_type;
 void* value;
 void (*format)(void* arg, parse_context<char_type>& parse_ctx, Context& ctx);
};

#if !FMT_BUILTIN_TYPES
#  define FMT_BUILTIN , monostate
#else
#  define FMT_BUILTIN
#endif

// A formatting argument value.
template <typename Context> class value {
 public:
 using char_type = typename Context::char_type;

union {
 monostate no_value;
 int int_value;
 unsigned uint_value;
 long long long_long_value;
 unsigned long long ulong_long_value;
 int128_opt int128_value;
 uint128_opt uint128_value;
 bool bool_value;
 char_type char_value;
 float float_value;
 double double_value;
 long double long_double_value;
 const void* pointer;
 string_value<char_type> string;
 custom_value<Context> custom;
 named_arg_value<char_type> named_args;
 };

constexpr FMT_INLINE value() : no_value() {}
 constexpr FMT_INLINE value(int x) : int_value(x) {}
 constexpr FMT_INLINE value(unsigned x FMT_BUILTIN) : uint_value(x) {}
 FMT_CONSTEXPR FMT_INLINE value(long x FMT_BUILTIN) : value(long_type(x)) {}
 FMT_CONSTEXPR FMT_INLINE value(unsigned long x FMT_BUILTIN)
 : value(ulong_type(x)) {}
 constexpr FMT_INLINE value(long long x FMT_BUILTIN) : long_long_value(x) {}
 constexpr FMT_INLINE value(unsigned long long x FMT_BUILTIN)
 : ulong_long_value(x) {}
 template <int N>
 constexpr FMT_INLINE value(bitint<N> x FMT_BUILTIN) : long_long_value(x) {}
 template <int N>
 constexpr FMT_INLINE value(ubitint<N> x FMT_BUILTIN) : ulong_long_value(x) {}
 FMT_INLINE value(int128_opt x FMT_BUILTIN) : int128_value(x) {}
 FMT_INLINE value(uint128_opt x FMT_BUILTIN) : uint128_value(x) {}
 constexpr FMT_INLINE value(float x FMT_BUILTIN) : float_value(x) {}
 constexpr FMT_INLINE value(double x FMT_BUILTIN) : double_value(x) {}
 FMT_INLINE value(long double x FMT_BUILTIN) : long_double_value(x) {}
 constexpr FMT_INLINE value(bool x FMT_BUILTIN) : bool_value(x) {}
 template <typename T, FMT_ENABLE_IF(is_char<T>::value)>
 constexpr FMT_INLINE value(T x FMT_BUILTIN) : char_value(x) {
 static_assert(std::is_same<T, char_type>::value,
 "mixing character types is disallowed");
 }
 FMT_CONSTEXPR FMT_INLINE value(const char_type* x FMT_BUILTIN) {
 string.data = x;
 if (is_constant_evaluated()) string.size = 0;
 }
 FMT_CONSTEXPR FMT_INLINE value(basic_string_view<char_type> x FMT_BUILTIN) {
 string.data = x.data();
 string.size = x.size();
 }
 FMT_INLINE value(const void* x FMT_BUILTIN) : pointer(x) {}

// We can't use mapped_t because of a bug in MSVC 2017.
 template <
 typename T,
 typename M = decltype(arg_mapper<char_type>::map(std::declval<T&>())),
 FMT_ENABLE_IF(!std::is_same<T, M>::value &&
 !std::is_integral<remove_cvref_t<T>>::value)>
 FMT_CONSTEXPR20 FMT_INLINE value(T&& x) {
 *this = arg_mapper<char_type>::map(x);
 }

template <
 typename T,
 typename M = decltype(arg_mapper<char_type>::map(std::declval<T&>())),
 FMT_ENABLE_IF(std::is_same<T, M>::value &&
 !std::is_integral<remove_cvref_t<T>>::value)>
 FMT_CONSTEXPR20 FMT_INLINE value(T&& x) {
 // Use enum instead of constexpr because the latter may generate code.
 enum { formattable_char = !std::is_same<T, unformattable_char>::value };
 static_assert(formattable_char, "mixing character types is disallowed");

// Formatting of arbitrary pointers is disallowed. If you want to format a
 // pointer cast it to `void*` or `const void*`. In particular, this forbids
 // formatting of `[const] volatile char*` printed as bool by iostreams.
 enum {
 formattable_pointer = !std::is_same<T, unformattable_pointer>::value
 };
 static_assert(formattable_pointer,
 "formatting of non-void pointers is disallowed");

using value_type = remove_cvref_t<T>;
 enum { formattable = !std::is_same<T, unformattable>::value };

#if defined(__cpp_if_constexpr)
 if constexpr (!formattable) type_is_unformattable_for<T, char_type> _;

// T may overload operator& e.g. std::vector<bool>::reference in libc++.
 if constexpr (std::is_same<decltype(&x), remove_reference_t<T>*>::value)
 custom.value = const_cast<value_type*>(&x);
#endif

static_assert(
 formattable,
 "cannot format an argument; to make type T formattable provide a "
 "formatter<T> specialization: https://fmt.dev/latest/api.html#udt");

if (!is_constant_evaluated())
 custom.value =
 const_cast<char*>(&reinterpret_cast<const volatile char&>(x));
 // Get the formatter type through the context to allow different contexts
 // have different extension points, e.g. `formatter<T>` for `format` and
 // `printf_formatter<T>` for `printf`.

custom.format = format_custom<value_type, formatter<value_type, char_type>>;
 }
 FMT_ALWAYS_INLINE value(const named_arg_info<char_type>* args, size_t size)
 : named_args{args, size} {}

private:
 // Formats an argument of a custom type, such as a user-defined class.
 template <typename T, typename Formatter>
 static void format_custom(void* arg, parse_context<char_type>& parse_ctx,
 Context& ctx) {
 auto f = Formatter();
 parse_ctx.advance_to(f.parse(parse_ctx));
 using qualified_type =
 conditional_t<has_const_formatter<T, char_type>(), const T, T>;
 // format must be const for compatibility with std::format and compilation.
 const auto& cf = f;
 ctx.advance_to(cf.format(*static_cast<qualified_type*>(arg), ctx));
 }
};

enum { packed_arg_bits = 4 };
// Maximum number of arguments with packed types.
enum { max_packed_args = 62 / packed_arg_bits };
enum : unsigned long long { is_unpacked_bit = 1ULL << 63 };
enum : unsigned long long { has_named_args_bit = 1ULL << 62 };

template <typename It, typename T, typename Enable = void>
struct is_output_iterator : std::false_type {};

template <> struct is_output_iterator<appender, char> : std::true_type {};

template <typename It, typename T>
struct is_output_iterator<
 It, T,
 void_t<decltype(*std::declval<decay_t<It>&>()++ = std::declval<T>())>>
 : std::true_type {};

#ifndef FMT_USE_LOCALE
# define FMT_USE_LOCALE (FMT_OPTIMIZE_SIZE <= 1)
#endif

// A type-erased reference to an std::locale to avoid a heavy <locale> include.
struct locale_ref {
#if FMT_USE_LOCALE
 private:
 const void* locale_; // A type-erased pointer to std::locale.

public:
 constexpr locale_ref() : locale_(nullptr) {}
 template <typename Locale> explicit locale_ref(const Locale& loc);
 explicit operator bool() const noexcept { return locale_ != nullptr; }
#endif

template <typename Locale> auto get() const -> Locale;
};

template <typename> constexpr auto encode_types() -> unsigned long long {
 return 0;
}

template <typename Context, typename Arg, typename... Args>
constexpr auto encode_types() -> unsigned long long {
 return static_cast<unsigned>(stored_type_constant<Arg, Context>::value) |
 (encode_types<Context, Args...>() << packed_arg_bits);
}

template <typename Context, typename... T, size_t NUM_ARGS = sizeof...(T)>
constexpr auto make_descriptor() -> unsigned long long {
 return NUM_ARGS <= max_packed_args ? encode_types<Context, T...>()
 : is_unpacked_bit | NUM_ARGS;
}

template <typename Context, size_t NUM_ARGS>
using arg_t = conditional_t<NUM_ARGS <= max_packed_args, value<Context>,
 basic_format_arg<Context>>;

template <typename Context, size_t NUM_ARGS, size_t NUM_NAMED_ARGS,
 unsigned long long DESC>
struct named_arg_store {
 // args_[0].named_args points to named_args to avoid bloating format_args.
 // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning.
 arg_t<Context, NUM_ARGS> args[1 + (NUM_ARGS != 0 ? NUM_ARGS : +1)];
 named_arg_info<typename Context::char_type> named_args[NUM_NAMED_ARGS];

template <typename... T>
 FMT_CONSTEXPR FMT_ALWAYS_INLINE named_arg_store(T&... values)
 : args{{named_args, NUM_NAMED_ARGS}, values...} {
 int arg_index = 0, named_arg_index = 0;
 FMT_APPLY_VARIADIC(
 init_named_arg(named_args, arg_index, named_arg_index, values));
 }

named_arg_store(named_arg_store&& rhs) {
 args[0] = {named_args, NUM_NAMED_ARGS};
 for (size_t i = 1; i < sizeof(args) / sizeof(*args); ++i)
 args[i] = rhs.args[i];
 for (size_t i = 0; i < NUM_NAMED_ARGS; ++i)
 named_args[i] = rhs.named_args[i];
 }

named_arg_store(const named_arg_store& rhs) = delete;
 named_arg_store& operator=(const named_arg_store& rhs) = delete;
 named_arg_store& operator=(named_arg_store&& rhs) = delete;
 operator const arg_t<Context, NUM_ARGS>*() const { return args + 1; }
};

// An array of references to arguments. It can be implicitly converted to
// `basic_format_args` for passing into type-erased formatting functions
// such as `vformat`. It is a plain struct to reduce binary size in debug mode.
template <typename Context, size_t NUM_ARGS, size_t NUM_NAMED_ARGS,
 unsigned long long DESC>
struct format_arg_store {
 // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning.
 using type =
 conditional_t<NUM_NAMED_ARGS == 0,
 arg_t<Context, NUM_ARGS>[NUM_ARGS != 0 ? NUM_ARGS : +1],
 named_arg_store<Context, NUM_ARGS, NUM_NAMED_ARGS, DESC>>;
 type args;
};

// TYPE can be different from type_constant<T>, e.g. for __float128.
template <typename T, typename Char, type TYPE> struct native_formatter {
 private:
 dynamic_format_specs<Char> specs_;

public:
  using nonlocking = void;

FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
 if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin();
 auto end = parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, TYPE);
 if (const_check(TYPE == type::char_type)) check_char_specs(specs_);
 return end;
 }

template <type U = TYPE,
 FMT_ENABLE_IF(U == type::string_type || U == type::cstring_type ||
 U == type::char_type)>
 FMT_CONSTEXPR void set_debug_format(bool set = true) {
 specs_.set_type(set ? presentation_type::debug : presentation_type::none);
 }

FMT_PRAGMA_CLANG(diagnostic ignored "-Wundefined-inline")
 template <typename FormatContext>
 FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const
 -> decltype(ctx.out());
};

template <typename T, typename Enable = void>
struct locking
 : bool_constant<mapped_type_constant<T>::value == type::custom_type> {};
template <typename T>
struct locking<T, void_t<typename formatter<remove_cvref_t<T>>::nonlocking>>
 : std::false_type {};

template <typename T = int> FMT_CONSTEXPR inline auto is_locking() -> bool {
 return locking<T>::value;
}
template <typename T1, typename T2, typename... Tail>
FMT_CONSTEXPR inline auto is_locking() -> bool {
 return locking<T1>::value || is_locking<T2, Tail...>();
}

FMT_API void vformat_to(buffer<char>& buf, string_view fmt, format_args args,
 locale_ref loc = {});

#ifdef _WIN32
FMT_API void vprint_mojibake(FILE*, string_view, format_args, bool);
#else  // format_args is passed by reference since it is defined later.
inline void vprint_mojibake(FILE*, string_view, const format_args&, bool) {}
#endif
}  // namespace detail

// The main public API.

template <typename Char>
FMT_CONSTEXPR void parse_context<Char>::do_check_arg_id(int arg_id) {
 // Argument id is only checked at compile time during parsing because
 // formatting has its own validation.
 if (detail::is_constant_evaluated() && use_constexpr_cast) {
 auto ctx = static_cast<detail::compile_parse_context<Char>*>(this);
 if (arg_id >= ctx->num_args()) report_error("argument not found");
 }
}

template <typename Char>
FMT_CONSTEXPR void parse_context<Char>::check_dynamic_spec(int arg_id) {
 using detail::compile_parse_context;
 if (detail::is_constant_evaluated() && use_constexpr_cast)
 static_cast<compile_parse_context<Char>*>(this)->check_dynamic_spec(arg_id);
}

FMT_BEGIN_EXPORT

// An output iterator that appends to a buffer. It is used instead of
// back_insert_iterator to reduce symbol sizes and avoid <iterator> dependency.
template <typename T> class basic_appender {
 protected:
 detail::buffer<T>* container;

public:
 using iterator_category = int;
 using value_type = T;
 using difference_type = ptrdiff_t;
 using pointer = T*;
 using reference = T&;
 using container_type = detail::buffer<T>;
 FMT_UNCHECKED_ITERATOR(basic_appender);

FMT_CONSTEXPR basic_appender(detail::buffer<T>& buf) : container(&buf) {}

FMT_CONSTEXPR20 auto operator=(T c) -> basic_appender& {
    container->push_back(c);
    return *this;
  }
  FMT_CONSTEXPR20 auto operator*() -> basic_appender& { return *this; }
  FMT_CONSTEXPR20 auto operator++() -> basic_appender& { return *this; }
  FMT_CONSTEXPR20 auto operator++(int) -> basic_appender { return *this; }
};

// A formatting argument. Context is a template parameter for the compiled API
// where output can be unbuffered.
template <typename Context> class basic_format_arg {
 private:
 detail::value<Context> value_;
 detail::type type_;

friend class basic_format_args<Context>;

using char_type = typename Context::char_type;

public:
 class handle {
 private:
 detail::custom_value<Context> custom_;

public:
 explicit handle(detail::custom_value<Context> custom) : custom_(custom) {}

void format(parse_context<char_type>& parse_ctx, Context& ctx) const {
 custom_.format(custom_.value, parse_ctx, ctx);
 }
 };

constexpr basic_format_arg() : type_(detail::type::none_type) {}
 basic_format_arg(const detail::named_arg_info<char_type>* args, size_t size)
 : value_(args, size) {}
 template <typename T>
 basic_format_arg(T&& val)
 : value_(val), type_(detail::stored_type_constant<T, Context>::value) {}

constexpr explicit operator bool() const noexcept {
    return type_ != detail::type::none_type;
  }
  auto type() const -> detail::type { return type_; }

/**
 * Visits an argument dispatching to the appropriate visit method based on
 * the argument type. For example, if the argument type is `double` then
 * `vis(value)` will be called with the value of type `double`.
 */
 template <typename Visitor>
 FMT_CONSTEXPR FMT_INLINE auto visit(Visitor&& vis) const -> decltype(vis(0)) {
 using detail::map;
 switch (type_) {
 case detail::type::none_type: break;
 case detail::type::int_type: return vis(value_.int_value);
 case detail::type::uint_type: return vis(value_.uint_value);
 case detail::type::long_long_type: return vis(value_.long_long_value);
 case detail::type::ulong_long_type: return vis(value_.ulong_long_value);
 case detail::type::int128_type: return vis(map(value_.int128_value));
 case detail::type::uint128_type: return vis(map(value_.uint128_value));
 case detail::type::bool_type: return vis(value_.bool_value);
 case detail::type::char_type: return vis(value_.char_value);
 case detail::type::float_type: return vis(value_.float_value);
 case detail::type::double_type: return vis(value_.double_value);
 case detail::type::long_double_type: return vis(value_.long_double_value);
 case detail::type::cstring_type: return vis(value_.string.data);
 case detail::type::string_type: return vis(value_.string.str());
 case detail::type::pointer_type: return vis(value_.pointer);
 case detail::type::custom_type: return vis(handle(value_.custom));
 }
 return vis(monostate());
 }

auto format_custom(const char_type* parse_begin,
 parse_context<char_type>& parse_ctx, Context& ctx)
 -> bool {
 if (type_ != detail::type::custom_type) return false;
 parse_ctx.advance_to(parse_begin);
 value_.custom.format(value_.custom.value, parse_ctx, ctx);
 return true;
 }
};

/**
 * A view of a collection of formatting arguments. To avoid lifetime issues it
 * should only be used as a parameter type in type-erased functions such as
 * `vformat`:
 *
 * void vlog(fmt::string_view fmt, fmt::format_args args); // OK
 * fmt::format_args args = fmt::make_format_args(); // Dangling reference
 */
template <typename Context> class basic_format_args {
 private:
 // A descriptor that contains information about formatting arguments.
 // If the number of arguments is less or equal to max_packed_args then
 // argument types are passed in the descriptor. This reduces binary code size
 // per formatting function call.
 unsigned long long desc_;
 union {
 // If is_packed() returns true then argument values are stored in values_;
 // otherwise they are stored in args_. This is done to improve cache
 // locality and reduce compiled code size since storing larger objects
 // may require more code (at least on x86-64) even if the same amount of
 // data is actually copied to stack. It saves ~10% on the bloat test.
 const detail::value<Context>* values_;
 const basic_format_arg<Context>* args_;
 };

constexpr auto is_packed() const -> bool {
    return (desc_ & detail::is_unpacked_bit) == 0;
  }
  constexpr auto has_named_args() const -> bool {
    return (desc_ & detail::has_named_args_bit) != 0;
  }

FMT_CONSTEXPR auto type(int index) const -> detail::type {
 int shift = index * detail::packed_arg_bits;
 unsigned mask = (1 << detail::packed_arg_bits) - 1;
 return static_cast<detail::type>((desc_ >> shift) & mask);
 }

template <size_t NUM_ARGS, size_t NUM_NAMED_ARGS, unsigned long long DESC>
 using store =
 detail::format_arg_store<Context, NUM_ARGS, NUM_NAMED_ARGS, DESC>;

public:
 using format_arg = basic_format_arg<Context>;

constexpr basic_format_args() : desc_(0), args_(nullptr) {}

/// Constructs a `basic_format_args` object from `format_arg_store`.
 template <size_t NUM_ARGS, size_t NUM_NAMED_ARGS, unsigned long long DESC,
 FMT_ENABLE_IF(NUM_ARGS <= detail::max_packed_args)>
 constexpr FMT_ALWAYS_INLINE basic_format_args(
 const store<NUM_ARGS, NUM_NAMED_ARGS, DESC>& s)
 : desc_(DESC | (NUM_NAMED_ARGS != 0 ? +detail::has_named_args_bit : 0)),
 values_(s.args) {}

template <size_t NUM_ARGS, size_t NUM_NAMED_ARGS, unsigned long long DESC,
 FMT_ENABLE_IF(NUM_ARGS > detail::max_packed_args)>
 constexpr basic_format_args(const store<NUM_ARGS, NUM_NAMED_ARGS, DESC>& s)
 : desc_(DESC | (NUM_NAMED_ARGS != 0 ? +detail::has_named_args_bit : 0)),
 args_(s.args) {}

/// Constructs a `basic_format_args` object from a dynamic list of arguments.
  constexpr basic_format_args(const format_arg* args, int count,
                              bool has_named = false)
      : desc_(detail::is_unpacked_bit | detail::to_unsigned(count) |
              (has_named ? +detail::has_named_args_bit : 0)),
        args_(args) {}

/// Returns the argument with the specified id.
 FMT_CONSTEXPR auto get(int id) const -> format_arg {
 auto arg = format_arg();
 if (!is_packed()) {
 if (id < max_size()) arg = args_[id];
 return arg;
 }
 if (static_cast<unsigned>(id) >= detail::max_packed_args) return arg;
 arg.type_ = type(id);
 if (arg.type_ != detail::type::none_type) arg.value_ = values_[id];
 return arg;
 }

template <typename Char>
 auto get(basic_string_view<Char> name) const -> format_arg {
 int id = get_id(name);
 return id >= 0 ? get(id) : format_arg();
 }

template <typename Char>
 FMT_CONSTEXPR auto get_id(basic_string_view<Char> name) const -> int {
 if (!has_named_args()) return -1;
 const auto& named_args =
 (is_packed() ? values_[-1] : args_[-1].value_).named_args;
 for (size_t i = 0; i < named_args.size; ++i) {
 if (named_args.data[i].name == name) return named_args.data[i].id;
 }
 return -1;
 }

auto max_size() const -> int {
 unsigned long long max_packed = detail::max_packed_args;
 return static_cast<int>(is_packed() ? max_packed
 : desc_ & ~detail::is_unpacked_bit);
 }
};

// A formatting context.
class context : private detail::locale_ref {
 private:
  appender out_;
  format_args args_;

public:
  /// The character type for the output.
  using char_type = char;

using iterator = appender;
 using format_arg = basic_format_arg<context>;
 using parse_context_type FMT_DEPRECATED = parse_context<>;
 template <typename T> using formatter_type FMT_DEPRECATED = formatter<T>;
 enum { builtin_types = FMT_BUILTIN_TYPES };

/// Constructs a `context` object. References to the arguments are stored
  /// in the object so make sure they have appropriate lifetimes.
  FMT_CONSTEXPR context(iterator out, format_args args,
                        detail::locale_ref loc = {})
      : locale_ref(loc), out_(out), args_(args) {}
  context(context&&) = default;
  context(const context&) = delete;
  void operator=(const context&) = delete;

FMT_CONSTEXPR auto arg(int id) const -> format_arg { return args_.get(id); }
  auto arg(string_view name) -> format_arg { return args_.get(name); }
  FMT_CONSTEXPR auto arg_id(string_view name) -> int {
    return args_.get_id(name);
  }

// Returns an iterator to the beginning of the output range.
  FMT_CONSTEXPR auto out() -> iterator { return out_; }

// Advances the begin iterator to `it`.
  void advance_to(iterator) {}

FMT_CONSTEXPR auto locale() -> detail::locale_ref { return *this; }
};

template <typename Char = char> struct runtime_format_string {
 basic_string_view<Char> str;
};

/**
 * Creates a runtime format string.
 *
 * **Example**:
 *
 * // Check format string at runtime instead of compile-time.
 * fmt::print(fmt::runtime("{:d}"), "I am not a number");
 */
inline auto runtime(string_view s) -> runtime_format_string<> { return {{s}}; }

/// A compile-time format string.
template <typename... T> struct fstring {
 private:
 static constexpr int num_static_named_args =
 detail::count_static_named_args<T...>();

using checker = detail::format_string_checker<
 char, static_cast<int>(sizeof...(T)), num_static_named_args,
 num_static_named_args != detail::count_named_args<T...>()>;

using arg_pack = detail::arg_pack<T...>;

public:
  string_view str;
  using t = fstring;

// Reports a compile-time error if S is not a valid format string for T.
 template <size_t N>
 FMT_CONSTEVAL FMT_ALWAYS_INLINE fstring(const char (&s)[N]) : str(s, N - 1) {
 using namespace detail;
 static_assert(count<(std::is_base_of<view, remove_reference_t<T>>::value &&
 std::is_reference<T>::value)...>() == 0,
 "passing views as lvalues is disallowed");
 if (FMT_USE_CONSTEVAL) parse_format_string<char>(s, checker(s, arg_pack()));
#ifdef FMT_ENFORCE_COMPILE_STRING
 static_assert(
 FMT_USE_CONSTEVAL && sizeof(s) != 0,
 "FMT_ENFORCE_COMPILE_STRING requires format strings to use FMT_STRING");
#endif
 }
 template <typename S,
 FMT_ENABLE_IF(std::is_convertible<const S&, string_view>::value)>
 FMT_CONSTEVAL FMT_ALWAYS_INLINE fstring(const S& s) : str(s) {
 if (FMT_USE_CONSTEVAL)
 detail::parse_format_string<char>(s, checker(s, arg_pack()));
#ifdef FMT_ENFORCE_COMPILE_STRING
 static_assert(
 FMT_USE_CONSTEVAL && sizeof(s) != 0,
 "FMT_ENFORCE_COMPILE_STRING requires format strings to use FMT_STRING");
#endif
 }
 template <typename S,
 FMT_ENABLE_IF(std::is_base_of<detail::compile_string, S>::value&&
 std::is_same<typename S::char_type, char>::value)>
 FMT_ALWAYS_INLINE fstring(const S&) : str(S()) {
 FMT_CONSTEXPR auto sv = string_view(S());
 FMT_CONSTEXPR int ignore =
 (parse_format_string(sv, checker(sv, arg_pack())), 0);
 detail::ignore_unused(ignore);
 }
 fstring(runtime_format_string<> fmt) : str(fmt.str) {}

// Returning by reference generates better code in debug mode.
  FMT_ALWAYS_INLINE operator const string_view&() const { return str; }
  auto get() const -> string_view { return str; }
};

template <typename... T> using format_string = typename fstring<T...>::t;

template <typename T, typename Char = char>
using is_formattable = bool_constant<
 !std::is_base_of<detail::unformattable,
 detail::mapped_t<conditional_t<std::is_void<T>::value,
 detail::unformattable, T>,
 Char>>::value>;
#ifdef __cpp_concepts
template <typename T, typename Char = char>
concept formattable = is_formattable<remove_reference_t<T>, Char>::value;
#endif

template <typename T, typename Char>
using has_formatter FMT_DEPRECATED = std::is_constructible<formatter<T, Char>>;

// A formatter specialization for natively supported types.
template <typename T, typename Char>
struct formatter<T, Char,
 enable_if_t<detail::type_constant<T, Char>::value !=
 detail::type::custom_type>>
 : detail::native_formatter<T, Char, detail::type_constant<T, Char>::value> {
};

/**
 * Constructs an object that stores references to arguments and can be
 * implicitly converted to `format_args`. `Context` can be omitted in which case
 * it defaults to `context`. See `arg` for lifetime considerations.
 */
// Take arguments by lvalue references to avoid some lifetime issues, e.g.
// auto args = make_format_args(std::string());
template <typename Context = context, typename... T,
 size_t NUM_ARGS = sizeof...(T),
 size_t NUM_NAMED_ARGS = detail::count_named_args<T...>(),
 unsigned long long DESC = detail::make_descriptor<Context, T...>()>
constexpr FMT_ALWAYS_INLINE auto make_format_args(T&... args)
 -> detail::format_arg_store<Context, NUM_ARGS, NUM_NAMED_ARGS, DESC> {
 // Suppress warnings for pathological types convertible to detail::value.
 FMT_PRAGMA_GCC(diagnostic ignored "-Wconversion")
 return {{args...}};
}

template <typename... T>
using vargs =
 detail::format_arg_store<context, sizeof...(T),
 detail::count_named_args<T...>(),
 detail::make_descriptor<context, T...>()>;

/**
 * Returns a named argument to be used in a formatting function.
 * It should only be used in a call to a formatting function.
 *
 * **Example**:
 *
 * fmt::print("The answer is {answer}.", fmt::arg("answer", 42));
 */
template <typename Char, typename T>
inline auto arg(const Char* name, const T& arg) -> detail::named_arg<Char, T> {
 return {name, arg};
}

/// Formats a string and writes the output to `out`.
template <typename OutputIt,
 FMT_ENABLE_IF(detail::is_output_iterator<remove_cvref_t<OutputIt>,
 char>::value)>
auto vformat_to(OutputIt&& out, string_view fmt, format_args args)
 -> remove_cvref_t<OutputIt> {
 auto&& buf = detail::get_buffer<char>(out);
 detail::vformat_to(buf, fmt, args, {});
 return detail::get_iterator(buf, out);
}

/**
 * Formats `args` according to specifications in `fmt`, writes the result to
 * the output iterator `out` and returns the iterator past the end of the output
 * range. `format_to` does not append a terminating null character.
 *
 * **Example**:
 *
 * auto out = std::vector<char>();
 * fmt::format_to(std::back_inserter(out), "{}", 42);
 */
template <typename OutputIt, typename... T,
 FMT_ENABLE_IF(detail::is_output_iterator<remove_cvref_t<OutputIt>,
 char>::value)>
FMT_INLINE auto format_to(OutputIt&& out, format_string<T...> fmt, T&&... args)
 -> remove_cvref_t<OutputIt> {
 return vformat_to(out, fmt.str, vargs<T...>{{args...}});
}

template <typename OutputIt> struct format_to_n_result {
 /// Iterator past the end of the output range.
 OutputIt out;
 /// Total (not truncated) output size.
 size_t size;
};

template <typename OutputIt, typename... T,
 FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args)
 -> format_to_n_result<OutputIt> {
 using traits = detail::fixed_buffer_traits;
 auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
 detail::vformat_to(buf, fmt, args, {});
 return {buf.out(), buf.count()};
}

/**
 * Formats `args` according to specifications in `fmt`, writes up to `n`
 * characters of the result to the output iterator `out` and returns the total
 * (not truncated) output size and the iterator past the end of the output
 * range. `format_to_n` does not append a terminating null character.
 */
template <typename OutputIt, typename... T,
 FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string<T...> fmt,
 T&&... args) -> format_to_n_result<OutputIt> {
 return vformat_to_n(out, n, fmt.str, vargs<T...>{{args...}});
}

struct format_to_result {
  /// Pointer to just after the last successful write in the array.
  char* out;
  /// Specifies if the output was truncated.
  bool truncated;

FMT_CONSTEXPR operator char*() const {
    // Report truncation to prevent silent data loss.
    if (truncated) report_error("output is truncated");
    return out;
  }
};

template <size_t N>
auto vformat_to(char (&out)[N], string_view fmt, format_args args)
 -> format_to_result {
 auto result = vformat_to_n(out, N, fmt, args);
 return {result.out, result.size > N};
}

template <size_t N, typename... T>
FMT_INLINE auto format_to(char (&out)[N], format_string<T...> fmt, T&&... args)
 -> format_to_result {
 auto result = vformat_to_n(out, N, fmt.str, vargs<T...>{{args...}});
 return {result.out, result.size > N};
}

/// Returns the number of chars in the output of `format(fmt, args...)`.
template <typename... T>
FMT_NODISCARD FMT_INLINE auto formatted_size(format_string<T...> fmt,
 T&&... args) -> size_t {
 auto buf = detail::counting_buffer<>();
 detail::vformat_to(buf, fmt.str, vargs<T...>{{args...}}, {});
 return buf.count();
}

FMT_API void vprint(string_view fmt, format_args args);
FMT_API void vprint(FILE* f, string_view fmt, format_args args);
FMT_API void vprintln(FILE* f, string_view fmt, format_args args);
FMT_API void vprint_buffered(FILE* f, string_view fmt, format_args args);

/**
 * Formats `args` according to specifications in `fmt` and writes the output
 * to `stdout`.
 *
 * **Example**:
 *
 * fmt::print("The answer is {}.", 42);
 */
template <typename... T>
FMT_INLINE void print(format_string<T...> fmt, T&&... args) {
 vargs<T...> va = {{args...}};
 if (!detail::use_utf8)
 return detail::vprint_mojibake(stdout, fmt.str, va, false);
 return detail::is_locking<T...>() ? vprint_buffered(stdout, fmt.str, va)
 : vprint(fmt.str, va);
}

/**
 * Formats `args` according to specifications in `fmt` and writes the
 * output to the file `f`.
 *
 * **Example**:
 *
 * fmt::print(stderr, "Don't {}!", "panic");
 */
template <typename... T>
FMT_INLINE void print(FILE* f, format_string<T...> fmt, T&&... args) {
 vargs<T...> va = {{args...}};
 if (!detail::use_utf8) return detail::vprint_mojibake(f, fmt.str, va, false);
 return detail::is_locking<T...>() ? vprint_buffered(f, fmt.str, va)
 : vprint(f, fmt.str, va);
}

/// Formats `args` according to specifications in `fmt` and writes the output
/// to the file `f` followed by a newline.
template <typename... T>
FMT_INLINE void println(FILE* f, format_string<T...> fmt, T&&... args) {
 vargs<T...> va = {{args...}};
 return detail::use_utf8 ? vprintln(f, fmt.str, va)
 : detail::vprint_mojibake(f, fmt.str, va, true);
}

/// Formats `args` according to specifications in `fmt` and writes the output
/// to `stdout` followed by a newline.
template <typename... T>
FMT_INLINE void println(format_string<T...> fmt, T&&... args) {
 return fmt::println(stdout, fmt, static_cast<T&&>(args)...);
}

FMT_END_EXPORT
FMT_PRAGMA_CLANG(diagnostic pop)
FMT_PRAGMA_GCC(pop_options)
FMT_END_NAMESPACE

#ifdef FMT_HEADER_ONLY
#  include "format.h"
#endif
#endif  // FMT_BASE_H_

#ifndef FMT_MODULE
# include <cmath> // std::signbit
# include <cstdint> // uint32_t
# include <cstring> // std::memcpy
# include <initializer_list> // std::initializer_list
# include <limits> // std::numeric_limits
# include <new> // std::bad_alloc
# if defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI)
// Workaround for pre gcc 5 libstdc++.
# include <memory> // std::allocator_traits
# endif
# include <stdexcept> // std::runtime_error
# include <string> // std::string
# include <system_error> // std::system_error

// Checking FMT_CPLUSPLUS for warning suppression in MSVC.
# if FMT_HAS_INCLUDE(<bit>) && FMT_CPLUSPLUS > 201703L
# include <bit> // std::bit_cast
# endif

// libc++ supports string_view in pre-c++17.
# if FMT_HAS_INCLUDE(<string_view>) && \
 (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION))
# include <string_view>
# define FMT_USE_STRING_VIEW
# endif
#endif // FMT_MODULE

#if defined(FMT_USE_NONTYPE_TEMPLATE_ARGS)
// Use the provided definition.
#elif defined(__NVCOMPILER)
#  define FMT_USE_NONTYPE_TEMPLATE_ARGS 0
#elif FMT_GCC_VERSION >= 903 && FMT_CPLUSPLUS >= 201709L
#  define FMT_USE_NONTYPE_TEMPLATE_ARGS 1
#elif defined(__cpp_nontype_template_args) && \
    __cpp_nontype_template_args >= 201911L
#  define FMT_USE_NONTYPE_TEMPLATE_ARGS 1
#elif FMT_CLANG_VERSION >= 1200 && FMT_CPLUSPLUS >= 202002L
#  define FMT_USE_NONTYPE_TEMPLATE_ARGS 1
#else
#  define FMT_USE_NONTYPE_TEMPLATE_ARGS 0
#endif

#if defined __cpp_inline_variables && __cpp_inline_variables >= 201606L
#  define FMT_INLINE_VARIABLE inline
#else
#  define FMT_INLINE_VARIABLE
#endif

// Check if RTTI is disabled.
#ifdef FMT_USE_RTTI
// Use the provided definition.
#elif defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || defined(_CPPRTTI) || \
    defined(__INTEL_RTTI__) || defined(__RTTI)
// __RTTI is for EDG compilers. _CPPRTTI is for MSVC.
#  define FMT_USE_RTTI 1
#else
#  define FMT_USE_RTTI 0
#endif

// Visibility when compiled as a shared library/object.
#if defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)
#  define FMT_SO_VISIBILITY(value) FMT_VISIBILITY(value)
#else
#  define FMT_SO_VISIBILITY(value)
#endif

#if FMT_GCC_VERSION || FMT_CLANG_VERSION
#  define FMT_NOINLINE __attribute__((noinline))
#else
#  define FMT_NOINLINE
#endif

namespace std {
template <> struct iterator_traits<fmt::appender> {
 using iterator_category = output_iterator_tag;
 using value_type = char;
 using difference_type = ptrdiff_t;
};
} // namespace std

#ifndef FMT_THROW
# if FMT_USE_EXCEPTIONS
# if FMT_MSC_VERSION || defined(__NVCC__)
FMT_BEGIN_NAMESPACE
namespace detail {
template <typename Exception> inline void do_throw(const Exception& x) {
 // Silence unreachable code warnings in MSVC and NVCC because these
 // are nearly impossible to fix in a generic code.
 volatile bool b = true;
 if (b) throw x;
}
} // namespace detail
FMT_END_NAMESPACE
# define FMT_THROW(x) detail::do_throw(x)
# else
# define FMT_THROW(x) throw x
# endif
# else
# define FMT_THROW(x) \
 ::fmt::detail::assert_fail(__FILE__, __LINE__, (x).what())
# endif
#endif

#ifdef FMT_NO_UNIQUE_ADDRESS
// Use the provided definition.
#elif FMT_CPLUSPLUS < 202002L
// Not supported.
#elif FMT_HAS_CPP_ATTRIBUTE(no_unique_address)
# define FMT_NO_UNIQUE_ADDRESS [[no_unique_address]]
// VS2019 v16.10 and later except clang-cl (https://reviews.llvm.org/D110485).
#elif FMT_MSC_VERSION >= 1929 && !FMT_CLANG_VERSION
# define FMT_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
#endif
#ifndef FMT_NO_UNIQUE_ADDRESS
# define FMT_NO_UNIQUE_ADDRESS
#endif

// Defining FMT_REDUCE_INT_INSTANTIATIONS to 1, will reduce the number of
// integer formatter template instantiations to just one by only using the
// largest integer type. This results in a reduction in binary size but will
// cause a decrease in integer formatting performance.
#if !defined(FMT_REDUCE_INT_INSTANTIATIONS)
#  define FMT_REDUCE_INT_INSTANTIATIONS 0
#endif

// __builtin_clz is broken in clang with Microsoft CodeGen:
// https://github.com/fmtlib/fmt/issues/519.
#if !FMT_MSC_VERSION
#  if FMT_HAS_BUILTIN(__builtin_clz) || FMT_GCC_VERSION || FMT_ICC_VERSION
#    define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
#  endif
#  if FMT_HAS_BUILTIN(__builtin_clzll) || FMT_GCC_VERSION || FMT_ICC_VERSION
#    define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
#  endif
#endif

// __builtin_ctz is broken in Intel Compiler Classic on Windows:
// https://github.com/fmtlib/fmt/issues/2510.
#ifndef __ICL
#  if FMT_HAS_BUILTIN(__builtin_ctz) || FMT_GCC_VERSION || FMT_ICC_VERSION || \
      defined(__NVCOMPILER)
#    define FMT_BUILTIN_CTZ(n) __builtin_ctz(n)
#  endif
#  if FMT_HAS_BUILTIN(__builtin_ctzll) || FMT_GCC_VERSION || \
      FMT_ICC_VERSION || defined(__NVCOMPILER)
#    define FMT_BUILTIN_CTZLL(n) __builtin_ctzll(n)
#  endif
#endif

#if FMT_MSC_VERSION && !defined(FMT_MODULE)
# include <intrin.h> // _BitScanReverse[64], _BitScanForward[64], _umul128
#endif

// Some compilers masquerade as both MSVC and GCC-likes or otherwise support
// __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the
// MSVC intrinsics if the clz and clzll builtins are not available.
#if FMT_MSC_VERSION && !defined(FMT_BUILTIN_CLZLL) && \
    !defined(FMT_BUILTIN_CTZLL)
FMT_BEGIN_NAMESPACE
namespace detail {
// Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning.
#  if !defined(__clang__)
#    pragma intrinsic(_BitScanForward)
#    pragma intrinsic(_BitScanReverse)
#    if defined(_WIN64)
#      pragma intrinsic(_BitScanForward64)
#      pragma intrinsic(_BitScanReverse64)
#    endif
#  endif

inline auto clz(uint32_t x) -> int {
 unsigned long r = 0;
 _BitScanReverse(&r, x);
 FMT_ASSERT(x != 0, "");
 // Static analysis complains about using uninitialized data
 // "r", but the only way that can happen is if "x" is 0,
 // which the callers guarantee to not happen.
 FMT_MSC_WARNING(suppress : 6102)
 return 31 ^ static_cast<int>(r);
}
# define FMT_BUILTIN_CLZ(n) detail::clz(n)

inline auto clzll(uint64_t x) -> int {
 unsigned long r = 0;
# ifdef _WIN64
 _BitScanReverse64(&r, x);
# else
 // Scan the high 32 bits.
 if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
 return 63 ^ static_cast<int>(r + 32);
 // Scan the low 32 bits.
 _BitScanReverse(&r, static_cast<uint32_t>(x));
# endif
 FMT_ASSERT(x != 0, "");
 FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning.
 return 63 ^ static_cast<int>(r);
}
# define FMT_BUILTIN_CLZLL(n) detail::clzll(n)

inline auto ctz(uint32_t x) -> int {
 unsigned long r = 0;
 _BitScanForward(&r, x);
 FMT_ASSERT(x != 0, "");
 FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning.
 return static_cast<int>(r);
}
# define FMT_BUILTIN_CTZ(n) detail::ctz(n)

inline auto ctzll(uint64_t x) -> int {
 unsigned long r = 0;
 FMT_ASSERT(x != 0, "");
 FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning.
# ifdef _WIN64
 _BitScanForward64(&r, x);
# else
 // Scan the low 32 bits.
 if (_BitScanForward(&r, static_cast<uint32_t>(x))) return static_cast<int>(r);
 // Scan the high 32 bits.
 _BitScanForward(&r, static_cast<uint32_t>(x >> 32));
 r += 32;
# endif
 return static_cast<int>(r);
}
# define FMT_BUILTIN_CTZLL(n) detail::ctzll(n)
} // namespace detail
FMT_END_NAMESPACE
#endif

FMT_BEGIN_NAMESPACE

template <typename Char, typename Traits, typename Allocator>
struct is_contiguous<std::basic_string<Char, Traits, Allocator>>
 : std::true_type {};

template <typename T> struct type_identity {
 using type = T;
};
template <typename T> using type_identity_t = typename type_identity<T>::type;

namespace detail {

FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) {
  ignore_unused(condition);
#ifdef FMT_FUZZ
  if (condition) throw std::runtime_error("fuzzing limit reached");
#endif
}

#if defined(FMT_USE_STRING_VIEW)
template <typename Char> using std_string_view = std::basic_string_view<Char>;
#else
template <typename T> struct std_string_view {};
#endif

template <typename Char, Char... C> struct string_literal {
 static constexpr Char value[sizeof...(C)] = {C...};
 constexpr operator basic_string_view<Char>() const {
 return {value, sizeof...(C)};
 }
};
#if FMT_CPLUSPLUS < 201703L
template <typename Char, Char... C>
constexpr Char string_literal<Char, C...>::value[sizeof...(C)];
#endif

// Implementation of std::bit_cast for pre-C++20.
template <typename To, typename From, FMT_ENABLE_IF(sizeof(To) == sizeof(From))>
FMT_CONSTEXPR20 auto bit_cast(const From& from) -> To {
#ifdef __cpp_lib_bit_cast
 if (is_constant_evaluated()) return std::bit_cast<To>(from);
#endif
 auto to = To();
 // The cast suppresses a bogus -Wclass-memaccess on GCC.
 std::memcpy(static_cast<void*>(&to), &from, sizeof(to));
 return to;
}

inline auto is_big_endian() -> bool {
#ifdef _WIN32
 return false;
#elif defined(__BIG_ENDIAN__)
 return true;
#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__)
 return __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__;
#else
 struct bytes {
 char data[sizeof(int)];
 };
 return bit_cast<bytes>(1).data[0] == 0;
#endif
}

class uint128_fallback {
 private:
  uint64_t lo_, hi_;

public:
  constexpr uint128_fallback(uint64_t hi, uint64_t lo) : lo_(lo), hi_(hi) {}
  constexpr uint128_fallback(uint64_t value = 0) : lo_(value), hi_(0) {}

constexpr auto high() const noexcept -> uint64_t { return hi_; }
  constexpr auto low() const noexcept -> uint64_t { return lo_; }

template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
 constexpr explicit operator T() const {
 return static_cast<T>(lo_);
 }

friend constexpr auto operator==(const uint128_fallback& lhs,
 const uint128_fallback& rhs) -> bool {
 return lhs.hi_ == rhs.hi_ && lhs.lo_ == rhs.lo_;
 }
 friend constexpr auto operator!=(const uint128_fallback& lhs,
 const uint128_fallback& rhs) -> bool {
 return !(lhs == rhs);
 }
 friend constexpr auto operator>(const uint128_fallback& lhs,
 const uint128_fallback& rhs) -> bool {
 return lhs.hi_ != rhs.hi_ ? lhs.hi_ > rhs.hi_ : lhs.lo_ > rhs.lo_;
 }
 friend constexpr auto operator|(const uint128_fallback& lhs,
 const uint128_fallback& rhs)
 -> uint128_fallback {
 return {lhs.hi_ | rhs.hi_, lhs.lo_ | rhs.lo_};
 }
 friend constexpr auto operator&(const uint128_fallback& lhs,
 const uint128_fallback& rhs)
 -> uint128_fallback {
 return {lhs.hi_ & rhs.hi_, lhs.lo_ & rhs.lo_};
 }
 friend constexpr auto operator~(const uint128_fallback& n)
 -> uint128_fallback {
 return {~n.hi_, ~n.lo_};
 }
 friend auto operator+(const uint128_fallback& lhs,
 const uint128_fallback& rhs) -> uint128_fallback {
 auto result = uint128_fallback(lhs);
 result += rhs;
 return result;
 }
 friend auto operator*(const uint128_fallback& lhs, uint32_t rhs)
 -> uint128_fallback {
 FMT_ASSERT(lhs.hi_ == 0, "");
 uint64_t hi = (lhs.lo_ >> 32) * rhs;
 uint64_t lo = (lhs.lo_ & ~uint32_t()) * rhs;
 uint64_t new_lo = (hi << 32) + lo;
 return {(hi >> 32) + (new_lo < lo ? 1 : 0), new_lo};
 }
 friend auto operator-(const uint128_fallback& lhs, uint64_t rhs)
 -> uint128_fallback {
 return {lhs.hi_ - (lhs.lo_ < rhs ? 1 : 0), lhs.lo_ - rhs};
 }
 FMT_CONSTEXPR auto operator>>(int shift) const -> uint128_fallback {
 if (shift == 64) return {0, hi_};
 if (shift > 64) return uint128_fallback(0, hi_) >> (shift - 64);
 return {hi_ >> shift, (hi_ << (64 - shift)) | (lo_ >> shift)};
 }
 FMT_CONSTEXPR auto operator<<(int shift) const -> uint128_fallback {
 if (shift == 64) return {lo_, 0};
 if (shift > 64) return uint128_fallback(lo_, 0) << (shift - 64);
 return {hi_ << shift | (lo_ >> (64 - shift)), (lo_ << shift)};
 }
 FMT_CONSTEXPR auto operator>>=(int shift) -> uint128_fallback& {
 return *this = *this >> shift;
 }
 FMT_CONSTEXPR void operator+=(uint128_fallback n) {
 uint64_t new_lo = lo_ + n.lo_;
 uint64_t new_hi = hi_ + n.hi_ + (new_lo < lo_ ? 1 : 0);
 FMT_ASSERT(new_hi >= hi_, "");
 lo_ = new_lo;
 hi_ = new_hi;
 }
 FMT_CONSTEXPR void operator&=(uint128_fallback n) {
 lo_ &= n.lo_;
 hi_ &= n.hi_;
 }

FMT_CONSTEXPR20 auto operator+=(uint64_t n) noexcept -> uint128_fallback& {
 if (is_constant_evaluated()) {
 lo_ += n;
 hi_ += (lo_ < n ? 1 : 0);
 return *this;
 }
#if FMT_HAS_BUILTIN(__builtin_addcll) && !defined(__ibmxl__)
 unsigned long long carry;
 lo_ = __builtin_addcll(lo_, n, 0, &carry);
 hi_ += carry;
#elif FMT_HAS_BUILTIN(__builtin_ia32_addcarryx_u64) && !defined(__ibmxl__)
 unsigned long long result;
 auto carry = __builtin_ia32_addcarryx_u64(0, lo_, n, &result);
 lo_ = result;
 hi_ += carry;
#elif defined(_MSC_VER) && defined(_M_X64)
 auto carry = _addcarry_u64(0, lo_, n, &lo_);
 _addcarry_u64(carry, hi_, 0, &hi_);
#else
 lo_ += n;
 hi_ += (lo_ < n ? 1 : 0);
#endif
 return *this;
 }
};

using uint128_t = conditional_t<FMT_USE_INT128, uint128_opt, uint128_fallback>;

#ifdef UINTPTR_MAX
using uintptr_t = ::uintptr_t;
#else
using uintptr_t = uint128_t;
#endif

// Returns the largest possible value for type T. Same as
// std::numeric_limits<T>::max() but shorter and not affected by the max macro.
template <typename T> constexpr auto max_value() -> T {
 return (std::numeric_limits<T>::max)();
}
template <typename T> constexpr auto num_bits() -> int {
 return std::numeric_limits<T>::digits;
}
// std::numeric_limits<T>::digits may return 0 for 128-bit ints.
template <> constexpr auto num_bits<int128_opt>() -> int { return 128; }
template <> constexpr auto num_bits<uint128_opt>() -> int { return 128; }
template <> constexpr auto num_bits<uint128_fallback>() -> int { return 128; }

// A heterogeneous bit_cast used for converting 96-bit long double to uint128_t
// and 128-bit pointers to uint128_fallback.
template <typename To, typename From, FMT_ENABLE_IF(sizeof(To) > sizeof(From))>
inline auto bit_cast(const From& from) -> To {
 constexpr auto size = static_cast<int>(sizeof(From) / sizeof(unsigned));
 struct data_t {
 unsigned value[static_cast<unsigned>(size)];
 } data = bit_cast<data_t>(from);
 auto result = To();
 if (const_check(is_big_endian())) {
 for (int i = 0; i < size; ++i)
 result = (result << num_bits<unsigned>()) | data.value[i];
 } else {
 for (int i = size - 1; i >= 0; --i)
 result = (result << num_bits<unsigned>()) | data.value[i];
 }
 return result;
}

template <typename UInt>
FMT_CONSTEXPR20 inline auto countl_zero_fallback(UInt n) -> int {
 int lz = 0;
 constexpr UInt msb_mask = static_cast<UInt>(1) << (num_bits<UInt>() - 1);
 for (; (n & msb_mask) == 0; n <<= 1) lz++;
 return lz;
}

FMT_CONSTEXPR20 inline auto countl_zero(uint32_t n) -> int {
#ifdef FMT_BUILTIN_CLZ
  if (!is_constant_evaluated()) return FMT_BUILTIN_CLZ(n);
#endif
  return countl_zero_fallback(n);
}

FMT_CONSTEXPR20 inline auto countl_zero(uint64_t n) -> int {
#ifdef FMT_BUILTIN_CLZLL
  if (!is_constant_evaluated()) return FMT_BUILTIN_CLZLL(n);
#endif
  return countl_zero_fallback(n);
}

FMT_INLINE void assume(bool condition) {
  (void)condition;
#if FMT_HAS_BUILTIN(__builtin_assume) && !FMT_ICC_VERSION
  __builtin_assume(condition);
#elif FMT_GCC_VERSION
  if (!condition) __builtin_unreachable();
#endif
}

// Attempts to reserve space for n extra characters in the output range.
// Returns a pointer to the reserved range or a reference to it.
template <typename OutputIt,
 FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value&&
 is_contiguous<typename OutputIt::container>::value)>
#if FMT_CLANG_VERSION >= 307 && !FMT_ICC_VERSION
__attribute__((no_sanitize("undefined")))
#endif
FMT_CONSTEXPR20 inline auto
reserve(OutputIt it, size_t n) -> typename OutputIt::value_type* {
 auto& c = get_container(it);
 size_t size = c.size();
 c.resize(size + n);
 return &c[size];
}

template <typename T>
FMT_CONSTEXPR20 inline auto reserve(basic_appender<T> it, size_t n)
 -> basic_appender<T> {
 buffer<T>& buf = get_container(it);
 buf.try_reserve(buf.size() + n);
 return it;
}

template <typename Iterator>
constexpr auto reserve(Iterator& it, size_t) -> Iterator& {
 return it;
}

template <typename OutputIt>
using reserve_iterator =
 remove_reference_t<decltype(reserve(std::declval<OutputIt&>(), 0))>;

template <typename T, typename OutputIt>
constexpr auto to_pointer(OutputIt, size_t) -> T* {
 return nullptr;
}
template <typename T>
FMT_CONSTEXPR20 auto to_pointer(basic_appender<T> it, size_t n) -> T* {
 buffer<T>& buf = get_container(it);
 auto size = buf.size();
 buf.try_reserve(size + n);
 if (buf.capacity() < size + n) return nullptr;
 buf.try_resize(size + n);
 return buf.data() + size;
}

template <typename OutputIt,
 FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value&&
 is_contiguous<typename OutputIt::container>::value)>
inline auto base_iterator(OutputIt it,
 typename OutputIt::container_type::value_type*)
 -> OutputIt {
 return it;
}

template <typename Iterator>
constexpr auto base_iterator(Iterator, Iterator it) -> Iterator {
 return it;
}

// <algorithm> is spectacularly slow to compile in C++20 so use a simple fill_n
// instead (#1998).
template <typename OutputIt, typename Size, typename T>
FMT_CONSTEXPR auto fill_n(OutputIt out, Size count, const T& value)
 -> OutputIt {
 for (Size i = 0; i < count; ++i) *out++ = value;
 return out;
}
template <typename T, typename Size>
FMT_CONSTEXPR20 auto fill_n(T* out, Size count, char value) -> T* {
 if (is_constant_evaluated()) return fill_n<T*, Size, T>(out, count, value);
 std::memset(out, value, to_unsigned(count));
 return out + count;
}

template <typename OutChar, typename InputIt, typename OutputIt>
FMT_CONSTEXPR FMT_NOINLINE auto copy_noinline(InputIt begin, InputIt end,
 OutputIt out) -> OutputIt {
 return copy<OutChar>(begin, end, out);
}

// A public domain branchless UTF-8 decoder by Christopher Wellons:
// https://github.com/skeeto/branchless-utf8
/* Decode the next character, c, from s, reporting errors in e.
 *
 * Since this is a branchless decoder, four bytes will be read from the
 * buffer regardless of the actual length of the next character. This
 * means the buffer _must_ have at least three bytes of zero padding
 * following the end of the data stream.
 *
 * Errors are reported in e, which will be non-zero if the parsed
 * character was somehow invalid: invalid byte sequence, non-canonical
 * encoding, or a surrogate half.
 *
 * The function returns a pointer to the next character. When an error
 * occurs, this pointer will be a guess that depends on the particular
 * error, but it will always advance at least one byte.
 */
FMT_CONSTEXPR inline auto utf8_decode(const char* s, uint32_t* c, int* e)
    -> const char* {
  constexpr const int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07};
  constexpr const uint32_t mins[] = {4194304, 0, 128, 2048, 65536};
  constexpr const int shiftc[] = {0, 18, 12, 6, 0};
  constexpr const int shifte[] = {0, 6, 4, 2, 0};

int len = "\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0\0\0\2\2\2\2\3\3\4"
 [static_cast<unsigned char>(*s) >> 3];
 // Compute the pointer to the next character early so that the next
 // iteration can start working on the next character. Neither Clang
 // nor GCC figure out this reordering on their own.
 const char* next = s + len + !len;

using uchar = unsigned char;

// Assume a four-byte character and load four bytes. Unused bits are
 // shifted out.
 *c = uint32_t(uchar(s[0]) & masks[len]) << 18;
 *c |= uint32_t(uchar(s[1]) & 0x3f) << 12;
 *c |= uint32_t(uchar(s[2]) & 0x3f) << 6;
 *c |= uint32_t(uchar(s[3]) & 0x3f) << 0;
 *c >>= shiftc[len];

// Accumulate the various error conditions.
 *e = (*c < mins[len]) << 6; // non-canonical encoding
 *e |= ((*c >> 11) == 0x1b) << 7; // surrogate half?
 *e |= (*c > 0x10FFFF) << 8; // out of range?
 *e |= (uchar(s[1]) & 0xc0) >> 2;
 *e |= (uchar(s[2]) & 0xc0) >> 4;
 *e |= uchar(s[3]) >> 6;
 *e ^= 0x2a; // top two bits of each tail byte correct?
 *e >>= shifte[len];

return next;
}

constexpr FMT_INLINE_VARIABLE uint32_t invalid_code_point = ~uint32_t();

// Invokes f(cp, sv) for every code point cp in s with sv being the string view
// corresponding to the code point. cp is invalid_code_point on error.
template <typename F>
FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) {
 auto decode = [f](const char* buf_ptr, const char* ptr) {
 auto cp = uint32_t();
 auto error = 0;
 auto end = utf8_decode(buf_ptr, &cp, &error);
 bool result = f(error ? invalid_code_point : cp,
 string_view(ptr, error ? 1 : to_unsigned(end - buf_ptr)));
 return result ? (error ? buf_ptr + 1 : end) : nullptr;
 };

auto p = s.data();
 const size_t block_size = 4; // utf8_decode always reads blocks of 4 chars.
 if (s.size() >= block_size) {
 for (auto end = p + s.size() - block_size + 1; p < end;) {
 p = decode(p, p);
 if (!p) return;
 }
 }
 auto num_chars_left = to_unsigned(s.data() + s.size() - p);
 if (num_chars_left == 0) return;

FMT_ASSERT(num_chars_left < block_size, "");
 char buf[2 * block_size - 1] = {};
 copy<char>(p, p + num_chars_left, buf);
 const char* buf_ptr = buf;
 do {
 auto end = decode(buf_ptr, p);
 if (!end) return;
 p += end - buf_ptr;
 buf_ptr = end;
 } while (buf_ptr < buf + num_chars_left);
}

template <typename Char>
inline auto compute_width(basic_string_view<Char> s) -> size_t {
 return s.size();
}

// Computes approximate display width of a UTF-8 string.
FMT_CONSTEXPR inline auto compute_width(string_view s) -> size_t {
 size_t num_code_points = 0;
 // It is not a lambda for compatibility with C++14.
 struct count_code_points {
 size_t* count;
 FMT_CONSTEXPR auto operator()(uint32_t cp, string_view) const -> bool {
 *count += to_unsigned(
 1 +
 (cp >= 0x1100 &&
 (cp <= 0x115f || // Hangul Jamo init. consonants
 cp == 0x2329 || // LEFT-POINTING ANGLE BRACKET
 cp == 0x232a || // RIGHT-POINTING ANGLE BRACKET
 // CJK ... Yi except IDEOGRAPHIC HALF FILL SPACE:
 (cp >= 0x2e80 && cp <= 0xa4cf && cp != 0x303f) ||
 (cp >= 0xac00 && cp <= 0xd7a3) || // Hangul Syllables
 (cp >= 0xf900 && cp <= 0xfaff) || // CJK Compatibility Ideographs
 (cp >= 0xfe10 && cp <= 0xfe19) || // Vertical Forms
 (cp >= 0xfe30 && cp <= 0xfe6f) || // CJK Compatibility Forms
 (cp >= 0xff00 && cp <= 0xff60) || // Fullwidth Forms
 (cp >= 0xffe0 && cp <= 0xffe6) || // Fullwidth Forms
 (cp >= 0x20000 && cp <= 0x2fffd) || // CJK
 (cp >= 0x30000 && cp <= 0x3fffd) ||
 // Miscellaneous Symbols and Pictographs + Emoticons:
 (cp >= 0x1f300 && cp <= 0x1f64f) ||
 // Supplemental Symbols and Pictographs:
 (cp >= 0x1f900 && cp <= 0x1f9ff))));
 return true;
 }
 };
 // We could avoid branches by using utf8_decode directly.
 for_each_codepoint(s, count_code_points{&num_code_points});
 return num_code_points;
}

template <typename Char>
inline auto code_point_index(basic_string_view<Char> s, size_t n) -> size_t {
 size_t size = s.size();
 return n < size ? n : size;
}

// Calculates the index of the nth code point in a UTF-8 string.
inline auto code_point_index(string_view s, size_t n) -> size_t {
  size_t result = s.size();
  const char* begin = s.begin();
  for_each_codepoint(s, [begin, &n, &result](uint32_t, string_view sv) {
    if (n != 0) {
      --n;
      return true;
    }
    result = to_unsigned(sv.begin() - begin);
    return false;
  });
  return result;
}

template <typename T> struct is_integral : std::is_integral<T> {};
template <> struct is_integral<int128_opt> : std::true_type {};
template <> struct is_integral<uint128_t> : std::true_type {};

template <typename T>
using is_signed =
 std::integral_constant<bool, std::numeric_limits<T>::is_signed ||
 std::is_same<T, int128_opt>::value>;

template <typename T>
using is_integer =
 bool_constant<is_integral<T>::value && !std::is_same<T, bool>::value &&
 !std::is_same<T, char>::value &&
 !std::is_same<T, wchar_t>::value>;

#if defined(FMT_USE_FLOAT128)
// Use the provided definition.
#elif FMT_CLANG_VERSION && FMT_HAS_INCLUDE(<quadmath.h>)
# define FMT_USE_FLOAT128 1
#elif FMT_GCC_VERSION && defined(_GLIBCXX_USE_FLOAT128) && \
 !defined(__STRICT_ANSI__)
# define FMT_USE_FLOAT128 1
#else
# define FMT_USE_FLOAT128 0
#endif
#if FMT_USE_FLOAT128
using float128 = __float128;
#else
using float128 = void;
#endif

template <typename T> using is_float128 = std::is_same<T, float128>;

template <typename T>
using is_floating_point =
 bool_constant<std::is_floating_point<T>::value || is_float128<T>::value>;

template <typename T, bool = std::is_floating_point<T>::value>
struct is_fast_float : bool_constant<std::numeric_limits<T>::is_iec559 &&
 sizeof(T) <= sizeof(double)> {};
template <typename T> struct is_fast_float<T, false> : std::false_type {};

template <typename T>
using is_double_double = bool_constant<std::numeric_limits<T>::digits == 106>;

#ifndef FMT_USE_FULL_CACHE_DRAGONBOX
#  define FMT_USE_FULL_CACHE_DRAGONBOX 0
#endif

template <typename T, typename Enable = void>
struct is_locale : std::false_type {};
template <typename T>
struct is_locale<T, void_t<decltype(T::classic())>> : std::true_type {};

// An allocator that uses malloc/free to allow removing dependency on the C++
// standard libary runtime.
template <typename T> struct allocator {
 using value_type = T;

T* allocate(size_t n) {
 FMT_ASSERT(n <= max_value<size_t>() / sizeof(T), "");
 T* p = static_cast<T*>(malloc(n * sizeof(T)));
 if (!p) FMT_THROW(std::bad_alloc());
 return p;
 }

void deallocate(T* p, size_t) { free(p); }
};

}  // namespace detail

FMT_BEGIN_EXPORT

// The number of characters to store in the basic_memory_buffer object itself
// to avoid dynamic memory allocation.
enum { inline_buffer_size = 500 };

/**
 * A dynamically growing memory buffer for trivially copyable/constructible
 * types with the first `SIZE` elements stored in the object itself. Most
 * commonly used via the `memory_buffer` alias for `char`.
 *
 * **Example**:
 *
 * auto out = fmt::memory_buffer();
 * fmt::format_to(std::back_inserter(out), "The answer is {}.", 42);
 *
 * This will append "The answer is 42." to `out`. The buffer content can be
 * converted to `std::string` with `to_string(out)`.
 */
template <typename T, size_t SIZE = inline_buffer_size,
 typename Allocator = detail::allocator<T>>
class basic_memory_buffer : public detail::buffer<T> {
 private:
 T store_[SIZE];

// Don't inherit from Allocator to avoid generating type_info for it.
  FMT_NO_UNIQUE_ADDRESS Allocator alloc_;

// Deallocate memory allocated by the buffer.
  FMT_CONSTEXPR20 void deallocate() {
    T* data = this->data();
    if (data != store_) alloc_.deallocate(data, this->capacity());
  }

static FMT_CONSTEXPR20 void grow(detail::buffer<T>& buf, size_t size) {
 detail::abort_fuzzing_if(size > 5000);
 auto& self = static_cast<basic_memory_buffer&>(buf);
 const size_t max_size =
 std::allocator_traits<Allocator>::max_size(self.alloc_);
 size_t old_capacity = buf.capacity();
 size_t new_capacity = old_capacity + old_capacity / 2;
 if (size > new_capacity)
 new_capacity = size;
 else if (new_capacity > max_size)
 new_capacity = size > max_size ? size : max_size;
 T* old_data = buf.data();
 T* new_data = self.alloc_.allocate(new_capacity);
 // Suppress a bogus -Wstringop-overflow in gcc 13.1 (#3481).
 detail::assume(buf.size() <= new_capacity);
 // The following code doesn't throw, so the raw pointer above doesn't leak.
 memcpy(new_data, old_data, buf.size() * sizeof(T));
 self.set(new_data, new_capacity);
 // deallocate must not throw according to the standard, but even if it does,
 // the buffer already uses the new storage and will deallocate it in
 // destructor.
 if (old_data != self.store_) self.alloc_.deallocate(old_data, old_capacity);
 }

public:
  using value_type = T;
  using const_reference = const T&;

FMT_CONSTEXPR20 explicit basic_memory_buffer(
 const Allocator& alloc = Allocator())
 : detail::buffer<T>(grow), alloc_(alloc) {
 this->set(store_, SIZE);
 if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T());
 }
 FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); }

private:
 // Move data from other to this buffer.
 FMT_CONSTEXPR20 void move(basic_memory_buffer& other) {
 alloc_ = std::move(other.alloc_);
 T* data = other.data();
 size_t size = other.size(), capacity = other.capacity();
 if (data == other.store_) {
 this->set(store_, capacity);
 detail::copy<T>(other.store_, other.store_ + size, store_);
 } else {
 this->set(data, capacity);
 // Set pointer to the inline array so that delete is not called
 // when deallocating.
 other.set(other.store_, 0);
 other.clear();
 }
 this->resize(size);
 }

public:
 /// Constructs a `basic_memory_buffer` object moving the content of the other
 /// object to it.
 FMT_CONSTEXPR20 basic_memory_buffer(basic_memory_buffer&& other) noexcept
 : detail::buffer<T>(grow) {
 move(other);
 }

/// Moves the content of the other `basic_memory_buffer` object to this one.
  auto operator=(basic_memory_buffer&& other) noexcept -> basic_memory_buffer& {
    FMT_ASSERT(this != &other, "");
    deallocate();
    move(other);
    return *this;
  }

// Returns a copy of the allocator associated with this buffer.
  auto get_allocator() const -> Allocator { return alloc_; }

/// Resizes the buffer to contain `count` elements. If T is a POD type new
  /// elements may not be initialized.
  FMT_CONSTEXPR20 void resize(size_t count) { this->try_resize(count); }

/// Increases the buffer capacity to `new_capacity`.
  void reserve(size_t new_capacity) { this->try_reserve(new_capacity); }

using detail::buffer<T>::append;
 template <typename ContiguousRange>
 FMT_CONSTEXPR20 void append(const ContiguousRange& range) {
 append(range.data(), range.data() + range.size());
 }
};

using memory_buffer = basic_memory_buffer<char>;

template <size_t SIZE>
FMT_NODISCARD auto to_string(basic_memory_buffer<char, SIZE>& buf)
 -> std::string {
 auto size = buf.size();
 detail::assume(size < std::string().max_size());
 return {buf.data(), size};
}

// A writer to a buffered stream. It doesn't own the underlying stream.
class writer {
 private:
 detail::buffer<char>* buf_;

// We cannot create a file buffer in advance because any write to a FILE may
  // invalidate it.
  FILE* file_;

public:
 writer(FILE* f) : buf_(nullptr), file_(f) {}
 writer(detail::buffer<char>& buf) : buf_(&buf) {}

/// Formats `args` according to specifications in `fmt` and writes the
 /// output to the file.
 template <typename... T> void print(format_string<T...> fmt, T&&... args) {
 if (buf_)
 fmt::format_to(appender(*buf_), fmt, std::forward<T>(args)...);
 else
 fmt::print(file_, fmt, std::forward<T>(args)...);
 }
};

class string_buffer {
 private:
 std::string str_;
 detail::container_buffer<std::string> buf_;

public:
  string_buffer() : buf_(str_) {}

operator writer() { return buf_; }
  std::string& str() { return str_; }
};

template <typename T, size_t SIZE, typename Allocator>
struct is_contiguous<basic_memory_buffer<T, SIZE, Allocator>> : std::true_type {
};

FMT_END_EXPORT
namespace detail {

template <typename Context, typename T>
FMT_CONSTEXPR auto make_arg(T& val) -> basic_format_arg<Context> {
 return {arg_mapper<typename Context::char_type>::map(val)};
}

FMT_API auto write_console(int fd, string_view text) -> bool;
FMT_API void print(FILE*, string_view);
}  // namespace detail

FMT_BEGIN_EXPORT

// Suppress a misleading warning in older versions of clang.
FMT_PRAGMA_CLANG(diagnostic ignored "-Wweak-vtables")

/// An error reported from a formatting function.
class FMT_SO_VISIBILITY("default") format_error : public std::runtime_error {
 public:
  using std::runtime_error::runtime_error;
};

namespace detail_exported {
#if FMT_USE_NONTYPE_TEMPLATE_ARGS
template <typename Char, size_t N> struct fixed_string {
 constexpr fixed_string(const Char (&str)[N]) {
 detail::copy<Char, const Char*, Char*>(static_cast<const Char*>(str),
 str + N, data);
 }
 Char data[N] = {};
};
#endif // FMT_USE_NONTYPE_TEMPLATE_ARGS

// Converts a compile-time string to basic_string_view.
template <typename Char, size_t N>
constexpr auto compile_string_to_view(const Char (&s)[N])
 -> basic_string_view<Char> {
 // Remove trailing NUL character if needed. Won't be present if this is used
 // with a raw character array (i.e. not defined as a string).
 return {s, N - (std::char_traits<Char>::to_int_type(s[N - 1]) == 0 ? 1 : 0)};
}
template <typename Char>
constexpr auto compile_string_to_view(basic_string_view<Char> s)
 -> basic_string_view<Char> {
 return s;
}
} // namespace detail_exported

// A generic formatting context with custom output iterator and character
// (code unit) support. Char is the format string code unit type which can be
// different from OutputIt::value_type.
template <typename OutputIt, typename Char> class generic_context {
 private:
 OutputIt out_;
 basic_format_args<generic_context> args_;
 detail::locale_ref loc_;

public:
 using char_type = Char;
 using iterator = OutputIt;
 using parse_context_type FMT_DEPRECATED = parse_context<Char>;
 template <typename T>
 using formatter_type FMT_DEPRECATED = formatter<T, Char>;
 enum { builtin_types = FMT_BUILTIN_TYPES };

constexpr generic_context(OutputIt out,
 basic_format_args<generic_context> args,
 detail::locale_ref loc = {})
 : out_(out), args_(args), loc_(loc) {}
 generic_context(generic_context&&) = default;
 generic_context(const generic_context&) = delete;
 void operator=(const generic_context&) = delete;

constexpr auto arg(int id) const -> basic_format_arg<generic_context> {
 return args_.get(id);
 }
 auto arg(basic_string_view<Char> name) -> basic_format_arg<generic_context> {
 return args_.get(name);
 }
 FMT_CONSTEXPR auto arg_id(basic_string_view<Char> name) -> int {
 return args_.get_id(name);
 }

FMT_CONSTEXPR auto out() -> iterator { return out_; }

void advance_to(iterator it) {
 if (!detail::is_back_insert_iterator<iterator>()) out_ = it;
 }

FMT_CONSTEXPR auto locale() -> detail::locale_ref { return loc_; }
};

class loc_value {
 private:
 basic_format_arg<context> value_;

public:
 template <typename T, FMT_ENABLE_IF(!detail::is_float128<T>::value)>
 loc_value(T value) : value_(detail::make_arg<context>(value)) {}

template <typename T, FMT_ENABLE_IF(detail::is_float128<T>::value)>
 loc_value(T) {}

template <typename Visitor> auto visit(Visitor&& vis) -> decltype(vis(0)) {
 return value_.visit(vis);
 }
};

// A locale facet that formats values in UTF-8.
// It is parameterized on the locale to avoid the heavy <locale> include.
template <typename Locale> class format_facet : public Locale::facet {
 private:
 std::string separator_;
 std::string grouping_;
 std::string decimal_point_;

protected:
  virtual auto do_put(appender out, loc_value val,
                      const format_specs& specs) const -> bool;

public:
  static FMT_API typename Locale::id id;

explicit format_facet(Locale& loc);
 explicit format_facet(string_view sep = "",
 std::initializer_list<unsigned char> g = {3},
 std::string decimal_point = ".")
 : separator_(sep.data(), sep.size()),
 grouping_(g.begin(), g.end()),
 decimal_point_(decimal_point) {}

auto put(appender out, loc_value val, const format_specs& specs) const
      -> bool {
    return do_put(out, val, specs);
  }
};

FMT_END_EXPORT

namespace detail {

// Returns true if value is negative, false otherwise.
// Same as `value < 0` but doesn't produce warnings if T is an unsigned type.
template <typename T, FMT_ENABLE_IF(is_signed<T>::value)>
constexpr auto is_negative(T value) -> bool {
 return value < 0;
}
template <typename T, FMT_ENABLE_IF(!is_signed<T>::value)>
constexpr auto is_negative(T) -> bool {
 return false;
}

// Smallest of uint32_t, uint64_t, uint128_t that is large enough to
// represent all values of an integral type T.
template <typename T>
using uint32_or_64_or_128_t =
 conditional_t<num_bits<T>() <= 32 && !FMT_REDUCE_INT_INSTANTIATIONS,
 uint32_t,
 conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>>;
template <typename T>
using uint64_or_128_t = conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>;

#define FMT_POWERS_OF_10(factor)                                  \
  factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \
      (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \
      (factor) * 100000000, (factor) * 1000000000

// Converts value in the range [0, 100) to a string.
// GCC generates slightly better code when value is pointer-size.
inline auto digits2(size_t value) -> const char* {
  // Align data since unaligned access may be slower when crossing a
  // hardware-specific boundary.
  alignas(2) static const char data[] =
      "0001020304050607080910111213141516171819"
      "2021222324252627282930313233343536373839"
      "4041424344454647484950515253545556575859"
      "6061626364656667686970717273747576777879"
      "8081828384858687888990919293949596979899";
  return &data[value * 2];
}

template <typename Char> constexpr auto getsign(sign s) -> Char {
 return static_cast<char>(((' ' << 24) | ('+' << 16) | ('-' << 8)) >>
 (static_cast<int>(s) * 8));
}

template <typename T> FMT_CONSTEXPR auto count_digits_fallback(T n) -> int {
 int count = 1;
 for (;;) {
 // Integer division is slow so do it for a group of four digits instead
 // of for every digit. The idea comes from the talk by Alexandrescu
 // "Three Optimization Tips for C++". See speed-test for a comparison.
 if (n < 10) return count;
 if (n < 100) return count + 1;
 if (n < 1000) return count + 2;
 if (n < 10000) return count + 3;
 n /= 10000u;
 count += 4;
 }
}
#if FMT_USE_INT128
FMT_CONSTEXPR inline auto count_digits(uint128_opt n) -> int {
 return count_digits_fallback(n);
}
#endif

#ifdef FMT_BUILTIN_CLZLL
// It is a separate function rather than a part of count_digits to workaround
// the lack of static constexpr in constexpr functions.
inline auto do_count_digits(uint64_t n) -> int {
 // This has comparable performance to the version by Kendall Willets
 // (https://github.com/fmtlib/format-benchmark/blob/master/digits10)
 // but uses smaller tables.
 // Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)).
 static constexpr uint8_t bsr2log10[] = {
 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5,
 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10,
 10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15,
 15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20};
 auto t = bsr2log10[FMT_BUILTIN_CLZLL(n | 1) ^ 63];
 static constexpr const uint64_t zero_or_powers_of_10[] = {
 0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL),
 10000000000000000000ULL};
 return t - (n < zero_or_powers_of_10[t]);
}
#endif

// Returns the number of decimal digits in n. Leading zeros are not counted
// except for n == 0 in which case count_digits returns 1.
FMT_CONSTEXPR20 inline auto count_digits(uint64_t n) -> int {
#ifdef FMT_BUILTIN_CLZLL
  if (!is_constant_evaluated() && !FMT_OPTIMIZE_SIZE) return do_count_digits(n);
#endif
  return count_digits_fallback(n);
}

// Counts the number of digits in n. BITS = log2(radix).
template <int BITS, typename UInt>
FMT_CONSTEXPR auto count_digits(UInt n) -> int {
#ifdef FMT_BUILTIN_CLZ
 if (!is_constant_evaluated() && num_bits<UInt>() == 32)
 return (FMT_BUILTIN_CLZ(static_cast<uint32_t>(n) | 1) ^ 31) / BITS + 1;
#endif
 // Lambda avoids unreachable code warnings from NVHPC.
 return [](UInt m) {
 int num_digits = 0;
 do {
 ++num_digits;
 } while ((m >>= BITS) != 0);
 return num_digits;
 }(n);
}

#ifdef FMT_BUILTIN_CLZ
// It is a separate function rather than a part of count_digits to workaround
// the lack of static constexpr in constexpr functions.
FMT_INLINE auto do_count_digits(uint32_t n) -> int {
// An optimization by Kendall Willets from https://bit.ly/3uOIQrB.
// This increments the upper 32 bits (log10(T) - 1) when >= T is added.
# define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
 static constexpr uint64_t table[] = {
 FMT_INC(0), FMT_INC(0), FMT_INC(0), // 8
 FMT_INC(10), FMT_INC(10), FMT_INC(10), // 64
 FMT_INC(100), FMT_INC(100), FMT_INC(100), // 512
 FMT_INC(1000), FMT_INC(1000), FMT_INC(1000), // 4096
 FMT_INC(10000), FMT_INC(10000), FMT_INC(10000), // 32k
 FMT_INC(100000), FMT_INC(100000), FMT_INC(100000), // 256k
 FMT_INC(1000000), FMT_INC(1000000), FMT_INC(1000000), // 2048k
 FMT_INC(10000000), FMT_INC(10000000), FMT_INC(10000000), // 16M
 FMT_INC(100000000), FMT_INC(100000000), FMT_INC(100000000), // 128M
 FMT_INC(1000000000), FMT_INC(1000000000), FMT_INC(1000000000), // 1024M
 FMT_INC(1000000000), FMT_INC(1000000000) // 4B
 };
 auto inc = table[FMT_BUILTIN_CLZ(n | 1) ^ 31];
 return static_cast<int>((n + inc) >> 32);
}
#endif

// Optional version of count_digits for better performance on 32-bit platforms.
FMT_CONSTEXPR20 inline auto count_digits(uint32_t n) -> int {
#ifdef FMT_BUILTIN_CLZ
  if (!is_constant_evaluated() && !FMT_OPTIMIZE_SIZE) return do_count_digits(n);
#endif
  return count_digits_fallback(n);
}

template <typename Int> constexpr auto digits10() noexcept -> int {
 return std::numeric_limits<Int>::digits10;
}
template <> constexpr auto digits10<int128_opt>() noexcept -> int { return 38; }
template <> constexpr auto digits10<uint128_t>() noexcept -> int { return 38; }

template <typename Char> struct thousands_sep_result {
 std::string grouping;
 Char thousands_sep;
};

template <typename Char>
FMT_API auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char>;
template <typename Char>
inline auto thousands_sep(locale_ref loc) -> thousands_sep_result<Char> {
 auto result = thousands_sep_impl<char>(loc);
 return {result.grouping, Char(result.thousands_sep)};
}
template <>
inline auto thousands_sep(locale_ref loc) -> thousands_sep_result<wchar_t> {
 return thousands_sep_impl<wchar_t>(loc);
}

template <typename Char>
FMT_API auto decimal_point_impl(locale_ref loc) -> Char;
template <typename Char> inline auto decimal_point(locale_ref loc) -> Char {
 return Char(decimal_point_impl<char>(loc));
}
template <> inline auto decimal_point(locale_ref loc) -> wchar_t {
 return decimal_point_impl<wchar_t>(loc);
}

// Compares two characters for equality.
template <typename Char> auto equal2(const Char* lhs, const char* rhs) -> bool {
 return lhs[0] == Char(rhs[0]) && lhs[1] == Char(rhs[1]);
}
inline auto equal2(const char* lhs, const char* rhs) -> bool {
 return memcmp(lhs, rhs, 2) == 0;
}

// Writes a two-digit value to out.
template <typename Char>
FMT_CONSTEXPR20 FMT_INLINE void write2digits(Char* out, size_t value) {
 if (!is_constant_evaluated() && std::is_same<Char, char>::value &&
 !FMT_OPTIMIZE_SIZE) {
 memcpy(out, digits2(value), 2);
 return;
 }
 *out++ = static_cast<Char>('0' + value / 10);
 *out = static_cast<Char>('0' + value % 10);
}

// Formats a decimal unsigned integer value writing to out pointing to a buffer
// of specified size. The caller must ensure that the buffer is large enough.
template <typename Char, typename UInt>
FMT_CONSTEXPR20 auto do_format_decimal(Char* out, UInt value, int size)
 -> Char* {
 FMT_ASSERT(size >= count_digits(value), "invalid digit count");
 unsigned n = to_unsigned(size);
 while (value >= 100) {
 // Integer division is slow so do it for a group of two digits instead
 // of for every digit. The idea comes from the talk by Alexandrescu
 // "Three Optimization Tips for C++". See speed-test for a comparison.
 n -= 2;
 write2digits(out + n, static_cast<unsigned>(value % 100));
 value /= 100;
 }
 if (value >= 10) {
 n -= 2;
 write2digits(out + n, static_cast<unsigned>(value));
 } else {
 out[--n] = static_cast<Char>('0' + value);
 }
 return out + n;
}

template <typename Char, typename UInt>
FMT_CONSTEXPR FMT_INLINE auto format_decimal(Char* out, UInt value,
 int num_digits) -> Char* {
 do_format_decimal(out, value, num_digits);
 return out + num_digits;
}

template <typename Char, typename UInt, typename OutputIt,
 FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value)>
FMT_CONSTEXPR auto format_decimal(OutputIt out, UInt value, int num_digits)
 -> OutputIt {
 if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
 do_format_decimal(ptr, value, num_digits);
 return out;
 }
 // Buffer is large enough to hold all digits (digits10 + 1).
 char buffer[digits10<UInt>() + 1];
 if (is_constant_evaluated()) fill_n(buffer, sizeof(buffer), '\0');
 do_format_decimal(buffer, value, num_digits);
 return copy_noinline<Char>(buffer, buffer + num_digits, out);
}

template <typename Char, typename UInt>
FMT_CONSTEXPR auto do_format_base2e(int base_bits, Char* out, UInt value,
 int size, bool upper = false) -> Char* {
 out += size;
 do {
 const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
 unsigned digit = static_cast<unsigned>(value & ((1 << base_bits) - 1));
 *--out = static_cast<Char>(base_bits < 4 ? static_cast<char>('0' + digit)
 : digits[digit]);
 } while ((value >>= base_bits) != 0);
 return out;
}

// Formats an unsigned integer in the power of two base (binary, octal, hex).
template <typename Char, typename UInt>
FMT_CONSTEXPR auto format_base2e(int base_bits, Char* out, UInt value,
 int num_digits, bool upper = false) -> Char* {
 do_format_base2e(base_bits, out, value, num_digits, upper);
 return out + num_digits;
}

template <typename Char, typename OutputIt, typename UInt,
 FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value)>
FMT_CONSTEXPR inline auto format_base2e(int base_bits, OutputIt out, UInt value,
 int num_digits, bool upper = false)
 -> OutputIt {
 if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
 format_base2e(base_bits, ptr, value, num_digits, upper);
 return out;
 }
 // Make buffer large enough for any base.
 char buffer[num_bits<UInt>()];
 if (is_constant_evaluated()) fill_n(buffer, sizeof(buffer), '\0');
 format_base2e(base_bits, buffer, value, num_digits, upper);
 return detail::copy_noinline<Char>(buffer, buffer + num_digits, out);
}

// A converter from UTF-8 to UTF-16.
class utf8_to_utf16 {
 private:
 basic_memory_buffer<wchar_t> buffer_;

public:
 FMT_API explicit utf8_to_utf16(string_view s);
 operator basic_string_view<wchar_t>() const { return {&buffer_[0], size()}; }
 auto size() const -> size_t { return buffer_.size() - 1; }
 auto c_str() const -> const wchar_t* { return &buffer_[0]; }
 auto str() const -> std::wstring { return {&buffer_[0], size()}; }
};

enum class to_utf8_error_policy { abort, replace };

// A converter from UTF-16/UTF-32 (host endian) to UTF-8.
template <typename WChar, typename Buffer = memory_buffer> class to_utf8 {
 private:
 Buffer buffer_;

public:
 to_utf8() {}
 explicit to_utf8(basic_string_view<WChar> s,
 to_utf8_error_policy policy = to_utf8_error_policy::abort) {
 static_assert(sizeof(WChar) == 2 || sizeof(WChar) == 4,
 "Expect utf16 or utf32");
 if (!convert(s, policy))
 FMT_THROW(std::runtime_error(sizeof(WChar) == 2 ? "invalid utf16"
 : "invalid utf32"));
 }
 operator string_view() const { return string_view(&buffer_[0], size()); }
 auto size() const -> size_t { return buffer_.size() - 1; }
 auto c_str() const -> const char* { return &buffer_[0]; }
 auto str() const -> std::string { return std::string(&buffer_[0], size()); }

// Performs conversion returning a bool instead of throwing exception on
 // conversion error. This method may still throw in case of memory allocation
 // error.
 auto convert(basic_string_view<WChar> s,
 to_utf8_error_policy policy = to_utf8_error_policy::abort)
 -> bool {
 if (!convert(buffer_, s, policy)) return false;
 buffer_.push_back(0);
 return true;
 }
 static auto convert(Buffer& buf, basic_string_view<WChar> s,
 to_utf8_error_policy policy = to_utf8_error_policy::abort)
 -> bool {
 for (auto p = s.begin(); p != s.end(); ++p) {
 uint32_t c = static_cast<uint32_t>(*p);
 if (sizeof(WChar) == 2 && c >= 0xd800 && c <= 0xdfff) {
 // Handle a surrogate pair.
 ++p;
 if (p == s.end() || (c & 0xfc00) != 0xd800 || (*p & 0xfc00) != 0xdc00) {
 if (policy == to_utf8_error_policy::abort) return false;
 buf.append(string_view("\xEF\xBF\xBD"));
 --p;
 continue;
 } else {
 c = (c << 10) + static_cast<uint32_t>(*p) - 0x35fdc00;
 }
 }
 if (c < 0x80) {
 buf.push_back(static_cast<char>(c));
 } else if (c < 0x800) {
 buf.push_back(static_cast<char>(0xc0 | (c >> 6)));
 buf.push_back(static_cast<char>(0x80 | (c & 0x3f)));
 } else if ((c >= 0x800 && c <= 0xd7ff) || (c >= 0xe000 && c <= 0xffff)) {
 buf.push_back(static_cast<char>(0xe0 | (c >> 12)));
 buf.push_back(static_cast<char>(0x80 | ((c & 0xfff) >> 6)));
 buf.push_back(static_cast<char>(0x80 | (c & 0x3f)));
 } else if (c >= 0x10000 && c <= 0x10ffff) {
 buf.push_back(static_cast<char>(0xf0 | (c >> 18)));
 buf.push_back(static_cast<char>(0x80 | ((c & 0x3ffff) >> 12)));
 buf.push_back(static_cast<char>(0x80 | ((c & 0xfff) >> 6)));
 buf.push_back(static_cast<char>(0x80 | (c & 0x3f)));
 } else {
 return false;
 }
 }
 return true;
 }
};

// Computes 128-bit result of multiplication of two 64-bit unsigned integers.
inline auto umul128(uint64_t x, uint64_t y) noexcept -> uint128_fallback {
#if FMT_USE_INT128
 auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
 return {static_cast<uint64_t>(p >> 64), static_cast<uint64_t>(p)};
#elif defined(_MSC_VER) && defined(_M_X64)
 auto hi = uint64_t();
 auto lo = _umul128(x, y, &hi);
 return {hi, lo};
#else
 const uint64_t mask = static_cast<uint64_t>(max_value<uint32_t>());

uint64_t a = x >> 32;
  uint64_t b = x & mask;
  uint64_t c = y >> 32;
  uint64_t d = y & mask;

uint64_t ac = a * c;
  uint64_t bc = b * c;
  uint64_t ad = a * d;
  uint64_t bd = b * d;

uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask);

return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32),
 (intermediate << 32) + (bd & mask)};
#endif
}

namespace dragonbox {
// Computes floor(log10(pow(2, e))) for e in [-2620, 2620] using the method from
// https://fmt.dev/papers/Dragonbox.pdf#page=28, section 6.1.
inline auto floor_log10_pow2(int e) noexcept -> int {
 FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent");
 static_assert((-1 >> 1) == -1, "right shift is not arithmetic");
 return (e * 315653) >> 20;
}

inline auto floor_log2_pow10(int e) noexcept -> int {
 FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
 return (e * 1741647) >> 19;
}

// Computes upper 64 bits of multiplication of two 64-bit unsigned integers.
inline auto umul128_upper64(uint64_t x, uint64_t y) noexcept -> uint64_t {
#if FMT_USE_INT128
 auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
 return static_cast<uint64_t>(p >> 64);
#elif defined(_MSC_VER) && defined(_M_X64)
 return __umulh(x, y);
#else
 return umul128(x, y).high();
#endif
}

// Computes upper 128 bits of multiplication of a 64-bit unsigned integer and a
// 128-bit unsigned integer.
inline auto umul192_upper128(uint64_t x, uint128_fallback y) noexcept
    -> uint128_fallback {
  uint128_fallback r = umul128(x, y.high());
  r += umul128_upper64(x, y.low());
  return r;
}

FMT_API auto get_cached_power(int k) noexcept -> uint128_fallback;

// Type-specific information that Dragonbox uses.
template <typename T, typename Enable = void> struct float_info;

template <> struct float_info<float> {
 using carrier_uint = uint32_t;
 static const int exponent_bits = 8;
 static const int kappa = 1;
 static const int big_divisor = 100;
 static const int small_divisor = 10;
 static const int min_k = -31;
 static const int max_k = 46;
 static const int shorter_interval_tie_lower_threshold = -35;
 static const int shorter_interval_tie_upper_threshold = -35;
};

template <> struct float_info<double> {
 using carrier_uint = uint64_t;
 static const int exponent_bits = 11;
 static const int kappa = 2;
 static const int big_divisor = 1000;
 static const int small_divisor = 100;
 static const int min_k = -292;
 static const int max_k = 341;
 static const int shorter_interval_tie_lower_threshold = -77;
 static const int shorter_interval_tie_upper_threshold = -77;
};

// An 80- or 128-bit floating point number.
template <typename T>
struct float_info<T, enable_if_t<std::numeric_limits<T>::digits == 64 ||
 std::numeric_limits<T>::digits == 113 ||
 is_float128<T>::value>> {
 using carrier_uint = detail::uint128_t;
 static const int exponent_bits = 15;
};

// A double-double floating point number.
template <typename T>
struct float_info<T, enable_if_t<is_double_double<T>::value>> {
 using carrier_uint = detail::uint128_t;
};

template <typename T> struct decimal_fp {
 using significand_type = typename float_info<T>::carrier_uint;
 significand_type significand;
 int exponent;
};

template <typename T> FMT_API auto to_decimal(T x) noexcept -> decimal_fp<T>;
} // namespace dragonbox

// Returns true iff Float has the implicit bit which is not stored.
template <typename Float> constexpr auto has_implicit_bit() -> bool {
 // An 80-bit FP number has a 64-bit significand an no implicit bit.
 return std::numeric_limits<Float>::digits != 64;
}

// Returns the number of significand bits stored in Float. The implicit bit is
// not counted since it is not stored.
template <typename Float> constexpr auto num_significand_bits() -> int {
 // std::numeric_limits may not support __float128.
 return is_float128<Float>() ? 112
 : (std::numeric_limits<Float>::digits -
 (has_implicit_bit<Float>() ? 1 : 0));
}

template <typename Float>
constexpr auto exponent_mask() ->
 typename dragonbox::float_info<Float>::carrier_uint {
 using float_uint = typename dragonbox::float_info<Float>::carrier_uint;
 return ((float_uint(1) << dragonbox::float_info<Float>::exponent_bits) - 1)
 << num_significand_bits<Float>();
}
template <typename Float> constexpr auto exponent_bias() -> int {
 // std::numeric_limits may not support __float128.
 return is_float128<Float>() ? 16383
 : std::numeric_limits<Float>::max_exponent - 1;
}

// Writes the exponent exp in the form "[+-]d{2,3}" to buffer.
template <typename Char, typename OutputIt>
FMT_CONSTEXPR auto write_exponent(int exp, OutputIt out) -> OutputIt {
 FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range");
 if (exp < 0) {
 *out++ = static_cast<Char>('-');
 exp = -exp;
 } else {
 *out++ = static_cast<Char>('+');
 }
 auto uexp = static_cast<uint32_t>(exp);
 if (is_constant_evaluated()) {
 if (uexp < 10) *out++ = '0';
 return format_decimal<Char>(out, uexp, count_digits(uexp));
 }
 if (uexp >= 100u) {
 const char* top = digits2(uexp / 100);
 if (uexp >= 1000u) *out++ = static_cast<Char>(top[0]);
 *out++ = static_cast<Char>(top[1]);
 uexp %= 100;
 }
 const char* d = digits2(uexp);
 *out++ = static_cast<Char>(d[0]);
 *out++ = static_cast<Char>(d[1]);
 return out;
}

// A floating-point number f * pow(2, e) where F is an unsigned type.
template <typename F> struct basic_fp {
 F f;
 int e;

static constexpr const int num_significand_bits =
 static_cast<int>(sizeof(F) * num_bits<unsigned char>());

constexpr basic_fp() : f(0), e(0) {}
  constexpr basic_fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}

// Constructs fp from an IEEE754 floating-point number.
 template <typename Float> FMT_CONSTEXPR basic_fp(Float n) { assign(n); }

// Assigns n to this and return true iff predecessor is closer than successor.
 template <typename Float, FMT_ENABLE_IF(!is_double_double<Float>::value)>
 FMT_CONSTEXPR auto assign(Float n) -> bool {
 static_assert(std::numeric_limits<Float>::digits <= 113, "unsupported FP");
 // Assume Float is in the format [sign][exponent][significand].
 using carrier_uint = typename dragonbox::float_info<Float>::carrier_uint;
 const auto num_float_significand_bits =
 detail::num_significand_bits<Float>();
 const auto implicit_bit = carrier_uint(1) << num_float_significand_bits;
 const auto significand_mask = implicit_bit - 1;
 auto u = bit_cast<carrier_uint>(n);
 f = static_cast<F>(u & significand_mask);
 auto biased_e = static_cast<int>((u & exponent_mask<Float>()) >>
 num_float_significand_bits);
 // The predecessor is closer if n is a normalized power of 2 (f == 0)
 // other than the smallest normalized number (biased_e > 1).
 auto is_predecessor_closer = f == 0 && biased_e > 1;
 if (biased_e == 0)
 biased_e = 1; // Subnormals use biased exponent 1 (min exponent).
 else if (has_implicit_bit<Float>())
 f += static_cast<F>(implicit_bit);
 e = biased_e - exponent_bias<Float>() - num_float_significand_bits;
 if (!has_implicit_bit<Float>()) ++e;
 return is_predecessor_closer;
 }

template <typename Float, FMT_ENABLE_IF(is_double_double<Float>::value)>
 FMT_CONSTEXPR auto assign(Float n) -> bool {
 static_assert(std::numeric_limits<double>::is_iec559, "unsupported FP");
 return assign(static_cast<double>(n));
 }
};

using fp = basic_fp<unsigned long long>;

// Normalizes the value converted from double and multiplied by (1 << SHIFT).
template <int SHIFT = 0, typename F>
FMT_CONSTEXPR auto normalize(basic_fp<F> value) -> basic_fp<F> {
 // Handle subnormals.
 const auto implicit_bit = F(1) << num_significand_bits<double>();
 const auto shifted_implicit_bit = implicit_bit << SHIFT;
 while ((value.f & shifted_implicit_bit) == 0) {
 value.f <<= 1;
 --value.e;
 }
 // Subtract 1 to account for hidden bit.
 const auto offset = basic_fp<F>::num_significand_bits -
 num_significand_bits<double>() - SHIFT - 1;
 value.f <<= offset;
 value.e -= offset;
 return value;
}

// Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking.
FMT_CONSTEXPR inline auto multiply(uint64_t lhs, uint64_t rhs) -> uint64_t {
#if FMT_USE_INT128
 auto product = static_cast<__uint128_t>(lhs) * rhs;
 auto f = static_cast<uint64_t>(product >> 64);
 return (static_cast<uint64_t>(product) & (1ULL << 63)) != 0 ? f + 1 : f;
#else
 // Multiply 32-bit parts of significands.
 uint64_t mask = (1ULL << 32) - 1;
 uint64_t a = lhs >> 32, b = lhs & mask;
 uint64_t c = rhs >> 32, d = rhs & mask;
 uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
 // Compute mid 64-bit of result and round.
 uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
 return ac + (ad >> 32) + (bc >> 32) + (mid >> 32);
#endif
}

FMT_CONSTEXPR inline auto operator*(fp x, fp y) -> fp {
  return {multiply(x.f, y.f), x.e + y.e + 64};
}

template <typename T, bool doublish = num_bits<T>() == num_bits<double>()>
using convert_float_result =
 conditional_t<std::is_same<T, float>::value || doublish, double, T>;

template <typename T>
constexpr auto convert_float(T value) -> convert_float_result<T> {
 return static_cast<convert_float_result<T>>(value);
}

template <typename Char, typename OutputIt>
FMT_NOINLINE FMT_CONSTEXPR auto fill(OutputIt it, size_t n,
 const basic_specs& specs) -> OutputIt {
 auto fill_size = specs.fill_size();
 if (fill_size == 1) return detail::fill_n(it, n, specs.fill_unit<Char>());
 if (const Char* data = specs.fill<Char>()) {
 for (size_t i = 0; i < n; ++i) it = copy<Char>(data, data + fill_size, it);
 }
 return it;
}

// Writes the output of f, padded according to format specifications in specs.
// size: output size in code units.
// width: output display width in (terminal) column positions.
template <typename Char, align default_align = align::left, typename OutputIt,
 typename F>
FMT_CONSTEXPR auto write_padded(OutputIt out, const format_specs& specs,
 size_t size, size_t width, F&& f) -> OutputIt {
 static_assert(default_align == align::left || default_align == align::right,
 "");
 unsigned spec_width = to_unsigned(specs.width);
 size_t padding = spec_width > width ? spec_width - width : 0;
 // Shifts are encoded as string literals because static constexpr is not
 // supported in constexpr functions.
 auto* shifts =
 default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
 size_t left_padding = padding >> shifts[static_cast<int>(specs.align())];
 size_t right_padding = padding - left_padding;
 auto it = reserve(out, size + padding * specs.fill_size());
 if (left_padding != 0) it = fill<Char>(it, left_padding, specs);
 it = f(it);
 if (right_padding != 0) it = fill<Char>(it, right_padding, specs);
 return base_iterator(out, it);
}

template <typename Char, align default_align = align::left, typename OutputIt,
 typename F>
constexpr auto write_padded(OutputIt out, const format_specs& specs,
 size_t size, F&& f) -> OutputIt {
 return write_padded<Char, default_align>(out, specs, size, size, f);
}

template <typename Char, align default_align = align::left, typename OutputIt>
FMT_CONSTEXPR auto write_bytes(OutputIt out, string_view bytes,
 const format_specs& specs = {}) -> OutputIt {
 return write_padded<Char, default_align>(
 out, specs, bytes.size(), [bytes](reserve_iterator<OutputIt> it) {
 const char* data = bytes.data();
 return copy<Char>(data, data + bytes.size(), it);
 });
}

template <typename Char, typename OutputIt, typename UIntPtr>
auto write_ptr(OutputIt out, UIntPtr value, const format_specs* specs)
 -> OutputIt {
 int num_digits = count_digits<4>(value);
 auto size = to_unsigned(num_digits) + size_t(2);
 auto write = [=](reserve_iterator<OutputIt> it) {
 *it++ = static_cast<Char>('0');
 *it++ = static_cast<Char>('x');
 return format_base2e<Char>(4, it, value, num_digits);
 };
 return specs ? write_padded<Char, align::right>(out, *specs, size, write)
 : base_iterator(out, write(reserve(out, size)));
}

// Returns true iff the code point cp is printable.
FMT_API auto is_printable(uint32_t cp) -> bool;

inline auto needs_escape(uint32_t cp) -> bool {
 if (cp < 0x20 || cp == 0x7f || cp == '"' || cp == '\\') return true;
 if (FMT_OPTIMIZE_SIZE > 1) return false;
 return !is_printable(cp);
}

template <typename Char> struct find_escape_result {
 const Char* begin;
 const Char* end;
 uint32_t cp;
};

template <typename Char>
auto find_escape(const Char* begin, const Char* end)
 -> find_escape_result<Char> {
 for (; begin != end; ++begin) {
 uint32_t cp = static_cast<unsigned_char<Char>>(*begin);
 if (const_check(sizeof(Char) == 1) && cp >= 0x80) continue;
 if (needs_escape(cp)) return {begin, begin + 1, cp};
 }
 return {begin, nullptr, 0};
}

inline auto find_escape(const char* begin, const char* end)
 -> find_escape_result<char> {
 if (!detail::use_utf8) return find_escape<char>(begin, end);
 auto result = find_escape_result<char>{end, nullptr, 0};
 for_each_codepoint(string_view(begin, to_unsigned(end - begin)),
 [&](uint32_t cp, string_view sv) {
 if (needs_escape(cp)) {
 result = {sv.begin(), sv.end(), cp};
 return false;
 }
 return true;
 });
 return result;
}

template <size_t width, typename Char, typename OutputIt>
auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt {
 *out++ = static_cast<Char>('\\');
 *out++ = static_cast<Char>(prefix);
 Char buf[width];
 fill_n(buf, width, static_cast<Char>('0'));
 format_base2e(4, buf, cp, width);
 return copy<Char>(buf, buf + width, out);
}

template <typename OutputIt, typename Char>
auto write_escaped_cp(OutputIt out, const find_escape_result<Char>& escape)
 -> OutputIt {
 auto c = static_cast<Char>(escape.cp);
 switch (escape.cp) {
 case '\n':
 *out++ = static_cast<Char>('\\');
 c = static_cast<Char>('n');
 break;
 case '\r':
 *out++ = static_cast<Char>('\\');
 c = static_cast<Char>('r');
 break;
 case '\t':
 *out++ = static_cast<Char>('\\');
 c = static_cast<Char>('t');
 break;
 case '"': FMT_FALLTHROUGH;
 case '\'': FMT_FALLTHROUGH;
 case '\\': *out++ = static_cast<Char>('\\'); break;
 default:
 if (escape.cp < 0x100) return write_codepoint<2, Char>(out, 'x', escape.cp);
 if (escape.cp < 0x10000)
 return write_codepoint<4, Char>(out, 'u', escape.cp);
 if (escape.cp < 0x110000)
 return write_codepoint<8, Char>(out, 'U', escape.cp);
 for (Char escape_char : basic_string_view<Char>(
 escape.begin, to_unsigned(escape.end - escape.begin))) {
 out = write_codepoint<2, Char>(out, 'x',
 static_cast<uint32_t>(escape_char) & 0xFF);
 }
 return out;
 }
 *out++ = c;
 return out;
}

template <typename Char, typename OutputIt>
auto write_escaped_string(OutputIt out, basic_string_view<Char> str)
 -> OutputIt {
 *out++ = static_cast<Char>('"');
 auto begin = str.begin(), end = str.end();
 do {
 auto escape = find_escape(begin, end);
 out = copy<Char>(begin, escape.begin, out);
 begin = escape.end;
 if (!begin) break;
 out = write_escaped_cp<OutputIt, Char>(out, escape);
 } while (begin != end);
 *out++ = static_cast<Char>('"');
 return out;
}

template <typename Char, typename OutputIt>
auto write_escaped_char(OutputIt out, Char v) -> OutputIt {
 Char v_array[1] = {v};
 *out++ = static_cast<Char>('\'');
 if ((needs_escape(static_cast<uint32_t>(v)) && v != static_cast<Char>('"')) ||
 v == static_cast<Char>('\'')) {
 out = write_escaped_cp(out,
 find_escape_result<Char>{v_array, v_array + 1,
 static_cast<uint32_t>(v)});
 } else {
 *out++ = v;
 }
 *out++ = static_cast<Char>('\'');
 return out;
}

template <typename Char, typename OutputIt>
FMT_CONSTEXPR auto write_char(OutputIt out, Char value,
 const format_specs& specs) -> OutputIt {
 bool is_debug = specs.type() == presentation_type::debug;
 return write_padded<Char>(out, specs, 1, [=](reserve_iterator<OutputIt> it) {
 if (is_debug) return write_escaped_char(it, value);
 *it++ = value;
 return it;
 });
}
template <typename Char, typename OutputIt>
FMT_CONSTEXPR auto write(OutputIt out, Char value, const format_specs& specs,
 locale_ref loc = {}) -> OutputIt {
 // char is formatted as unsigned char for consistency across platforms.
 using unsigned_type =
 conditional_t<std::is_same<Char, char>::value, unsigned char, unsigned>;
 return check_char_specs(specs)
 ? write_char<Char>(out, value, specs)
 : write<Char>(out, static_cast<unsigned_type>(value), specs, loc);
}

template <typename Char> class digit_grouping {
 private:
 std::string grouping_;
 std::basic_string<Char> thousands_sep_;

struct next_state {
    std::string::const_iterator group;
    int pos;
  };
  auto initial_state() const -> next_state { return {grouping_.begin(), 0}; }

// Returns the next digit group separator position.
 auto next(next_state& state) const -> int {
 if (thousands_sep_.empty()) return max_value<int>();
 if (state.group == grouping_.end()) return state.pos += grouping_.back();
 if (*state.group <= 0 || *state.group == max_value<char>())
 return max_value<int>();
 state.pos += *state.group++;
 return state.pos;
 }

public:
 explicit digit_grouping(locale_ref loc, bool localized = true) {
 if (!localized) return;
 auto sep = thousands_sep<Char>(loc);
 grouping_ = sep.grouping;
 if (sep.thousands_sep) thousands_sep_.assign(1, sep.thousands_sep);
 }
 digit_grouping(std::string grouping, std::basic_string<Char> sep)
 : grouping_(std::move(grouping)), thousands_sep_(std::move(sep)) {}

auto has_separator() const -> bool { return !thousands_sep_.empty(); }

auto count_separators(int num_digits) const -> int {
    int count = 0;
    auto state = initial_state();
    while (num_digits > next(state)) ++count;
    return count;
  }

// Applies grouping to digits and write the output to out.
 template <typename Out, typename C>
 auto apply(Out out, basic_string_view<C> digits) const -> Out {
 auto num_digits = static_cast<int>(digits.size());
 auto separators = basic_memory_buffer<int>();
 separators.push_back(0);
 auto state = initial_state();
 while (int i = next(state)) {
 if (i >= num_digits) break;
 separators.push_back(i);
 }
 for (int i = 0, sep_index = static_cast<int>(separators.size() - 1);
 i < num_digits; ++i) {
 if (num_digits - i == separators[sep_index]) {
 out = copy<Char>(thousands_sep_.data(),
 thousands_sep_.data() + thousands_sep_.size(), out);
 --sep_index;
 }
 *out++ = static_cast<Char>(digits[to_unsigned(i)]);
 }
 return out;
 }
};

FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) {
 prefix |= prefix != 0 ? value << 8 : value;
 prefix += (1u + (value > 0xff ? 1 : 0)) << 24;
}

// Writes a decimal integer with digit grouping.
template <typename OutputIt, typename UInt, typename Char>
auto write_int(OutputIt out, UInt value, unsigned prefix,
 const format_specs& specs, const digit_grouping<Char>& grouping)
 -> OutputIt {
 static_assert(std::is_same<uint64_or_128_t<UInt>, UInt>::value, "");
 int num_digits = 0;
 auto buffer = memory_buffer();
 switch (specs.type()) {
 default: FMT_ASSERT(false, ""); FMT_FALLTHROUGH;
 case presentation_type::none:
 case presentation_type::dec:
 num_digits = count_digits(value);
 format_decimal<char>(appender(buffer), value, num_digits);
 break;
 case presentation_type::hex:
 if (specs.alt())
 prefix_append(prefix, unsigned(specs.upper() ? 'X' : 'x') << 8 | '0');
 num_digits = count_digits<4>(value);
 format_base2e<char>(4, appender(buffer), value, num_digits, specs.upper());
 break;
 case presentation_type::oct:
 num_digits = count_digits<3>(value);
 // Octal prefix '0' is counted as a digit, so only add it if precision
 // is not greater than the number of digits.
 if (specs.alt() && specs.precision <= num_digits && value != 0)
 prefix_append(prefix, '0');
 format_base2e<char>(3, appender(buffer), value, num_digits);
 break;
 case presentation_type::bin:
 if (specs.alt())
 prefix_append(prefix, unsigned(specs.upper() ? 'B' : 'b') << 8 | '0');
 num_digits = count_digits<1>(value);
 format_base2e<char>(1, appender(buffer), value, num_digits);
 break;
 case presentation_type::chr:
 return write_char<Char>(out, static_cast<Char>(value), specs);
 }

unsigned size = (prefix != 0 ? prefix >> 24 : 0) + to_unsigned(num_digits) +
 to_unsigned(grouping.count_separators(num_digits));
 return write_padded<Char, align::right>(
 out, specs, size, size, [&](reserve_iterator<OutputIt> it) {
 for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
 *it++ = static_cast<Char>(p & 0xff);
 return grouping.apply(it, string_view(buffer.data(), buffer.size()));
 });
}

#if FMT_USE_LOCALE
// Writes a localized value.
FMT_API auto write_loc(appender out, loc_value value, const format_specs& specs,
 locale_ref loc) -> bool;
#endif
template <typename OutputIt>
inline auto write_loc(OutputIt, loc_value, const format_specs&, locale_ref)
 -> bool {
 return false;
}

template <typename UInt> struct write_int_arg {
 UInt abs_value;
 unsigned prefix;
};

template <typename T>
FMT_CONSTEXPR auto make_write_int_arg(T value, sign s)
 -> write_int_arg<uint32_or_64_or_128_t<T>> {
 auto prefix = 0u;
 auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
 if (is_negative(value)) {
 prefix = 0x01000000 | '-';
 abs_value = 0 - abs_value;
 } else {
 constexpr const unsigned prefixes[4] = {0, 0, 0x1000000u | '+',
 0x1000000u | ' '};
 prefix = prefixes[static_cast<int>(s)];
 }
 return {abs_value, prefix};
}

template <typename Char = char> struct loc_writer {
 basic_appender<Char> out;
 const format_specs& specs;
 std::basic_string<Char> sep;
 std::string grouping;
 std::basic_string<Char> decimal_point;

template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
 auto operator()(T value) -> bool {
 auto arg = make_write_int_arg(value, specs.sign());
 write_int(out, static_cast<uint64_or_128_t<T>>(arg.abs_value), arg.prefix,
 specs, digit_grouping<Char>(grouping, sep));
 return true;
 }

template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
 auto operator()(T) -> bool {
 return false;
 }
};

// Size and padding computation separate from write_int to avoid template bloat.
struct size_padding {
  unsigned size;
  unsigned padding;

FMT_CONSTEXPR size_padding(int num_digits, unsigned prefix,
                             const format_specs& specs)
      : size((prefix >> 24) + to_unsigned(num_digits)), padding(0) {
    if (specs.align() == align::numeric) {
      auto width = to_unsigned(specs.width);
      if (width > size) {
        padding = width - size;
        size = width;
      }
    } else if (specs.precision > num_digits) {
      size = (prefix >> 24) + to_unsigned(specs.precision);
      padding = to_unsigned(specs.precision - num_digits);
    }
  }
};

template <typename Char, typename OutputIt, typename T>
FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, write_int_arg<T> arg,
 const format_specs& specs) -> OutputIt {
 static_assert(std::is_same<T, uint32_or_64_or_128_t<T>>::value, "");

constexpr int buffer_size = num_bits<T>();
 char buffer[buffer_size];
 if (is_constant_evaluated()) fill_n(buffer, buffer_size, '\0');
 const char* begin = nullptr;
 const char* end = buffer + buffer_size;

auto abs_value = arg.abs_value;
 auto prefix = arg.prefix;
 switch (specs.type()) {
 default: FMT_ASSERT(false, ""); FMT_FALLTHROUGH;
 case presentation_type::none:
 case presentation_type::dec:
 begin = do_format_decimal(buffer, abs_value, buffer_size);
 break;
 case presentation_type::hex:
 begin = do_format_base2e(4, buffer, abs_value, buffer_size, specs.upper());
 if (specs.alt())
 prefix_append(prefix, unsigned(specs.upper() ? 'X' : 'x') << 8 | '0');
 break;
 case presentation_type::oct: {
 begin = do_format_base2e(3, buffer, abs_value, buffer_size);
 // Octal prefix '0' is counted as a digit, so only add it if precision
 // is not greater than the number of digits.
 auto num_digits = end - begin;
 if (specs.alt() && specs.precision <= num_digits && abs_value != 0)
 prefix_append(prefix, '0');
 break;
 }
 case presentation_type::bin:
 begin = do_format_base2e(1, buffer, abs_value, buffer_size);
 if (specs.alt())
 prefix_append(prefix, unsigned(specs.upper() ? 'B' : 'b') << 8 | '0');
 break;
 case presentation_type::chr:
 return write_char<Char>(out, static_cast<Char>(abs_value), specs);
 }

// Write an integer in the format
 // <left-padding><prefix><numeric-padding><digits><right-padding>
 // prefix contains chars in three lower bytes and the size in the fourth byte.
 int num_digits = static_cast<int>(end - begin);
 // Slightly faster check for specs.width == 0 && specs.precision == -1.
 if ((specs.width | (specs.precision + 1)) == 0) {
 auto it = reserve(out, to_unsigned(num_digits) + (prefix >> 24));
 for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
 *it++ = static_cast<Char>(p & 0xff);
 return base_iterator(out, copy<Char>(begin, end, it));
 }
 auto sp = size_padding(num_digits, prefix, specs);
 unsigned padding = sp.padding;
 return write_padded<Char, align::right>(
 out, specs, sp.size, [=](reserve_iterator<OutputIt> it) {
 for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
 *it++ = static_cast<Char>(p & 0xff);
 it = detail::fill_n(it, padding, static_cast<Char>('0'));
 return copy<Char>(begin, end, it);
 });
}

template <typename Char, typename OutputIt, typename T>
FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline(OutputIt out,
 write_int_arg<T> arg,
 const format_specs& specs)
 -> OutputIt {
 return write_int<Char>(out, arg, specs);
}

template <typename Char, typename T,
 FMT_ENABLE_IF(is_integral<T>::value &&
 !std::is_same<T, bool>::value &&
 !std::is_same<T, Char>::value)>
FMT_CONSTEXPR FMT_INLINE auto write(basic_appender<Char> out, T value,
 const format_specs& specs, locale_ref loc)
 -> basic_appender<Char> {
 if (specs.localized() && write_loc(out, value, specs, loc)) return out;
 return write_int_noinline<Char>(out, make_write_int_arg(value, specs.sign()),
 specs);
}

// An inlined version of write used in format string compilation.
template <typename Char, typename OutputIt, typename T,
 FMT_ENABLE_IF(is_integral<T>::value &&
 !std::is_same<T, bool>::value &&
 !std::is_same<T, Char>::value &&
 !std::is_same<OutputIt, basic_appender<Char>>::value)>
FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value,
 const format_specs& specs, locale_ref loc)
 -> OutputIt {
 if (specs.localized() && write_loc(out, value, specs, loc)) return out;
 return write_int<Char>(out, make_write_int_arg(value, specs.sign()), specs);
}

template <typename Char, typename OutputIt>
FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> s,
 const format_specs& specs) -> OutputIt {
 auto data = s.data();
 auto size = s.size();
 if (specs.precision >= 0 && to_unsigned(specs.precision) < size)
 size = code_point_index(s, to_unsigned(specs.precision));

bool is_debug = specs.type() == presentation_type::debug;
 if (is_debug) {
 auto buf = counting_buffer<Char>();
 write_escaped_string(basic_appender<Char>(buf), s);
 size = buf.count();
 }

size_t width = 0;
 if (specs.width != 0) {
 width =
 is_debug ? size : compute_width(basic_string_view<Char>(data, size));
 }
 return write_padded<Char>(
 out, specs, size, width, [=](reserve_iterator<OutputIt> it) {
 return is_debug ? write_escaped_string(it, s)
 : copy<Char>(data, data + size, it);
 });
}
template <typename Char, typename OutputIt>
FMT_CONSTEXPR auto write(OutputIt out,
 basic_string_view<type_identity_t<Char>> s,
 const format_specs& specs, locale_ref) -> OutputIt {
 return write<Char>(out, s, specs);
}
template <typename Char, typename OutputIt>
FMT_CONSTEXPR auto write(OutputIt out, const Char* s, const format_specs& specs,
 locale_ref) -> OutputIt {
 if (specs.type() == presentation_type::pointer)
 return write_ptr<Char>(out, bit_cast<uintptr_t>(s), &specs);
 if (!s) report_error("string pointer is null");
 return write<Char>(out, basic_string_view<Char>(s), specs, {});
}

template <typename Char, typename OutputIt, typename T,
 FMT_ENABLE_IF(is_integral<T>::value &&
 !std::is_same<T, bool>::value &&
 !std::is_same<T, Char>::value)>
FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
 auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
 bool negative = is_negative(value);
 // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
 if (negative) abs_value = ~abs_value + 1;
 int num_digits = count_digits(abs_value);
 auto size = (negative ? 1 : 0) + static_cast<size_t>(num_digits);
 if (auto ptr = to_pointer<Char>(out, size)) {
 if (negative) *ptr++ = static_cast<Char>('-');
 format_decimal<Char>(ptr, abs_value, num_digits);
 return out;
 }
 if (negative) *out++ = static_cast<Char>('-');
 return format_decimal<Char>(out, abs_value, num_digits);
}

template <typename Char>
FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end,
 format_specs& specs) -> const Char* {
 FMT_ASSERT(begin != end, "");
 auto alignment = align::none;
 auto p = begin + code_point_length(begin);
 if (end - p <= 0) p = begin;
 for (;;) {
 switch (to_ascii(*p)) {
 case '<': alignment = align::left; break;
 case '>': alignment = align::right; break;
 case '^': alignment = align::center; break;
 }
 if (alignment != align::none) {
 if (p != begin) {
 auto c = *begin;
 if (c == '}') return begin;
 if (c == '{') {
 report_error("invalid fill character '{'");
 return begin;
 }
 specs.set_fill(basic_string_view<Char>(begin, to_unsigned(p - begin)));
 begin = p + 1;
 } else {
 ++begin;
 }
 break;
 } else if (p == begin) {
 break;
 }
 p = begin;
 }
 specs.set_align(alignment);
 return begin;
}

template <typename Char, typename OutputIt>
FMT_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isnan,
 format_specs specs, sign s) -> OutputIt {
 auto str =
 isnan ? (specs.upper() ? "NAN" : "nan") : (specs.upper() ? "INF" : "inf");
 constexpr size_t str_size = 3;
 auto size = str_size + (s != sign::none ? 1 : 0);
 // Replace '0'-padding with space for non-finite values.
 const bool is_zero_fill =
 specs.fill_size() == 1 && specs.fill_unit<Char>() == '0';
 if (is_zero_fill) specs.set_fill(' ');
 return write_padded<Char>(out, specs, size,
 [=](reserve_iterator<OutputIt> it) {
 if (s != sign::none)
 *it++ = detail::getsign<Char>(s);
 return copy<Char>(str, str + str_size, it);
 });
}

// A decimal floating-point number significand * pow(10, exp).
struct big_decimal_fp {
  const char* significand;
  int significand_size;
  int exponent;
};

constexpr auto get_significand_size(const big_decimal_fp& f) -> int {
 return f.significand_size;
}
template <typename T>
inline auto get_significand_size(const dragonbox::decimal_fp<T>& f) -> int {
 return count_digits(f.significand);
}

template <typename Char, typename OutputIt>
constexpr auto write_significand(OutputIt out, const char* significand,
 int significand_size) -> OutputIt {
 return copy<Char>(significand, significand + significand_size, out);
}
template <typename Char, typename OutputIt, typename UInt>
inline auto write_significand(OutputIt out, UInt significand,
 int significand_size) -> OutputIt {
 return format_decimal<Char>(out, significand, significand_size);
}
template <typename Char, typename OutputIt, typename T, typename Grouping>
FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand,
 int significand_size, int exponent,
 const Grouping& grouping) -> OutputIt {
 if (!grouping.has_separator()) {
 out = write_significand<Char>(out, significand, significand_size);
 return detail::fill_n(out, exponent, static_cast<Char>('0'));
 }
 auto buffer = memory_buffer();
 write_significand<char>(appender(buffer), significand, significand_size);
 detail::fill_n(appender(buffer), exponent, '0');
 return grouping.apply(out, string_view(buffer.data(), buffer.size()));
}

template <typename Char, typename UInt,
 FMT_ENABLE_IF(std::is_integral<UInt>::value)>
inline auto write_significand(Char* out, UInt significand, int significand_size,
 int integral_size, Char decimal_point) -> Char* {
 if (!decimal_point) return format_decimal(out, significand, significand_size);
 out += significand_size + 1;
 Char* end = out;
 int floating_size = significand_size - integral_size;
 for (int i = floating_size / 2; i > 0; --i) {
 out -= 2;
 write2digits(out, static_cast<std::size_t>(significand % 100));
 significand /= 100;
 }
 if (floating_size % 2 != 0) {
 *--out = static_cast<Char>('0' + significand % 10);
 significand /= 10;
 }
 *--out = decimal_point;
 format_decimal(out - integral_size, significand, integral_size);
 return end;
}

template <typename OutputIt, typename UInt, typename Char,
 FMT_ENABLE_IF(!std::is_pointer<remove_cvref_t<OutputIt>>::value)>
inline auto write_significand(OutputIt out, UInt significand,
 int significand_size, int integral_size,
 Char decimal_point) -> OutputIt {
 // Buffer is large enough to hold digits (digits10 + 1) and a decimal point.
 Char buffer[digits10<UInt>() + 2];
 auto end = write_significand(buffer, significand, significand_size,
 integral_size, decimal_point);
 return detail::copy_noinline<Char>(buffer, end, out);
}

template <typename OutputIt, typename Char>
FMT_CONSTEXPR auto write_significand(OutputIt out, const char* significand,
 int significand_size, int integral_size,
 Char decimal_point) -> OutputIt {
 out = detail::copy_noinline<Char>(significand, significand + integral_size,
 out);
 if (!decimal_point) return out;
 *out++ = decimal_point;
 return detail::copy_noinline<Char>(significand + integral_size,
 significand + significand_size, out);
}

template <typename OutputIt, typename Char, typename T, typename Grouping>
FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand,
 int significand_size, int integral_size,
 Char decimal_point,
 const Grouping& grouping) -> OutputIt {
 if (!grouping.has_separator()) {
 return write_significand(out, significand, significand_size, integral_size,
 decimal_point);
 }
 auto buffer = basic_memory_buffer<Char>();
 write_significand(basic_appender<Char>(buffer), significand, significand_size,
 integral_size, decimal_point);
 grouping.apply(
 out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size)));
 return detail::copy_noinline<Char>(buffer.data() + integral_size,
 buffer.end(), out);
}

template <typename Char, typename OutputIt, typename DecimalFP,
 typename Grouping = digit_grouping<Char>>
FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f,
 const format_specs& specs, sign s,
 locale_ref loc) -> OutputIt {
 auto significand = f.significand;
 int significand_size = get_significand_size(f);
 const Char zero = static_cast<Char>('0');
 size_t size = to_unsigned(significand_size) + (s != sign::none ? 1 : 0);
 using iterator = reserve_iterator<OutputIt>;

Char decimal_point = specs.localized() ? detail::decimal_point<Char>(loc)
 : static_cast<Char>('.');

int output_exp = f.exponent + significand_size - 1;
 auto use_exp_format = [=]() {
 if (specs.type() == presentation_type::exp) return true;
 if (specs.type() == presentation_type::fixed) return false;
 // Use the fixed notation if the exponent is in [exp_lower, exp_upper),
 // e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation.
 const int exp_lower = -4, exp_upper = 16;
 return output_exp < exp_lower ||
 output_exp >= (specs.precision > 0 ? specs.precision : exp_upper);
 };
 if (use_exp_format()) {
 int num_zeros = 0;
 if (specs.alt()) {
 num_zeros = specs.precision - significand_size;
 if (num_zeros < 0) num_zeros = 0;
 size += to_unsigned(num_zeros);
 } else if (significand_size == 1) {
 decimal_point = Char();
 }
 auto abs_output_exp = output_exp >= 0 ? output_exp : -output_exp;
 int exp_digits = 2;
 if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3;

size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits);
 char exp_char = specs.upper() ? 'E' : 'e';
 auto write = [=](iterator it) {
 if (s != sign::none) *it++ = detail::getsign<Char>(s);
 // Insert a decimal point after the first digit and add an exponent.
 it = write_significand(it, significand, significand_size, 1,
 decimal_point);
 if (num_zeros > 0) it = detail::fill_n(it, num_zeros, zero);
 *it++ = static_cast<Char>(exp_char);
 return write_exponent<Char>(output_exp, it);
 };
 return specs.width > 0
 ? write_padded<Char, align::right>(out, specs, size, write)
 : base_iterator(out, write(reserve(out, size)));
 }

int exp = f.exponent + significand_size;
 if (f.exponent >= 0) {
 // 1234e5 -> 123400000[.0+]
 size += to_unsigned(f.exponent);
 int num_zeros = specs.precision - exp;
 abort_fuzzing_if(num_zeros > 5000);
 if (specs.alt()) {
 ++size;
 if (num_zeros <= 0 && specs.type() != presentation_type::fixed)
 num_zeros = 0;
 if (num_zeros > 0) size += to_unsigned(num_zeros);
 }
 auto grouping = Grouping(loc, specs.localized());
 size += to_unsigned(grouping.count_separators(exp));
 return write_padded<Char, align::right>(out, specs, size, [&](iterator it) {
 if (s != sign::none) *it++ = detail::getsign<Char>(s);
 it = write_significand<Char>(it, significand, significand_size,
 f.exponent, grouping);
 if (!specs.alt()) return it;
 *it++ = decimal_point;
 return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
 });
 } else if (exp > 0) {
 // 1234e-2 -> 12.34[0+]
 int num_zeros = specs.alt() ? specs.precision - significand_size : 0;
 size += 1 + to_unsigned(num_zeros > 0 ? num_zeros : 0);
 auto grouping = Grouping(loc, specs.localized());
 size += to_unsigned(grouping.count_separators(exp));
 return write_padded<Char, align::right>(out, specs, size, [&](iterator it) {
 if (s != sign::none) *it++ = detail::getsign<Char>(s);
 it = write_significand(it, significand, significand_size, exp,
 decimal_point, grouping);
 return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
 });
 }
 // 1234e-6 -> 0.001234
 int num_zeros = -exp;
 if (significand_size == 0 && specs.precision >= 0 &&
 specs.precision < num_zeros) {
 num_zeros = specs.precision;
 }
 bool pointy = num_zeros != 0 || significand_size != 0 || specs.alt();
 size += 1 + (pointy ? 1 : 0) + to_unsigned(num_zeros);
 return write_padded<Char, align::right>(out, specs, size, [&](iterator it) {
 if (s != sign::none) *it++ = detail::getsign<Char>(s);
 *it++ = zero;
 if (!pointy) return it;
 *it++ = decimal_point;
 it = detail::fill_n(it, num_zeros, zero);
 return write_significand<Char>(it, significand, significand_size);
 });
}

template <typename Char> class fallback_digit_grouping {
 public:
 constexpr fallback_digit_grouping(locale_ref, bool) {}

constexpr auto has_separator() const -> bool { return false; }

constexpr auto count_separators(int) const -> int { return 0; }

template <typename Out, typename C>
 constexpr auto apply(Out out, basic_string_view<C>) const -> Out {
 return out;
 }
};

template <typename Char, typename OutputIt, typename DecimalFP>
FMT_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& f,
 const format_specs& specs, sign s,
 locale_ref loc) -> OutputIt {
 if (is_constant_evaluated()) {
 return do_write_float<Char, OutputIt, DecimalFP,
 fallback_digit_grouping<Char>>(out, f, specs, s, loc);
 } else {
 return do_write_float<Char>(out, f, specs, s, loc);
 }
}

template <typename T> constexpr auto isnan(T value) -> bool {
 return value != value; // std::isnan doesn't support __float128.
}

template <typename T, typename Enable = void>
struct has_isfinite : std::false_type {};

template <typename T>
struct has_isfinite<T, enable_if_t<sizeof(std::isfinite(T())) != 0>>
 : std::true_type {};

template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value&&
 has_isfinite<T>::value)>
FMT_CONSTEXPR20 auto isfinite(T value) -> bool {
 constexpr T inf = T(std::numeric_limits<double>::infinity());
 if (is_constant_evaluated())
 return !detail::isnan(value) && value < inf && value > -inf;
 return std::isfinite(value);
}
template <typename T, FMT_ENABLE_IF(!has_isfinite<T>::value)>
FMT_CONSTEXPR auto isfinite(T value) -> bool {
 T inf = T(std::numeric_limits<double>::infinity());
 // std::isfinite doesn't support __float128.
 return !detail::isnan(value) && value < inf && value > -inf;
}

template <typename T, FMT_ENABLE_IF(is_floating_point<T>::value)>
FMT_INLINE FMT_CONSTEXPR bool signbit(T value) {
 if (is_constant_evaluated()) {
#ifdef __cpp_if_constexpr
 if constexpr (std::numeric_limits<double>::is_iec559) {
 auto bits = detail::bit_cast<uint64_t>(static_cast<double>(value));
 return (bits >> (num_bits<uint64_t>() - 1)) != 0;
 }
#endif
 }
 return std::signbit(static_cast<double>(value));
}

inline FMT_CONSTEXPR20 void adjust_precision(int& precision, int exp10) {
 // Adjust fixed precision by exponent because it is relative to decimal
 // point.
 if (exp10 > 0 && precision > max_value<int>() - exp10)
 FMT_THROW(format_error("number is too big"));
 precision += exp10;
}

class bigint {
 private:
 // A bigint is stored as an array of bigits (big digits), with bigit at index
 // 0 being the least significant one.
 using bigit = uint32_t;
 using double_bigit = uint64_t;
 enum { bigits_capacity = 32 };
 basic_memory_buffer<bigit, bigits_capacity> bigits_;
 int exp_;

FMT_CONSTEXPR20 auto operator[](int index) const -> bigit {
    return bigits_[to_unsigned(index)];
  }
  FMT_CONSTEXPR20 auto operator[](int index) -> bigit& {
    return bigits_[to_unsigned(index)];
  }

static constexpr const int bigit_bits = num_bits<bigit>();

friend struct formatter<bigint>;

FMT_CONSTEXPR20 void subtract_bigits(int index, bigit other, bigit& borrow) {
 auto result = static_cast<double_bigit>((*this)[index]) - other - borrow;
 (*this)[index] = static_cast<bigit>(result);
 borrow = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
 }

FMT_CONSTEXPR20 void remove_leading_zeros() {
 int num_bigits = static_cast<int>(bigits_.size()) - 1;
 while (num_bigits > 0 && (*this)[num_bigits] == 0) --num_bigits;
 bigits_.resize(to_unsigned(num_bigits + 1));
 }

// Computes *this -= other assuming aligned bigints and *this >= other.
  FMT_CONSTEXPR20 void subtract_aligned(const bigint& other) {
    FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints");
    FMT_ASSERT(compare(*this, other) >= 0, "");
    bigit borrow = 0;
    int i = other.exp_ - exp_;
    for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j)
      subtract_bigits(i, other.bigits_[j], borrow);
    while (borrow > 0) subtract_bigits(i, 0, borrow);
    remove_leading_zeros();
  }

FMT_CONSTEXPR20 void multiply(uint32_t value) {
 const double_bigit wide_value = value;
 bigit carry = 0;
 for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
 double_bigit result = bigits_[i] * wide_value + carry;
 bigits_[i] = static_cast<bigit>(result);
 carry = static_cast<bigit>(result >> bigit_bits);
 }
 if (carry != 0) bigits_.push_back(carry);
 }

template <typename UInt, FMT_ENABLE_IF(std::is_same<UInt, uint64_t>::value ||
 std::is_same<UInt, uint128_t>::value)>
 FMT_CONSTEXPR20 void multiply(UInt value) {
 using half_uint =
 conditional_t<std::is_same<UInt, uint128_t>::value, uint64_t, uint32_t>;
 const int shift = num_bits<half_uint>() - bigit_bits;
 const UInt lower = static_cast<half_uint>(value);
 const UInt upper = value >> num_bits<half_uint>();
 UInt carry = 0;
 for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
 UInt result = lower * bigits_[i] + static_cast<bigit>(carry);
 carry = (upper * bigits_[i] << shift) + (result >> bigit_bits) +
 (carry >> bigit_bits);
 bigits_[i] = static_cast<bigit>(result);
 }
 while (carry != 0) {
 bigits_.push_back(static_cast<bigit>(carry));
 carry >>= bigit_bits;
 }
 }

template <typename UInt, FMT_ENABLE_IF(std::is_same<UInt, uint64_t>::value ||
 std::is_same<UInt, uint128_t>::value)>
 FMT_CONSTEXPR20 void assign(UInt n) {
 size_t num_bigits = 0;
 do {
 bigits_[num_bigits++] = static_cast<bigit>(n);
 n >>= bigit_bits;
 } while (n != 0);
 bigits_.resize(num_bigits);
 exp_ = 0;
 }

public:
  FMT_CONSTEXPR20 bigint() : exp_(0) {}
  explicit bigint(uint64_t n) { assign(n); }

bigint(const bigint&) = delete;
  void operator=(const bigint&) = delete;

FMT_CONSTEXPR20 void assign(const bigint& other) {
 auto size = other.bigits_.size();
 bigits_.resize(size);
 auto data = other.bigits_.data();
 copy<bigit>(data, data + size, bigits_.data());
 exp_ = other.exp_;
 }

template <typename Int> FMT_CONSTEXPR20 void operator=(Int n) {
 FMT_ASSERT(n > 0, "");
 assign(uint64_or_128_t<Int>(n));
 }

FMT_CONSTEXPR20 auto num_bigits() const -> int {
 return static_cast<int>(bigits_.size()) + exp_;
 }

FMT_NOINLINE FMT_CONSTEXPR20 auto operator<<=(int shift) -> bigint& {
 FMT_ASSERT(shift >= 0, "");
 exp_ += shift / bigit_bits;
 shift %= bigit_bits;
 if (shift == 0) return *this;
 bigit carry = 0;
 for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
 bigit c = bigits_[i] >> (bigit_bits - shift);
 bigits_[i] = (bigits_[i] << shift) + carry;
 carry = c;
 }
 if (carry != 0) bigits_.push_back(carry);
 return *this;
 }

template <typename Int>
 FMT_CONSTEXPR20 auto operator*=(Int value) -> bigint& {
 FMT_ASSERT(value > 0, "");
 multiply(uint32_or_64_or_128_t<Int>(value));
 return *this;
 }

friend FMT_CONSTEXPR20 auto compare(const bigint& lhs, const bigint& rhs)
 -> int {
 int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits();
 if (num_lhs_bigits != num_rhs_bigits)
 return num_lhs_bigits > num_rhs_bigits ? 1 : -1;
 int i = static_cast<int>(lhs.bigits_.size()) - 1;
 int j = static_cast<int>(rhs.bigits_.size()) - 1;
 int end = i - j;
 if (end < 0) end = 0;
 for (; i >= end; --i, --j) {
 bigit lhs_bigit = lhs[i], rhs_bigit = rhs[j];
 if (lhs_bigit != rhs_bigit) return lhs_bigit > rhs_bigit ? 1 : -1;
 }
 if (i != j) return i > j ? 1 : -1;
 return 0;
 }

// Returns compare(lhs1 + lhs2, rhs).
 friend FMT_CONSTEXPR20 auto add_compare(const bigint& lhs1,
 const bigint& lhs2, const bigint& rhs)
 -> int {
 auto minimum = [](int a, int b) { return a b ? a : b; };
 int max_lhs_bigits = maximum(lhs1.num_bigits(), lhs2.num_bigits());
 int num_rhs_bigits = rhs.num_bigits();
 if (max_lhs_bigits + 1 < num_rhs_bigits) return -1;
 if (max_lhs_bigits > num_rhs_bigits) return 1;
 auto get_bigit = [](const bigint& n, int i) -> bigit {
 return i >= n.exp_ && i < n.num_bigits() ? n[i - n.exp_] : 0;
 };
 double_bigit borrow = 0;
 int min_exp = minimum(minimum(lhs1.exp_, lhs2.exp_), rhs.exp_);
 for (int i = num_rhs_bigits - 1; i >= min_exp; --i) {
 double_bigit sum =
 static_cast<double_bigit>(get_bigit(lhs1, i)) + get_bigit(lhs2, i);
 bigit rhs_bigit = get_bigit(rhs, i);
 if (sum > rhs_bigit + borrow) return 1;
 borrow = rhs_bigit + borrow - sum;
 if (borrow > 1) return -1;
 borrow <<= bigit_bits;
 }
 return borrow != 0 ? -1 : 0;
 }

// Assigns pow(10, exp) to this bigint.
 FMT_CONSTEXPR20 void assign_pow10(int exp) {
 FMT_ASSERT(exp >= 0, "");
 if (exp == 0) return *this = 1;
 // Find the top bit.
 int bitmask = 1;
 while (exp >= bitmask) bitmask <<= 1;
 bitmask >>= 1;
 // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by
 // repeated squaring and multiplication.
 *this = 5;
 bitmask >>= 1;
 while (bitmask != 0) {
 square();
 if ((exp & bitmask) != 0) *this *= 5;
 bitmask >>= 1;
 }
 *this <<= exp; // Multiply by pow(2, exp) by shifting.
 }

FMT_CONSTEXPR20 void square() {
 int num_bigits = static_cast<int>(bigits_.size());
 int num_result_bigits = 2 * num_bigits;
 basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
 bigits_.resize(to_unsigned(num_result_bigits));
 auto sum = uint128_t();
 for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {
 // Compute bigit at position bigit_index of the result by adding
 // cross-product terms n[i] * n[j] such that i + j == bigit_index.
 for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {
 // Most terms are multiplied twice which can be optimized in the future.
 sum += static_cast<double_bigit>(n[i]) * n[j];
 }
 (*this)[bigit_index] = static_cast<bigit>(sum);
 sum >>= num_bits<bigit>(); // Compute the carry.
 }
 // Do the same for the top half.
 for (int bigit_index = num_bigits; bigit_index < num_result_bigits;
 ++bigit_index) {
 for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)
 sum += static_cast<double_bigit>(n[i++]) * n[j--];
 (*this)[bigit_index] = static_cast<bigit>(sum);
 sum >>= num_bits<bigit>();
 }
 remove_leading_zeros();
 exp_ *= 2;
 }

// If this bigint has a bigger exponent than other, adds trailing zero to make
 // exponents equal. This simplifies some operations such as subtraction.
 FMT_CONSTEXPR20 void align(const bigint& other) {
 int exp_difference = exp_ - other.exp_;
 if (exp_difference <= 0) return;
 int num_bigits = static_cast<int>(bigits_.size());
 bigits_.resize(to_unsigned(num_bigits + exp_difference));
 for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
 bigits_[j] = bigits_[i];
 memset(bigits_.data(), 0, to_unsigned(exp_difference) * sizeof(bigit));
 exp_ -= exp_difference;
 }

// Divides this bignum by divisor, assigning the remainder to this and
 // returning the quotient.
 FMT_CONSTEXPR20 auto divmod_assign(const bigint& divisor) -> int {
 FMT_ASSERT(this != &divisor, "");
 if (compare(*this, divisor) < 0) return 0;
 FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
 align(divisor);
 int quotient = 0;
 do {
 subtract_aligned(divisor);
 ++quotient;
 } while (compare(*this, divisor) >= 0);
 return quotient;
 }
};

// format_dragon flags.
enum dragon {
  predecessor_closer = 1,
  fixup = 2,  // Run fixup to correct exp10 which can be off by one.
  fixed = 4,
};

// Formats a floating-point number using a variation of the Fixed-Precision
// Positive Floating-Point Printout ((FPP)^2) algorithm by Steele & White:
// https://fmt.dev/papers/p372-steele.pdf.
FMT_CONSTEXPR20 inline void format_dragon(basic_fp<uint128_t> value,
 unsigned flags, int num_digits,
 buffer<char>& buf, int& exp10) {
 bigint numerator; // 2 * R in (FPP)^2.
 bigint denominator; // 2 * S in (FPP)^2.
 // lower and upper are differences between value and corresponding boundaries.
 bigint lower; // (M^- in (FPP)^2).
 bigint upper_store; // upper's value if different from lower.
 bigint* upper = nullptr; // (M^+ in (FPP)^2).
 // Shift numerator and denominator by an extra bit or two (if lower boundary
 // is closer) to make lower and upper integers. This eliminates multiplication
 // by 2 during later computations.
 bool is_predecessor_closer = (flags & dragon::predecessor_closer) != 0;
 int shift = is_predecessor_closer ? 2 : 1;
 if (value.e >= 0) {
 numerator = value.f;
 numerator <<= value.e + shift;
 lower = 1;
 lower <<= value.e;
 if (is_predecessor_closer) {
 upper_store = 1;
 upper_store <<= value.e + 1;
 upper = &upper_store;
 }
 denominator.assign_pow10(exp10);
 denominator <<= shift;
 } else if (exp10 < 0) {
 numerator.assign_pow10(-exp10);
 lower.assign(numerator);
 if (is_predecessor_closer) {
 upper_store.assign(numerator);
 upper_store <<= 1;
 upper = &upper_store;
 }
 numerator *= value.f;
 numerator <<= shift;
 denominator = 1;
 denominator <<= shift - value.e;
 } else {
 numerator = value.f;
 numerator <<= shift;
 denominator.assign_pow10(exp10);
 denominator <<= shift - value.e;
 lower = 1;
 if (is_predecessor_closer) {
 upper_store = 1ULL << 1;
 upper = &upper_store;
 }
 }
 int even = static_cast<int>((value.f & 1) == 0);
 if (!upper) upper = &lower;
 bool shortest = num_digits < 0;
 if ((flags & dragon::fixup) != 0) {
 if (add_compare(numerator, *upper, denominator) + even <= 0) {
 --exp10;
 numerator *= 10;
 if (num_digits < 0) {
 lower *= 10;
 if (upper != &lower) *upper *= 10;
 }
 }
 if ((flags & dragon::fixed) != 0) adjust_precision(num_digits, exp10 + 1);
 }
 // Invariant: value == (numerator / denominator) * pow(10, exp10).
 if (shortest) {
 // Generate the shortest representation.
 num_digits = 0;
 char* data = buf.data();
 for (;;) {
 int digit = numerator.divmod_assign(denominator);
 bool low = compare(numerator, lower) - even < 0; // numerator <[=] lower.
 // numerator + upper >[=] pow10:
 bool high = add_compare(numerator, *upper, denominator) + even > 0;
 data[num_digits++] = static_cast<char>('0' + digit);
 if (low || high) {
 if (!low) {
 ++data[num_digits - 1];
 } else if (high) {
 int result = add_compare(numerator, numerator, denominator);
 // Round half to even.
 if (result > 0 || (result == 0 && (digit % 2) != 0))
 ++data[num_digits - 1];
 }
 buf.try_resize(to_unsigned(num_digits));
 exp10 -= num_digits - 1;
 return;
 }
 numerator *= 10;
 lower *= 10;
 if (upper != &lower) *upper *= 10;
 }
 }
 // Generate the given number of digits.
 exp10 -= num_digits - 1;
 if (num_digits <= 0) {
 auto digit = '0';
 if (num_digits == 0) {
 denominator *= 10;
 digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0';
 }
 buf.push_back(digit);
 return;
 }
 buf.try_resize(to_unsigned(num_digits));
 for (int i = 0; i < num_digits - 1; ++i) {
 int digit = numerator.divmod_assign(denominator);
 buf[i] = static_cast<char>('0' + digit);
 numerator *= 10;
 }
 int digit = numerator.divmod_assign(denominator);
 auto result = add_compare(numerator, numerator, denominator);
 if (result > 0 || (result == 0 && (digit % 2) != 0)) {
 if (digit == 9) {
 const auto overflow = '0' + 10;
 buf[num_digits - 1] = overflow;
 // Propagate the carry.
 for (int i = num_digits - 1; i > 0 && buf[i] == overflow; --i) {
 buf[i] = '0';
 ++buf[i - 1];
 }
 if (buf[0] == overflow) {
 buf[0] = '1';
 if ((flags & dragon::fixed) != 0)
 buf.push_back('0');
 else
 ++exp10;
 }
 return;
 }
 ++digit;
 }
 buf[num_digits - 1] = static_cast<char>('0' + digit);
}

// Formats a floating-point number using the hexfloat format.
template <typename Float, FMT_ENABLE_IF(!is_double_double<Float>::value)>
FMT_CONSTEXPR20 void format_hexfloat(Float value, format_specs specs,
 buffer<char>& buf) {
 // float is passed as double to reduce the number of instantiations and to
 // simplify implementation.
 static_assert(!std::is_same<Float, float>::value, "");

using info = dragonbox::float_info<Float>;

// Assume Float is in the format [sign][exponent][significand].
  using carrier_uint = typename info::carrier_uint;

const auto num_float_significand_bits = detail::num_significand_bits<Float>();

basic_fp<carrier_uint> f(value);
 f.e += num_float_significand_bits;
 if (!has_implicit_bit<Float>()) --f.e;

const auto num_fraction_bits =
 num_float_significand_bits + (has_implicit_bit<Float>() ? 1 : 0);
 const auto num_xdigits = (num_fraction_bits + 3) / 4;

const auto leading_shift = ((num_xdigits - 1) * 4);
 const auto leading_mask = carrier_uint(0xF) << leading_shift;
 const auto leading_xdigit =
 static_cast<uint32_t>((f.f & leading_mask) >> leading_shift);
 if (leading_xdigit > 1) f.e -= (32 - countl_zero(leading_xdigit) - 1);

int print_xdigits = num_xdigits - 1;
 if (specs.precision >= 0 && print_xdigits > specs.precision) {
 const int shift = ((print_xdigits - specs.precision - 1) * 4);
 const auto mask = carrier_uint(0xF) << shift;
 const auto v = static_cast<uint32_t>((f.f & mask) >> shift);

if (v >= 8) {
 const auto inc = carrier_uint(1) << (shift + 4);
 f.f += inc;
 f.f &= ~(inc - 1);
 }

// Check long double overflow
 if (!has_implicit_bit<Float>()) {
 const auto implicit_bit = carrier_uint(1) << num_float_significand_bits;
 if ((f.f & implicit_bit) == implicit_bit) {
 f.f >>= 4;
 f.e += 4;
 }
 }

print_xdigits = specs.precision;
  }

char xdigits[num_bits<carrier_uint>() / 4];
 detail::fill_n(xdigits, sizeof(xdigits), '0');
 format_base2e(4, xdigits, f.f, num_xdigits, specs.upper());

// Remove zero tail
  while (print_xdigits > 0 && xdigits[print_xdigits] == '0') --print_xdigits;

buf.push_back('0');
 buf.push_back(specs.upper() ? 'X' : 'x');
 buf.push_back(xdigits[0]);
 if (specs.alt() || print_xdigits > 0 || print_xdigits < specs.precision)
 buf.push_back('.');
 buf.append(xdigits + 1, xdigits + 1 + print_xdigits);
 for (; print_xdigits < specs.precision; ++print_xdigits) buf.push_back('0');

buf.push_back(specs.upper() ? 'P' : 'p');

uint32_t abs_e;
 if (f.e < 0) {
 buf.push_back('-');
 abs_e = static_cast<uint32_t>(-f.e);
 } else {
 buf.push_back('+');
 abs_e = static_cast<uint32_t>(f.e);
 }
 format_decimal<char>(appender(buf), abs_e, detail::count_digits(abs_e));
}

template <typename Float, FMT_ENABLE_IF(is_double_double<Float>::value)>
FMT_CONSTEXPR20 void format_hexfloat(Float value, format_specs specs,
 buffer<char>& buf) {
 format_hexfloat(static_cast<double>(value), specs, buf);
}

constexpr auto fractional_part_rounding_thresholds(int index) -> uint32_t {
  // For checking rounding thresholds.
  // The kth entry is chosen to be the smallest integer such that the
  // upper 32-bits of 10^(k+1) times it is strictly bigger than 5 * 10^k.
  // It is equal to ceil(2^31 + 2^32/10^(k + 1)).
  // These are stored in a string literal because we cannot have static arrays
  // in constexpr functions and non-static ones are poorly optimized.
  return U"\x9999999a\x828f5c29\x80418938\x80068db9\x8000a7c6\x800010c7"
         U"\x800001ae\x8000002b"[index];
}

template <typename Float>
FMT_CONSTEXPR20 auto format_float(Float value, int precision,
 const format_specs& specs, bool binary32,
 buffer<char>& buf) -> int {
 // float is passed as double to reduce the number of instantiations.
 static_assert(!std::is_same<Float, float>::value, "");
 auto converted_value = convert_float(value);

const bool fixed = specs.type() == presentation_type::fixed;
 if (value == 0) {
 if (precision <= 0 || !fixed) {
 buf.push_back('0');
 return 0;
 }
 buf.try_resize(to_unsigned(precision));
 fill_n(buf.data(), precision, '0');
 return -precision;
 }

int exp = 0;
 bool use_dragon = true;
 unsigned dragon_flags = 0;
 if (!is_fast_float<Float>() || is_constant_evaluated()) {
 const auto inv_log2_10 = 0.3010299956639812; // 1 / log2(10)
 using info = dragonbox::float_info<decltype(converted_value)>;
 const auto f = basic_fp<typename info::carrier_uint>(converted_value);
 // Compute exp, an approximate power of 10, such that
 // 10^(exp - 1) <= value < 10^exp or 10^exp <= value < 10^(exp + 1).
 // This is based on log10(value) == log2(value) / log2(10) and approximation
 // of log2(value) by e + num_fraction_bits idea from double-conversion.
 auto e = (f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10;
 exp = static_cast<int>(e);
 if (e > exp) ++exp; // Compute ceil.
 dragon_flags = dragon::fixup;
 } else {
 // Extract significand bits and exponent bits.
 using info = dragonbox::float_info<double>;
 auto br = bit_cast<uint64_t>(static_cast<double>(value));

const uint64_t significand_mask =
 (static_cast<uint64_t>(1) << num_significand_bits<double>()) - 1;
 uint64_t significand = (br & significand_mask);
 int exponent = static_cast<int>((br & exponent_mask<double>()) >>
 num_significand_bits<double>());

if (exponent != 0) { // Check if normal.
 exponent -= exponent_bias<double>() + num_significand_bits<double>();
 significand |=
 (static_cast<uint64_t>(1) << num_significand_bits<double>());
 significand <<= 1;
 } else {
 // Normalize subnormal inputs.
 FMT_ASSERT(significand != 0, "zeros should not appear here");
 int shift = countl_zero(significand);
 FMT_ASSERT(shift >= num_bits<uint64_t>() - num_significand_bits<double>(),
 "");
 shift -= (num_bits<uint64_t>() - num_significand_bits<double>() - 2);
 exponent = (std::numeric_limits<double>::min_exponent -
 num_significand_bits<double>()) -
 shift;
 significand <<= shift;
 }

// Compute the first several nonzero decimal significand digits.
 // We call the number we get the first segment.
 const int k = info::kappa - dragonbox::floor_log10_pow2(exponent);
 exp = -k;
 const int beta = exponent + dragonbox::floor_log2_pow10(k);
 uint64_t first_segment;
 bool has_more_segments;
 int digits_in_the_first_segment;
 {
 const auto r = dragonbox::umul192_upper128(
 significand << beta, dragonbox::get_cached_power(k));
 first_segment = r.high();
 has_more_segments = r.low() != 0;

// The first segment can have 18 ~ 19 digits.
      if (first_segment >= 1000000000000000000ULL) {
        digits_in_the_first_segment = 19;
      } else {
        // When it is of 18-digits, we align it to 19-digits by adding a bogus
        // zero at the end.
        digits_in_the_first_segment = 18;
        first_segment *= 10;
      }
    }

// Compute the actual number of decimal digits to print.
    if (fixed) adjust_precision(precision, exp + digits_in_the_first_segment);

// Use Dragon4 only when there might be not enough digits in the first
    // segment.
    if (digits_in_the_first_segment > precision) {
      use_dragon = false;

if (precision <= 0) {
 exp += digits_in_the_first_segment;

if (precision < 0) {
 // Nothing to do, since all we have are just leading zeros.
 buf.try_resize(0);
 } else {
 // We may need to round-up.
 buf.try_resize(1);
 if ((first_segment | static_cast<uint64_t>(has_more_segments)) >
 5000000000000000000ULL) {
 buf[0] = '1';
 } else {
 buf[0] = '0';
 }
 }
 } // precision <= 0
 else {
 exp += digits_in_the_first_segment - precision;

// When precision > 0, we divide the first segment into three
 // subsegments, each with 9, 9, and 0 ~ 1 digits so that each fits
 // in 32-bits which usually allows faster calculation than in
 // 64-bits. Since some compiler (e.g. MSVC) doesn't know how to optimize
 // division-by-constant for large 64-bit divisors, we do it here
 // manually. The magic number 7922816251426433760 below is equal to
 // ceil(2^(64+32) / 10^10).
 const uint32_t first_subsegment = static_cast<uint32_t>(
 dragonbox::umul128_upper64(first_segment, 7922816251426433760ULL) >>
 32);
 const uint64_t second_third_subsegments =
 first_segment - first_subsegment * 10000000000ULL;

uint64_t prod;
        uint32_t digits;
        bool should_round_up;
        int number_of_digits_to_print = precision > 9 ? 9 : precision;

// Print a 9-digits subsegment, either the first or the second.
        auto print_subsegment = [&](uint32_t subsegment, char* buffer) {
          int number_of_digits_printed = 0;

// If we want to print an odd number of digits from the subsegment,
 if ((number_of_digits_to_print & 1) != 0) {
 // Convert to 64-bit fixed-point fractional form with 1-digit
 // integer part. The magic number 720575941 is a good enough
 // approximation of 2^(32 + 24) / 10^8; see
 // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case
 // for details.
 prod = ((subsegment * static_cast<uint64_t>(720575941)) >> 24) + 1;
 digits = static_cast<uint32_t>(prod >> 32);
 *buffer = static_cast<char>('0' + digits);
 number_of_digits_printed++;
 }
 // If we want to print an even number of digits from the
 // first_subsegment,
 else {
 // Convert to 64-bit fixed-point fractional form with 2-digits
 // integer part. The magic number 450359963 is a good enough
 // approximation of 2^(32 + 20) / 10^7; see
 // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case
 // for details.
 prod = ((subsegment * static_cast<uint64_t>(450359963)) >> 20) + 1;
 digits = static_cast<uint32_t>(prod >> 32);
 write2digits(buffer, digits);
 number_of_digits_printed += 2;
 }

// Print all digit pairs.
 while (number_of_digits_printed < number_of_digits_to_print) {
 prod = static_cast<uint32_t>(prod) * static_cast<uint64_t>(100);
 digits = static_cast<uint32_t>(prod >> 32);
 write2digits(buffer + number_of_digits_printed, digits);
 number_of_digits_printed += 2;
 }
 };

// Print first subsegment.
        print_subsegment(first_subsegment, buf.data());

// Perform rounding if the first subsegment is the last subsegment to
 // print.
 if (precision <= 9) {
 // Rounding inside the subsegment.
 // We round-up if:
 // - either the fractional part is strictly larger than 1/2, or
 // - the fractional part is exactly 1/2 and the last digit is odd.
 // We rely on the following observations:
 // - If fractional_part >= threshold, then the fractional part is
 // strictly larger than 1/2.
 // - If the MSB of fractional_part is set, then the fractional part
 // must be at least 1/2.
 // - When the MSB of fractional_part is set, either
 // second_third_subsegments being nonzero or has_more_segments
 // being true means there are further digits not printed, so the
 // fractional part is strictly larger than 1/2.
 if (precision < 9) {
 uint32_t fractional_part = static_cast<uint32_t>(prod);
 should_round_up =
 fractional_part >= fractional_part_rounding_thresholds(
 8 - number_of_digits_to_print) ||
 ((fractional_part >> 31) &
 ((digits & 1) | (second_third_subsegments != 0) |
 has_more_segments)) != 0;
 }
 // Rounding at the subsegment boundary.
 // In this case, the fractional part is at least 1/2 if and only if
 // second_third_subsegments >= 5000000000ULL, and is strictly larger
 // than 1/2 if we further have either second_third_subsegments >
 // 5000000000ULL or has_more_segments == true.
 else {
 should_round_up = second_third_subsegments > 5000000000ULL ||
 (second_third_subsegments == 5000000000ULL &&
 ((digits & 1) != 0 || has_more_segments));
 }
 }
 // Otherwise, print the second subsegment.
 else {
 // Compilers are not aware of how to leverage the maximum value of
 // second_third_subsegments to find out a better magic number which
 // allows us to eliminate an additional shift. 1844674407370955162 =
 // ceil(2^64/10) < ceil(2^64*(10^9/(10^10 - 1))).
 const uint32_t second_subsegment =
 static_cast<uint32_t>(dragonbox::umul128_upper64(
 second_third_subsegments, 1844674407370955162ULL));
 const uint32_t third_subsegment =
 static_cast<uint32_t>(second_third_subsegments) -
 second_subsegment * 10;

number_of_digits_to_print = precision - 9;
          print_subsegment(second_subsegment, buf.data() + 9);

// Rounding inside the subsegment.
 if (precision < 18) {
 // The condition third_subsegment != 0 implies that the segment was
 // of 19 digits, so in this case the third segment should be
 // consisting of a genuine digit from the input.
 uint32_t fractional_part = static_cast<uint32_t>(prod);
 should_round_up =
 fractional_part >= fractional_part_rounding_thresholds(
 8 - number_of_digits_to_print) ||
 ((fractional_part >> 31) &
 ((digits & 1) | (third_subsegment != 0) |
 has_more_segments)) != 0;
 }
 // Rounding at the subsegment boundary.
 else {
 // In this case, the segment must be of 19 digits, thus
 // the third subsegment should be consisting of a genuine digit from
 // the input.
 should_round_up = third_subsegment > 5 ||
 (third_subsegment == 5 &&
 ((digits & 1) != 0 || has_more_segments));
 }
 }

// Round-up if necessary.
 if (should_round_up) {
 ++buf[precision - 1];
 for (int i = precision - 1; i > 0 && buf[i] > '9'; --i) {
 buf[i] = '0';
 ++buf[i - 1];
 }
 if (buf[0] > '9') {
 buf[0] = '1';
 if (fixed)
 buf[precision++] = '0';
 else
 ++exp;
 }
 }
 buf.try_resize(to_unsigned(precision));
 }
 } // if (digits_in_the_first_segment > precision)
 else {
 // Adjust the exponent for its use in Dragon4.
 exp += digits_in_the_first_segment - 1;
 }
 }
 if (use_dragon) {
 auto f = basic_fp<uint128_t>();
 bool is_predecessor_closer = binary32 ? f.assign(static_cast<float>(value))
 : f.assign(converted_value);
 if (is_predecessor_closer) dragon_flags |= dragon::predecessor_closer;
 if (fixed) dragon_flags |= dragon::fixed;
 // Limit precision to the maximum possible number of significant digits in
 // an IEEE754 double because we don't need to generate zeros.
 const int max_double_digits = 767;
 if (precision > max_double_digits) precision = max_double_digits;
 format_dragon(f, dragon_flags, precision, buf, exp);
 }
 if (!fixed && !specs.alt()) {
 // Remove trailing zeros.
 auto num_digits = buf.size();
 while (num_digits > 0 && buf[num_digits - 1] == '0') {
 --num_digits;
 ++exp;
 }
 buf.try_resize(num_digits);
 }
 return exp;
}

template <typename Char, typename OutputIt, typename T>
FMT_CONSTEXPR20 auto write_float(OutputIt out, T value, format_specs specs,
 locale_ref loc) -> OutputIt {
 // Use signbit because value < 0 is false for NaN.
 sign s = detail::signbit(value) ? sign::minus : specs.sign();

if (!detail::isfinite(value))
 return write_nonfinite<Char>(out, detail::isnan(value), specs, s);

if (specs.align() == align::numeric && s != sign::none) {
 *out++ = detail::getsign<Char>(s);
 s = sign::none;
 if (specs.width != 0) --specs.width;
 }

int precision = specs.precision;
 if (precision < 0) {
 if (specs.type() != presentation_type::none) {
 precision = 6;
 } else if (is_fast_float<T>::value && !is_constant_evaluated()) {
 // Use Dragonbox for the shortest format.
 using floaty = conditional_t<sizeof(T) >= sizeof(double), double, float>;
 auto dec = dragonbox::to_decimal(static_cast<floaty>(value));
 return write_float<Char>(out, dec, specs, s, loc);
 }
 }

memory_buffer buffer;
 if (specs.type() == presentation_type::hexfloat) {
 if (s != sign::none) buffer.push_back(detail::getsign<char>(s));
 format_hexfloat(convert_float(value), specs, buffer);
 return write_bytes<Char, align::right>(out, {buffer.data(), buffer.size()},
 specs);
 }

if (specs.type() == presentation_type::exp) {
 if (precision == max_value<int>())
 report_error("number is too big");
 else
 ++precision;
 if (specs.precision != 0) specs.set_alt();
 } else if (specs.type() == presentation_type::fixed) {
 if (specs.precision != 0) specs.set_alt();
 } else if (precision == 0) {
 precision = 1;
 }
 int exp = format_float(convert_float(value), precision, specs,
 std::is_same<T, float>(), buffer);

specs.precision = precision;
 auto f = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp};
 return write_float<Char>(out, f, specs, s, loc);
}

template <typename Char, typename OutputIt, typename T,
 FMT_ENABLE_IF(is_floating_point<T>::value)>
FMT_CONSTEXPR20 auto write(OutputIt out, T value, format_specs specs,
 locale_ref loc = {}) -> OutputIt {
 return specs.localized() && write_loc(out, value, specs, loc)
 ? out
 : write_float<Char>(out, value, specs, loc);
}

template <typename Char, typename OutputIt, typename T,
 FMT_ENABLE_IF(is_fast_float<T>::value)>
FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt {
 if (is_constant_evaluated()) return write<Char>(out, value, format_specs());

auto s = detail::signbit(value) ? sign::minus : sign::none;

constexpr auto specs = format_specs();
 using floaty = conditional_t<sizeof(T) >= sizeof(double), double, float>;
 using floaty_uint = typename dragonbox::float_info<floaty>::carrier_uint;
 floaty_uint mask = exponent_mask<floaty>();
 if ((bit_cast<floaty_uint>(value) & mask) == mask)
 return write_nonfinite<Char>(out, std::isnan(value), specs, s);

auto dec = dragonbox::to_decimal(static_cast<floaty>(value));
 return write_float<Char>(out, dec, specs, s, {});
}

template <typename Char, typename OutputIt, typename T,
 FMT_ENABLE_IF(is_floating_point<T>::value &&
 !is_fast_float<T>::value)>
inline auto write(OutputIt out, T value) -> OutputIt {
 return write<Char>(out, value, format_specs());
}

template <typename Char, typename OutputIt>
auto write(OutputIt out, monostate, format_specs = {}, locale_ref = {})
 -> OutputIt {
 FMT_ASSERT(false, "");
 return out;
}

template <typename Char, typename OutputIt>
FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> value)
 -> OutputIt {
 return copy_noinline<Char>(value.begin(), value.end(), out);
}

template <typename Char, typename OutputIt, typename T,
 FMT_ENABLE_IF(has_to_string_view<T>::value)>
constexpr auto write(OutputIt out, const T& value) -> OutputIt {
 return write<Char>(out, to_string_view(value));
}

// FMT_ENABLE_IF() condition separated to workaround an MSVC bug.
template <
 typename Char, typename OutputIt, typename T,
 bool check = std::is_enum<T>::value && !std::is_same<T, Char>::value &&
 mapped_type_constant<T, Char>::value != type::custom_type,
 FMT_ENABLE_IF(check)>
FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
 return write<Char>(out, static_cast<underlying_t<T>>(value));
}

template <typename Char, typename OutputIt, typename T,
 FMT_ENABLE_IF(std::is_same<T, bool>::value)>
FMT_CONSTEXPR auto write(OutputIt out, T value, const format_specs& specs = {},
 locale_ref = {}) -> OutputIt {
 return specs.type() != presentation_type::none &&
 specs.type() != presentation_type::string
 ? write<Char>(out, value ? 1 : 0, specs, {})
 : write_bytes<Char>(out, value ? "true" : "false", specs);
}

template <typename Char, typename OutputIt>
FMT_CONSTEXPR auto write(OutputIt out, Char value) -> OutputIt {
 auto it = reserve(out, 1);
 *it++ = value;
 return base_iterator(out, it);
}

template <typename Char, typename OutputIt>
FMT_CONSTEXPR20 auto write(OutputIt out, const Char* value) -> OutputIt {
 if (value) return write(out, basic_string_view<Char>(value));
 report_error("string pointer is null");
 return out;
}

template <typename Char, typename OutputIt, typename T,
 FMT_ENABLE_IF(std::is_same<T, void>::value)>
auto write(OutputIt out, const T* value, const format_specs& specs = {},
 locale_ref = {}) -> OutputIt {
 return write_ptr<Char>(out, bit_cast<uintptr_t>(value), &specs);
}

// A write overload that handles implicit conversions.
template <typename Char, typename OutputIt, typename T,
 typename Context = basic_format_context<OutputIt, Char>>
FMT_CONSTEXPR auto write(OutputIt out, const T& value) -> enable_if_t<
 std::is_class<T>::value && !has_to_string_view<T>::value &&
 !is_floating_point<T>::value && !std::is_same<T, Char>::value &&
 !std::is_same<
 T, remove_cvref_t<decltype(arg_mapper<Char>::map(value))>>::value,
 OutputIt> {
 return write<Char>(out, arg_mapper<Char>::map(value));
}

template <typename Char, typename OutputIt, typename T,
 FMT_ENABLE_IF(mapped_type_constant<T, Char>::value ==
 type::custom_type &&
 !std::is_fundamental<T>::value)>
FMT_CONSTEXPR auto write(OutputIt out, const T& value) -> OutputIt {
 auto f = formatter<T, Char>();
 auto parse_ctx = parse_context<Char>({});
 f.parse(parse_ctx);
 auto ctx = basic_format_context<OutputIt, Char>(out, {}, {});
 return f.format(value, ctx);
}

template <typename T>
using is_builtin =
 bool_constant<std::is_same<T, int>::value || FMT_BUILTIN_TYPES>;

// An argument visitor that formats the argument and writes it via the output
// iterator. It's a class and not a generic lambda for compatibility with C++11.
template <typename Char> struct default_arg_formatter {
 using context = buffered_context<Char>;

basic_appender<Char> out;

void operator()(monostate) { report_error("argument not found"); }

template <typename T, FMT_ENABLE_IF(is_builtin<T>::value)>
 void operator()(T value) {
 write<Char>(out, value);
 }

template <typename T, FMT_ENABLE_IF(!is_builtin<T>::value)>
 void operator()(T) {
 FMT_ASSERT(false, "");
 }

void operator()(typename basic_format_arg<context>::handle h) {
 // Use a null locale since the default format must be unlocalized.
 auto parse_ctx = parse_context<Char>({});
 auto format_ctx = context(out, {}, {});
 h.format(parse_ctx, format_ctx);
 }
};

template <typename Char> struct arg_formatter {
 basic_appender<Char> out;
 const format_specs& specs;
 FMT_NO_UNIQUE_ADDRESS locale_ref locale;

template <typename T, FMT_ENABLE_IF(is_builtin<T>::value)>
 FMT_CONSTEXPR FMT_INLINE void operator()(T value) {
 detail::write<Char>(out, value, specs, locale);
 }

template <typename T, FMT_ENABLE_IF(!is_builtin<T>::value)>
 void operator()(T) {
 FMT_ASSERT(false, "");
 }

void operator()(typename basic_format_arg<buffered_context<Char>>::handle) {
 // User-defined types are handled separately because they require access
 // to the parse context.
 }
};

struct dynamic_spec_getter {
 template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
 FMT_CONSTEXPR auto operator()(T value) -> unsigned long long {
 return is_negative(value) ? ~0ull : static_cast<unsigned long long>(value);
 }

template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
 FMT_CONSTEXPR auto operator()(T) -> unsigned long long {
 report_error("width/precision is not integer");
 return 0;
 }
};

template <typename Context, typename ID>
FMT_CONSTEXPR auto get_arg(Context& ctx, ID id) -> basic_format_arg<Context> {
 auto arg = ctx.arg(id);
 if (!arg) report_error("argument not found");
 return arg;
}

template <typename Context>
FMT_CONSTEXPR int get_dynamic_spec(
 arg_id_kind kind, const arg_ref<typename Context::char_type>& ref,
 Context& ctx) {
 FMT_ASSERT(kind != arg_id_kind::none, "");
 auto arg =
 kind == arg_id_kind::index ? ctx.arg(ref.index) : ctx.arg(ref.name);
 if (!arg) report_error("argument not found");
 unsigned long long value = arg.visit(dynamic_spec_getter());
 if (value > to_unsigned(max_value<int>()))
 report_error("width/precision is out of range");
 return static_cast<int>(value);
}

template <typename Context>
FMT_CONSTEXPR void handle_dynamic_spec(
 arg_id_kind kind, int& value,
 const arg_ref<typename Context::char_type>& ref, Context& ctx) {
 if (kind != arg_id_kind::none) value = get_dynamic_spec(kind, ref, ctx);
}

#if FMT_USE_NONTYPE_TEMPLATE_ARGS
template <typename T, typename Char, size_t N,
 fmt::detail_exported::fixed_string<Char, N> Str>
struct static_named_arg : view {
 static constexpr auto name = Str.data;

const T& value;
  static_named_arg(const T& v) : value(v) {}
};

template <typename T, typename Char, size_t N,
 fmt::detail_exported::fixed_string<Char, N> Str>
struct is_named_arg<static_named_arg<T, Char, N, Str>> : std::true_type {};

template <typename T, typename Char, size_t N,
 fmt::detail_exported::fixed_string<Char, N> Str>
struct is_static_named_arg<static_named_arg<T, Char, N, Str>> : std::true_type {
};

template <typename Char, size_t N,
 fmt::detail_exported::fixed_string<Char, N> Str>
struct udl_arg {
 template <typename T> auto operator=(T&& value) const {
 return static_named_arg<T, Char, N, Str>(std::forward<T>(value));
 }
};
#else
template <typename Char> struct udl_arg {
 const Char* str;

template <typename T> auto operator=(T&& value) const -> named_arg<Char, T> {
 return {str, std::forward<T>(value)};
 }
};
#endif // FMT_USE_NONTYPE_TEMPLATE_ARGS

template <typename Char> struct format_handler {
 parse_context<Char> parse_ctx;
 buffered_context<Char> ctx;

void on_text(const Char* begin, const Char* end) {
 copy_noinline<Char>(begin, end, ctx.out());
 }

FMT_CONSTEXPR auto on_arg_id() -> int { return parse_ctx.next_arg_id(); }
 FMT_CONSTEXPR auto on_arg_id(int id) -> int {
 parse_ctx.check_arg_id(id);
 return id;
 }
 FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int {
 parse_ctx.check_arg_id(id);
 int arg_id = ctx.arg_id(id);
 if (arg_id < 0) report_error("argument not found");
 return arg_id;
 }

FMT_INLINE void on_replacement_field(int id, const Char*) {
 ctx.arg(id).visit(default_arg_formatter<Char>{ctx.out()});
 }

auto on_format_specs(int id, const Char* begin, const Char* end)
      -> const Char* {
    auto arg = get_arg(ctx, id);
    // Not using a visitor for custom types gives better codegen.
    if (arg.format_custom(begin, parse_ctx, ctx)) return parse_ctx.begin();

auto specs = dynamic_format_specs<Char>();
 begin = parse_format_specs(begin, end, specs, parse_ctx, arg.type());
 if (specs.dynamic()) {
 handle_dynamic_spec(specs.dynamic_width(), specs.width, specs.width_ref,
 ctx);
 handle_dynamic_spec(specs.dynamic_precision(), specs.precision,
 specs.precision_ref, ctx);
 }

arg.visit(arg_formatter<Char>{ctx.out(), specs, ctx.locale()});
 return begin;
 }

FMT_NORETURN void on_error(const char* message) { report_error(message); }
};

// DEPRECATED!
template <typename Char = char> struct vformat_args {
 using type = basic_format_args<buffered_context<Char>>;
};
template <> struct vformat_args<char> {
 using type = format_args;
};

template <typename Char>
void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt,
 typename vformat_args<Char>::type args, locale_ref loc = {}) {
 auto out = basic_appender<Char>(buf);
 parse_format_string(
 fmt, format_handler<Char>{parse_context<Char>(fmt), {out, args, loc}});
}

using format_func = void (*)(detail::buffer<char>&, int, const char*);

FMT_API void format_error_code(buffer<char>& out, int error_code,
 string_view message) noexcept;

using fmt::report_error;
FMT_API void report_error(format_func func, int error_code,
                          const char* message) noexcept;

template <typename T>
struct has_format_as
 : bool_constant<!std::is_same<format_as_t<T>, void>::value> {};

FMT_BEGIN_EXPORT

#ifndef FMT_HEADER_ONLY
extern template FMT_API auto thousands_sep_impl<char>(locale_ref)
 -> thousands_sep_result<char>;
extern template FMT_API auto thousands_sep_impl<wchar_t>(locale_ref)
 -> thousands_sep_result<wchar_t>;
extern template FMT_API auto decimal_point_impl(locale_ref) -> char;
extern template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t;
#endif // FMT_HEADER_ONLY

FMT_END_EXPORT

template <typename T, typename Char, type TYPE>
template <typename FormatContext>
FMT_CONSTEXPR auto native_formatter<T, Char, TYPE>::format(
 const T& val, FormatContext& ctx) const -> decltype(ctx.out()) {
 if (!specs_.dynamic())
 return write<Char>(ctx.out(), val, specs_, ctx.locale());
 auto specs = format_specs(specs_);
 handle_dynamic_spec(specs.dynamic_width(), specs.width, specs_.width_ref,
 ctx);
 handle_dynamic_spec(specs.dynamic_precision(), specs.precision,
 specs_.precision_ref, ctx);
 return write<Char>(ctx.out(), val, specs, ctx.locale());
}
} // namespace detail

template <typename T, typename Char>
struct formatter<T, Char, enable_if_t<detail::has_format_as<T>::value>>
 : formatter<detail::format_as_t<T>, Char> {
 template <typename FormatContext>
 FMT_CONSTEXPR auto format(const T& value, FormatContext& ctx) const
 -> decltype(ctx.out()) {
 auto&& val = format_as(value); // Make an lvalue reference for format.
 return formatter<detail::format_as_t<T>, Char>::format(val, ctx);
 }
};

#define FMT_FORMAT_AS(Type, Base) \
 template <typename Char> \
 struct formatter<Type, Char> : formatter<Base, Char> { \
 template <typename FormatContext> \
 FMT_CONSTEXPR auto format(Type value, FormatContext& ctx) const \
 -> decltype(ctx.out()) { \
 return formatter<Base, Char>::format(value, ctx); \
 } \
 }

FMT_FORMAT_AS(signed char, int);
FMT_FORMAT_AS(unsigned char, unsigned);
FMT_FORMAT_AS(short, int);
FMT_FORMAT_AS(unsigned short, unsigned);
FMT_FORMAT_AS(long, detail::long_type);
FMT_FORMAT_AS(unsigned long, detail::ulong_type);
FMT_FORMAT_AS(Char*, const Char*);
FMT_FORMAT_AS(detail::std_string_view<Char>, basic_string_view<Char>);
FMT_FORMAT_AS(std::nullptr_t, const void*);
FMT_FORMAT_AS(void*, const void*);

template <typename Char, size_t N>
struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {};

template <typename Char, typename Traits, typename Allocator>
class formatter<std::basic_string<Char, Traits, Allocator>, Char>
 : public formatter<basic_string_view<Char>, Char> {};

template <int N, typename Char>
struct formatter<detail::bitint<N>, Char> : formatter<long long, Char> {};
template <int N, typename Char>
struct formatter<detail::ubitint<N>, Char>
 : formatter<unsigned long long, Char> {};

/**
 * Converts `p` to `const void*` for pointer formatting.
 *
 * **Example**:
 *
 * auto s = fmt::format("{}", fmt::ptr(p));
 */
template <typename T> auto ptr(T p) -> const void* {
 static_assert(std::is_pointer<T>::value, "");
 return detail::bit_cast<const void*>(p);
}

/**
 * Converts `e` to the underlying type.
 *
 * **Example**:
 *
 * enum class color { red, green, blue };
 * auto s = fmt::format("{}", fmt::underlying(color::red));
 */
template <typename Enum>
constexpr auto underlying(Enum e) noexcept -> underlying_t<Enum> {
 return static_cast<underlying_t<Enum>>(e);
}

namespace enums {
template <typename Enum, FMT_ENABLE_IF(std::is_enum<Enum>::value)>
constexpr auto format_as(Enum e) noexcept -> underlying_t<Enum> {
 return static_cast<underlying_t<Enum>>(e);
}
} // namespace enums

class bytes {
 private:
 string_view data_;
 friend struct formatter<bytes>;

public:
  explicit bytes(string_view data) : data_(data) {}
};

template <> struct formatter<bytes> {
 private:
 detail::dynamic_format_specs<> specs_;

public:
 FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* {
 return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,
 detail::type::string_type);
 }

template <typename FormatContext>
 auto format(bytes b, FormatContext& ctx) const -> decltype(ctx.out()) {
 auto specs = specs_;
 detail::handle_dynamic_spec(specs.dynamic_width(), specs.width,
 specs.width_ref, ctx);
 detail::handle_dynamic_spec(specs.dynamic_precision(), specs.precision,
 specs.precision_ref, ctx);
 return detail::write_bytes<char>(ctx.out(), b.data_, specs);
 }
};

// group_digits_view is not derived from view because it copies the argument.
template <typename T> struct group_digits_view {
 T value;
};

/**
 * Returns a view that formats an integer value using ',' as a
 * locale-independent thousands separator.
 *
 * **Example**:
 *
 * fmt::print("{}", fmt::group_digits(12345));
 * // Output: "12,345"
 */
template <typename T> auto group_digits(T value) -> group_digits_view<T> {
 return {value};
}

template <typename T> struct formatter<group_digits_view<T>> : formatter<T> {
 private:
 detail::dynamic_format_specs<> specs_;

public:
 FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* {
 return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,
 detail::type::int_type);
 }

template <typename FormatContext>
 auto format(group_digits_view<T> t, FormatContext& ctx) const
 -> decltype(ctx.out()) {
 auto specs = specs_;
 detail::handle_dynamic_spec(specs.dynamic_width(), specs.width,
 specs.width_ref, ctx);
 detail::handle_dynamic_spec(specs.dynamic_precision(), specs.precision,
 specs.precision_ref, ctx);
 auto arg = detail::make_write_int_arg(t.value, specs.sign());
 return detail::write_int(
 ctx.out(), static_cast<detail::uint64_or_128_t<T>>(arg.abs_value),
 arg.prefix, specs, detail::digit_grouping<char>("\3", ","));
 }
};

template <typename T, typename Char> struct nested_view {
 const formatter<T, Char>* fmt;
 const T* value;
};

template <typename T, typename Char>
struct formatter<nested_view<T, Char>, Char> {
 FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
 return ctx.begin();
 }
 template <typename FormatContext>
 auto format(nested_view<T, Char> view, FormatContext& ctx) const
 -> decltype(ctx.out()) {
 return view.fmt->format(*view.value, ctx);
 }
};

template <typename T, typename Char = char> struct nested_formatter {
 private:
 basic_specs specs_;
 int width_;
 formatter<T, Char> formatter_;

public:
  constexpr nested_formatter() : width_(0) {}

FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
 auto it = ctx.begin(), end = ctx.end();
 if (it == end) return it;
 auto specs = format_specs();
 it = detail::parse_align(it, end, specs);
 specs_ = specs;
 Char c = *it;
 auto width_ref = detail::arg_ref<Char>();
 if ((c >= '0' && c <= '9') || c == '{') {
 it = detail::parse_width(it, end, specs, width_ref, ctx);
 width_ = specs.width;
 }
 ctx.advance_to(it);
 return formatter_.parse(ctx);
 }

template <typename FormatContext, typename F>
 auto write_padded(FormatContext& ctx, F write) const -> decltype(ctx.out()) {
 if (width_ == 0) return write(ctx.out());
 auto buf = basic_memory_buffer<Char>();
 write(basic_appender<Char>(buf));
 auto specs = format_specs();
 specs.width = width_;
 specs.set_fill(
 basic_string_view<Char>(specs_.fill<Char>(), specs_.fill_size()));
 specs.set_align(specs_.align());
 return detail::write<Char>(
 ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs);
 }

auto nested(const T& value) const -> nested_view<T, Char> {
 return nested_view<T, Char>{&formatter_, &value};
 }
};

template <typename Char>
struct formatter<detail::float128, Char>
 : detail::native_formatter<detail::float128, Char,
 detail::type::float_type> {};

inline namespace literals {
#if FMT_USE_NONTYPE_TEMPLATE_ARGS
template <detail_exported::fixed_string Str> constexpr auto operator""_a() {
 using char_t = remove_cvref_t<decltype(Str.data[0])>;
 return detail::udl_arg<char_t, sizeof(Str.data) / sizeof(char_t), Str>();
}
#else
/**
 * User-defined literal equivalent of `fmt::arg`.
 *
 * **Example**:
 *
 * using namespace fmt::literals;
 * fmt::print("The answer is {answer}.", "answer"_a=42);
 */
constexpr auto operator""_a(const char* s, size_t) -> detail::udl_arg<char> {
 return {s};
}
#endif // FMT_USE_NONTYPE_TEMPLATE_ARGS
} // namespace literals

/// A fast integer formatter.
class format_int {
 private:
 // Buffer should be large enough to hold all digits (digits10 + 1),
 // a sign and a null character.
 enum { buffer_size = std::numeric_limits<unsigned long long>::digits10 + 3 };
 mutable char buffer_[buffer_size];
 char* str_;

template <typename UInt>
 FMT_CONSTEXPR20 auto format_unsigned(UInt value) -> char* {
 auto n = static_cast<detail::uint32_or_64_or_128_t<UInt>>(value);
 return detail::do_format_decimal(buffer_, n, buffer_size - 1);
 }

template <typename Int>
 FMT_CONSTEXPR20 auto format_signed(Int value) -> char* {
 auto abs_value = static_cast<detail::uint32_or_64_or_128_t<Int>>(value);
 bool negative = value < 0;
 if (negative) abs_value = 0 - abs_value;
 auto begin = format_unsigned(abs_value);
 if (negative) *--begin = '-';
 return begin;
 }

public:
  explicit FMT_CONSTEXPR20 format_int(int value) : str_(format_signed(value)) {}
  explicit FMT_CONSTEXPR20 format_int(long value)
      : str_(format_signed(value)) {}
  explicit FMT_CONSTEXPR20 format_int(long long value)
      : str_(format_signed(value)) {}
  explicit FMT_CONSTEXPR20 format_int(unsigned value)
      : str_(format_unsigned(value)) {}
  explicit FMT_CONSTEXPR20 format_int(unsigned long value)
      : str_(format_unsigned(value)) {}
  explicit FMT_CONSTEXPR20 format_int(unsigned long long value)
      : str_(format_unsigned(value)) {}

/// Returns the number of characters written to the output buffer.
  FMT_CONSTEXPR20 auto size() const -> size_t {
    return detail::to_unsigned(buffer_ - str_ + buffer_size - 1);
  }

/// Returns a pointer to the output buffer content. No terminating null
  /// character is appended.
  FMT_CONSTEXPR20 auto data() const -> const char* { return str_; }

/// Returns a pointer to the output buffer content with terminating null
  /// character appended.
  FMT_CONSTEXPR20 auto c_str() const -> const char* {
    buffer_[buffer_size - 1] = '\0';
    return str_;
  }

/// Returns the content of the output buffer as an `std::string`.
  auto str() const -> std::string { return {str_, size()}; }
};

#define FMT_STRING_IMPL(s, base) \
 [] { \
 /* Use the hidden visibility as a workaround for a GCC bug (#1973). */ \
 /* Use a macro-like name to avoid shadowing warnings. */ \
 struct FMT_VISIBILITY("hidden") FMT_COMPILE_STRING : base { \
 using char_type = fmt::remove_cvref_t<decltype(s[0])>; \
 FMT_CONSTEXPR explicit operator fmt::basic_string_view<char_type>() \
 const { \
 return fmt::detail_exported::compile_string_to_view<char_type>(s); \
 } \
 }; \
 using FMT_STRING_VIEW = \
 fmt::basic_string_view<typename FMT_COMPILE_STRING::char_type>; \
 fmt::detail::ignore_unused(FMT_STRING_VIEW(FMT_COMPILE_STRING())); \
 return FMT_COMPILE_STRING(); \
 }()

/**
 * Constructs a compile-time format string from a string literal `s`.
 *
 * **Example**:
 *
 *     // A compile-time error because 'd' is an invalid specifier for strings.
 *     std::string s = fmt::format(FMT_STRING("{:d}"), "foo");
 */
#define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::detail::compile_string)

FMT_BEGIN_EXPORT
FMT_API auto vsystem_error(int error_code, string_view fmt, format_args args)
    -> std::system_error;

/**
 * Constructs `std::system_error` with a message formatted with
 * `fmt::format(fmt, args...)`.
 * `error_code` is a system error code as given by `errno`.
 *
 * **Example**:
 *
 * // This throws std::system_error with the description
 * // cannot open file 'madeup': No such file or directory
 * // or similar (system message may vary).
 * const char* filename = "madeup";
 * FILE* file = fopen(filename, "r");
 * if (!file)
 * throw fmt::system_error(errno, "cannot open file '{}'", filename);
 */
template <typename... T>
auto system_error(int error_code, format_string<T...> fmt, T&&... args)
 -> std::system_error {
 return vsystem_error(error_code, fmt.str, vargs<T...>{{args...}});
}

/**
 * Formats an error message for an error returned by an operating system or a
 * language runtime, for example a file opening error, and writes it to `out`.
 * The format is the same as the one used by `std::system_error(ec, message)`
 * where `ec` is `std::error_code(error_code, std::generic_category())`.
 * It is implementation-defined but normally looks like:
 *
 * <message>: <system-message>
 *
 * where `<message>` is the passed message and `<system-message>` is the system
 * message corresponding to the error code.
 * `error_code` is a system error code as given by `errno`.
 */
FMT_API void format_system_error(detail::buffer<char>& out, int error_code,
 const char* message) noexcept;

// Reports a system error without throwing an exception.
// Can be used to report errors from destructors.
FMT_API void report_system_error(int error_code, const char* message) noexcept;

template <typename Locale, FMT_ENABLE_IF(detail::is_locale<Locale>::value)>
auto vformat(const Locale& loc, string_view fmt, format_args args)
 -> std::string {
 auto buf = memory_buffer();
 detail::vformat_to(buf, fmt, args, detail::locale_ref(loc));
 return {buf.data(), buf.size()};
}

template <typename Locale, typename... T,
 FMT_ENABLE_IF(detail::is_locale<Locale>::value)>
FMT_INLINE auto format(const Locale& loc, format_string<T...> fmt, T&&... args)
 -> std::string {
 return fmt::vformat(loc, fmt.str, vargs<T...>{{args...}});
}

template <typename OutputIt, typename Locale,
 FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value&&
 detail::is_locale<Locale>::value)>
auto vformat_to(OutputIt out, const Locale& loc, string_view fmt,
 format_args args) -> OutputIt {
 auto&& buf = detail::get_buffer<char>(out);
 detail::vformat_to(buf, fmt, args, detail::locale_ref(loc));
 return detail::get_iterator(buf, out);
}

template <typename OutputIt, typename Locale, typename... T,
 FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value&&
 detail::is_locale<Locale>::value)>
FMT_INLINE auto format_to(OutputIt out, const Locale& loc,
 format_string<T...> fmt, T&&... args) -> OutputIt {
 return fmt::vformat_to(out, loc, fmt.str, vargs<T...>{{args...}});
}

template <typename Locale, typename... T,
 FMT_ENABLE_IF(detail::is_locale<Locale>::value)>
FMT_NODISCARD FMT_INLINE auto formatted_size(const Locale& loc,
 format_string<T...> fmt,
 T&&... args) -> size_t {
 auto buf = detail::counting_buffer<>();
 detail::vformat_to(buf, fmt.str, vargs<T...>{{args...}},
 detail::locale_ref(loc));
 return buf.count();
}

FMT_API auto vformat(string_view fmt, format_args args) -> std::string;

/**
 * Formats `args` according to specifications in `fmt` and returns the result
 * as a string.
 *
 * **Example**:
 *
 * #include <fmt/format.h>
 * std::string message = fmt::format("The answer is {}.", 42);
 */
template <typename... T>
FMT_NODISCARD FMT_INLINE auto format(format_string<T...> fmt, T&&... args)
 -> std::string {
 return vformat(fmt.str, vargs<T...>{{args...}});
}

/**
 * Converts `value` to `std::string` using the default format for type `T`.
 *
 * **Example**:
 *
 * std::string answer = fmt::to_string(42);
 */
template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
FMT_NODISCARD auto to_string(T value) -> std::string {
 // The buffer should be large enough to store the number including the sign
 // or "false" for bool.
 constexpr int max_size = detail::digits10<T>() + 2;
 char buffer[max_size > 5 ? static_cast<unsigned>(max_size) : 5];
 char* begin = buffer;
 return {buffer, detail::write<char>(begin, value)};
}

template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value &&
 !detail::has_format_as<T>::value)>
FMT_NODISCARD auto to_string(const T& value) -> std::string {
 auto buffer = memory_buffer();
 detail::write<char>(appender(buffer), value);
 return {buffer.data(), buffer.size()};
}

template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value &&
 detail::has_format_as<T>::value)>
FMT_NODISCARD auto to_string(const T& value) -> std::string {
 return to_string(format_as(value));
}

FMT_END_EXPORT
FMT_END_NAMESPACE

#ifdef FMT_HEADER_ONLY
#  define FMT_FUNC inline
#  include "format-inl.h"
#else
#  define FMT_FUNC
#endif

// Restore _LIBCPP_REMOVE_TRANSITIVE_INCLUDES.
#ifdef FMT_REMOVE_TRANSITIVE_INCLUDES
#  undef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
#endif

#endif  // FMT_FORMAT_H_

namespace fmt_detail {
template <typename... T> inline void _tzset(T...) {}
} // namespace fmt_detail

FMT_BEGIN_NAMESPACE

// Enable safe chrono durations, unless explicitly disabled.
#ifndef FMT_SAFE_DURATION_CAST
#  define FMT_SAFE_DURATION_CAST 1
#endif
#if FMT_SAFE_DURATION_CAST

// For conversion between std::chrono::durations without undefined
// behaviour or erroneous results.
// This is a stripped down version of duration_cast, for inclusion in fmt.
// See https://github.com/pauldreik/safe_duration_cast
//
// Copyright Paul Dreik 2019
namespace safe_duration_cast {

template <typename To, typename From,
 FMT_ENABLE_IF(!std::is_same<From, To>::value &&
 std::numeric_limits<From>::is_signed ==
 std::numeric_limits<To>::is_signed)>
FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)
 -> To {
 ec = 0;
 using F = std::numeric_limits<From>;
 using T = std::numeric_limits<To>;
 static_assert(F::is_integer, "From must be integral");
 static_assert(T::is_integer, "To must be integral");

// A and B are both signed, or both unsigned.
 if (detail::const_check(F::digits <= T::digits)) {
 // From fits in To without any problem.
 } else {
 // From does not always fit in To, resort to a dynamic check.
 if (from < (T::min)() || from > (T::max)()) {
 // outside range.
 ec = 1;
 return {};
 }
 }
 return static_cast<To>(from);
}

/// Converts From to To, without loss. If the dynamic value of from
/// can't be converted to To without loss, ec is set.
template <typename To, typename From,
 FMT_ENABLE_IF(!std::is_same<From, To>::value &&
 std::numeric_limits<From>::is_signed !=
 std::numeric_limits<To>::is_signed)>
FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)
 -> To {
 ec = 0;
 using F = std::numeric_limits<From>;
 using T = std::numeric_limits<To>;
 static_assert(F::is_integer, "From must be integral");
 static_assert(T::is_integer, "To must be integral");

if (detail::const_check(F::is_signed && !T::is_signed)) {
 // From may be negative, not allowed!
 if (fmt::detail::is_negative(from)) {
 ec = 1;
 return {};
 }
 // From is positive. Can it always fit in To?
 if (detail::const_check(F::digits > T::digits) &&
 from > static_cast<From>(detail::max_value<To>())) {
 ec = 1;
 return {};
 }
 }

if (detail::const_check(!F::is_signed && T::is_signed &&
 F::digits >= T::digits) &&
 from > static_cast<From>(detail::max_value<To>())) {
 ec = 1;
 return {};
 }
 return static_cast<To>(from); // Lossless conversion.
}

template <typename To, typename From,
 FMT_ENABLE_IF(std::is_same<From, To>::value)>
FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)
 -> To {
 ec = 0;
 return from;
} // function

// clang-format off
/**
 * converts From to To if possible, otherwise ec is set.
 *
 * input | output
 * ---------------------------------|---------------
 * NaN | NaN
 * Inf | Inf
 * normal, fits in output | converted (possibly lossy)
 * normal, does not fit in output | ec is set
 * subnormal | best effort
 * -Inf | -Inf
 */
// clang-format on
template <typename To, typename From,
 FMT_ENABLE_IF(!std::is_same<From, To>::value)>
FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To {
 ec = 0;
 using T = std::numeric_limits<To>;
 static_assert(std::is_floating_point<From>::value, "From must be floating");
 static_assert(std::is_floating_point<To>::value, "To must be floating");

// catch the only happy case
 if (std::isfinite(from)) {
 if (from >= T::lowest() && from <= (T::max)()) {
 return static_cast<To>(from);
 }
 // not within range.
 ec = 1;
 return {};
 }

// nan and inf will be preserved
 return static_cast<To>(from);
} // function

template <typename To, typename From,
 FMT_ENABLE_IF(std::is_same<From, To>::value)>
FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To {
 ec = 0;
 static_assert(std::is_floating_point<From>::value, "From must be floating");
 return from;
}

/// Safe duration_cast between floating point durations
template <typename To, typename FromRep, typename FromPeriod,
 FMT_ENABLE_IF(std::is_floating_point<FromRep>::value),
 FMT_ENABLE_IF(std::is_floating_point<typename To::rep>::value)>
auto safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
 int& ec) -> To {
 using From = std::chrono::duration<FromRep, FromPeriod>;
 ec = 0;
 if (std::isnan(from.count())) {
 // nan in, gives nan out. easy.
 return To{std::numeric_limits<typename To::rep>::quiet_NaN()};
 }
 // maybe we should also check if from is denormal, and decide what to do about
 // it.

// +-inf should be preserved.
  if (std::isinf(from.count())) {
    return To{from.count()};
  }

// the basic idea is that we need to convert from count() in the from type
 // to count() in the To type, by multiplying it with this:
 struct Factor
 : std::ratio_divide<typename From::period, typename To::period> {};

static_assert(Factor::num > 0, "num must be positive");
  static_assert(Factor::den > 0, "den must be positive");

// the conversion is like this: multiply from.count() with Factor::num
 // /Factor::den and convert it to To::rep, all this without
 // overflow/underflow. let's start by finding a suitable type that can hold
 // both To, From and Factor::num
 using IntermediateRep =
 typename std::common_type<typename From::rep, typename To::rep,
 decltype(Factor::num)>::type;

// force conversion of From::rep -> IntermediateRep to be safe,
 // even if it will never happen be narrowing in this context.
 IntermediateRep count =
 safe_float_conversion<IntermediateRep>(from.count(), ec);
 if (ec) {
 return {};
 }

// multiply with Factor::num without overflow or underflow
 if (detail::const_check(Factor::num != 1)) {
 constexpr auto max1 = detail::max_value<IntermediateRep>() /
 static_cast<IntermediateRep>(Factor::num);
 if (count > max1) {
 ec = 1;
 return {};
 }
 constexpr auto min1 = std::numeric_limits<IntermediateRep>::lowest() /
 static_cast<IntermediateRep>(Factor::num);
 if (count < min1) {
 ec = 1;
 return {};
 }
 count *= static_cast<IntermediateRep>(Factor::num);
 }

// this can't go wrong, right? den>0 is checked earlier.
 if (detail::const_check(Factor::den != 1)) {
 using common_t = typename std::common_type<IntermediateRep, intmax_t>::type;
 count /= static_cast<common_t>(Factor::den);
 }

// convert to the to type, safely
  using ToRep = typename To::rep;

const ToRep tocount = safe_float_conversion<ToRep>(count, ec);
 if (ec) {
 return {};
 }
 return To{tocount};
}
} // namespace safe_duration_cast
#endif

namespace detail {

// Check if std::chrono::utc_time is available.
#ifdef FMT_USE_UTC_TIME
// Use the provided definition.
#elif defined(__cpp_lib_chrono)
#  define FMT_USE_UTC_TIME (__cpp_lib_chrono >= 201907L)
#else
#  define FMT_USE_UTC_TIME 0
#endif
#if FMT_USE_UTC_TIME
using utc_clock = std::chrono::utc_clock;
#else
struct utc_clock {
  void to_sys();
};
#endif

// Check if std::chrono::local_time is available.
#ifdef FMT_USE_LOCAL_TIME
// Use the provided definition.
#elif defined(__cpp_lib_chrono)
#  define FMT_USE_LOCAL_TIME (__cpp_lib_chrono >= 201907L)
#else
#  define FMT_USE_LOCAL_TIME 0
#endif
#if FMT_USE_LOCAL_TIME
using local_t = std::chrono::local_t;
#else
struct local_t {};
#endif

}  // namespace detail

template <typename Duration>
using sys_time = std::chrono::time_point<std::chrono::system_clock, Duration>;

template <typename Duration>
using utc_time = std::chrono::time_point<detail::utc_clock, Duration>;

template <class Duration>
using local_time = std::chrono::time_point<detail::local_t, Duration>;

namespace detail {

// Prevents expansion of a preceding token as a function-style macro.
// Usage: f FMT_NOMACRO()
#define FMT_NOMACRO

template <typename T = void> struct null {};
inline auto localtime_r FMT_NOMACRO(...) -> null<> { return null<>(); }
inline auto localtime_s(...) -> null<> { return null<>(); }
inline auto gmtime_r(...) -> null<> { return null<>(); }
inline auto gmtime_s(...) -> null<> { return null<>(); }

// It is defined here and not in ostream.h because the latter has expensive
// includes.
template <typename StreamBuf> class formatbuf : public StreamBuf {
 private:
 using char_type = typename StreamBuf::char_type;
 using streamsize = decltype(std::declval<StreamBuf>().sputn(nullptr, 0));
 using int_type = typename StreamBuf::int_type;
 using traits_type = typename StreamBuf::traits_type;

buffer<char_type>& buffer_;

public:
 explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {}

protected:
  // The put area is always empty. This makes the implementation simpler and has
  // the advantage that the streambuf and the buffer are always in sync and
  // sputc never writes into uninitialized memory. A disadvantage is that each
  // call to sputc always results in a (virtual) call to overflow. There is no
  // disadvantage here for sputn since this always results in a call to xsputn.

auto overflow(int_type ch) -> int_type override {
 if (!traits_type::eq_int_type(ch, traits_type::eof()))
 buffer_.push_back(static_cast<char_type>(ch));
 return ch;
 }

auto xsputn(const char_type* s, streamsize count) -> streamsize override {
    buffer_.append(s, s + count);
    return count;
  }
};

inline auto get_classic_locale() -> const std::locale& {
  static const auto& locale = std::locale::classic();
  return locale;
}

template <typename CodeUnit> struct codecvt_result {
 static constexpr const size_t max_size = 32;
 CodeUnit buf[max_size];
 CodeUnit* end;
};

template <typename CodeUnit>
void write_codecvt(codecvt_result<CodeUnit>& out, string_view in,
 const std::locale& loc) {
 FMT_PRAGMA_CLANG(diagnostic push)
 FMT_PRAGMA_CLANG(diagnostic ignored "-Wdeprecated")
 auto& f = std::use_facet<std::codecvt<CodeUnit, char, std::mbstate_t>>(loc);
 FMT_PRAGMA_CLANG(diagnostic pop)
 auto mb = std::mbstate_t();
 const char* from_next = nullptr;
 auto result = f.in(mb, in.begin(), in.end(), from_next, std::begin(out.buf),
 std::end(out.buf), out.end);
 if (result != std::codecvt_base::ok)
 FMT_THROW(format_error("failed to format time"));
}

template <typename OutputIt>
auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc)
 -> OutputIt {
 if (detail::use_utf8 && loc != get_classic_locale()) {
 // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and
 // gcc-4.
#if FMT_MSC_VERSION != 0 || \
 (defined(__GLIBCXX__) && \
 (!defined(_GLIBCXX_USE_DUAL_ABI) || _GLIBCXX_USE_DUAL_ABI == 0))
 // The _GLIBCXX_USE_DUAL_ABI macro is always defined in libstdc++ from gcc-5
 // and newer.
 using code_unit = wchar_t;
#else
 using code_unit = char32_t;
#endif

using unit_t = codecvt_result<code_unit>;
 unit_t unit;
 write_codecvt(unit, in, loc);
 // In UTF-8 is used one to four one-byte code units.
 auto u =
 to_utf8<code_unit, basic_memory_buffer<char, unit_t::max_size * 4>>();
 if (!u.convert({unit.buf, to_unsigned(unit.end - unit.buf)}))
 FMT_THROW(format_error("failed to format time"));
 return copy<char>(u.c_str(), u.c_str() + u.size(), out);
 }
 return copy<char>(in.data(), in.data() + in.size(), out);
}

template <typename Char, typename OutputIt,
 FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc)
 -> OutputIt {
 codecvt_result<Char> unit;
 write_codecvt(unit, sv, loc);
 return copy<Char>(unit.buf, unit.end, out);
}

template <typename Char, typename OutputIt,
 FMT_ENABLE_IF(std::is_same<Char, char>::value)>
auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc)
 -> OutputIt {
 return write_encoded_tm_str(out, sv, loc);
}

template <typename Char>
inline void do_write(buffer<Char>& buf, const std::tm& time,
 const std::locale& loc, char format, char modifier) {
 auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
 auto&& os = std::basic_ostream<Char>(&format_buf);
 os.imbue(loc);
 const auto& facet = std::use_facet<std::time_put<Char>>(loc);
 auto end = facet.put(os, os, Char(' '), &time, format, modifier);
 if (end.failed()) FMT_THROW(format_error("failed to format time"));
}

template <typename Char, typename OutputIt,
 FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
auto write(OutputIt out, const std::tm& time, const std::locale& loc,
 char format, char modifier = 0) -> OutputIt {
 auto&& buf = get_buffer<Char>(out);
 do_write<Char>(buf, time, loc, format, modifier);
 return get_iterator(buf, out);
}

template <typename Char, typename OutputIt,
 FMT_ENABLE_IF(std::is_same<Char, char>::value)>
auto write(OutputIt out, const std::tm& time, const std::locale& loc,
 char format, char modifier = 0) -> OutputIt {
 auto&& buf = basic_memory_buffer<Char>();
 do_write<char>(buf, time, loc, format, modifier);
 return write_encoded_tm_str(out, string_view(buf.data(), buf.size()), loc);
}

template <typename Rep1, typename Rep2>
struct is_same_arithmetic_type
 : public std::integral_constant<bool,
 (std::is_integral<Rep1>::value &&
 std::is_integral<Rep2>::value) ||
 (std::is_floating_point<Rep1>::value &&
 std::is_floating_point<Rep2>::value)> {
};

inline void throw_duration_error() {
  FMT_THROW(format_error("cannot format duration"));
}

// Cast one integral duration to another with an overflow check.
template <typename To, typename FromRep, typename FromPeriod,
 FMT_ENABLE_IF(std::is_integral<FromRep>::value&&
 std::is_integral<typename To::rep>::value)>
auto duration_cast(std::chrono::duration<FromRep, FromPeriod> from) -> To {
#if !FMT_SAFE_DURATION_CAST
 return std::chrono::duration_cast<To>(from);
#else
 // The conversion factor: to.count() == factor * from.count().
 using factor = std::ratio_divide<FromPeriod, typename To::period>;

using common_rep = typename std::common_type<FromRep, typename To::rep,
 decltype(factor::num)>::type;

int ec = 0;
 auto count = safe_duration_cast::lossless_integral_conversion<common_rep>(
 from.count(), ec);
 if (ec) throw_duration_error();

// Multiply from.count() by factor and check for overflow.
 if (const_check(factor::num != 1)) {
 if (count > max_value<common_rep>() / factor::num) throw_duration_error();
 const auto min = (std::numeric_limits<common_rep>::min)() / factor::num;
 if (const_check(!std::is_unsigned<common_rep>::value) && count < min)
 throw_duration_error();
 count *= factor::num;
 }
 if (const_check(factor::den != 1)) count /= factor::den;
 auto to =
 To(safe_duration_cast::lossless_integral_conversion<typename To::rep>(
 count, ec));
 if (ec) throw_duration_error();
 return to;
#endif
}

template <typename To, typename FromRep, typename FromPeriod,
 FMT_ENABLE_IF(std::is_floating_point<FromRep>::value&&
 std::is_floating_point<typename To::rep>::value)>
auto duration_cast(std::chrono::duration<FromRep, FromPeriod> from) -> To {
#if FMT_SAFE_DURATION_CAST
 // Throwing version of safe_duration_cast is only available for
 // integer to integer or float to float casts.
 int ec;
 To to = safe_duration_cast::safe_duration_cast<To>(from, ec);
 if (ec) throw_duration_error();
 return to;
#else
 // Standard duration cast, may overflow.
 return std::chrono::duration_cast<To>(from);
#endif
}

template <
 typename To, typename FromRep, typename FromPeriod,
 FMT_ENABLE_IF(!is_same_arithmetic_type<FromRep, typename To::rep>::value)>
auto duration_cast(std::chrono::duration<FromRep, FromPeriod> from) -> To {
 // Mixed integer <-> float cast is not supported by safe_duration_cast.
 return std::chrono::duration_cast<To>(from);
}

template <typename Duration>
auto to_time_t(sys_time<Duration> time_point) -> std::time_t {
 // Cannot use std::chrono::system_clock::to_time_t since this would first
 // require a cast to std::chrono::system_clock::time_point, which could
 // overflow.
 return detail::duration_cast<std::chrono::duration<std::time_t>>(
 time_point.time_since_epoch())
 .count();
}
} // namespace detail

FMT_BEGIN_EXPORT

/**
 * Converts given time since epoch as `std::time_t` value into calendar time,
 * expressed in local time. Unlike `std::localtime`, this function is
 * thread-safe on most platforms.
 */
inline auto localtime(std::time_t time) -> std::tm {
  struct dispatcher {
    std::time_t time_;
    std::tm tm_;

dispatcher(std::time_t t) : time_(t) {}

auto run() -> bool {
      using namespace fmt::detail;
      return handle(localtime_r(&time_, &tm_));
    }

auto handle(std::tm* tm) -> bool { return tm != nullptr; }

auto handle(detail::null<>) -> bool {
 using namespace fmt::detail;
 return fallback(localtime_s(&tm_, &time_));
 }

auto fallback(int res) -> bool { return res == 0; }

#if !FMT_MSC_VERSION
 auto fallback(detail::null<>) -> bool {
 using namespace fmt::detail;
 std::tm* tm = std::localtime(&time_);
 if (tm) tm_ = *tm;
 return tm != nullptr;
 }
#endif
 };
 dispatcher lt(time);
 // Too big time values may be unsupported.
 if (!lt.run()) FMT_THROW(format_error("time_t value out of range"));
 return lt.tm_;
}

#if FMT_USE_LOCAL_TIME
template <typename Duration>
inline auto localtime(std::chrono::local_time<Duration> time) -> std::tm {
 return localtime(
 detail::to_time_t(std::chrono::current_zone()->to_sys(time)));
}
#endif

/**
 * Converts given time since epoch as `std::time_t` value into calendar time,
 * expressed in Coordinated Universal Time (UTC). Unlike `std::gmtime`, this
 * function is thread-safe on most platforms.
 */
inline auto gmtime(std::time_t time) -> std::tm {
  struct dispatcher {
    std::time_t time_;
    std::tm tm_;

dispatcher(std::time_t t) : time_(t) {}

auto run() -> bool {
      using namespace fmt::detail;
      return handle(gmtime_r(&time_, &tm_));
    }

auto handle(std::tm* tm) -> bool { return tm != nullptr; }

auto handle(detail::null<>) -> bool {
 using namespace fmt::detail;
 return fallback(gmtime_s(&tm_, &time_));
 }

auto fallback(int res) -> bool { return res == 0; }

#if !FMT_MSC_VERSION
 auto fallback(detail::null<>) -> bool {
 std::tm* tm = std::gmtime(&time_);
 if (tm) tm_ = *tm;
 return tm != nullptr;
 }
#endif
 };
 auto gt = dispatcher(time);
 // Too big time values may be unsupported.
 if (!gt.run()) FMT_THROW(format_error("time_t value out of range"));
 return gt.tm_;
}

template <typename Duration>
inline auto gmtime(sys_time<Duration> time_point) -> std::tm {
 return gmtime(detail::to_time_t(time_point));
}

namespace detail {

// Writes two-digit numbers a, b and c separated by sep to buf.
// The method by Pavel Novikov based on
// https://johnnylee-sde.github.io/Fast-unsigned-integer-to-time-string/.
inline void write_digit2_separated(char* buf, unsigned a, unsigned b,
 unsigned c, char sep) {
 unsigned long long digits =
 a | (b << 24) | (static_cast<unsigned long long>(c) << 48);
 // Convert each value to BCD.
 // We have x = a * 10 + b and we want to convert it to BCD y = a * 16 + b.
 // The difference is
 // y - x = a * 6
 // a can be found from x:
 // a = floor(x / 10)
 // then
 // y = x + a * 6 = x + floor(x / 10) * 6
 // floor(x / 10) is (x * 205) >> 11 (needs 16 bits).
 digits += (((digits * 205) >> 11) & 0x000f00000f00000f) * 6;
 // Put low nibbles to high bytes and high nibbles to low bytes.
 digits = ((digits & 0x00f00000f00000f0) >> 4) |
 ((digits & 0x000f00000f00000f) << 8);
 auto usep = static_cast<unsigned long long>(sep);
 // Add ASCII '0' to each digit byte and insert separators.
 digits |= 0x3030003030003030 | (usep << 16) | (usep << 40);

constexpr const size_t len = 8;
  if (const_check(is_big_endian())) {
    char tmp[len];
    std::memcpy(tmp, &digits, len);
    std::reverse_copy(tmp, tmp + len, buf);
  } else {
    std::memcpy(buf, &digits, len);
  }
}

template <typename Period>
FMT_CONSTEXPR inline auto get_units() -> const char* {
 if (std::is_same<Period, std::atto>::value) return "as";
 if (std::is_same<Period, std::femto>::value) return "fs";
 if (std::is_same<Period, std::pico>::value) return "ps";
 if (std::is_same<Period, std::nano>::value) return "ns";
 if (std::is_same<Period, std::micro>::value)
 return detail::use_utf8 ? "µs" : "us";
 if (std::is_same<Period, std::milli>::value) return "ms";
 if (std::is_same<Period, std::centi>::value) return "cs";
 if (std::is_same<Period, std::deci>::value) return "ds";
 if (std::is_same<Period, std::ratio<1>>::value) return "s";
 if (std::is_same<Period, std::deca>::value) return "das";
 if (std::is_same<Period, std::hecto>::value) return "hs";
 if (std::is_same<Period, std::kilo>::value) return "ks";
 if (std::is_same<Period, std::mega>::value) return "Ms";
 if (std::is_same<Period, std::giga>::value) return "Gs";
 if (std::is_same<Period, std::tera>::value) return "Ts";
 if (std::is_same<Period, std::peta>::value) return "Ps";
 if (std::is_same<Period, std::exa>::value) return "Es";
 if (std::is_same<Period, std::ratio<60>>::value) return "min";
 if (std::is_same<Period, std::ratio<3600>>::value) return "h";
 if (std::is_same<Period, std::ratio<86400>>::value) return "d";
 return nullptr;
}

enum class numeric_system {
  standard,
  // Alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale.
  alternative
};

// Glibc extensions for formatting numeric values.
enum class pad_type {
  // Pad a numeric result string with zeros (the default).
  zero,
  // Do not pad a numeric result string.
  none,
  // Pad a numeric result string with spaces.
  space,
};

template <typename OutputIt>
auto write_padding(OutputIt out, pad_type pad, int width) -> OutputIt {
 if (pad == pad_type::none) return out;
 return detail::fill_n(out, width, pad == pad_type::space ? ' ' : '0');
}

template <typename OutputIt>
auto write_padding(OutputIt out, pad_type pad) -> OutputIt {
 if (pad != pad_type::none) *out++ = pad == pad_type::space ? ' ' : '0';
 return out;
}

// Parses a put_time-like format string and invokes handler actions.
template <typename Char, typename Handler>
FMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end,
 Handler&& handler) -> const Char* {
 if (begin == end || *begin == '}') return begin;
 if (*begin != '%') FMT_THROW(format_error("invalid format"));
 auto ptr = begin;
 while (ptr != end) {
 pad_type pad = pad_type::zero;
 auto c = *ptr;
 if (c == '}') break;
 if (c != '%') {
 ++ptr;
 continue;
 }
 if (begin != ptr) handler.on_text(begin, ptr);
 ++ptr; // consume '%'
 if (ptr == end) FMT_THROW(format_error("invalid format"));
 c = *ptr;
 switch (c) {
 case '_':
 pad = pad_type::space;
 ++ptr;
 break;
 case '-':
 pad = pad_type::none;
 ++ptr;
 break;
 }
 if (ptr == end) FMT_THROW(format_error("invalid format"));
 c = *ptr++;
 switch (c) {
 case '%': handler.on_text(ptr - 1, ptr); break;
 case 'n': {
 const Char newline[] = {'\n'};
 handler.on_text(newline, newline + 1);
 break;
 }
 case 't': {
 const Char tab[] = {'\t'};
 handler.on_text(tab, tab + 1);
 break;
 }
 // Year:
 case 'Y': handler.on_year(numeric_system::standard); break;
 case 'y': handler.on_short_year(numeric_system::standard); break;
 case 'C': handler.on_century(numeric_system::standard); break;
 case 'G': handler.on_iso_week_based_year(); break;
 case 'g': handler.on_iso_week_based_short_year(); break;
 // Day of the week:
 case 'a': handler.on_abbr_weekday(); break;
 case 'A': handler.on_full_weekday(); break;
 case 'w': handler.on_dec0_weekday(numeric_system::standard); break;
 case 'u': handler.on_dec1_weekday(numeric_system::standard); break;
 // Month:
 case 'b':
 case 'h': handler.on_abbr_month(); break;
 case 'B': handler.on_full_month(); break;
 case 'm': handler.on_dec_month(numeric_system::standard); break;
 // Day of the year/month:
 case 'U':
 handler.on_dec0_week_of_year(numeric_system::standard, pad);
 break;
 case 'W':
 handler.on_dec1_week_of_year(numeric_system::standard, pad);
 break;
 case 'V': handler.on_iso_week_of_year(numeric_system::standard, pad); break;
 case 'j': handler.on_day_of_year(); break;
 case 'd': handler.on_day_of_month(numeric_system::standard, pad); break;
 case 'e':
 handler.on_day_of_month(numeric_system::standard, pad_type::space);
 break;
 // Hour, minute, second:
 case 'H': handler.on_24_hour(numeric_system::standard, pad); break;
 case 'I': handler.on_12_hour(numeric_system::standard, pad); break;
 case 'M': handler.on_minute(numeric_system::standard, pad); break;
 case 'S': handler.on_second(numeric_system::standard, pad); break;
 // Other:
 case 'c': handler.on_datetime(numeric_system::standard); break;
 case 'x': handler.on_loc_date(numeric_system::standard); break;
 case 'X': handler.on_loc_time(numeric_system::standard); break;
 case 'D': handler.on_us_date(); break;
 case 'F': handler.on_iso_date(); break;
 case 'r': handler.on_12_hour_time(); break;
 case 'R': handler.on_24_hour_time(); break;
 case 'T': handler.on_iso_time(); break;
 case 'p': handler.on_am_pm(); break;
 case 'Q': handler.on_duration_value(); break;
 case 'q': handler.on_duration_unit(); break;
 case 'z': handler.on_utc_offset(numeric_system::standard); break;
 case 'Z': handler.on_tz_name(); break;
 // Alternative representation:
 case 'E': {
 if (ptr == end) FMT_THROW(format_error("invalid format"));
 c = *ptr++;
 switch (c) {
 case 'Y': handler.on_year(numeric_system::alternative); break;
 case 'y': handler.on_offset_year(); break;
 case 'C': handler.on_century(numeric_system::alternative); break;
 case 'c': handler.on_datetime(numeric_system::alternative); break;
 case 'x': handler.on_loc_date(numeric_system::alternative); break;
 case 'X': handler.on_loc_time(numeric_system::alternative); break;
 case 'z': handler.on_utc_offset(numeric_system::alternative); break;
 default: FMT_THROW(format_error("invalid format"));
 }
 break;
 }
 case 'O':
 if (ptr == end) FMT_THROW(format_error("invalid format"));
 c = *ptr++;
 switch (c) {
 case 'y': handler.on_short_year(numeric_system::alternative); break;
 case 'm': handler.on_dec_month(numeric_system::alternative); break;
 case 'U':
 handler.on_dec0_week_of_year(numeric_system::alternative, pad);
 break;
 case 'W':
 handler.on_dec1_week_of_year(numeric_system::alternative, pad);
 break;
 case 'V':
 handler.on_iso_week_of_year(numeric_system::alternative, pad);
 break;
 case 'd':
 handler.on_day_of_month(numeric_system::alternative, pad);
 break;
 case 'e':
 handler.on_day_of_month(numeric_system::alternative, pad_type::space);
 break;
 case 'w': handler.on_dec0_weekday(numeric_system::alternative); break;
 case 'u': handler.on_dec1_weekday(numeric_system::alternative); break;
 case 'H': handler.on_24_hour(numeric_system::alternative, pad); break;
 case 'I': handler.on_12_hour(numeric_system::alternative, pad); break;
 case 'M': handler.on_minute(numeric_system::alternative, pad); break;
 case 'S': handler.on_second(numeric_system::alternative, pad); break;
 case 'z': handler.on_utc_offset(numeric_system::alternative); break;
 default: FMT_THROW(format_error("invalid format"));
 }
 break;
 default: FMT_THROW(format_error("invalid format"));
 }
 begin = ptr;
 }
 if (begin != ptr) handler.on_text(begin, ptr);
 return ptr;
}

template <typename Derived> struct null_chrono_spec_handler {
 FMT_CONSTEXPR void unsupported() {
 static_cast<Derived*>(this)->unsupported();
 }
 FMT_CONSTEXPR void on_year(numeric_system) { unsupported(); }
 FMT_CONSTEXPR void on_short_year(numeric_system) { unsupported(); }
 FMT_CONSTEXPR void on_offset_year() { unsupported(); }
 FMT_CONSTEXPR void on_century(numeric_system) { unsupported(); }
 FMT_CONSTEXPR void on_iso_week_based_year() { unsupported(); }
 FMT_CONSTEXPR void on_iso_week_based_short_year() { unsupported(); }
 FMT_CONSTEXPR void on_abbr_weekday() { unsupported(); }
 FMT_CONSTEXPR void on_full_weekday() { unsupported(); }
 FMT_CONSTEXPR void on_dec0_weekday(numeric_system) { unsupported(); }
 FMT_CONSTEXPR void on_dec1_weekday(numeric_system) { unsupported(); }
 FMT_CONSTEXPR void on_abbr_month() { unsupported(); }
 FMT_CONSTEXPR void on_full_month() { unsupported(); }
 FMT_CONSTEXPR void on_dec_month(numeric_system) { unsupported(); }
 FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system, pad_type) {
 unsupported();
 }
 FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system, pad_type) {
 unsupported();
 }
 FMT_CONSTEXPR void on_iso_week_of_year(numeric_system, pad_type) {
 unsupported();
 }
 FMT_CONSTEXPR void on_day_of_year() { unsupported(); }
 FMT_CONSTEXPR void on_day_of_month(numeric_system, pad_type) {
 unsupported();
 }
 FMT_CONSTEXPR void on_24_hour(numeric_system) { unsupported(); }
 FMT_CONSTEXPR void on_12_hour(numeric_system) { unsupported(); }
 FMT_CONSTEXPR void on_minute(numeric_system) { unsupported(); }
 FMT_CONSTEXPR void on_second(numeric_system) { unsupported(); }
 FMT_CONSTEXPR void on_datetime(numeric_system) { unsupported(); }
 FMT_CONSTEXPR void on_loc_date(numeric_system) { unsupported(); }
 FMT_CONSTEXPR void on_loc_time(numeric_system) { unsupported(); }
 FMT_CONSTEXPR void on_us_date() { unsupported(); }
 FMT_CONSTEXPR void on_iso_date() { unsupported(); }
 FMT_CONSTEXPR void on_12_hour_time() { unsupported(); }
 FMT_CONSTEXPR void on_24_hour_time() { unsupported(); }
 FMT_CONSTEXPR void on_iso_time() { unsupported(); }
 FMT_CONSTEXPR void on_am_pm() { unsupported(); }
 FMT_CONSTEXPR void on_duration_value() { unsupported(); }
 FMT_CONSTEXPR void on_duration_unit() { unsupported(); }
 FMT_CONSTEXPR void on_utc_offset(numeric_system) { unsupported(); }
 FMT_CONSTEXPR void on_tz_name() { unsupported(); }
};

struct tm_format_checker : null_chrono_spec_handler<tm_format_checker> {
 FMT_NORETURN void unsupported() { FMT_THROW(format_error("no format")); }

template <typename Char>
 FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
 FMT_CONSTEXPR void on_year(numeric_system) {}
 FMT_CONSTEXPR void on_short_year(numeric_system) {}
 FMT_CONSTEXPR void on_offset_year() {}
 FMT_CONSTEXPR void on_century(numeric_system) {}
 FMT_CONSTEXPR void on_iso_week_based_year() {}
 FMT_CONSTEXPR void on_iso_week_based_short_year() {}
 FMT_CONSTEXPR void on_abbr_weekday() {}
 FMT_CONSTEXPR void on_full_weekday() {}
 FMT_CONSTEXPR void on_dec0_weekday(numeric_system) {}
 FMT_CONSTEXPR void on_dec1_weekday(numeric_system) {}
 FMT_CONSTEXPR void on_abbr_month() {}
 FMT_CONSTEXPR void on_full_month() {}
 FMT_CONSTEXPR void on_dec_month(numeric_system) {}
 FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system, pad_type) {}
 FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system, pad_type) {}
 FMT_CONSTEXPR void on_iso_week_of_year(numeric_system, pad_type) {}
 FMT_CONSTEXPR void on_day_of_year() {}
 FMT_CONSTEXPR void on_day_of_month(numeric_system, pad_type) {}
 FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {}
 FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {}
 FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {}
 FMT_CONSTEXPR void on_second(numeric_system, pad_type) {}
 FMT_CONSTEXPR void on_datetime(numeric_system) {}
 FMT_CONSTEXPR void on_loc_date(numeric_system) {}
 FMT_CONSTEXPR void on_loc_time(numeric_system) {}
 FMT_CONSTEXPR void on_us_date() {}
 FMT_CONSTEXPR void on_iso_date() {}
 FMT_CONSTEXPR void on_12_hour_time() {}
 FMT_CONSTEXPR void on_24_hour_time() {}
 FMT_CONSTEXPR void on_iso_time() {}
 FMT_CONSTEXPR void on_am_pm() {}
 FMT_CONSTEXPR void on_utc_offset(numeric_system) {}
 FMT_CONSTEXPR void on_tz_name() {}
};

inline auto tm_wday_full_name(int wday) -> const char* {
 static constexpr const char* full_name_list[] = {
 "Sunday", "Monday", "Tuesday", "Wednesday",
 "Thursday", "Friday", "Saturday"};
 return wday >= 0 && wday <= 6 ? full_name_list[wday] : "?";
}
inline auto tm_wday_short_name(int wday) -> const char* {
 static constexpr const char* short_name_list[] = {"Sun", "Mon", "Tue", "Wed",
 "Thu", "Fri", "Sat"};
 return wday >= 0 && wday <= 6 ? short_name_list[wday] : "???";
}

inline auto tm_mon_full_name(int mon) -> const char* {
 static constexpr const char* full_name_list[] = {
 "January", "February", "March", "April", "May", "June",
 "July", "August", "September", "October", "November", "December"};
 return mon >= 0 && mon <= 11 ? full_name_list[mon] : "?";
}
inline auto tm_mon_short_name(int mon) -> const char* {
 static constexpr const char* short_name_list[] = {
 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
 };
 return mon >= 0 && mon <= 11 ? short_name_list[mon] : "???";
}

template <typename T, typename = void>
struct has_member_data_tm_gmtoff : std::false_type {};
template <typename T>
struct has_member_data_tm_gmtoff<T, void_t<decltype(T::tm_gmtoff)>>
 : std::true_type {};

template <typename T, typename = void>
struct has_member_data_tm_zone : std::false_type {};
template <typename T>
struct has_member_data_tm_zone<T, void_t<decltype(T::tm_zone)>>
 : std::true_type {};

inline void tzset_once() {
  static bool init = []() {
    using namespace fmt_detail;
    _tzset();
    return false;
  }();
  ignore_unused(init);
}

// Converts value to Int and checks that it's in the range [0, upper).
template <typename T, typename Int, FMT_ENABLE_IF(std::is_integral<T>::value)>
inline auto to_nonnegative_int(T value, Int upper) -> Int {
 if (!std::is_unsigned<Int>::value &&
 (value < 0 || to_unsigned(value) > to_unsigned(upper))) {
 FMT_THROW(fmt::format_error("chrono value is out of range"));
 }
 return static_cast<Int>(value);
}
template <typename T, typename Int, FMT_ENABLE_IF(!std::is_integral<T>::value)>
inline auto to_nonnegative_int(T value, Int upper) -> Int {
 auto int_value = static_cast<Int>(value);
 if (int_value < 0 || value > static_cast<T>(upper))
 FMT_THROW(format_error("invalid value"));
 return int_value;
}

constexpr auto pow10(std::uint32_t n) -> long long {
  return n == 0 ? 1 : 10 * pow10(n - 1);
}

// Counts the number of fractional digits in the range [0, 18] according to the
// C++20 spec. If more than 18 fractional digits are required then returns 6 for
// microseconds precision.
template <long long Num, long long Den, int N = 0,
 bool Enabled = (N < 19) && (Num <= max_value<long long>() / 10)>
struct count_fractional_digits {
 static constexpr int value =
 Num % Den == 0 ? N : count_fractional_digits<Num * 10, Den, N + 1>::value;
};

// Base case that doesn't instantiate any more templates
// in order to avoid overflow.
template <long long Num, long long Den, int N>
struct count_fractional_digits<Num, Den, N, false> {
 static constexpr int value = (Num % Den == 0) ? N : 6;
};

// Format subseconds which are given as an integer type with an appropriate
// number of digits.
template <typename Char, typename OutputIt, typename Duration>
void write_fractional_seconds(OutputIt& out, Duration d, int precision = -1) {
 constexpr auto num_fractional_digits =
 count_fractional_digits<Duration::period::num,
 Duration::period::den>::value;

using subsecond_precision = std::chrono::duration<
 typename std::common_type<typename Duration::rep,
 std::chrono::seconds::rep>::type,
 std::ratio<1, pow10(num_fractional_digits)>>;

const auto fractional = d - detail::duration_cast<std::chrono::seconds>(d);
 const auto subseconds =
 std::chrono::treat_as_floating_point<
 typename subsecond_precision::rep>::value
 ? fractional.count()
 : detail::duration_cast<subsecond_precision>(fractional).count();
 auto n = static_cast<uint32_or_64_or_128_t<long long>>(subseconds);
 const int num_digits = count_digits(n);

int leading_zeroes = (std::max)(0, num_fractional_digits - num_digits);
 if (precision < 0) {
 FMT_ASSERT(!std::is_floating_point<typename Duration::rep>::value, "");
 if (std::ratio_less<typename subsecond_precision::period,
 std::chrono::seconds::period>::value) {
 *out++ = '.';
 out = detail::fill_n(out, leading_zeroes, '0');
 out = format_decimal<Char>(out, n, num_digits);
 }
 } else if (precision > 0) {
 *out++ = '.';
 leading_zeroes = (std::min)(leading_zeroes, precision);
 int remaining = precision - leading_zeroes;
 out = detail::fill_n(out, leading_zeroes, '0');
 if (remaining < num_digits) {
 int num_truncated_digits = num_digits - remaining;
 n /= to_unsigned(pow10(to_unsigned(num_truncated_digits)));
 if (n != 0) out = format_decimal<Char>(out, n, remaining);
 return;
 }
 if (n != 0) {
 out = format_decimal<Char>(out, n, num_digits);
 remaining -= num_digits;
 }
 out = detail::fill_n(out, remaining, '0');
 }
}

// Format subseconds which are given as a floating point type with an
// appropriate number of digits. We cannot pass the Duration here, as we
// explicitly need to pass the Rep value in the chrono_formatter.
template <typename Duration>
void write_floating_seconds(memory_buffer& buf, Duration duration,
 int num_fractional_digits = -1) {
 using rep = typename Duration::rep;
 FMT_ASSERT(std::is_floating_point<rep>::value, "");

auto val = duration.count();

if (num_fractional_digits < 0) {
 // For `std::round` with fallback to `round`:
 // On some toolchains `std::round` is not available (e.g. GCC 6).
 using namespace std;
 num_fractional_digits =
 count_fractional_digits<Duration::period::num,
 Duration::period::den>::value;
 if (num_fractional_digits < 6 && static_cast<rep>(round(val)) != val)
 num_fractional_digits = 6;
 }

fmt::format_to(std::back_inserter(buf), FMT_STRING("{:.{}f}"),
 std::fmod(val * static_cast<rep>(Duration::period::num) /
 static_cast<rep>(Duration::period::den),
 static_cast<rep>(60)),
 num_fractional_digits);
}

template <typename OutputIt, typename Char,
 typename Duration = std::chrono::seconds>
class tm_writer {
 private:
 static constexpr int days_per_week = 7;

const std::locale& loc_;
  const bool is_classic_;
  OutputIt out_;
  const Duration* subsecs_;
  const std::tm& tm_;

auto tm_sec() const noexcept -> int {
 FMT_ASSERT(tm_.tm_sec >= 0 && tm_.tm_sec <= 61, "");
 return tm_.tm_sec;
 }
 auto tm_min() const noexcept -> int {
 FMT_ASSERT(tm_.tm_min >= 0 && tm_.tm_min <= 59, "");
 return tm_.tm_min;
 }
 auto tm_hour() const noexcept -> int {
 FMT_ASSERT(tm_.tm_hour >= 0 && tm_.tm_hour <= 23, "");
 return tm_.tm_hour;
 }
 auto tm_mday() const noexcept -> int {
 FMT_ASSERT(tm_.tm_mday >= 1 && tm_.tm_mday <= 31, "");
 return tm_.tm_mday;
 }
 auto tm_mon() const noexcept -> int {
 FMT_ASSERT(tm_.tm_mon >= 0 && tm_.tm_mon <= 11, "");
 return tm_.tm_mon;
 }
 auto tm_year() const noexcept -> long long { return 1900ll + tm_.tm_year; }
 auto tm_wday() const noexcept -> int {
 FMT_ASSERT(tm_.tm_wday >= 0 && tm_.tm_wday <= 6, "");
 return tm_.tm_wday;
 }
 auto tm_yday() const noexcept -> int {
 FMT_ASSERT(tm_.tm_yday >= 0 && tm_.tm_yday <= 365, "");
 return tm_.tm_yday;
 }

auto tm_hour12() const noexcept -> int {
 const auto h = tm_hour();
 const auto z = h < 12 ? h : h - 12;
 return z == 0 ? 12 : z;
 }

// POSIX and the C Standard are unclear or inconsistent about what %C and %y
 // do if the year is negative or exceeds 9999. Use the convention that %C
 // concatenated with %y yields the same output as %Y, and that %Y contains at
 // least 4 characters, with more only if necessary.
 auto split_year_lower(long long year) const noexcept -> int {
 auto l = year % 100;
 if (l < 0) l = -l; // l in [0, 99]
 return static_cast<int>(l);
 }

// Algorithm: https://en.wikipedia.org/wiki/ISO_week_date.
 auto iso_year_weeks(long long curr_year) const noexcept -> int {
 const auto prev_year = curr_year - 1;
 const auto curr_p =
 (curr_year + curr_year / 4 - curr_year / 100 + curr_year / 400) %
 days_per_week;
 const auto prev_p =
 (prev_year + prev_year / 4 - prev_year / 100 + prev_year / 400) %
 days_per_week;
 return 52 + ((curr_p == 4 || prev_p == 3) ? 1 : 0);
 }
 auto iso_week_num(int tm_yday, int tm_wday) const noexcept -> int {
 return (tm_yday + 11 - (tm_wday == 0 ? days_per_week : tm_wday)) /
 days_per_week;
 }
 auto tm_iso_week_year() const noexcept -> long long {
 const auto year = tm_year();
 const auto w = iso_week_num(tm_yday(), tm_wday());
 if (w < 1) return year - 1;
 if (w > iso_year_weeks(year)) return year + 1;
 return year;
 }
 auto tm_iso_week_of_year() const noexcept -> int {
 const auto year = tm_year();
 const auto w = iso_week_num(tm_yday(), tm_wday());
 if (w < 1) return iso_year_weeks(year - 1);
 if (w > iso_year_weeks(year)) return 1;
 return w;
 }

void write1(int value) {
 *out_++ = static_cast<char>('0' + to_unsigned(value) % 10);
 }
 void write2(int value) {
 const char* d = digits2(to_unsigned(value) % 100);
 *out_++ = *d++;
 *out_++ = *d;
 }
 void write2(int value, pad_type pad) {
 unsigned int v = to_unsigned(value) % 100;
 if (v >= 10) {
 const char* d = digits2(v);
 *out_++ = *d++;
 *out_++ = *d;
 } else {
 out_ = detail::write_padding(out_, pad);
 *out_++ = static_cast<char>('0' + v);
 }
 }

void write_year_extended(long long year) {
 // At least 4 characters.
 int width = 4;
 if (year < 0) {
 *out_++ = '-';
 year = 0 - year;
 --width;
 }
 uint32_or_64_or_128_t<long long> n = to_unsigned(year);
 const int num_digits = count_digits(n);
 if (width > num_digits)
 out_ = detail::fill_n(out_, width - num_digits, '0');
 out_ = format_decimal<Char>(out_, n, num_digits);
 }
 void write_year(long long year) {
 if (year >= 0 && year < 10000) {
 write2(static_cast<int>(year / 100));
 write2(static_cast<int>(year % 100));
 } else {
 write_year_extended(year);
 }
 }

void write_utc_offset(long offset, numeric_system ns) {
 if (offset < 0) {
 *out_++ = '-';
 offset = -offset;
 } else {
 *out_++ = '+';
 }
 offset /= 60;
 write2(static_cast<int>(offset / 60));
 if (ns != numeric_system::standard) *out_++ = ':';
 write2(static_cast<int>(offset % 60));
 }

template <typename T, FMT_ENABLE_IF(has_member_data_tm_gmtoff<T>::value)>
 void format_utc_offset_impl(const T& tm, numeric_system ns) {
 write_utc_offset(tm.tm_gmtoff, ns);
 }
 template <typename T, FMT_ENABLE_IF(!has_member_data_tm_gmtoff<T>::value)>
 void format_utc_offset_impl(const T& tm, numeric_system ns) {
#if defined(_WIN32) && defined(_UCRT)
 tzset_once();
 long offset = 0;
 _get_timezone(&offset);
 if (tm.tm_isdst) {
 long dstbias = 0;
 _get_dstbias(&dstbias);
 offset += dstbias;
 }
 write_utc_offset(-offset, ns);
#else
 if (ns == numeric_system::standard) return format_localized('z');

// Extract timezone offset from timezone conversion functions.
    std::tm gtm = tm;
    std::time_t gt = std::mktime(&gtm);
    std::tm ltm = gmtime(gt);
    std::time_t lt = std::mktime(&ltm);
    long offset = gt - lt;
    write_utc_offset(offset, ns);
#endif
  }

template <typename T, FMT_ENABLE_IF(has_member_data_tm_zone<T>::value)>
 void format_tz_name_impl(const T& tm) {
 if (is_classic_)
 out_ = write_tm_str<Char>(out_, tm.tm_zone, loc_);
 else
 format_localized('Z');
 }
 template <typename T, FMT_ENABLE_IF(!has_member_data_tm_zone<T>::value)>
 void format_tz_name_impl(const T&) {
 format_localized('Z');
 }

void format_localized(char format, char modifier = 0) {
 out_ = write<Char>(out_, tm_, loc_, format, modifier);
 }

public:
  tm_writer(const std::locale& loc, OutputIt out, const std::tm& tm,
            const Duration* subsecs = nullptr)
      : loc_(loc),
        is_classic_(loc_ == get_classic_locale()),
        out_(out),
        subsecs_(subsecs),
        tm_(tm) {}

auto out() const -> OutputIt { return out_; }

FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) {
 out_ = copy<Char>(begin, end, out_);
 }

void on_abbr_weekday() {
    if (is_classic_)
      out_ = write(out_, tm_wday_short_name(tm_wday()));
    else
      format_localized('a');
  }
  void on_full_weekday() {
    if (is_classic_)
      out_ = write(out_, tm_wday_full_name(tm_wday()));
    else
      format_localized('A');
  }
  void on_dec0_weekday(numeric_system ns) {
    if (is_classic_ || ns == numeric_system::standard) return write1(tm_wday());
    format_localized('w', 'O');
  }
  void on_dec1_weekday(numeric_system ns) {
    if (is_classic_ || ns == numeric_system::standard) {
      auto wday = tm_wday();
      write1(wday == 0 ? days_per_week : wday);
    } else {
      format_localized('u', 'O');
    }
  }

void on_abbr_month() {
    if (is_classic_)
      out_ = write(out_, tm_mon_short_name(tm_mon()));
    else
      format_localized('b');
  }
  void on_full_month() {
    if (is_classic_)
      out_ = write(out_, tm_mon_full_name(tm_mon()));
    else
      format_localized('B');
  }

void on_datetime(numeric_system ns) {
 if (is_classic_) {
 on_abbr_weekday();
 *out_++ = ' ';
 on_abbr_month();
 *out_++ = ' ';
 on_day_of_month(numeric_system::standard, pad_type::space);
 *out_++ = ' ';
 on_iso_time();
 *out_++ = ' ';
 on_year(numeric_system::standard);
 } else {
 format_localized('c', ns == numeric_system::standard ? '\0' : 'E');
 }
 }
 void on_loc_date(numeric_system ns) {
 if (is_classic_)
 on_us_date();
 else
 format_localized('x', ns == numeric_system::standard ? '\0' : 'E');
 }
 void on_loc_time(numeric_system ns) {
 if (is_classic_)
 on_iso_time();
 else
 format_localized('X', ns == numeric_system::standard ? '\0' : 'E');
 }
 void on_us_date() {
 char buf[8];
 write_digit2_separated(buf, to_unsigned(tm_mon() + 1),
 to_unsigned(tm_mday()),
 to_unsigned(split_year_lower(tm_year())), '/');
 out_ = copy<Char>(std::begin(buf), std::end(buf), out_);
 }
 void on_iso_date() {
 auto year = tm_year();
 char buf[10];
 size_t offset = 0;
 if (year >= 0 && year < 10000) {
 write2digits(buf, static_cast<size_t>(year / 100));
 } else {
 offset = 4;
 write_year_extended(year);
 year = 0;
 }
 write_digit2_separated(buf + 2, static_cast<unsigned>(year % 100),
 to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()),
 '-');
 out_ = copy<Char>(std::begin(buf) + offset, std::end(buf), out_);
 }

void on_utc_offset(numeric_system ns) { format_utc_offset_impl(tm_, ns); }
  void on_tz_name() { format_tz_name_impl(tm_); }

void on_year(numeric_system ns) {
    if (is_classic_ || ns == numeric_system::standard)
      return write_year(tm_year());
    format_localized('Y', 'E');
  }
  void on_short_year(numeric_system ns) {
    if (is_classic_ || ns == numeric_system::standard)
      return write2(split_year_lower(tm_year()));
    format_localized('y', 'O');
  }
  void on_offset_year() {
    if (is_classic_) return write2(split_year_lower(tm_year()));
    format_localized('y', 'E');
  }

void on_century(numeric_system ns) {
 if (is_classic_ || ns == numeric_system::standard) {
 auto year = tm_year();
 auto upper = year / 100;
 if (year >= -99 && year < 0) {
 // Zero upper on negative year.
 *out_++ = '-';
 *out_++ = '0';
 } else if (upper >= 0 && upper < 100) {
 write2(static_cast<int>(upper));
 } else {
 out_ = write<Char>(out_, upper);
 }
 } else {
 format_localized('C', 'E');
 }
 }

void on_dec_month(numeric_system ns) {
    if (is_classic_ || ns == numeric_system::standard)
      return write2(tm_mon() + 1);
    format_localized('m', 'O');
  }

void on_dec0_week_of_year(numeric_system ns, pad_type pad) {
    if (is_classic_ || ns == numeric_system::standard)
      return write2((tm_yday() + days_per_week - tm_wday()) / days_per_week,
                    pad);
    format_localized('U', 'O');
  }
  void on_dec1_week_of_year(numeric_system ns, pad_type pad) {
    if (is_classic_ || ns == numeric_system::standard) {
      auto wday = tm_wday();
      write2((tm_yday() + days_per_week -
              (wday == 0 ? (days_per_week - 1) : (wday - 1))) /
                 days_per_week,
             pad);
    } else {
      format_localized('W', 'O');
    }
  }
  void on_iso_week_of_year(numeric_system ns, pad_type pad) {
    if (is_classic_ || ns == numeric_system::standard)
      return write2(tm_iso_week_of_year(), pad);
    format_localized('V', 'O');
  }

void on_iso_week_based_year() { write_year(tm_iso_week_year()); }
  void on_iso_week_based_short_year() {
    write2(split_year_lower(tm_iso_week_year()));
  }

void on_day_of_year() {
    auto yday = tm_yday() + 1;
    write1(yday / 100);
    write2(yday % 100);
  }
  void on_day_of_month(numeric_system ns, pad_type pad) {
    if (is_classic_ || ns == numeric_system::standard)
      return write2(tm_mday(), pad);
    format_localized('d', 'O');
  }

void on_24_hour(numeric_system ns, pad_type pad) {
    if (is_classic_ || ns == numeric_system::standard)
      return write2(tm_hour(), pad);
    format_localized('H', 'O');
  }
  void on_12_hour(numeric_system ns, pad_type pad) {
    if (is_classic_ || ns == numeric_system::standard)
      return write2(tm_hour12(), pad);
    format_localized('I', 'O');
  }
  void on_minute(numeric_system ns, pad_type pad) {
    if (is_classic_ || ns == numeric_system::standard)
      return write2(tm_min(), pad);
    format_localized('M', 'O');
  }

void on_second(numeric_system ns, pad_type pad) {
 if (is_classic_ || ns == numeric_system::standard) {
 write2(tm_sec(), pad);
 if (subsecs_) {
 if (std::is_floating_point<typename Duration::rep>::value) {
 auto buf = memory_buffer();
 write_floating_seconds(buf, *subsecs_);
 if (buf.size() > 1) {
 // Remove the leading "0", write something like ".123".
 out_ = copy<Char>(buf.begin() + 1, buf.end(), out_);
 }
 } else {
 write_fractional_seconds<Char>(out_, *subsecs_);
 }
 }
 } else {
 // Currently no formatting of subseconds when a locale is set.
 format_localized('S', 'O');
 }
 }

void on_12_hour_time() {
 if (is_classic_) {
 char buf[8];
 write_digit2_separated(buf, to_unsigned(tm_hour12()),
 to_unsigned(tm_min()), to_unsigned(tm_sec()), ':');
 out_ = copy<Char>(std::begin(buf), std::end(buf), out_);
 *out_++ = ' ';
 on_am_pm();
 } else {
 format_localized('r');
 }
 }
 void on_24_hour_time() {
 write2(tm_hour());
 *out_++ = ':';
 write2(tm_min());
 }
 void on_iso_time() {
 on_24_hour_time();
 *out_++ = ':';
 on_second(numeric_system::standard, pad_type::zero);
 }

void on_am_pm() {
 if (is_classic_) {
 *out_++ = tm_hour() < 12 ? 'A' : 'P';
 *out_++ = 'M';
 } else {
 format_localized('p');
 }
 }

// These apply to chrono durations but not tm.
  void on_duration_value() {}
  void on_duration_unit() {}
};

struct chrono_format_checker : null_chrono_spec_handler<chrono_format_checker> {
 bool has_precision_integral = false;

FMT_NORETURN void unsupported() { FMT_THROW(format_error("no date")); }

template <typename Char>
 FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
 FMT_CONSTEXPR void on_day_of_year() {}
 FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {}
 FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {}
 FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {}
 FMT_CONSTEXPR void on_second(numeric_system, pad_type) {}
 FMT_CONSTEXPR void on_12_hour_time() {}
 FMT_CONSTEXPR void on_24_hour_time() {}
 FMT_CONSTEXPR void on_iso_time() {}
 FMT_CONSTEXPR void on_am_pm() {}
 FMT_CONSTEXPR void on_duration_value() const {
 if (has_precision_integral) {
 FMT_THROW(format_error("precision not allowed for this argument type"));
 }
 }
 FMT_CONSTEXPR void on_duration_unit() {}
};

template <typename T,
 FMT_ENABLE_IF(std::is_integral<T>::value&& has_isfinite<T>::value)>
inline auto isfinite(T) -> bool {
 return true;
}

template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
inline auto mod(T x, int y) -> T {
 return x % static_cast<T>(y);
}
template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
inline auto mod(T x, int y) -> T {
 return std::fmod(x, static_cast<T>(y));
}

// If T is an integral type, maps T to its unsigned counterpart, otherwise
// leaves it unchanged (unlike std::make_unsigned).
template <typename T, bool INTEGRAL = std::is_integral<T>::value>
struct make_unsigned_or_unchanged {
 using type = T;
};

template <typename T> struct make_unsigned_or_unchanged<T, true> {
 using type = typename std::make_unsigned<T>::type;
};

template <typename Rep, typename Period,
 FMT_ENABLE_IF(std::is_integral<Rep>::value)>
inline auto get_milliseconds(std::chrono::duration<Rep, Period> d)
 -> std::chrono::duration<Rep, std::milli> {
 // this may overflow and/or the result may not fit in the
 // target type.
#if FMT_SAFE_DURATION_CAST
 using CommonSecondsType =
 typename std::common_type<decltype(d), std::chrono::seconds>::type;
 const auto d_as_common = detail::duration_cast<CommonSecondsType>(d);
 const auto d_as_whole_seconds =
 detail::duration_cast<std::chrono::seconds>(d_as_common);
 // this conversion should be nonproblematic
 const auto diff = d_as_common - d_as_whole_seconds;
 const auto ms =
 detail::duration_cast<std::chrono::duration<Rep, std::milli>>(diff);
 return ms;
#else
 auto s = detail::duration_cast<std::chrono::seconds>(d);
 return detail::duration_cast<std::chrono::milliseconds>(d - s);
#endif
}

template <typename Char, typename Rep, typename OutputIt,
 FMT_ENABLE_IF(std::is_integral<Rep>::value)>
auto format_duration_value(OutputIt out, Rep val, int) -> OutputIt {
 return write<Char>(out, val);
}

template <typename Char, typename Rep, typename OutputIt,
 FMT_ENABLE_IF(std::is_floating_point<Rep>::value)>
auto format_duration_value(OutputIt out, Rep val, int precision) -> OutputIt {
 auto specs = format_specs();
 specs.precision = precision;
 specs.set_type(precision >= 0 ? presentation_type::fixed
 : presentation_type::general);
 return write<Char>(out, val, specs);
}

template <typename Char, typename OutputIt>
auto copy_unit(string_view unit, OutputIt out, Char) -> OutputIt {
 return copy<Char>(unit.begin(), unit.end(), out);
}

template <typename OutputIt>
auto copy_unit(string_view unit, OutputIt out, wchar_t) -> OutputIt {
 // This works when wchar_t is UTF-32 because units only contain characters
 // that have the same representation in UTF-16 and UTF-32.
 utf8_to_utf16 u(unit);
 return copy<wchar_t>(u.c_str(), u.c_str() + u.size(), out);
}

template <typename Char, typename Period, typename OutputIt>
auto format_duration_unit(OutputIt out) -> OutputIt {
 if (const char* unit = get_units<Period>())
 return copy_unit(string_view(unit), out, Char());
 *out++ = '[';
 out = write<Char>(out, Period::num);
 if (const_check(Period::den != 1)) {
 *out++ = '/';
 out = write<Char>(out, Period::den);
 }
 *out++ = ']';
 *out++ = 's';
 return out;
}

class get_locale {
 private:
  union {
    std::locale locale_;
  };
  bool has_locale_ = false;

public:
 get_locale(bool localized, locale_ref loc) : has_locale_(localized) {
 if (localized)
 ::new (&locale_) std::locale(loc.template get<std::locale>());
 }
 ~get_locale() {
 if (has_locale_) locale_.~locale();
 }
 operator const std::locale&() const {
 return has_locale_ ? locale_ : get_classic_locale();
 }
};

template <typename FormatContext, typename OutputIt, typename Rep,
 typename Period>
struct chrono_formatter {
 FormatContext& context;
 OutputIt out;
 int precision;
 bool localized = false;
 // rep is unsigned to avoid overflow.
 using rep =
 conditional_t<std::is_integral<Rep>::value && sizeof(Rep) < sizeof(int),
 unsigned, typename make_unsigned_or_unchanged<Rep>::type>;
 rep val;
 using seconds = std::chrono::duration<rep>;
 seconds s;
 using milliseconds = std::chrono::duration<rep, std::milli>;
 bool negative;

using char_type = typename FormatContext::char_type;
 using tm_writer_type = tm_writer<OutputIt, char_type>;

chrono_formatter(FormatContext& ctx, OutputIt o,
 std::chrono::duration<Rep, Period> d)
 : context(ctx),
 out(o),
 val(static_cast<rep>(d.count())),
 negative(false) {
 if (d.count() < 0) {
 val = 0 - val;
 negative = true;
 }

// this may overflow and/or the result may not fit in the
 // target type.
 // might need checked conversion (rep!=Rep)
 s = detail::duration_cast<seconds>(std::chrono::duration<rep, Period>(val));
 }

// returns true if nan or inf, writes to out.
  auto handle_nan_inf() -> bool {
    if (isfinite(val)) {
      return false;
    }
    if (isnan(val)) {
      write_nan();
      return true;
    }
    // must be +-inf
    if (val > 0) {
      write_pinf();
    } else {
      write_ninf();
    }
    return true;
  }

auto days() const -> Rep { return static_cast<Rep>(s.count() / 86400); }
 auto hour() const -> Rep {
 return static_cast<Rep>(mod((s.count() / 3600), 24));
 }

auto hour12() const -> Rep {
 Rep hour = static_cast<Rep>(mod((s.count() / 3600), 12));
 return hour <= 0 ? 12 : hour;
 }

auto minute() const -> Rep {
 return static_cast<Rep>(mod((s.count() / 60), 60));
 }
 auto second() const -> Rep { return static_cast<Rep>(mod(s.count(), 60)); }

auto time() const -> std::tm {
    auto time = std::tm();
    time.tm_hour = to_nonnegative_int(hour(), 24);
    time.tm_min = to_nonnegative_int(minute(), 60);
    time.tm_sec = to_nonnegative_int(second(), 60);
    return time;
  }

void write_sign() {
    if (negative) {
      *out++ = '-';
      negative = false;
    }
  }

void write(Rep value, int width, pad_type pad = pad_type::zero) {
 write_sign();
 if (isnan(value)) return write_nan();
 uint32_or_64_or_128_t<int> n =
 to_unsigned(to_nonnegative_int(value, max_value<int>()));
 int num_digits = detail::count_digits(n);
 if (width > num_digits) {
 out = detail::write_padding(out, pad, width - num_digits);
 }
 out = format_decimal<char_type>(out, n, num_digits);
 }

void write_nan() { std::copy_n("nan", 3, out); }
  void write_pinf() { std::copy_n("inf", 3, out); }
  void write_ninf() { std::copy_n("-inf", 4, out); }

template <typename Callback, typename... Args>
 void format_tm(const tm& time, Callback cb, Args... args) {
 if (isnan(val)) return write_nan();
 get_locale loc(localized, context.locale());
 auto w = tm_writer_type(loc, out, time);
 (w.*cb)(args...);
 out = w.out();
 }

void on_text(const char_type* begin, const char_type* end) {
 copy<char_type>(begin, end, out);
 }

// These are not implemented because durations don't have date information.
  void on_abbr_weekday() {}
  void on_full_weekday() {}
  void on_dec0_weekday(numeric_system) {}
  void on_dec1_weekday(numeric_system) {}
  void on_abbr_month() {}
  void on_full_month() {}
  void on_datetime(numeric_system) {}
  void on_loc_date(numeric_system) {}
  void on_loc_time(numeric_system) {}
  void on_us_date() {}
  void on_iso_date() {}
  void on_utc_offset(numeric_system) {}
  void on_tz_name() {}
  void on_year(numeric_system) {}
  void on_short_year(numeric_system) {}
  void on_offset_year() {}
  void on_century(numeric_system) {}
  void on_iso_week_based_year() {}
  void on_iso_week_based_short_year() {}
  void on_dec_month(numeric_system) {}
  void on_dec0_week_of_year(numeric_system, pad_type) {}
  void on_dec1_week_of_year(numeric_system, pad_type) {}
  void on_iso_week_of_year(numeric_system, pad_type) {}
  void on_day_of_month(numeric_system, pad_type) {}

void on_day_of_year() {
    if (handle_nan_inf()) return;
    write(days(), 0);
  }

void on_24_hour(numeric_system ns, pad_type pad) {
    if (handle_nan_inf()) return;

if (ns == numeric_system::standard) return write(hour(), 2, pad);
    auto time = tm();
    time.tm_hour = to_nonnegative_int(hour(), 24);
    format_tm(time, &tm_writer_type::on_24_hour, ns, pad);
  }

void on_12_hour(numeric_system ns, pad_type pad) {
    if (handle_nan_inf()) return;

if (ns == numeric_system::standard) return write(hour12(), 2, pad);
    auto time = tm();
    time.tm_hour = to_nonnegative_int(hour12(), 12);
    format_tm(time, &tm_writer_type::on_12_hour, ns, pad);
  }

void on_minute(numeric_system ns, pad_type pad) {
    if (handle_nan_inf()) return;

if (ns == numeric_system::standard) return write(minute(), 2, pad);
    auto time = tm();
    time.tm_min = to_nonnegative_int(minute(), 60);
    format_tm(time, &tm_writer_type::on_minute, ns, pad);
  }

void on_second(numeric_system ns, pad_type pad) {
    if (handle_nan_inf()) return;

if (ns == numeric_system::standard) {
 if (std::is_floating_point<rep>::value) {
 auto buf = memory_buffer();
 write_floating_seconds(buf, std::chrono::duration<rep, Period>(val),
 precision);
 if (negative) *out++ = '-';
 if (buf.size() < 2 || buf[1] == '.') {
 out = detail::write_padding(out, pad);
 }
 out = copy<char_type>(buf.begin(), buf.end(), out);
 } else {
 write(second(), 2, pad);
 write_fractional_seconds<char_type>(
 out, std::chrono::duration<rep, Period>(val), precision);
 }
 return;
 }
 auto time = tm();
 time.tm_sec = to_nonnegative_int(second(), 60);
 format_tm(time, &tm_writer_type::on_second, ns, pad);
 }

void on_12_hour_time() {
    if (handle_nan_inf()) return;
    format_tm(time(), &tm_writer_type::on_12_hour_time);
  }

void on_24_hour_time() {
    if (handle_nan_inf()) {
      *out++ = ':';
      handle_nan_inf();
      return;
    }

write(hour(), 2);
    *out++ = ':';
    write(minute(), 2);
  }

void on_iso_time() {
    on_24_hour_time();
    *out++ = ':';
    if (handle_nan_inf()) return;
    on_second(numeric_system::standard, pad_type::zero);
  }

void on_am_pm() {
    if (handle_nan_inf()) return;
    format_tm(time(), &tm_writer_type::on_am_pm);
  }

void on_duration_value() {
 if (handle_nan_inf()) return;
 write_sign();
 out = format_duration_value<char_type>(out, val, precision);
 }

void on_duration_unit() {
 out = format_duration_unit<char_type, Period>(out);
 }
};

}  // namespace detail

#if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907
using weekday = std::chrono::weekday;
using day = std::chrono::day;
using month = std::chrono::month;
using year = std::chrono::year;
using year_month_day = std::chrono::year_month_day;
#else
// A fallback version of weekday.
class weekday {
 private:
  unsigned char value_;

public:
 weekday() = default;
 constexpr explicit weekday(unsigned wd) noexcept
 : value_(static_cast<unsigned char>(wd != 7 ? wd : 0)) {}
 constexpr auto c_encoding() const noexcept -> unsigned { return value_; }
};

class day {
 private:
  unsigned char value_;

public:
 day() = default;
 constexpr explicit day(unsigned d) noexcept
 : value_(static_cast<unsigned char>(d)) {}
 constexpr explicit operator unsigned() const noexcept { return value_; }
};

class month {
 private:
  unsigned char value_;

public:
 month() = default;
 constexpr explicit month(unsigned m) noexcept
 : value_(static_cast<unsigned char>(m)) {}
 constexpr explicit operator unsigned() const noexcept { return value_; }
};

class year {
 private:
  int value_;

public:
  year() = default;
  constexpr explicit year(int y) noexcept : value_(y) {}
  constexpr explicit operator int() const noexcept { return value_; }
};

class year_month_day {
 private:
  fmt::year year_;
  fmt::month month_;
  fmt::day day_;

public:
  year_month_day() = default;
  constexpr year_month_day(const year& y, const month& m, const day& d) noexcept
      : year_(y), month_(m), day_(d) {}
  constexpr auto year() const noexcept -> fmt::year { return year_; }
  constexpr auto month() const noexcept -> fmt::month { return month_; }
  constexpr auto day() const noexcept -> fmt::day { return day_; }
};
#endif

template <typename Char>
struct formatter<weekday, Char> : private formatter<std::tm, Char> {
 private:
 bool localized_ = false;
 bool use_tm_formatter_ = false;

public:
 FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
 auto it = ctx.begin(), end = ctx.end();
 if (it != end && *it == 'L') {
 ++it;
 localized_ = true;
 return it;
 }
 use_tm_formatter_ = it != end && *it != '}';
 return use_tm_formatter_ ? formatter<std::tm, Char>::parse(ctx) : it;
 }

template <typename FormatContext>
 auto format(weekday wd, FormatContext& ctx) const -> decltype(ctx.out()) {
 auto time = std::tm();
 time.tm_wday = static_cast<int>(wd.c_encoding());
 if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx);
 detail::get_locale loc(localized_, ctx.locale());
 auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time);
 w.on_abbr_weekday();
 return w.out();
 }
};

template <typename Char>
struct formatter<day, Char> : private formatter<std::tm, Char> {
 private:
 bool use_tm_formatter_ = false;

public:
 FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
 auto it = ctx.begin(), end = ctx.end();
 use_tm_formatter_ = it != end && *it != '}';
 return use_tm_formatter_ ? formatter<std::tm, Char>::parse(ctx) : it;
 }

template <typename FormatContext>
 auto format(day d, FormatContext& ctx) const -> decltype(ctx.out()) {
 auto time = std::tm();
 time.tm_mday = static_cast<int>(static_cast<unsigned>(d));
 if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx);
 detail::get_locale loc(false, ctx.locale());
 auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time);
 w.on_day_of_month(detail::numeric_system::standard, detail::pad_type::zero);
 return w.out();
 }
};

template <typename Char>
struct formatter<month, Char> : private formatter<std::tm, Char> {
 private:
 bool localized_ = false;
 bool use_tm_formatter_ = false;

template <typename FormatContext>
 auto format(month m, FormatContext& ctx) const -> decltype(ctx.out()) {
 auto time = std::tm();
 time.tm_mon = static_cast<int>(static_cast<unsigned>(m)) - 1;
 if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx);
 detail::get_locale loc(localized_, ctx.locale());
 auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time);
 w.on_abbr_month();
 return w.out();
 }
};

template <typename Char>
struct formatter<year, Char> : private formatter<std::tm, Char> {
 private:
 bool use_tm_formatter_ = false;

template <typename FormatContext>
 auto format(year y, FormatContext& ctx) const -> decltype(ctx.out()) {
 auto time = std::tm();
 time.tm_year = static_cast<int>(y) - 1900;
 if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx);
 detail::get_locale loc(false, ctx.locale());
 auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time);
 w.on_year(detail::numeric_system::standard);
 return w.out();
 }
};

template <typename Char>
struct formatter<year_month_day, Char> : private formatter<std::tm, Char> {
 private:
 bool use_tm_formatter_ = false;

template <typename FormatContext>
 auto format(year_month_day val, FormatContext& ctx) const
 -> decltype(ctx.out()) {
 auto time = std::tm();
 time.tm_year = static_cast<int>(val.year()) - 1900;
 time.tm_mon = static_cast<int>(static_cast<unsigned>(val.month())) - 1;
 time.tm_mday = static_cast<int>(static_cast<unsigned>(val.day()));
 if (use_tm_formatter_) return formatter<std::tm, Char>::format(time, ctx);
 detail::get_locale loc(true, ctx.locale());
 auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time);
 w.on_iso_date();
 return w.out();
 }
};

template <typename Rep, typename Period, typename Char>
struct formatter<std::chrono::duration<Rep, Period>, Char> {
 private:
 format_specs specs_;
 detail::arg_ref<Char> width_ref_;
 detail::arg_ref<Char> precision_ref_;
 bool localized_ = false;
 basic_string_view<Char> fmt_;

public:
 FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
 auto it = ctx.begin(), end = ctx.end();
 if (it == end || *it == '}') return it;

it = detail::parse_align(it, end, specs_);
    if (it == end) return it;

Char c = *it;
 if ((c >= '0' && c <= '9') || c == '{') {
 it = detail::parse_width(it, end, specs_, width_ref_, ctx);
 if (it == end) return it;
 }

auto checker = detail::chrono_format_checker();
 if (*it == '.') {
 checker.has_precision_integral = !std::is_floating_point<Rep>::value;
 it = detail::parse_precision(it, end, specs_, precision_ref_, ctx);
 }
 if (it != end && *it == 'L') {
 localized_ = true;
 ++it;
 }
 end = detail::parse_chrono_format(it, end, checker);
 fmt_ = {it, detail::to_unsigned(end - it)};
 return end;
 }

template <typename FormatContext>
 auto format(std::chrono::duration<Rep, Period> d, FormatContext& ctx) const
 -> decltype(ctx.out()) {
 auto specs = specs_;
 auto precision = specs.precision;
 specs.precision = -1;
 auto begin = fmt_.begin(), end = fmt_.end();
 // As a possible future optimization, we could avoid extra copying if width
 // is not specified.
 auto buf = basic_memory_buffer<Char>();
 auto out = basic_appender<Char>(buf);
 detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_,
 ctx);
 detail::handle_dynamic_spec(specs.dynamic_precision(), precision,
 precision_ref_, ctx);
 if (begin == end || *begin == '}') {
 out = detail::format_duration_value<Char>(out, d.count(), precision);
 detail::format_duration_unit<Char, Period>(out);
 } else {
 using chrono_formatter =
 detail::chrono_formatter<FormatContext, decltype(out), Rep, Period>;
 auto f = chrono_formatter(ctx, out, d);
 f.precision = precision;
 f.localized = localized_;
 detail::parse_chrono_format(begin, end, f);
 }
 return detail::write(
 ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs);
 }
};

template <typename Char> struct formatter<std::tm, Char> {
 private:
 format_specs specs_;
 detail::arg_ref<Char> width_ref_;

protected:
 basic_string_view<Char> fmt_;

template <typename Duration, typename FormatContext>
 auto do_format(const std::tm& tm, FormatContext& ctx,
 const Duration* subsecs) const -> decltype(ctx.out()) {
 auto specs = specs_;
 auto buf = basic_memory_buffer<Char>();
 auto out = basic_appender<Char>(buf);
 detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_,
 ctx);

auto loc_ref = ctx.locale();
 detail::get_locale loc(static_cast<bool>(loc_ref), loc_ref);
 auto w =
 detail::tm_writer<decltype(out), Char, Duration>(loc, out, tm, subsecs);
 detail::parse_chrono_format(fmt_.begin(), fmt_.end(), w);
 return detail::write(
 ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs);
 }

public:
 FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
 auto it = ctx.begin(), end = ctx.end();
 if (it == end || *it == '}') return it;

it = detail::parse_align(it, end, specs_);
    if (it == end) return it;

Char c = *it;
 if ((c >= '0' && c <= '9') || c == '{') {
 it = detail::parse_width(it, end, specs_, width_ref_, ctx);
 if (it == end) return it;
 }

end = detail::parse_chrono_format(it, end, detail::tm_format_checker());
    // Replace the default format string only if the new spec is not empty.
    if (end != it) fmt_ = {it, detail::to_unsigned(end - it)};
    return end;
  }

template <typename FormatContext>
 auto format(const std::tm& tm, FormatContext& ctx) const
 -> decltype(ctx.out()) {
 return do_format<std::chrono::seconds>(tm, ctx, nullptr);
 }
};

template <typename Char, typename Duration>
struct formatter<sys_time<Duration>, Char> : formatter<std::tm, Char> {
 FMT_CONSTEXPR formatter() {
 this->fmt_ = detail::string_literal<Char, '%', 'F', ' ', '%', 'T'>();
 }

template <typename FormatContext>
 auto format(sys_time<Duration> val, FormatContext& ctx) const
 -> decltype(ctx.out()) {
 std::tm tm = gmtime(val);
 using period = typename Duration::period;
 if (detail::const_check(
 period::num == 1 && period::den == 1 &&
 !std::is_floating_point<typename Duration::rep>::value)) {
 return formatter<std::tm, Char>::format(tm, ctx);
 }
 Duration epoch = val.time_since_epoch();
 Duration subsecs = detail::duration_cast<Duration>(
 epoch - detail::duration_cast<std::chrono::seconds>(epoch));
 if (subsecs.count() < 0) {
 auto second = detail::duration_cast<Duration>(std::chrono::seconds(1));
 if (tm.tm_sec != 0)
 --tm.tm_sec;
 else
 tm = gmtime(val - second);
 subsecs += detail::duration_cast<Duration>(std::chrono::seconds(1));
 }
 return formatter<std::tm, Char>::do_format(tm, ctx, &subsecs);
 }
};

template <typename Duration, typename Char>
struct formatter<utc_time<Duration>, Char>
 : formatter<sys_time<Duration>, Char> {
 template <typename FormatContext>
 auto format(utc_time<Duration> val, FormatContext& ctx) const
 -> decltype(ctx.out()) {
 return formatter<sys_time<Duration>, Char>::format(
 detail::utc_clock::to_sys(val), ctx);
 }
};

template <typename Duration, typename Char>
struct formatter<local_time<Duration>, Char> : formatter<std::tm, Char> {
 FMT_CONSTEXPR formatter() {
 this->fmt_ = detail::string_literal<Char, '%', 'F', ' ', '%', 'T'>();
 }

template <typename FormatContext>
 auto format(local_time<Duration> val, FormatContext& ctx) const
 -> decltype(ctx.out()) {
 using period = typename Duration::period;
 if (period::num == 1 && period::den == 1 &&
 !std::is_floating_point<typename Duration::rep>::value) {
 return formatter<std::tm, Char>::format(localtime(val), ctx);
 }
 auto epoch = val.time_since_epoch();
 auto subsecs = detail::duration_cast<Duration>(
 epoch - detail::duration_cast<std::chrono::seconds>(epoch));
 return formatter<std::tm, Char>::do_format(localtime(val), ctx, &subsecs);
 }
};

FMT_END_EXPORT
FMT_END_NAMESPACE

#endif  // FMT_CHRONO_H_

int main() {
 fmt::format("{:%M:%S}",
 std::chrono::duration<short, std::ratio<1, 100>>(0x8000));
}