From 0028ca3545feac7c943d20e4d96ed5232d60838f Mon Sep 17 00:00:00 2001
From: "alexey.lysiuk" <alexey.lysiuk@gmail.com>
Date: Mon, 20 Jun 2022 10:30:39 +0300
Subject: [PATCH] update fmt to 8.1.1

---
 deps/fmt/include/fmt/args.h                   |  234 +
 deps/fmt/include/fmt/chrono.h                 | 1363 +++++-
 deps/fmt/include/fmt/color.h                  |  157 +-
 deps/fmt/include/fmt/compile.h                |  849 ++--
 deps/fmt/include/fmt/core.h                   | 2706 +++++++----
 deps/fmt/include/fmt/format-inl.h             | 2444 +++++-----
 deps/fmt/include/fmt/format.h                 | 4172 +++++++----------
 deps/fmt/include/fmt/locale.h                 |   66 +-
 deps/fmt/include/fmt/os.h                     |  227 +-
 deps/fmt/include/fmt/ostream.h                |  112 +-
 deps/fmt/include/fmt/posix.h                  |    2 -
 deps/fmt/include/fmt/printf.h                 |  480 +-
 deps/fmt/include/fmt/ranges.h                 |  749 ++-
 deps/fmt/include/fmt/xchar.h                  |  236 +
 .../lib/cmake/fmt/fmt-config-version.cmake    |   23 +-
 deps/fmt/lib/cmake/fmt/fmt-targets.cmake      |    2 +-
 deps/fmt/lib/libfmt.a                         |  Bin 537768 -> 350288 bytes
 deps/fmt/lib/pkgconfig/fmt.pc                 |    2 +-
 18 files changed, 7787 insertions(+), 6037 deletions(-)
 create mode 100644 deps/fmt/include/fmt/args.h
 delete mode 100644 deps/fmt/include/fmt/posix.h
 create mode 100644 deps/fmt/include/fmt/xchar.h

diff --git a/deps/fmt/include/fmt/args.h b/deps/fmt/include/fmt/args.h
new file mode 100644
index 00000000..9a8e4ed2
--- /dev/null
+++ b/deps/fmt/include/fmt/args.h
@@ -0,0 +1,234 @@
+// Formatting library for C++ - dynamic format arguments
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_ARGS_H_
+#define FMT_ARGS_H_
+
+#include <functional>  // std::reference_wrapper
+#include <memory>      // std::unique_ptr
+#include <vector>
+
+#include "core.h"
+
+FMT_BEGIN_NAMESPACE
+
+namespace detail {
+
+template <typename T> struct is_reference_wrapper : std::false_type {};
+template <typename T>
+struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
+
+template <typename T> const T& unwrap(const T& v) { return v; }
+template <typename T> const T& unwrap(const std::reference_wrapper<T>& v) {
+  return static_cast<const T&>(v);
+}
+
+class dynamic_arg_list {
+  // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
+  // templates it doesn't complain about inability to deduce single translation
+  // unit for placing vtable. So storage_node_base is made a fake template.
+  template <typename = void> struct node {
+    virtual ~node() = default;
+    std::unique_ptr<node<>> next;
+  };
+
+  template <typename T> struct typed_node : node<> {
+    T value;
+
+    template <typename Arg>
+    FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {}
+
+    template <typename Char>
+    FMT_CONSTEXPR typed_node(const basic_string_view<Char>& arg)
+        : value(arg.data(), arg.size()) {}
+  };
+
+  std::unique_ptr<node<>> head_;
+
+ public:
+  template <typename T, typename Arg> const T& push(const Arg& arg) {
+    auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
+    auto& value = new_node->value;
+    new_node->next = std::move(head_);
+    head_ = std::move(new_node);
+    return value;
+  }
+};
+}  // namespace detail
+
+/**
+  \rst
+  A dynamic version of `fmt::format_arg_store`.
+  It's equipped with a storage to potentially temporary objects which lifetimes
+  could be shorter than the format arguments object.
+
+  It can be implicitly converted into `~fmt::basic_format_args` for passing
+  into type-erased formatting functions such as `~fmt::vformat`.
+  \endrst
+ */
+template <typename Context>
+class dynamic_format_arg_store
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+    // Workaround a GCC template argument substitution bug.
+    : public basic_format_args<Context>
+#endif
+{
+ private:
+  using char_type = typename Context::char_type;
+
+  template <typename T> struct need_copy {
+    static constexpr detail::type mapped_type =
+        detail::mapped_type_constant<T, Context>::value;
+
+    enum {
+      value = !(detail::is_reference_wrapper<T>::value ||
+                std::is_same<T, basic_string_view<char_type>>::value ||
+                std::is_same<T, detail::std_string_view<char_type>>::value ||
+                (mapped_type != detail::type::cstring_type &&
+                 mapped_type != detail::type::string_type &&
+                 mapped_type != detail::type::custom_type))
+    };
+  };
+
+  template <typename T>
+  using stored_type = conditional_t<detail::is_string<T>::value &&
+                                        !has_formatter<T, Context>::value &&
+                                        !detail::is_reference_wrapper<T>::value,
+                                    std::basic_string<char_type>, T>;
+
+  // Storage of basic_format_arg must be contiguous.
+  std::vector<basic_format_arg<Context>> data_;
+  std::vector<detail::named_arg_info<char_type>> named_info_;
+
+  // Storage of arguments not fitting into basic_format_arg must grow
+  // without relocation because items in data_ refer to it.
+  detail::dynamic_arg_list dynamic_args_;
+
+  friend class basic_format_args<Context>;
+
+  unsigned long long get_types() const {
+    return detail::is_unpacked_bit | data_.size() |
+           (named_info_.empty()
+                ? 0ULL
+                : static_cast<unsigned long long>(detail::has_named_args_bit));
+  }
+
+  const basic_format_arg<Context>* data() const {
+    return named_info_.empty() ? data_.data() : data_.data() + 1;
+  }
+
+  template <typename T> void emplace_arg(const T& arg) {
+    data_.emplace_back(detail::make_arg<Context>(arg));
+  }
+
+  template <typename T>
+  void emplace_arg(const detail::named_arg<char_type, T>& arg) {
+    if (named_info_.empty()) {
+      constexpr const detail::named_arg_info<char_type>* zero_ptr{nullptr};
+      data_.insert(data_.begin(), {zero_ptr, 0});
+    }
+    data_.emplace_back(detail::make_arg<Context>(detail::unwrap(arg.value)));
+    auto pop_one = [](std::vector<basic_format_arg<Context>>* data) {
+      data->pop_back();
+    };
+    std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)>
+        guard{&data_, pop_one};
+    named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)});
+    data_[0].value_.named_args = {named_info_.data(), named_info_.size()};
+    guard.release();
+  }
+
+ public:
+  constexpr dynamic_format_arg_store() = default;
+
+  /**
+    \rst
+    Adds an argument into the dynamic store for later passing to a formatting
+    function.
+
+    Note that custom types and string types (but not string views) are copied
+    into the store dynamically allocating memory if necessary.
+
+    **Example**::
+
+      fmt::dynamic_format_arg_store<fmt::format_context> store;
+      store.push_back(42);
+      store.push_back("abc");
+      store.push_back(1.5f);
+      std::string result = fmt::vformat("{} and {} and {}", store);
+    \endrst
+  */
+  template <typename T> void push_back(const T& arg) {
+    if (detail::const_check(need_copy<T>::value))
+      emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
+    else
+      emplace_arg(detail::unwrap(arg));
+  }
+
+  /**
+    \rst
+    Adds a reference to the argument into the dynamic store for later passing to
+    a formatting function.
+
+    **Example**::
+
+      fmt::dynamic_format_arg_store<fmt::format_context> store;
+      char band[] = "Rolling Stones";
+      store.push_back(std::cref(band));
+      band[9] = 'c'; // Changing str affects the output.
+      std::string result = fmt::vformat("{}", store);
+      // result == "Rolling Scones"
+    \endrst
+  */
+  template <typename T> void push_back(std::reference_wrapper<T> arg) {
+    static_assert(
+        need_copy<T>::value,
+        "objects of built-in types and string views are always copied");
+    emplace_arg(arg.get());
+  }
+
+  /**
+    Adds named argument into the dynamic store for later passing to a formatting
+    function. ``std::reference_wrapper`` is supported to avoid copying of the
+    argument. The name is always copied into the store.
+  */
+  template <typename T>
+  void push_back(const detail::named_arg<char_type, T>& arg) {
+    const char_type* arg_name =
+        dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();
+    if (detail::const_check(need_copy<T>::value)) {
+      emplace_arg(
+          fmt::arg(arg_name, dynamic_args_.push<stored_type<T>>(arg.value)));
+    } else {
+      emplace_arg(fmt::arg(arg_name, arg.value));
+    }
+  }
+
+  /** Erase all elements from the store */
+  void clear() {
+    data_.clear();
+    named_info_.clear();
+    dynamic_args_ = detail::dynamic_arg_list();
+  }
+
+  /**
+    \rst
+    Reserves space to store at least *new_cap* arguments including
+    *new_cap_named* named arguments.
+    \endrst
+  */
+  void reserve(size_t new_cap, size_t new_cap_named) {
+    FMT_ASSERT(new_cap >= new_cap_named,
+               "Set of arguments includes set of named arguments");
+    data_.reserve(new_cap);
+    named_info_.reserve(new_cap_named);
+  }
+};
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_ARGS_H_
diff --git a/deps/fmt/include/fmt/chrono.h b/deps/fmt/include/fmt/chrono.h
index 1a3b8d5e..682efd8d 100644
--- a/deps/fmt/include/fmt/chrono.h
+++ b/deps/fmt/include/fmt/chrono.h
@@ -8,16 +8,32 @@
 #ifndef FMT_CHRONO_H_
 #define FMT_CHRONO_H_
 
+#include <algorithm>
 #include <chrono>
 #include <ctime>
+#include <iterator>
 #include <locale>
-#include <sstream>
+#include <ostream>
+#include <type_traits>
 
 #include "format.h"
-#include "locale.h"
 
 FMT_BEGIN_NAMESPACE
 
+// Enable tzset.
+#ifndef FMT_USE_TZSET
+// UWP doesn't provide _tzset.
+#  if FMT_HAS_INCLUDE("winapifamily.h")
+#    include <winapifamily.h>
+#  endif
+#  if defined(_WIN32) && (!defined(WINAPI_FAMILY) || \
+                          (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
+#    define FMT_USE_TZSET 1
+#  else
+#    define FMT_USE_TZSET 0
+#  endif
+#endif
+
 // Enable safe chrono durations, unless explicitly disabled.
 #ifndef FMT_SAFE_DURATION_CAST
 #  define FMT_SAFE_DURATION_CAST 1
@@ -44,7 +60,7 @@ FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
   static_assert(T::is_integer, "To must be integral");
 
   // A and B are both signed, or both unsigned.
-  if (F::digits <= T::digits) {
+  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.
@@ -79,14 +95,15 @@ FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
       return {};
     }
     // From is positive. Can it always fit in To?
-    if (F::digits > T::digits &&
+    if (detail::const_check(F::digits > T::digits) &&
         from > static_cast<From>(detail::max_value<To>())) {
       ec = 1;
       return {};
     }
   }
 
-  if (!F::is_signed && T::is_signed && F::digits >= T::digits &&
+  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 {};
@@ -243,7 +260,7 @@ To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
   }
 
   // multiply with Factor::num without overflow or underflow
-  if (Factor::num != 1) {
+  if (detail::const_check(Factor::num != 1)) {
     constexpr auto max1 = detail::max_value<IntermediateRep>() /
                           static_cast<IntermediateRep>(Factor::num);
     if (count > max1) {
@@ -260,7 +277,7 @@ To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
   }
 
   // this can't go wrong, right? den>0 is checked earlier.
-  if (Factor::den != 1) {
+  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);
   }
@@ -282,13 +299,154 @@ To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
 #define FMT_NOMACRO
 
 namespace detail {
+template <typename T = void> struct null {};
 inline null<> localtime_r FMT_NOMACRO(...) { return null<>(); }
 inline null<> localtime_s(...) { return null<>(); }
 inline null<> gmtime_r(...) { return null<>(); }
 inline null<> gmtime_s(...) { return null<>(); }
+
+inline const std::locale& get_classic_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>
+constexpr const size_t codecvt_result<CodeUnit>::max_size;
+
+template <typename CodeUnit>
+void write_codecvt(codecvt_result<CodeUnit>& out, string_view in_buf,
+                   const std::locale& loc) {
+  using codecvt = std::codecvt<CodeUnit, char, std::mbstate_t>;
+#if FMT_CLANG_VERSION
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wdeprecated"
+  auto& f = std::use_facet<codecvt>(loc);
+#  pragma clang diagnostic pop
+#else
+  auto& f = std::use_facet<codecvt>(loc);
+#endif
+  auto mb = std::mbstate_t();
+  const char* from_next = nullptr;
+  auto result = f.in(mb, in_buf.begin(), in_buf.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::is_utf8() && loc != get_classic_locale()) {
+    // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and
+    // gcc-4.
+#if FMT_MSC_VER != 0 || \
+    (defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI))
+    // 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&& buf = basic_memory_buffer<char, unit_t::max_size * 4>();
+    for (code_unit* p = unit.buf; p != unit.end; ++p) {
+      uint32_t c = static_cast<uint32_t>(*p);
+      if (sizeof(code_unit) == 2 && c >= 0xd800 && c <= 0xdfff) {
+        // surrogate pair
+        ++p;
+        if (p == unit.end || (c & 0xfc00) != 0xd800 ||
+            (*p & 0xfc00) != 0xdc00) {
+          FMT_THROW(format_error("failed to format time"));
+        }
+        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 {
+        FMT_THROW(format_error("failed to format time"));
+      }
+    }
+    return copy_str<char>(buf.data(), buf.data() + buf.size(), out);
+  }
+  return copy_str<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_str<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);
+  using iterator = std::ostreambuf_iterator<Char>;
+  const auto& facet = std::use_facet<std::time_put<Char, iterator>>(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 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);
+}
+
 }  // namespace detail
 
-// Thread-safe replacement for std::localtime
+FMT_MODULE_EXPORT_BEGIN
+
+/**
+  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 std::tm localtime(std::time_t time) {
   struct dispatcher {
     std::time_t time_;
@@ -330,7 +488,11 @@ inline std::tm localtime(
   return localtime(std::chrono::system_clock::to_time_t(time_point));
 }
 
-// Thread-safe replacement for std::gmtime
+/**
+  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 std::tm gmtime(std::time_t time) {
   struct dispatcher {
     std::time_t time_;
@@ -371,96 +533,64 @@ inline std::tm gmtime(
   return gmtime(std::chrono::system_clock::to_time_t(time_point));
 }
 
-namespace detail {
-inline size_t strftime(char* str, size_t count, const char* format,
-                       const std::tm* time) {
-  return std::strftime(str, count, format, time);
+FMT_BEGIN_DETAIL_NAMESPACE
+
+// 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];
+    memcpy(tmp, &digits, len);
+    std::reverse_copy(tmp, tmp + len, buf);
+  } else {
+    memcpy(buf, &digits, len);
+  }
 }
 
-inline size_t strftime(wchar_t* str, size_t count, const wchar_t* format,
-                       const std::tm* time) {
-  return std::wcsftime(str, count, format, time);
-}
-}  // namespace detail
-
-template <typename Char>
-struct formatter<std::chrono::time_point<std::chrono::system_clock>, Char>
-    : formatter<std::tm, Char> {
-  template <typename FormatContext>
-  auto format(std::chrono::time_point<std::chrono::system_clock> val,
-              FormatContext& ctx) -> decltype(ctx.out()) {
-    std::tm time = localtime(val);
-    return formatter<std::tm, Char>::format(time, ctx);
-  }
-};
-
-template <typename Char> struct formatter<std::tm, Char> {
-  template <typename ParseContext>
-  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    auto it = ctx.begin();
-    if (it != ctx.end() && *it == ':') ++it;
-    auto end = it;
-    while (end != ctx.end() && *end != '}') ++end;
-    tm_format.reserve(detail::to_unsigned(end - it + 1));
-    tm_format.append(it, end);
-    tm_format.push_back('\0');
-    return end;
-  }
-
-  template <typename FormatContext>
-  auto format(const std::tm& tm, FormatContext& ctx) -> decltype(ctx.out()) {
-    basic_memory_buffer<Char> buf;
-    size_t start = buf.size();
-    for (;;) {
-      size_t size = buf.capacity() - start;
-      size_t count = detail::strftime(&buf[start], size, &tm_format[0], &tm);
-      if (count != 0) {
-        buf.resize(start + count);
-        break;
-      }
-      if (size >= tm_format.size() * 256) {
-        // If the buffer is 256 times larger than the format string, assume
-        // that `strftime` gives an empty result. There doesn't seem to be a
-        // better way to distinguish the two cases:
-        // https://github.com/fmtlib/fmt/issues/367
-        break;
-      }
-      const size_t MIN_GROWTH = 10;
-      buf.reserve(buf.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
-    }
-    return std::copy(buf.begin(), buf.end(), ctx.out());
-  }
-
-  basic_memory_buffer<Char> tm_format;
-};
-
-namespace detail {
-template <typename Period> FMT_CONSTEXPR const char* get_units() {
+template <typename Period> FMT_CONSTEXPR inline const char* get_units() {
+  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 "µs";
+  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 "m";
+  if (std::is_same<Period, std::ratio<3600>>::value) return "h";
   return nullptr;
 }
-template <> FMT_CONSTEXPR const char* get_units<std::atto>() { return "as"; }
-template <> FMT_CONSTEXPR const char* get_units<std::femto>() { return "fs"; }
-template <> FMT_CONSTEXPR const char* get_units<std::pico>() { return "ps"; }
-template <> FMT_CONSTEXPR const char* get_units<std::nano>() { return "ns"; }
-template <> FMT_CONSTEXPR const char* get_units<std::micro>() { return "µs"; }
-template <> FMT_CONSTEXPR const char* get_units<std::milli>() { return "ms"; }
-template <> FMT_CONSTEXPR const char* get_units<std::centi>() { return "cs"; }
-template <> FMT_CONSTEXPR const char* get_units<std::deci>() { return "ds"; }
-template <> FMT_CONSTEXPR const char* get_units<std::ratio<1>>() { return "s"; }
-template <> FMT_CONSTEXPR const char* get_units<std::deca>() { return "das"; }
-template <> FMT_CONSTEXPR const char* get_units<std::hecto>() { return "hs"; }
-template <> FMT_CONSTEXPR const char* get_units<std::kilo>() { return "ks"; }
-template <> FMT_CONSTEXPR const char* get_units<std::mega>() { return "Ms"; }
-template <> FMT_CONSTEXPR const char* get_units<std::giga>() { return "Gs"; }
-template <> FMT_CONSTEXPR const char* get_units<std::tera>() { return "Ts"; }
-template <> FMT_CONSTEXPR const char* get_units<std::peta>() { return "Ps"; }
-template <> FMT_CONSTEXPR const char* get_units<std::exa>() { return "Es"; }
-template <> FMT_CONSTEXPR const char* get_units<std::ratio<60>>() {
-  return "m";
-}
-template <> FMT_CONSTEXPR const char* get_units<std::ratio<3600>>() {
-  return "h";
-}
 
 enum class numeric_system {
   standard,
@@ -499,6 +629,22 @@ FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin,
       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();
@@ -514,11 +660,34 @@ FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin,
       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);
+      break;
+    case 'W':
+      handler.on_dec1_week_of_year(numeric_system::standard);
+      break;
+    case 'V':
+      handler.on_iso_week_of_year(numeric_system::standard);
+      break;
+    case 'j':
+      handler.on_day_of_year();
+      break;
+    case 'd':
+      handler.on_day_of_month(numeric_system::standard);
+      break;
+    case 'e':
+      handler.on_day_of_month_space(numeric_system::standard);
+      break;
     // Hour, minute, second:
     case 'H':
       handler.on_24_hour(numeric_system::standard);
@@ -577,6 +746,15 @@ FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin,
       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;
@@ -595,6 +773,27 @@ FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin,
       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);
+        break;
+      case 'W':
+        handler.on_dec1_week_of_year(numeric_system::alternative);
+        break;
+      case 'V':
+        handler.on_iso_week_of_year(numeric_system::alternative);
+        break;
+      case 'd':
+        handler.on_day_of_month(numeric_system::alternative);
+        break;
+      case 'e':
+        handler.on_day_of_month_space(numeric_system::alternative);
+        break;
       case 'w':
         handler.on_dec0_weekday(numeric_system::alternative);
         break;
@@ -626,33 +825,566 @@ FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin,
   return ptr;
 }
 
-struct chrono_format_checker {
-  FMT_NORETURN void report_no_date() { FMT_THROW(format_error("no date")); }
+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) { unsupported(); }
+  FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_day_of_year() { unsupported(); }
+  FMT_CONSTEXPR void on_day_of_month(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_day_of_month_space(numeric_system) { 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() { unsupported(); }
+  FMT_CONSTEXPR void on_tz_name() { unsupported(); }
+};
 
-  template <typename Char> void on_text(const Char*, const Char*) {}
-  FMT_NORETURN void on_abbr_weekday() { report_no_date(); }
-  FMT_NORETURN void on_full_weekday() { report_no_date(); }
-  FMT_NORETURN void on_dec0_weekday(numeric_system) { report_no_date(); }
-  FMT_NORETURN void on_dec1_weekday(numeric_system) { report_no_date(); }
-  FMT_NORETURN void on_abbr_month() { report_no_date(); }
-  FMT_NORETURN void on_full_month() { report_no_date(); }
-  void on_24_hour(numeric_system) {}
-  void on_12_hour(numeric_system) {}
-  void on_minute(numeric_system) {}
-  void on_second(numeric_system) {}
-  FMT_NORETURN void on_datetime(numeric_system) { report_no_date(); }
-  FMT_NORETURN void on_loc_date(numeric_system) { report_no_date(); }
-  FMT_NORETURN void on_loc_time(numeric_system) { report_no_date(); }
-  FMT_NORETURN void on_us_date() { report_no_date(); }
-  FMT_NORETURN void on_iso_date() { report_no_date(); }
-  void on_12_hour_time() {}
-  void on_24_hour_time() {}
-  void on_iso_time() {}
-  void on_am_pm() {}
+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) {}
+  FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) {}
+  FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) {}
+  FMT_CONSTEXPR void on_day_of_year() {}
+  FMT_CONSTEXPR void on_day_of_month(numeric_system) {}
+  FMT_CONSTEXPR void on_day_of_month_space(numeric_system) {}
+  FMT_CONSTEXPR void on_24_hour(numeric_system) {}
+  FMT_CONSTEXPR void on_12_hour(numeric_system) {}
+  FMT_CONSTEXPR void on_minute(numeric_system) {}
+  FMT_CONSTEXPR void on_second(numeric_system) {}
+  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() {}
+  FMT_CONSTEXPR void on_tz_name() {}
+};
+
+inline const char* tm_wday_full_name(int wday) {
+  static constexpr const char* full_name_list[] = {
+      "Sunday",   "Monday", "Tuesday", "Wednesday",
+      "Thursday", "Friday", "Saturday"};
+  return wday >= 0 && wday <= 6 ? full_name_list[wday] : "?";
+}
+inline const char* tm_wday_short_name(int wday) {
+  static constexpr const char* short_name_list[] = {"Sun", "Mon", "Tue", "Wed",
+                                                    "Thu", "Fri", "Sat"};
+  return wday >= 0 && wday <= 6 ? short_name_list[wday] : "???";
+}
+
+inline const char* tm_mon_full_name(int mon) {
+  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 const char* tm_mon_short_name(int mon) {
+  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 {};
+
+#if FMT_USE_TZSET
+inline void tzset_once() {
+  static bool init = []() -> bool {
+    _tzset();
+    return true;
+  }();
+  ignore_unused(init);
+}
+#endif
+
+template <typename OutputIt, typename Char> class tm_writer {
+ private:
+  static constexpr int days_per_week = 7;
+
+  const std::locale& loc_;
+  const bool is_classic_;
+  OutputIt out_;
+  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#Calculating_the_week_number_from_a_month_and_day_of_the_month_or_ordinal_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 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_ = std::fill_n(out_, width - num_digits, '0');
+    out_ = format_decimal<Char>(out_, n, num_digits).end;
+  }
+  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) {
+    if (offset < 0) {
+      *out_++ = '-';
+      offset = -offset;
+    } else {
+      *out_++ = '+';
+    }
+    offset /= 60;
+    write2(static_cast<int>(offset / 60));
+    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) {
+    write_utc_offset(tm.tm_gmtoff);
+  }
+  template <typename T, FMT_ENABLE_IF(!has_member_data_tm_gmtoff<T>::value)>
+  void format_utc_offset_impl(const T& tm) {
+#if defined(_WIN32) && defined(_UCRT)
+#  if FMT_USE_TZSET
+    tzset_once();
+#  endif
+    long offset = 0;
+    _get_timezone(&offset);
+    if (tm.tm_isdst) {
+      long dstbias = 0;
+      _get_dstbias(&dstbias);
+      offset += dstbias;
+    }
+    write_utc_offset(-offset);
+#else
+    ignore_unused(tm);
+    format_localized('z');
+#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)
+      : loc_(loc),
+        is_classic_(loc_ == get_classic_locale()),
+        out_(out),
+        tm_(tm) {}
+
+  OutputIt out() const { return out_; }
+
+  FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) {
+    out_ = copy_str<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_space(numeric_system::standard);
+      *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_str<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) {
+      copy2(buf, digits2(to_unsigned(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_str<Char>(std::begin(buf) + offset, std::end(buf), out_);
+  }
+
+  void on_utc_offset() { format_utc_offset_impl(tm_); }
+  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) {
+    if (is_classic_ || ns == numeric_system::standard)
+      return write2((tm_yday() + days_per_week - tm_wday()) / days_per_week);
+    format_localized('U', 'O');
+  }
+  void on_dec1_week_of_year(numeric_system ns) {
+    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);
+    } else {
+      format_localized('W', 'O');
+    }
+  }
+  void on_iso_week_of_year(numeric_system ns) {
+    if (is_classic_ || ns == numeric_system::standard)
+      return write2(tm_iso_week_of_year());
+    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) {
+    if (is_classic_ || ns == numeric_system::standard) return write2(tm_mday());
+    format_localized('d', 'O');
+  }
+  void on_day_of_month_space(numeric_system ns) {
+    if (is_classic_ || ns == numeric_system::standard) {
+      auto mday = to_unsigned(tm_mday()) % 100;
+      const char* d2 = digits2(mday);
+      *out_++ = mday < 10 ? ' ' : d2[0];
+      *out_++ = d2[1];
+    } else {
+      format_localized('e', 'O');
+    }
+  }
+
+  void on_24_hour(numeric_system ns) {
+    if (is_classic_ || ns == numeric_system::standard) return write2(tm_hour());
+    format_localized('H', 'O');
+  }
+  void on_12_hour(numeric_system ns) {
+    if (is_classic_ || ns == numeric_system::standard)
+      return write2(tm_hour12());
+    format_localized('I', 'O');
+  }
+  void on_minute(numeric_system ns) {
+    if (is_classic_ || ns == numeric_system::standard) return write2(tm_min());
+    format_localized('M', 'O');
+  }
+  void on_second(numeric_system ns) {
+    if (is_classic_ || ns == numeric_system::standard) return write2(tm_sec());
+    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_str<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() {
+    char buf[8];
+    write_digit2_separated(buf, to_unsigned(tm_hour()), to_unsigned(tm_min()),
+                           to_unsigned(tm_sec()), ':');
+    out_ = copy_str<Char>(std::begin(buf), std::end(buf), out_);
+  }
+
+  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() {}
-  FMT_NORETURN void on_utc_offset() { report_no_date(); }
-  FMT_NORETURN void on_tz_name() { report_no_date(); }
+};
+
+struct chrono_format_checker : null_chrono_spec_handler<chrono_format_checker> {
+  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_24_hour(numeric_system) {}
+  FMT_CONSTEXPR void on_12_hour(numeric_system) {}
+  FMT_CONSTEXPR void on_minute(numeric_system) {}
+  FMT_CONSTEXPR void on_second(numeric_system) {}
+  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() {}
+  FMT_CONSTEXPR void on_duration_unit() {}
 };
 
 template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
@@ -668,25 +1400,20 @@ template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
 inline bool isfinite(T) {
   return true;
 }
-template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-inline bool isfinite(T value) {
-  return std::isfinite(value);
-}
 
-// Converts value to int and checks that it's in the range [0, upper).
-template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-inline int to_nonnegative_int(T value, int upper) {
-  FMT_ASSERT(value >= 0 && value <= upper, "invalid value");
+// 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 Int to_nonnegative_int(T value, Int upper) {
+  FMT_ASSERT(value >= 0 && to_unsigned(value) <= to_unsigned(upper),
+             "invalid value");
   (void)upper;
-  return static_cast<int>(value);
+  return static_cast<Int>(value);
 }
-template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-inline int to_nonnegative_int(T value, int upper) {
-  FMT_ASSERT(
-      std::isnan(value) || (value >= 0 && value <= static_cast<T>(upper)),
-      "invalid value");
-  (void)upper;
-  return static_cast<int>(value);
+template <typename T, typename Int, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+inline Int to_nonnegative_int(T value, Int upper) {
+  if (value < 0 || value > static_cast<T>(upper))
+    FMT_THROW(format_error("invalid value"));
+  return static_cast<Int>(value);
 }
 
 template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
@@ -743,26 +1470,55 @@ inline std::chrono::duration<Rep, std::milli> get_milliseconds(
 #endif
 }
 
-template <typename Rep, typename Period,
-          FMT_ENABLE_IF(std::is_floating_point<Rep>::value)>
-inline std::chrono::duration<Rep, std::milli> get_milliseconds(
-    std::chrono::duration<Rep, Period> d) {
-  using common_type = typename std::common_type<Rep, std::intmax_t>::type;
-  auto ms = mod(d.count() * static_cast<common_type>(Period::num) /
-                    static_cast<common_type>(Period::den) * 1000,
-                1000);
-  return std::chrono::duration<Rep, std::milli>(static_cast<Rep>(ms));
+// Returns 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.
+constexpr int count_fractional_digits(long long num, long long den, int n = 0) {
+  return num % den == 0
+             ? n
+             : (n > 18 ? 6 : count_fractional_digits(num * 10, den, n + 1));
 }
 
-template <typename Char, typename Rep, typename OutputIt>
-OutputIt format_duration_value(OutputIt out, Rep val, int precision) {
-  const Char pr_f[] = {'{', ':', '.', '{', '}', 'f', '}', 0};
-  if (precision >= 0) return format_to(out, pr_f, val, precision);
-  const Char fp_f[] = {'{', ':', 'g', '}', 0};
-  const Char format[] = {'{', '}', 0};
-  return format_to(out, std::is_floating_point<Rep>::value ? fp_f : format,
-                   val);
+constexpr long long pow10(std::uint32_t n) {
+  return n == 0 ? 1 : 10 * pow10(n - 1);
 }
+
+template <class Rep, class Period,
+          FMT_ENABLE_IF(std::numeric_limits<Rep>::is_signed)>
+constexpr std::chrono::duration<Rep, Period> abs(
+    std::chrono::duration<Rep, Period> d) {
+  // We need to compare the duration using the count() method directly
+  // due to a compiler bug in clang-11 regarding the spaceship operator,
+  // when -Wzero-as-null-pointer-constant is enabled.
+  // In clang-12 the bug has been fixed. See
+  // https://bugs.llvm.org/show_bug.cgi?id=46235 and the reproducible example:
+  // https://www.godbolt.org/z/Knbb5joYx.
+  return d.count() >= d.zero().count() ? d : -d;
+}
+
+template <class Rep, class Period,
+          FMT_ENABLE_IF(!std::numeric_limits<Rep>::is_signed)>
+constexpr std::chrono::duration<Rep, Period> abs(
+    std::chrono::duration<Rep, Period> d) {
+  return d;
+}
+
+template <typename Char, typename Rep, typename OutputIt,
+          FMT_ENABLE_IF(std::is_integral<Rep>::value)>
+OutputIt format_duration_value(OutputIt out, Rep val, int) {
+  return write<Char>(out, val);
+}
+
+template <typename Char, typename Rep, typename OutputIt,
+          FMT_ENABLE_IF(std::is_floating_point<Rep>::value)>
+OutputIt format_duration_value(OutputIt out, Rep val, int precision) {
+  auto specs = basic_format_specs<Char>();
+  specs.precision = precision;
+  specs.type = precision >= 0 ? presentation_type::fixed_lower
+                              : presentation_type::general_lower;
+  return write<Char>(out, val, specs);
+}
+
 template <typename Char, typename OutputIt>
 OutputIt copy_unit(string_view unit, OutputIt out, Char) {
   return std::copy(unit.begin(), unit.end(), out);
@@ -780,18 +1536,44 @@ template <typename Char, typename Period, typename OutputIt>
 OutputIt format_duration_unit(OutputIt out) {
   if (const char* unit = get_units<Period>())
     return copy_unit(string_view(unit), out, Char());
-  const Char num_f[] = {'[', '{', '}', ']', 's', 0};
-  if (const_check(Period::den == 1)) return format_to(out, num_f, Period::num);
-  const Char num_def_f[] = {'[', '{', '}', '/', '{', '}', ']', 's', 0};
-  return format_to(out, num_def_f, Period::num, Period::den);
+  *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),
@@ -803,9 +1585,10 @@ struct chrono_formatter {
   bool negative;
 
   using char_type = typename FormatContext::char_type;
+  using tm_writer_type = tm_writer<OutputIt, char_type>;
 
-  explicit chrono_formatter(FormatContext& ctx, OutputIt o,
-                            std::chrono::duration<Rep, Period> d)
+  chrono_formatter(FormatContext& ctx, OutputIt o,
+                   std::chrono::duration<Rep, Period> d)
       : context(ctx),
         out(o),
         val(static_cast<rep>(d.count())),
@@ -880,19 +1663,48 @@ struct chrono_formatter {
     out = format_decimal<char_type>(out, n, num_digits).end;
   }
 
+  template <class Duration> void write_fractional_seconds(Duration d) {
+    constexpr auto num_fractional_digits =
+        count_fractional_digits(Duration::period::num, Duration::period::den);
+
+    using subsecond_precision = std::chrono::duration<
+        typename std::common_type<typename Duration::rep,
+                                  std::chrono::seconds::rep>::type,
+        std::ratio<1, detail::pow10(num_fractional_digits)>>;
+    if (std::ratio_less<typename subsecond_precision::period,
+                        std::chrono::seconds::period>::value) {
+      *out++ = '.';
+      // Don't convert long double to integer seconds to avoid overflow.
+      using sec = conditional_t<
+          std::is_same<typename Duration::rep, long double>::value,
+          std::chrono::duration<long double>, std::chrono::seconds>;
+      auto fractional = detail::abs(d) - std::chrono::duration_cast<sec>(d);
+      const auto subseconds =
+          std::chrono::treat_as_floating_point<
+              typename subsecond_precision::rep>::value
+              ? fractional.count()
+              : std::chrono::duration_cast<subsecond_precision>(fractional)
+                    .count();
+      uint32_or_64_or_128_t<long long> n =
+          to_unsigned(to_nonnegative_int(subseconds, max_value<long long>()));
+      int num_digits = detail::count_digits(n);
+      if (num_fractional_digits > num_digits)
+        out = std::fill_n(out, num_fractional_digits - num_digits, '0');
+      out = format_decimal<char_type>(out, n, num_digits).end;
+    }
+  }
+
   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); }
 
-  void format_localized(const tm& time, char format, char modifier = 0) {
+  template <typename Callback, typename... Args>
+  void format_tm(const tm& time, Callback cb, Args... args) {
     if (isnan(val)) return write_nan();
-    auto locale = context.locale().template get<std::locale>();
-    auto& facet = std::use_facet<std::time_put<char_type>>(locale);
-    std::basic_ostringstream<char_type> os;
-    os.imbue(locale);
-    facet.put(os, os, ' ', &time, format, modifier);
-    auto str = os.str();
-    std::copy(str.begin(), str.end(), out);
+    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) {
@@ -913,6 +1725,19 @@ struct chrono_formatter {
   void on_iso_date() {}
   void on_utc_offset() {}
   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) {}
+  void on_dec1_week_of_year(numeric_system) {}
+  void on_iso_week_of_year(numeric_system) {}
+  void on_day_of_year() {}
+  void on_day_of_month(numeric_system) {}
+  void on_day_of_month_space(numeric_system) {}
 
   void on_24_hour(numeric_system ns) {
     if (handle_nan_inf()) return;
@@ -920,7 +1745,7 @@ struct chrono_formatter {
     if (ns == numeric_system::standard) return write(hour(), 2);
     auto time = tm();
     time.tm_hour = to_nonnegative_int(hour(), 24);
-    format_localized(time, 'H', 'O');
+    format_tm(time, &tm_writer_type::on_24_hour, ns);
   }
 
   void on_12_hour(numeric_system ns) {
@@ -929,7 +1754,7 @@ struct chrono_formatter {
     if (ns == numeric_system::standard) return write(hour12(), 2);
     auto time = tm();
     time.tm_hour = to_nonnegative_int(hour12(), 12);
-    format_localized(time, 'I', 'O');
+    format_tm(time, &tm_writer_type::on_12_hour, ns);
   }
 
   void on_minute(numeric_system ns) {
@@ -938,7 +1763,7 @@ struct chrono_formatter {
     if (ns == numeric_system::standard) return write(minute(), 2);
     auto time = tm();
     time.tm_min = to_nonnegative_int(minute(), 60);
-    format_localized(time, 'M', 'O');
+    format_tm(time, &tm_writer_type::on_minute, ns);
   }
 
   void on_second(numeric_system ns) {
@@ -946,29 +1771,17 @@ struct chrono_formatter {
 
     if (ns == numeric_system::standard) {
       write(second(), 2);
-#if FMT_SAFE_DURATION_CAST
-      // convert rep->Rep
-      using duration_rep = std::chrono::duration<rep, Period>;
-      using duration_Rep = std::chrono::duration<Rep, Period>;
-      auto tmpval = fmt_safe_duration_cast<duration_Rep>(duration_rep{val});
-#else
-      auto tmpval = std::chrono::duration<Rep, Period>(val);
-#endif
-      auto ms = get_milliseconds(tmpval);
-      if (ms != std::chrono::milliseconds(0)) {
-        *out++ = '.';
-        write(ms.count(), 3);
-      }
+      write_fractional_seconds(std::chrono::duration<rep, Period>{val});
       return;
     }
     auto time = tm();
     time.tm_sec = to_nonnegative_int(second(), 60);
-    format_localized(time, 'S', 'O');
+    format_tm(time, &tm_writer_type::on_second, ns);
   }
 
   void on_12_hour_time() {
     if (handle_nan_inf()) return;
-    format_localized(time(), 'r');
+    format_tm(time(), &tm_writer_type::on_12_hour_time);
   }
 
   void on_24_hour_time() {
@@ -987,12 +1800,12 @@ struct chrono_formatter {
     on_24_hour_time();
     *out++ = ':';
     if (handle_nan_inf()) return;
-    write(second(), 2);
+    on_second(numeric_system::standard);
   }
 
   void on_am_pm() {
     if (handle_nan_inf()) return;
-    format_localized(time(), 'p');
+    format_tm(time(), &tm_writer_type::on_am_pm);
   }
 
   void on_duration_value() {
@@ -1005,17 +1818,64 @@ struct chrono_formatter {
     out = format_duration_unit<char_type, Period>(out);
   }
 };
-}  // namespace detail
+
+FMT_END_DETAIL_NAMESPACE
+
+#if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907
+using weekday = std::chrono::weekday;
+#else
+// A fallback version of weekday.
+class weekday {
+ private:
+  unsigned char value;
+
+ public:
+  weekday() = default;
+  explicit constexpr weekday(unsigned wd) noexcept
+      : value(static_cast<unsigned char>(wd != 7 ? wd : 0)) {}
+  constexpr unsigned c_encoding() const noexcept { return value; }
+};
+
+class year_month_day {};
+#endif
+
+// A rudimentary weekday formatter.
+template <typename Char> struct formatter<weekday, Char> {
+ private:
+  bool localized = false;
+
+ public:
+  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
+      -> decltype(ctx.begin()) {
+    auto begin = ctx.begin(), end = ctx.end();
+    if (begin != end && *begin == 'L') {
+      ++begin;
+      localized = true;
+    }
+    return begin;
+  }
+
+  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());
+    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 Rep, typename Period, typename Char>
 struct formatter<std::chrono::duration<Rep, Period>, Char> {
  private:
   basic_format_specs<Char> specs;
-  int precision;
+  int precision = -1;
   using arg_ref_type = detail::arg_ref<Char>;
   arg_ref_type width_ref;
   arg_ref_type precision_ref;
-  mutable basic_string_view<Char> format_str;
+  bool localized = false;
+  basic_string_view<Char> format_str;
   using duration = std::chrono::duration<Rep, Period>;
 
   struct spec_handler {
@@ -1038,17 +1898,21 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
     }
 
     void on_error(const char* msg) { FMT_THROW(format_error(msg)); }
-    void on_fill(basic_string_view<Char> fill) { f.specs.fill = fill; }
-    void on_align(align_t align) { f.specs.align = align; }
-    void on_width(int width) { f.specs.width = width; }
-    void on_precision(int _precision) { f.precision = _precision; }
-    void end_precision() {}
+    FMT_CONSTEXPR void on_fill(basic_string_view<Char> fill) {
+      f.specs.fill = fill;
+    }
+    FMT_CONSTEXPR void on_align(align_t align) { f.specs.align = align; }
+    FMT_CONSTEXPR void on_width(int width) { f.specs.width = width; }
+    FMT_CONSTEXPR void on_precision(int _precision) {
+      f.precision = _precision;
+    }
+    FMT_CONSTEXPR void end_precision() {}
 
-    template <typename Id> void on_dynamic_width(Id arg_id) {
+    template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
       f.width_ref = make_arg_ref(arg_id);
     }
 
-    template <typename Id> void on_dynamic_precision(Id arg_id) {
+    template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
       f.precision_ref = make_arg_ref(arg_id);
     }
   };
@@ -1073,13 +1937,16 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
       else
         handler.on_error("precision not allowed for this argument type");
     }
-    end = parse_chrono_format(begin, end, detail::chrono_format_checker());
+    if (begin != end && *begin == 'L') {
+      ++begin;
+      localized = true;
+    }
+    end = detail::parse_chrono_format(begin, end,
+                                      detail::chrono_format_checker());
     return {begin, end};
   }
 
  public:
-  formatter() : precision(-1) {}
-
   FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
       -> decltype(ctx.begin()) {
     auto range = do_parse(ctx);
@@ -1089,30 +1956,112 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
   }
 
   template <typename FormatContext>
-  auto format(const duration& d, FormatContext& ctx) -> decltype(ctx.out()) {
+  auto format(const duration& d, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    auto specs_copy = specs;
+    auto precision_copy = precision;
     auto begin = format_str.begin(), end = format_str.end();
     // As a possible future optimization, we could avoid extra copying if width
     // is not specified.
     basic_memory_buffer<Char> buf;
     auto out = std::back_inserter(buf);
-    detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref,
-                                                       ctx);
-    detail::handle_dynamic_spec<detail::precision_checker>(precision,
+    detail::handle_dynamic_spec<detail::width_checker>(specs_copy.width,
+                                                       width_ref, ctx);
+    detail::handle_dynamic_spec<detail::precision_checker>(precision_copy,
                                                            precision_ref, ctx);
     if (begin == end || *begin == '}') {
-      out = detail::format_duration_value<Char>(out, d.count(), precision);
+      out = detail::format_duration_value<Char>(out, d.count(), precision_copy);
       detail::format_duration_unit<Char, Period>(out);
     } else {
       detail::chrono_formatter<FormatContext, decltype(out), Rep, Period> f(
           ctx, out, d);
-      f.precision = precision;
-      parse_chrono_format(begin, end, f);
+      f.precision = precision_copy;
+      f.localized = localized;
+      detail::parse_chrono_format(begin, end, f);
     }
     return detail::write(
-        ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs);
+        ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs_copy);
   }
 };
 
+template <typename Char, typename Duration>
+struct formatter<std::chrono::time_point<std::chrono::system_clock, Duration>,
+                 Char> : formatter<std::tm, Char> {
+  FMT_CONSTEXPR formatter() {
+    this->do_parse(default_specs,
+                   default_specs + sizeof(default_specs) / sizeof(Char));
+  }
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return this->do_parse(ctx.begin(), ctx.end(), true);
+  }
+
+  template <typename FormatContext>
+  auto format(std::chrono::time_point<std::chrono::system_clock> val,
+              FormatContext& ctx) const -> decltype(ctx.out()) {
+    return formatter<std::tm, Char>::format(localtime(val), ctx);
+  }
+
+  static constexpr const Char default_specs[] = {'%', 'F', ' ', '%', 'T'};
+};
+
+template <typename Char, typename Duration>
+constexpr const Char
+    formatter<std::chrono::time_point<std::chrono::system_clock, Duration>,
+              Char>::default_specs[];
+
+template <typename Char> struct formatter<std::tm, Char> {
+ private:
+  enum class spec {
+    unknown,
+    year_month_day,
+    hh_mm_ss,
+  };
+  spec spec_ = spec::unknown;
+  basic_string_view<Char> specs;
+
+ protected:
+  template <typename It>
+  FMT_CONSTEXPR auto do_parse(It begin, It end, bool with_default = false)
+      -> It {
+    if (begin != end && *begin == ':') ++begin;
+    end = detail::parse_chrono_format(begin, end, detail::tm_format_checker());
+    if (!with_default || end != begin)
+      specs = {begin, detail::to_unsigned(end - begin)};
+    // basic_string_view<>::compare isn't constexpr before C++17.
+    if (specs.size() == 2 && specs[0] == Char('%')) {
+      if (specs[1] == Char('F'))
+        spec_ = spec::year_month_day;
+      else if (specs[1] == Char('T'))
+        spec_ = spec::hh_mm_ss;
+    }
+    return end;
+  }
+
+ public:
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return this->do_parse(ctx.begin(), ctx.end());
+  }
+
+  template <typename FormatContext>
+  auto format(const std::tm& tm, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    const auto loc_ref = ctx.locale();
+    detail::get_locale loc(static_cast<bool>(loc_ref), loc_ref);
+    auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), tm);
+    if (spec_ == spec::year_month_day)
+      w.on_iso_date();
+    else if (spec_ == spec::hh_mm_ss)
+      w.on_iso_time();
+    else
+      detail::parse_chrono_format(specs.begin(), specs.end(), w);
+    return w.out();
+  }
+};
+
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
 #endif  // FMT_CHRONO_H_
diff --git a/deps/fmt/include/fmt/color.h b/deps/fmt/include/fmt/color.h
index 94e3419d..dfbe4829 100644
--- a/deps/fmt/include/fmt/color.h
+++ b/deps/fmt/include/fmt/color.h
@@ -10,7 +10,15 @@
 
 #include "format.h"
 
+// __declspec(deprecated) is broken in some MSVC versions.
+#if FMT_MSC_VER
+#  define FMT_DEPRECATED_NONMSVC
+#else
+#  define FMT_DEPRECATED_NONMSVC FMT_DEPRECATED
+#endif
+
 FMT_BEGIN_NAMESPACE
+FMT_MODULE_EXPORT_BEGIN
 
 enum class color : uint32_t {
   alice_blue = 0xF0F8FF,               // rgb(240,248,255)
@@ -177,9 +185,13 @@ enum class terminal_color : uint8_t {
 
 enum class emphasis : uint8_t {
   bold = 1,
-  italic = 1 << 1,
-  underline = 1 << 2,
-  strikethrough = 1 << 3
+  faint = 1 << 1,
+  italic = 1 << 2,
+  underline = 1 << 3,
+  blink = 1 << 4,
+  reverse = 1 << 5,
+  conceal = 1 << 6,
+  strikethrough = 1 << 7,
 };
 
 // rgb is a struct for red, green and blue colors.
@@ -198,7 +210,7 @@ struct rgb {
   uint8_t b;
 };
 
-namespace detail {
+FMT_BEGIN_DETAIL_NAMESPACE
 
 // color is a struct of either a rgb color or a terminal color.
 struct color_type {
@@ -221,9 +233,10 @@ struct color_type {
     uint32_t rgb_color;
   } value;
 };
-}  // namespace detail
 
-// Experimental text formatting support.
+FMT_END_DETAIL_NAMESPACE
+
+/** A text style consisting of foreground and background colors and emphasis. */
 class text_style {
  public:
   FMT_CONSTEXPR text_style(emphasis em = emphasis()) FMT_NOEXCEPT
@@ -260,33 +273,14 @@ class text_style {
     return lhs |= rhs;
   }
 
-  FMT_CONSTEXPR text_style& operator&=(const text_style& rhs) {
-    if (!set_foreground_color) {
-      set_foreground_color = rhs.set_foreground_color;
-      foreground_color = rhs.foreground_color;
-    } else if (rhs.set_foreground_color) {
-      if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
-        FMT_THROW(format_error("can't AND a terminal color"));
-      foreground_color.value.rgb_color &= rhs.foreground_color.value.rgb_color;
-    }
-
-    if (!set_background_color) {
-      set_background_color = rhs.set_background_color;
-      background_color = rhs.background_color;
-    } else if (rhs.set_background_color) {
-      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
-        FMT_THROW(format_error("can't AND a terminal color"));
-      background_color.value.rgb_color &= rhs.background_color.value.rgb_color;
-    }
-
-    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) &
-                                static_cast<uint8_t>(rhs.ems));
-    return *this;
+  FMT_DEPRECATED_NONMSVC FMT_CONSTEXPR text_style& operator&=(
+      const text_style& rhs) {
+    return and_assign(rhs);
   }
 
-  friend FMT_CONSTEXPR text_style operator&(text_style lhs,
-                                            const text_style& rhs) {
-    return lhs &= rhs;
+  FMT_DEPRECATED_NONMSVC friend FMT_CONSTEXPR text_style
+  operator&(text_style lhs, const text_style& rhs) {
+    return lhs.and_assign(rhs);
   }
 
   FMT_CONSTEXPR bool has_foreground() const FMT_NOEXCEPT {
@@ -326,8 +320,34 @@ class text_style {
     }
   }
 
+  // DEPRECATED!
+  FMT_CONSTEXPR text_style& and_assign(const text_style& rhs) {
+    if (!set_foreground_color) {
+      set_foreground_color = rhs.set_foreground_color;
+      foreground_color = rhs.foreground_color;
+    } else if (rhs.set_foreground_color) {
+      if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
+        FMT_THROW(format_error("can't AND a terminal color"));
+      foreground_color.value.rgb_color &= rhs.foreground_color.value.rgb_color;
+    }
+
+    if (!set_background_color) {
+      set_background_color = rhs.set_background_color;
+      background_color = rhs.background_color;
+    } else if (rhs.set_background_color) {
+      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
+        FMT_THROW(format_error("can't AND a terminal color"));
+      background_color.value.rgb_color &= rhs.background_color.value.rgb_color;
+    }
+
+    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) &
+                                static_cast<uint8_t>(rhs.ems));
+    return *this;
+  }
+
   friend FMT_CONSTEXPR_DECL text_style fg(detail::color_type foreground)
       FMT_NOEXCEPT;
+
   friend FMT_CONSTEXPR_DECL text_style bg(detail::color_type background)
       FMT_NOEXCEPT;
 
@@ -338,19 +358,22 @@ class text_style {
   emphasis ems;
 };
 
-FMT_CONSTEXPR text_style fg(detail::color_type foreground) FMT_NOEXCEPT {
-  return text_style(/*is_foreground=*/true, foreground);
+/** Creates a text style from the foreground (text) color. */
+FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) FMT_NOEXCEPT {
+  return text_style(true, foreground);
 }
 
-FMT_CONSTEXPR text_style bg(detail::color_type background) FMT_NOEXCEPT {
-  return text_style(/*is_foreground=*/false, background);
+/** Creates a text style from the background color. */
+FMT_CONSTEXPR inline text_style bg(detail::color_type background) FMT_NOEXCEPT {
+  return text_style(false, background);
 }
 
-FMT_CONSTEXPR text_style operator|(emphasis lhs, emphasis rhs) FMT_NOEXCEPT {
+FMT_CONSTEXPR inline text_style operator|(emphasis lhs,
+                                          emphasis rhs) FMT_NOEXCEPT {
   return text_style(lhs) | rhs;
 }
 
-namespace detail {
+FMT_BEGIN_DETAIL_NAMESPACE
 
 template <typename Char> struct ansi_color_escape {
   FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color,
@@ -358,7 +381,7 @@ template <typename Char> struct ansi_color_escape {
     // If we have a terminal color, we need to output another escape code
     // sequence.
     if (!text_color.is_rgb) {
-      bool is_background = esc == detail::data::background_color;
+      bool is_background = esc == string_view("\x1b[48;2;");
       uint32_t value = text_color.value.term_color;
       // Background ASCII codes are the same as the foreground ones but with
       // 10 more.
@@ -390,16 +413,18 @@ template <typename Char> struct ansi_color_escape {
     buffer[19] = static_cast<Char>(0);
   }
   FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT {
-    uint8_t em_codes[4] = {};
-    uint8_t em_bits = static_cast<uint8_t>(em);
-    if (em_bits & static_cast<uint8_t>(emphasis::bold)) em_codes[0] = 1;
-    if (em_bits & static_cast<uint8_t>(emphasis::italic)) em_codes[1] = 3;
-    if (em_bits & static_cast<uint8_t>(emphasis::underline)) em_codes[2] = 4;
-    if (em_bits & static_cast<uint8_t>(emphasis::strikethrough))
-      em_codes[3] = 9;
+    uint8_t em_codes[num_emphases] = {};
+    if (has_emphasis(em, emphasis::bold)) em_codes[0] = 1;
+    if (has_emphasis(em, emphasis::faint)) em_codes[1] = 2;
+    if (has_emphasis(em, emphasis::italic)) em_codes[2] = 3;
+    if (has_emphasis(em, emphasis::underline)) em_codes[3] = 4;
+    if (has_emphasis(em, emphasis::blink)) em_codes[4] = 5;
+    if (has_emphasis(em, emphasis::reverse)) em_codes[5] = 7;
+    if (has_emphasis(em, emphasis::conceal)) em_codes[6] = 8;
+    if (has_emphasis(em, emphasis::strikethrough)) em_codes[7] = 9;
 
     size_t index = 0;
-    for (int i = 0; i < 4; ++i) {
+    for (size_t i = 0; i < num_emphases; ++i) {
       if (!em_codes[i]) continue;
       buffer[index++] = static_cast<Char>('\x1b');
       buffer[index++] = static_cast<Char>('[');
@@ -411,12 +436,13 @@ template <typename Char> struct ansi_color_escape {
   FMT_CONSTEXPR operator const Char*() const FMT_NOEXCEPT { return buffer; }
 
   FMT_CONSTEXPR const Char* begin() const FMT_NOEXCEPT { return buffer; }
-  FMT_CONSTEXPR const Char* end() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR_CHAR_TRAITS const Char* end() const FMT_NOEXCEPT {
     return buffer + std::char_traits<Char>::length(buffer);
   }
 
  private:
-  Char buffer[7u + 3u * 4u + 1u];
+  static constexpr size_t num_emphases = 8;
+  Char buffer[7u + 3u * num_emphases + 1u];
 
   static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out,
                                    char delimiter) FMT_NOEXCEPT {
@@ -425,18 +451,22 @@ template <typename Char> struct ansi_color_escape {
     out[2] = static_cast<Char>('0' + c % 10);
     out[3] = static_cast<Char>(delimiter);
   }
+  static FMT_CONSTEXPR bool has_emphasis(emphasis em,
+                                         emphasis mask) FMT_NOEXCEPT {
+    return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask);
+  }
 };
 
 template <typename Char>
 FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
     detail::color_type foreground) FMT_NOEXCEPT {
-  return ansi_color_escape<Char>(foreground, detail::data::foreground_color);
+  return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
 }
 
 template <typename Char>
 FMT_CONSTEXPR ansi_color_escape<Char> make_background_color(
     detail::color_type background) FMT_NOEXCEPT {
-  return ansi_color_escape<Char>(background, detail::data::background_color);
+  return ansi_color_escape<Char>(background, "\x1b[48;2;");
 }
 
 template <typename Char>
@@ -455,18 +485,17 @@ inline void fputs<wchar_t>(const wchar_t* chars, FILE* stream) FMT_NOEXCEPT {
 }
 
 template <typename Char> inline void reset_color(FILE* stream) FMT_NOEXCEPT {
-  fputs(detail::data::reset_color, stream);
+  fputs("\x1b[0m", stream);
 }
 
 template <> inline void reset_color<wchar_t>(FILE* stream) FMT_NOEXCEPT {
-  fputs(detail::data::wreset_color, stream);
+  fputs(L"\x1b[0m", stream);
 }
 
 template <typename Char>
 inline void reset_color(buffer<Char>& buffer) FMT_NOEXCEPT {
-  const char* begin = data::reset_color;
-  const char* end = begin + sizeof(data::reset_color) - 1;
-  buffer.append(begin, end);
+  auto reset_color = string_view("\x1b[0m");
+  buffer.append(reset_color.begin(), reset_color.end());
 }
 
 template <typename Char>
@@ -489,10 +518,11 @@ void vformat_to(buffer<Char>& buf, const text_style& ts,
     auto background = detail::make_background_color<Char>(ts.get_background());
     buf.append(background.begin(), background.end());
   }
-  detail::vformat_to(buf, format_str, args);
+  detail::vformat_to(buf, format_str, args, {});
   if (has_style) detail::reset_color<Char>(buf);
 }
-}  // namespace detail
+
+FMT_END_DETAIL_NAMESPACE
 
 template <typename S, typename Char = char_t<S>>
 void vprint(std::FILE* f, const text_style& ts, const S& format,
@@ -523,11 +553,15 @@ void print(std::FILE* f, const text_style& ts, const S& format_str,
 }
 
 /**
+  \rst
   Formats a string and prints it to stdout using ANSI escape sequences to
   specify text formatting.
-  Example:
+
+  **Example**::
+
     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
                "Elapsed time: {0:.2f} seconds", 1.23);
+  \endrst
  */
 template <typename S, typename... Args,
           FMT_ENABLE_IF(detail::is_string<S>::value)>
@@ -559,8 +593,8 @@ inline std::basic_string<Char> vformat(
 template <typename S, typename... Args, typename Char = char_t<S>>
 inline std::basic_string<Char> format(const text_style& ts, const S& format_str,
                                       const Args&... args) {
-  return vformat(ts, to_string_view(format_str),
-                 fmt::make_args_checked<Args...>(format_str, args...));
+  return fmt::vformat(ts, to_string_view(format_str),
+                      fmt::make_args_checked<Args...>(format_str, args...));
 }
 
 /**
@@ -571,7 +605,7 @@ template <typename OutputIt, typename Char,
 OutputIt vformat_to(
     OutputIt out, const text_style& ts, basic_string_view<Char> format_str,
     basic_format_args<buffer_context<type_identity_t<Char>>> args) {
-  decltype(detail::get_buffer<Char>(out)) buf(detail::get_buffer_init(out));
+  auto&& buf = detail::get_buffer<Char>(out);
   detail::vformat_to(buf, ts, format_str, args);
   return detail::get_iterator(buf);
 }
@@ -598,6 +632,7 @@ inline auto format_to(OutputIt out, const text_style& ts, const S& format_str,
                     fmt::make_args_checked<Args...>(format_str, args...));
 }
 
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
 #endif  // FMT_COLOR_H_
diff --git a/deps/fmt/include/fmt/compile.h b/deps/fmt/include/fmt/compile.h
index 3a33b020..1dba3ddb 100644
--- a/deps/fmt/include/fmt/compile.h
+++ b/deps/fmt/include/fmt/compile.h
@@ -8,13 +8,135 @@
 #ifndef FMT_COMPILE_H_
 #define FMT_COMPILE_H_
 
-#include <vector>
-
 #include "format.h"
 
 FMT_BEGIN_NAMESPACE
 namespace detail {
 
+// An output iterator that counts the number of objects written to it and
+// discards them.
+class counting_iterator {
+ private:
+  size_t count_;
+
+ public:
+  using iterator_category = std::output_iterator_tag;
+  using difference_type = std::ptrdiff_t;
+  using pointer = void;
+  using reference = void;
+  using _Unchecked_type = counting_iterator;  // Mark iterator as checked.
+
+  struct value_type {
+    template <typename T> void operator=(const T&) {}
+  };
+
+  counting_iterator() : count_(0) {}
+
+  size_t count() const { return count_; }
+
+  counting_iterator& operator++() {
+    ++count_;
+    return *this;
+  }
+  counting_iterator operator++(int) {
+    auto it = *this;
+    ++*this;
+    return it;
+  }
+
+  friend counting_iterator operator+(counting_iterator it, difference_type n) {
+    it.count_ += static_cast<size_t>(n);
+    return it;
+  }
+
+  value_type operator*() const { return {}; }
+};
+
+template <typename Char, typename InputIt>
+inline counting_iterator copy_str(InputIt begin, InputIt end,
+                                  counting_iterator it) {
+  return it + (end - begin);
+}
+
+template <typename OutputIt> class truncating_iterator_base {
+ protected:
+  OutputIt out_;
+  size_t limit_;
+  size_t count_ = 0;
+
+  truncating_iterator_base() : out_(), limit_(0) {}
+
+  truncating_iterator_base(OutputIt out, size_t limit)
+      : out_(out), limit_(limit) {}
+
+ public:
+  using iterator_category = std::output_iterator_tag;
+  using value_type = typename std::iterator_traits<OutputIt>::value_type;
+  using difference_type = std::ptrdiff_t;
+  using pointer = void;
+  using reference = void;
+  using _Unchecked_type =
+      truncating_iterator_base;  // Mark iterator as checked.
+
+  OutputIt base() const { return out_; }
+  size_t count() const { return count_; }
+};
+
+// An output iterator that truncates the output and counts the number of objects
+// written to it.
+template <typename OutputIt,
+          typename Enable = typename std::is_void<
+              typename std::iterator_traits<OutputIt>::value_type>::type>
+class truncating_iterator;
+
+template <typename OutputIt>
+class truncating_iterator<OutputIt, std::false_type>
+    : public truncating_iterator_base<OutputIt> {
+  mutable typename truncating_iterator_base<OutputIt>::value_type blackhole_;
+
+ public:
+  using value_type = typename truncating_iterator_base<OutputIt>::value_type;
+
+  truncating_iterator() = default;
+
+  truncating_iterator(OutputIt out, size_t limit)
+      : truncating_iterator_base<OutputIt>(out, limit) {}
+
+  truncating_iterator& operator++() {
+    if (this->count_++ < this->limit_) ++this->out_;
+    return *this;
+  }
+
+  truncating_iterator operator++(int) {
+    auto it = *this;
+    ++*this;
+    return it;
+  }
+
+  value_type& operator*() const {
+    return this->count_ < this->limit_ ? *this->out_ : blackhole_;
+  }
+};
+
+template <typename OutputIt>
+class truncating_iterator<OutputIt, std::true_type>
+    : public truncating_iterator_base<OutputIt> {
+ public:
+  truncating_iterator() = default;
+
+  truncating_iterator(OutputIt out, size_t limit)
+      : truncating_iterator_base<OutputIt>(out, limit) {}
+
+  template <typename T> truncating_iterator& operator=(T val) {
+    if (this->count_++ < this->limit_) *this->out_++ = val;
+    return *this;
+  }
+
+  truncating_iterator& operator++() { return *this; }
+  truncating_iterator& operator++(int) { return *this; }
+  truncating_iterator& operator*() { return *this; }
+};
+
 // A compile-time string which is compiled into fast formatting code.
 class compiled_string {};
 
@@ -34,336 +156,30 @@ struct is_compiled_string : std::is_base_of<compiled_string, S> {};
     std::string s = fmt::format(FMT_COMPILE("{}"), 42);
   \endrst
  */
-#define FMT_COMPILE(s) FMT_STRING_IMPL(s, fmt::detail::compiled_string)
+#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
+#  define FMT_COMPILE(s) \
+    FMT_STRING_IMPL(s, fmt::detail::compiled_string, explicit)
+#else
+#  define FMT_COMPILE(s) FMT_STRING(s)
+#endif
+
+#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+template <typename Char, size_t N,
+          fmt::detail_exported::fixed_string<Char, N> Str>
+struct udl_compiled_string : compiled_string {
+  using char_type = Char;
+  constexpr operator basic_string_view<char_type>() const {
+    return {Str.data, N - 1};
+  }
+};
+#endif
 
 template <typename T, typename... Tail>
 const T& first(const T& value, const Tail&...) {
   return value;
 }
 
-// Part of a compiled format string. It can be either literal text or a
-// replacement field.
-template <typename Char> struct format_part {
-  enum class kind { arg_index, arg_name, text, replacement };
-
-  struct replacement {
-    arg_ref<Char> arg_id;
-    dynamic_format_specs<Char> specs;
-  };
-
-  kind part_kind;
-  union value {
-    int arg_index;
-    basic_string_view<Char> str;
-    replacement repl;
-
-    FMT_CONSTEXPR value(int index = 0) : arg_index(index) {}
-    FMT_CONSTEXPR value(basic_string_view<Char> s) : str(s) {}
-    FMT_CONSTEXPR value(replacement r) : repl(r) {}
-  } val;
-  // Position past the end of the argument id.
-  const Char* arg_id_end = nullptr;
-
-  FMT_CONSTEXPR format_part(kind k = kind::arg_index, value v = {})
-      : part_kind(k), val(v) {}
-
-  static FMT_CONSTEXPR format_part make_arg_index(int index) {
-    return format_part(kind::arg_index, index);
-  }
-  static FMT_CONSTEXPR format_part make_arg_name(basic_string_view<Char> name) {
-    return format_part(kind::arg_name, name);
-  }
-  static FMT_CONSTEXPR format_part make_text(basic_string_view<Char> text) {
-    return format_part(kind::text, text);
-  }
-  static FMT_CONSTEXPR format_part make_replacement(replacement repl) {
-    return format_part(kind::replacement, repl);
-  }
-};
-
-template <typename Char> struct part_counter {
-  unsigned num_parts = 0;
-
-  FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) {
-    if (begin != end) ++num_parts;
-  }
-
-  FMT_CONSTEXPR int on_arg_id() { return ++num_parts, 0; }
-  FMT_CONSTEXPR int on_arg_id(int) { return ++num_parts, 0; }
-  FMT_CONSTEXPR int on_arg_id(basic_string_view<Char>) {
-    return ++num_parts, 0;
-  }
-
-  FMT_CONSTEXPR void on_replacement_field(int, const Char*) {}
-
-  FMT_CONSTEXPR const Char* on_format_specs(int, const Char* begin,
-                                            const Char* end) {
-    // Find the matching brace.
-    unsigned brace_counter = 0;
-    for (; begin != end; ++begin) {
-      if (*begin == '{') {
-        ++brace_counter;
-      } else if (*begin == '}') {
-        if (brace_counter == 0u) break;
-        --brace_counter;
-      }
-    }
-    return begin;
-  }
-
-  FMT_CONSTEXPR void on_error(const char*) {}
-};
-
-// Counts the number of parts in a format string.
-template <typename Char>
-FMT_CONSTEXPR unsigned count_parts(basic_string_view<Char> format_str) {
-  part_counter<Char> counter;
-  parse_format_string<true>(format_str, counter);
-  return counter.num_parts;
-}
-
-template <typename Char, typename PartHandler>
-class format_string_compiler : public error_handler {
- private:
-  using part = format_part<Char>;
-
-  PartHandler handler_;
-  part part_;
-  basic_string_view<Char> format_str_;
-  basic_format_parse_context<Char> parse_context_;
-
- public:
-  FMT_CONSTEXPR format_string_compiler(basic_string_view<Char> format_str,
-                                       PartHandler handler)
-      : handler_(handler),
-        format_str_(format_str),
-        parse_context_(format_str) {}
-
-  FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) {
-    if (begin != end)
-      handler_(part::make_text({begin, to_unsigned(end - begin)}));
-  }
-
-  FMT_CONSTEXPR int on_arg_id() {
-    part_ = part::make_arg_index(parse_context_.next_arg_id());
-    return 0;
-  }
-
-  FMT_CONSTEXPR int on_arg_id(int id) {
-    parse_context_.check_arg_id(id);
-    part_ = part::make_arg_index(id);
-    return 0;
-  }
-
-  FMT_CONSTEXPR int on_arg_id(basic_string_view<Char> id) {
-    part_ = part::make_arg_name(id);
-    return 0;
-  }
-
-  FMT_CONSTEXPR void on_replacement_field(int, const Char* ptr) {
-    part_.arg_id_end = ptr;
-    handler_(part_);
-  }
-
-  FMT_CONSTEXPR const Char* on_format_specs(int, const Char* begin,
-                                            const Char* end) {
-    auto repl = typename part::replacement();
-    dynamic_specs_handler<basic_format_parse_context<Char>> handler(
-        repl.specs, parse_context_);
-    auto it = parse_format_specs(begin, end, handler);
-    if (*it != '}') on_error("missing '}' in format string");
-    repl.arg_id = part_.part_kind == part::kind::arg_index
-                      ? arg_ref<Char>(part_.val.arg_index)
-                      : arg_ref<Char>(part_.val.str);
-    auto part = part::make_replacement(repl);
-    part.arg_id_end = begin;
-    handler_(part);
-    return it;
-  }
-};
-
-// Compiles a format string and invokes handler(part) for each parsed part.
-template <bool IS_CONSTEXPR, typename Char, typename PartHandler>
-FMT_CONSTEXPR void compile_format_string(basic_string_view<Char> format_str,
-                                         PartHandler handler) {
-  parse_format_string<IS_CONSTEXPR>(
-      format_str,
-      format_string_compiler<Char, PartHandler>(format_str, handler));
-}
-
-template <typename OutputIt, typename Context, typename Id>
-void format_arg(
-    basic_format_parse_context<typename Context::char_type>& parse_ctx,
-    Context& ctx, Id arg_id) {
-  ctx.advance_to(visit_format_arg(
-      arg_formatter<OutputIt, typename Context::char_type>(ctx, &parse_ctx),
-      ctx.arg(arg_id)));
-}
-
-// vformat_to is defined in a subnamespace to prevent ADL.
-namespace cf {
-template <typename Context, typename OutputIt, typename CompiledFormat>
-auto vformat_to(OutputIt out, CompiledFormat& cf,
-                basic_format_args<Context> args) -> typename Context::iterator {
-  using char_type = typename Context::char_type;
-  basic_format_parse_context<char_type> parse_ctx(
-      to_string_view(cf.format_str_));
-  Context ctx(out, args);
-
-  const auto& parts = cf.parts();
-  for (auto part_it = std::begin(parts); part_it != std::end(parts);
-       ++part_it) {
-    const auto& part = *part_it;
-    const auto& value = part.val;
-
-    using format_part_t = format_part<char_type>;
-    switch (part.part_kind) {
-    case format_part_t::kind::text: {
-      const auto text = value.str;
-      auto output = ctx.out();
-      auto&& it = reserve(output, text.size());
-      it = std::copy_n(text.begin(), text.size(), it);
-      ctx.advance_to(output);
-      break;
-    }
-
-    case format_part_t::kind::arg_index:
-      advance_to(parse_ctx, part.arg_id_end);
-      detail::format_arg<OutputIt>(parse_ctx, ctx, value.arg_index);
-      break;
-
-    case format_part_t::kind::arg_name:
-      advance_to(parse_ctx, part.arg_id_end);
-      detail::format_arg<OutputIt>(parse_ctx, ctx, value.str);
-      break;
-
-    case format_part_t::kind::replacement: {
-      const auto& arg_id_value = value.repl.arg_id.val;
-      const auto arg = value.repl.arg_id.kind == arg_id_kind::index
-                           ? ctx.arg(arg_id_value.index)
-                           : ctx.arg(arg_id_value.name);
-
-      auto specs = value.repl.specs;
-
-      handle_dynamic_spec<width_checker>(specs.width, specs.width_ref, ctx);
-      handle_dynamic_spec<precision_checker>(specs.precision,
-                                             specs.precision_ref, ctx);
-
-      error_handler h;
-      numeric_specs_checker<error_handler> checker(h, arg.type());
-      if (specs.align == align::numeric) checker.require_numeric_argument();
-      if (specs.sign != sign::none) checker.check_sign();
-      if (specs.alt) checker.require_numeric_argument();
-      if (specs.precision >= 0) checker.check_precision();
-
-      advance_to(parse_ctx, part.arg_id_end);
-      ctx.advance_to(
-          visit_format_arg(arg_formatter<OutputIt, typename Context::char_type>(
-                               ctx, nullptr, &specs),
-                           arg));
-      break;
-    }
-    }
-  }
-  return ctx.out();
-}
-}  // namespace cf
-
-struct basic_compiled_format {};
-
-template <typename S, typename = void>
-struct compiled_format_base : basic_compiled_format {
-  using char_type = char_t<S>;
-  using parts_container = std::vector<detail::format_part<char_type>>;
-
-  parts_container compiled_parts;
-
-  explicit compiled_format_base(basic_string_view<char_type> format_str) {
-    compile_format_string<false>(format_str,
-                                 [this](const format_part<char_type>& part) {
-                                   compiled_parts.push_back(part);
-                                 });
-  }
-
-  const parts_container& parts() const { return compiled_parts; }
-};
-
-template <typename Char, unsigned N> struct format_part_array {
-  format_part<Char> data[N] = {};
-  FMT_CONSTEXPR format_part_array() = default;
-};
-
-template <typename Char, unsigned N>
-FMT_CONSTEXPR format_part_array<Char, N> compile_to_parts(
-    basic_string_view<Char> format_str) {
-  format_part_array<Char, N> parts;
-  unsigned counter = 0;
-  // This is not a lambda for compatibility with older compilers.
-  struct {
-    format_part<Char>* parts;
-    unsigned* counter;
-    FMT_CONSTEXPR void operator()(const format_part<Char>& part) {
-      parts[(*counter)++] = part;
-    }
-  } collector{parts.data, &counter};
-  compile_format_string<true>(format_str, collector);
-  if (counter < N) {
-    parts.data[counter] =
-        format_part<Char>::make_text(basic_string_view<Char>());
-  }
-  return parts;
-}
-
-template <typename T> constexpr const T& constexpr_max(const T& a, const T& b) {
-  return (a < b) ? b : a;
-}
-
-template <typename S>
-struct compiled_format_base<S, enable_if_t<is_compile_string<S>::value>>
-    : basic_compiled_format {
-  using char_type = char_t<S>;
-
-  FMT_CONSTEXPR explicit compiled_format_base(basic_string_view<char_type>) {}
-
-// Workaround for old compilers. Format string compilation will not be
-// performed there anyway.
-#if FMT_USE_CONSTEXPR
-  static FMT_CONSTEXPR_DECL const unsigned num_format_parts =
-      constexpr_max(count_parts(to_string_view(S())), 1u);
-#else
-  static const unsigned num_format_parts = 1;
-#endif
-
-  using parts_container = format_part<char_type>[num_format_parts];
-
-  const parts_container& parts() const {
-    static FMT_CONSTEXPR_DECL const auto compiled_parts =
-        compile_to_parts<char_type, num_format_parts>(
-            detail::to_string_view(S()));
-    return compiled_parts.data;
-  }
-};
-
-template <typename S, typename... Args>
-class compiled_format : private compiled_format_base<S> {
- public:
-  using typename compiled_format_base<S>::char_type;
-
- private:
-  basic_string_view<char_type> format_str_;
-
-  template <typename Context, typename OutputIt, typename CompiledFormat>
-  friend auto cf::vformat_to(OutputIt out, CompiledFormat& cf,
-                             basic_format_args<Context> args) ->
-      typename Context::iterator;
-
- public:
-  compiled_format() = delete;
-  explicit constexpr compiled_format(basic_string_view<char_type> format_str)
-      : compiled_format_base<S>(format_str), format_str_(format_str) {}
-};
-
-#ifdef __cpp_if_constexpr
+#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
 template <typename... Args> struct type_list {};
 
 // Returns a reference to the argument at index N from [first, rest...].
@@ -374,13 +190,20 @@ constexpr const auto& get([[maybe_unused]] const T& first,
   if constexpr (N == 0)
     return first;
   else
-    return get<N - 1>(rest...);
+    return detail::get<N - 1>(rest...);
+}
+
+template <typename Char, typename... Args>
+constexpr int get_arg_index_by_name(basic_string_view<Char> name,
+                                    type_list<Args...>) {
+  return get_arg_index_by_name<Args...>(name);
 }
 
 template <int N, typename> struct get_type_impl;
 
 template <int N, typename... Args> struct get_type_impl<N, type_list<Args...>> {
-  using type = remove_cvref_t<decltype(get<N>(std::declval<Args>()...))>;
+  using type =
+      remove_cvref_t<decltype(detail::get<N>(std::declval<Args>()...))>;
 };
 
 template <int N, typename T>
@@ -393,7 +216,7 @@ template <typename Char> struct text {
   using char_type = Char;
 
   template <typename OutputIt, typename... Args>
-  OutputIt format(OutputIt out, const Args&...) const {
+  constexpr OutputIt format(OutputIt out, const Args&...) const {
     return write<Char>(out, data);
   }
 };
@@ -412,11 +235,22 @@ template <typename Char> struct code_unit {
   using char_type = Char;
 
   template <typename OutputIt, typename... Args>
-  OutputIt format(OutputIt out, const Args&...) const {
+  constexpr OutputIt format(OutputIt out, const Args&...) const {
     return write<Char>(out, value);
   }
 };
 
+// This ensures that the argument type is convertible to `const T&`.
+template <typename T, int N, typename... Args>
+constexpr const T& get_arg_checked(const Args&... args) {
+  const auto& arg = detail::get<N>(args...);
+  if constexpr (detail::is_named_arg<remove_cvref_t<decltype(arg)>>()) {
+    return arg.value;
+  } else {
+    return arg;
+  }
+}
+
 template <typename Char>
 struct is_compiled_format<code_unit<Char>> : std::true_type {};
 
@@ -425,29 +259,58 @@ template <typename Char, typename T, int N> struct field {
   using char_type = Char;
 
   template <typename OutputIt, typename... Args>
-  OutputIt format(OutputIt out, const Args&... args) const {
-    // This ensures that the argument type is convertile to `const T&`.
-    const T& arg = get<N>(args...);
-    return write<Char>(out, arg);
+  constexpr OutputIt format(OutputIt out, const Args&... args) const {
+    return write<Char>(out, get_arg_checked<T, N>(args...));
   }
 };
 
 template <typename Char, typename T, int N>
 struct is_compiled_format<field<Char, T, N>> : std::true_type {};
 
+// A replacement field that refers to argument with name.
+template <typename Char> struct runtime_named_field {
+  using char_type = Char;
+  basic_string_view<Char> name;
+
+  template <typename OutputIt, typename T>
+  constexpr static bool try_format_argument(
+      OutputIt& out,
+      // [[maybe_unused]] due to unused-but-set-parameter warning in GCC 7,8,9
+      [[maybe_unused]] basic_string_view<Char> arg_name, const T& arg) {
+    if constexpr (is_named_arg<typename std::remove_cv<T>::type>::value) {
+      if (arg_name == arg.name) {
+        out = write<Char>(out, arg.value);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&... args) const {
+    bool found = (try_format_argument(out, name, args) || ...);
+    if (!found) {
+      FMT_THROW(format_error("argument with specified name is not found"));
+    }
+    return out;
+  }
+};
+
+template <typename Char>
+struct is_compiled_format<runtime_named_field<Char>> : std::true_type {};
+
 // A replacement field that refers to argument N and has format specifiers.
 template <typename Char, typename T, int N> struct spec_field {
   using char_type = Char;
-  mutable formatter<T, Char> fmt;
+  formatter<T, Char> fmt;
 
   template <typename OutputIt, typename... Args>
-  OutputIt format(OutputIt out, const Args&... args) const {
-    // This ensures that the argument type is convertile to `const T&`.
-    const T& arg = get<N>(args...);
+  constexpr FMT_INLINE OutputIt format(OutputIt out,
+                                       const Args&... args) const {
     const auto& vargs =
-        make_format_args<basic_format_context<OutputIt, Char>>(args...);
+        fmt::make_format_args<basic_format_context<OutputIt, Char>>(args...);
     basic_format_context<OutputIt, Char> ctx(out, vargs);
-    return fmt.format(arg, ctx);
+    return fmt.format(get_arg_checked<T, N>(args...), ctx);
   }
 };
 
@@ -460,7 +323,7 @@ template <typename L, typename R> struct concat {
   using char_type = typename L::char_type;
 
   template <typename OutputIt, typename... Args>
-  OutputIt format(OutputIt out, const Args&... args) const {
+  constexpr OutputIt format(OutputIt out, const Args&... args) const {
     out = lhs.format(out, args...);
     return rhs.format(out, args...);
   }
@@ -508,14 +371,79 @@ template <typename T, typename Char> struct parse_specs_result {
   int next_arg_id;
 };
 
+constexpr int manual_indexing_id = -1;
+
 template <typename T, typename Char>
 constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
-                                                  size_t pos, int arg_id) {
+                                                  size_t pos, int next_arg_id) {
   str.remove_prefix(pos);
-  auto ctx = basic_format_parse_context<Char>(str, {}, arg_id + 1);
+  auto ctx = basic_format_parse_context<Char>(str, {}, next_arg_id);
   auto f = formatter<T, Char>();
   auto end = f.parse(ctx);
-  return {f, pos + (end - str.data()) + 1, ctx.next_arg_id()};
+  return {f, pos + fmt::detail::to_unsigned(end - str.data()) + 1,
+          next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()};
+}
+
+template <typename Char> struct arg_id_handler {
+  arg_ref<Char> arg_id;
+
+  constexpr int operator()() {
+    FMT_ASSERT(false, "handler cannot be used with automatic indexing");
+    return 0;
+  }
+  constexpr int operator()(int id) {
+    arg_id = arg_ref<Char>(id);
+    return 0;
+  }
+  constexpr int operator()(basic_string_view<Char> id) {
+    arg_id = arg_ref<Char>(id);
+    return 0;
+  }
+
+  constexpr void on_error(const char* message) {
+    FMT_THROW(format_error(message));
+  }
+};
+
+template <typename Char> struct parse_arg_id_result {
+  arg_ref<Char> arg_id;
+  const Char* arg_id_end;
+};
+
+template <int ID, typename Char>
+constexpr auto parse_arg_id(const Char* begin, const Char* end) {
+  auto handler = arg_id_handler<Char>{arg_ref<Char>{}};
+  auto arg_id_end = parse_arg_id(begin, end, handler);
+  return parse_arg_id_result<Char>{handler.arg_id, arg_id_end};
+}
+
+template <typename T, typename Enable = void> struct field_type {
+  using type = remove_cvref_t<T>;
+};
+
+template <typename T>
+struct field_type<T, enable_if_t<detail::is_named_arg<T>::value>> {
+  using type = remove_cvref_t<decltype(T::value)>;
+};
+
+template <typename T, typename Args, size_t END_POS, int ARG_INDEX, int NEXT_ID,
+          typename S>
+constexpr auto parse_replacement_field_then_tail(S format_str) {
+  using char_type = typename S::char_type;
+  constexpr auto str = basic_string_view<char_type>(format_str);
+  constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type();
+  if constexpr (c == '}') {
+    return parse_tail<Args, END_POS + 1, NEXT_ID>(
+        field<char_type, typename field_type<T>::type, ARG_INDEX>(),
+        format_str);
+  } else if constexpr (c == ':') {
+    constexpr auto result = parse_specs<typename field_type<T>::type>(
+        str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID);
+    return parse_tail<Args, result.end, result.next_arg_id>(
+        spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
+            result.fmt},
+        format_str);
+  }
 }
 
 // Compiles a non-empty format string and returns the compiled representation
@@ -523,27 +451,59 @@ constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
 template <typename Args, size_t POS, int ID, typename S>
 constexpr auto compile_format_string(S format_str) {
   using char_type = typename S::char_type;
-  constexpr basic_string_view<char_type> str = format_str;
+  constexpr auto str = basic_string_view<char_type>(format_str);
   if constexpr (str[POS] == '{') {
-    if (POS + 1 == str.size())
-      throw format_error("unmatched '{' in format string");
+    if constexpr (POS + 1 == str.size())
+      FMT_THROW(format_error("unmatched '{' in format string"));
     if constexpr (str[POS + 1] == '{') {
       return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
-    } else if constexpr (str[POS + 1] == '}') {
-      using type = get_type<ID, Args>;
-      return parse_tail<Args, POS + 2, ID + 1>(field<char_type, type, ID>(),
-                                               format_str);
-    } else if constexpr (str[POS + 1] == ':') {
-      using type = get_type<ID, Args>;
-      constexpr auto result = parse_specs<type>(str, POS + 2, ID);
-      return parse_tail<Args, result.end, result.next_arg_id>(
-          spec_field<char_type, type, ID>{result.fmt}, format_str);
+    } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') {
+      static_assert(ID != manual_indexing_id,
+                    "cannot switch from manual to automatic argument indexing");
+      constexpr auto next_id =
+          ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
+      return parse_replacement_field_then_tail<get_type<ID, Args>, Args,
+                                               POS + 1, ID, next_id>(
+          format_str);
     } else {
-      return unknown_format();
+      constexpr auto arg_id_result =
+          parse_arg_id<ID>(str.data() + POS + 1, str.data() + str.size());
+      constexpr auto arg_id_end_pos = arg_id_result.arg_id_end - str.data();
+      constexpr char_type c =
+          arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type();
+      static_assert(c == '}' || c == ':', "missing '}' in format string");
+      if constexpr (arg_id_result.arg_id.kind == arg_id_kind::index) {
+        static_assert(
+            ID == manual_indexing_id || ID == 0,
+            "cannot switch from automatic to manual argument indexing");
+        constexpr auto arg_index = arg_id_result.arg_id.val.index;
+        return parse_replacement_field_then_tail<get_type<arg_index, Args>,
+                                                 Args, arg_id_end_pos,
+                                                 arg_index, manual_indexing_id>(
+            format_str);
+      } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) {
+        constexpr auto arg_index =
+            get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{});
+        if constexpr (arg_index != invalid_arg_index) {
+          constexpr auto next_id =
+              ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
+          return parse_replacement_field_then_tail<
+              decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos,
+              arg_index, next_id>(format_str);
+        } else {
+          if constexpr (c == '}') {
+            return parse_tail<Args, arg_id_end_pos + 1, ID>(
+                runtime_named_field<char_type>{arg_id_result.arg_id.val.name},
+                format_str);
+          } else if constexpr (c == ':') {
+            return unknown_format();  // no type info for specs parsing
+          }
+        }
+      }
     }
   } else if constexpr (str[POS] == '}') {
-    if (POS + 1 == str.size())
-      throw format_error("unmatched '}' in format string");
+    if constexpr (POS + 1 == str.size())
+      FMT_THROW(format_error("unmatched '}' in format string"));
     return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
   } else {
     constexpr auto end = parse_text(str, POS + 1);
@@ -558,144 +518,125 @@ constexpr auto compile_format_string(S format_str) {
 }
 
 template <typename... Args, typename S,
-          FMT_ENABLE_IF(is_compile_string<S>::value ||
-                        detail::is_compiled_string<S>::value)>
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
 constexpr auto compile(S format_str) {
-  constexpr basic_string_view<typename S::char_type> str = format_str;
+  constexpr auto str = basic_string_view<typename S::char_type>(format_str);
   if constexpr (str.size() == 0) {
     return detail::make_text(str, 0, 0);
   } else {
     constexpr auto result =
         detail::compile_format_string<detail::type_list<Args...>, 0, 0>(
             format_str);
-    if constexpr (std::is_same<remove_cvref_t<decltype(result)>,
-                               detail::unknown_format>()) {
-      return detail::compiled_format<S, Args...>(to_string_view(format_str));
-    } else {
-      return result;
-    }
+    return result;
   }
 }
-#else
-template <typename... Args, typename S,
-          FMT_ENABLE_IF(is_compile_string<S>::value)>
-constexpr auto compile(S format_str) -> detail::compiled_format<S, Args...> {
-  return detail::compiled_format<S, Args...>(to_string_view(format_str));
-}
-#endif  // __cpp_if_constexpr
-
-// Compiles the format string which must be a string literal.
-template <typename... Args, typename Char, size_t N>
-auto compile(const Char (&format_str)[N])
-    -> detail::compiled_format<const Char*, Args...> {
-  return detail::compiled_format<const Char*, Args...>(
-      basic_string_view<Char>(format_str, N - 1));
-}
+#endif  // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
 }  // namespace detail
 
-// DEPRECATED! use FMT_COMPILE instead.
-template <typename... Args>
-FMT_DEPRECATED auto compile(const Args&... args)
-    -> decltype(detail::compile(args...)) {
-  return detail::compile(args...);
-}
+FMT_MODULE_EXPORT_BEGIN
 
-#if FMT_USE_CONSTEXPR
-#  ifdef __cpp_if_constexpr
+#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
 
 template <typename CompiledFormat, typename... Args,
           typename Char = typename CompiledFormat::char_type,
           FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
 FMT_INLINE std::basic_string<Char> format(const CompiledFormat& cf,
                                           const Args&... args) {
-  basic_memory_buffer<Char> buffer;
-  cf.format(detail::buffer_appender<Char>(buffer), args...);
-  return to_string(buffer);
+  auto s = std::basic_string<Char>();
+  cf.format(std::back_inserter(s), args...);
+  return s;
 }
 
 template <typename OutputIt, typename CompiledFormat, typename... Args,
           FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
-OutputIt format_to(OutputIt out, const CompiledFormat& cf,
-                   const Args&... args) {
+constexpr FMT_INLINE OutputIt format_to(OutputIt out, const CompiledFormat& cf,
+                                        const Args&... args) {
   return cf.format(out, args...);
 }
-#  endif  // __cpp_if_constexpr
-#endif    // FMT_USE_CONSTEXPR
-
-template <typename CompiledFormat, typename... Args,
-          typename Char = typename CompiledFormat::char_type,
-          FMT_ENABLE_IF(std::is_base_of<detail::basic_compiled_format,
-                                        CompiledFormat>::value)>
-std::basic_string<Char> format(const CompiledFormat& cf, const Args&... args) {
-  basic_memory_buffer<Char> buffer;
-  using context = buffer_context<Char>;
-  detail::cf::vformat_to<context>(detail::buffer_appender<Char>(buffer), cf,
-                                  make_format_args<context>(args...));
-  return to_string(buffer);
-}
 
 template <typename S, typename... Args,
           FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
 FMT_INLINE std::basic_string<typename S::char_type> format(const S&,
                                                            Args&&... args) {
-#ifdef __cpp_if_constexpr
   if constexpr (std::is_same<typename S::char_type, char>::value) {
-    constexpr basic_string_view<typename S::char_type> str = S();
-    if (str.size() == 2 && str[0] == '{' && str[1] == '}')
-      return fmt::to_string(detail::first(args...));
+    constexpr auto str = basic_string_view<typename S::char_type>(S());
+    if constexpr (str.size() == 2 && str[0] == '{' && str[1] == '}') {
+      const auto& first = detail::first(args...);
+      if constexpr (detail::is_named_arg<
+                        remove_cvref_t<decltype(first)>>::value) {
+        return fmt::to_string(first.value);
+      } else {
+        return fmt::to_string(first);
+      }
+    }
   }
+  constexpr auto compiled = detail::compile<Args...>(S());
+  if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
+                             detail::unknown_format>()) {
+    return format(static_cast<basic_string_view<typename S::char_type>>(S()),
+                  std::forward<Args>(args)...);
+  } else {
+    return format(compiled, std::forward<Args>(args)...);
+  }
+}
+
+template <typename OutputIt, typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
+  constexpr auto compiled = detail::compile<Args...>(S());
+  if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
+                             detail::unknown_format>()) {
+    return format_to(out,
+                     static_cast<basic_string_view<typename S::char_type>>(S()),
+                     std::forward<Args>(args)...);
+  } else {
+    return format_to(out, compiled, std::forward<Args>(args)...);
+  }
+}
 #endif
-  constexpr auto compiled = detail::compile<Args...>(S());
-  return format(compiled, std::forward<Args>(args)...);
-}
-
-template <typename OutputIt, typename CompiledFormat, typename... Args,
-          FMT_ENABLE_IF(std::is_base_of<detail::basic_compiled_format,
-                                        CompiledFormat>::value)>
-OutputIt format_to(OutputIt out, const CompiledFormat& cf,
-                   const Args&... args) {
-  using char_type = typename CompiledFormat::char_type;
-  using context = format_context_t<OutputIt, char_type>;
-  return detail::cf::vformat_to<context>(out, cf,
-                                         make_format_args<context>(args...));
-}
 
 template <typename OutputIt, typename S, typename... Args,
           FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-OutputIt format_to(OutputIt out, const S&, const Args&... args) {
-  constexpr auto compiled = detail::compile<Args...>(S());
-  return format_to(out, compiled, args...);
-}
-
-template <typename OutputIt, typename CompiledFormat, typename... Args>
-auto format_to_n(OutputIt out, size_t n, const CompiledFormat& cf,
-                 const Args&... args) ->
-    typename std::enable_if<
-        detail::is_output_iterator<OutputIt,
-                                   typename CompiledFormat::char_type>::value &&
-            std::is_base_of<detail::basic_compiled_format,
-                            CompiledFormat>::value,
-        format_to_n_result<OutputIt>>::type {
-  auto it =
-      format_to(detail::truncating_iterator<OutputIt>(out, n), cf, args...);
+format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n,
+                                         const S& format_str, Args&&... args) {
+  auto it = format_to(detail::truncating_iterator<OutputIt>(out, n), format_str,
+                      std::forward<Args>(args)...);
   return {it.base(), it.count()};
 }
 
-template <typename OutputIt, typename S, typename... Args,
+template <typename S, typename... Args,
           FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n, const S&,
-                                         const Args&... args) {
-  constexpr auto compiled = detail::compile<Args...>(S());
-  auto it = format_to(detail::truncating_iterator<OutputIt>(out, n), compiled,
-                      args...);
-  return {it.base(), it.count()};
+size_t formatted_size(const S& format_str, const Args&... args) {
+  return format_to(detail::counting_iterator(), format_str, args...).count();
 }
 
-template <typename CompiledFormat, typename... Args>
-size_t formatted_size(const CompiledFormat& cf, const Args&... args) {
-  return format_to(detail::counting_iterator(), cf, args...).count();
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+void print(std::FILE* f, const S& format_str, const Args&... args) {
+  memory_buffer buffer;
+  format_to(std::back_inserter(buffer), format_str, args...);
+  detail::print(f, {buffer.data(), buffer.size()});
 }
 
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+void print(const S& format_str, const Args&... args) {
+  print(stdout, format_str, args...);
+}
+
+#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+inline namespace literals {
+template <detail_exported::fixed_string Str>
+constexpr detail::udl_compiled_string<
+    remove_cvref_t<decltype(Str.data[0])>,
+    sizeof(Str.data) / sizeof(decltype(Str.data[0])), Str>
+operator""_cf() {
+  return {};
+}
+}  // namespace literals
+#endif
+
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
 #endif  // FMT_COMPILE_H_
diff --git a/deps/fmt/include/fmt/core.h b/deps/fmt/include/fmt/core.h
index 0a81e0cc..92a7aa1d 100644
--- a/deps/fmt/include/fmt/core.h
+++ b/deps/fmt/include/fmt/core.h
@@ -1,4 +1,4 @@
-// Formatting library for C++ - the core API
+// Formatting library for C++ - the core API for char/UTF-8
 //
 // Copyright (c) 2012 - present, Victor Zverovich
 // All rights reserved.
@@ -8,42 +8,47 @@
 #ifndef FMT_CORE_H_
 #define FMT_CORE_H_
 
-#include <cstdio>  // std::FILE
+#include <cstddef>  // std::byte
+#include <cstdio>   // std::FILE
 #include <cstring>
-#include <functional>
 #include <iterator>
-#include <memory>
+#include <limits>
 #include <string>
 #include <type_traits>
-#include <vector>
 
 // The fmt library version in the form major * 10000 + minor * 100 + patch.
-#define FMT_VERSION 70103
+#define FMT_VERSION 80101
 
-#ifdef __clang__
+#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__)
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && \
+    !defined(__NVCOMPILER)
 #  define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
 #else
 #  define FMT_GCC_VERSION 0
 #endif
 
-#if defined(__INTEL_COMPILER)
+#ifndef FMT_GCC_PRAGMA
+// Workaround _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884.
+#  if FMT_GCC_VERSION >= 504
+#    define FMT_GCC_PRAGMA(arg) _Pragma(arg)
+#  else
+#    define FMT_GCC_PRAGMA(arg)
+#  endif
+#endif
+
+#ifdef __ICL
+#  define FMT_ICC_VERSION __ICL
+#elif defined(__INTEL_COMPILER)
 #  define FMT_ICC_VERSION __INTEL_COMPILER
 #else
 #  define FMT_ICC_VERSION 0
 #endif
 
-#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
-#  define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION
-#else
-#  define FMT_HAS_GXX_CXX11 0
-#endif
-
 #ifdef __NVCC__
 #  define FMT_NVCC __NVCC__
 #else
@@ -52,10 +57,10 @@
 
 #ifdef _MSC_VER
 #  define FMT_MSC_VER _MSC_VER
-#  define FMT_SUPPRESS_MSC_WARNING(n) __pragma(warning(suppress : n))
+#  define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__))
 #else
 #  define FMT_MSC_VER 0
-#  define FMT_SUPPRESS_MSC_WARNING(n)
+#  define FMT_MSC_WARNING(...)
 #endif
 
 #ifdef __has_feature
@@ -64,7 +69,8 @@
 #  define FMT_HAS_FEATURE(x) 0
 #endif
 
-#if defined(__has_include) && !defined(__INTELLISENSE__) && \
+#if defined(__has_include) &&                             \
+    (!defined(__INTELLISENSE__) || FMT_MSC_VER > 1900) && \
     (!FMT_ICC_VERSION || FMT_ICC_VERSION >= 1600)
 #  define FMT_HAS_INCLUDE(x) __has_include(x)
 #else
@@ -77,17 +83,23 @@
 #  define FMT_HAS_CPP_ATTRIBUTE(x) 0
 #endif
 
+#ifdef _MSVC_LANG
+#  define FMT_CPLUSPLUS _MSVC_LANG
+#else
+#  define FMT_CPLUSPLUS __cplusplus
+#endif
+
 #define FMT_HAS_CPP14_ATTRIBUTE(attribute) \
-  (__cplusplus >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))
+  (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))
 
 #define FMT_HAS_CPP17_ATTRIBUTE(attribute) \
-  (__cplusplus >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))
+  (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))
 
 // Check if relaxed C++14 constexpr is supported.
 // GCC doesn't allow throw in constexpr until version 6 (bug 67371).
 #ifndef FMT_USE_CONSTEXPR
 #  define FMT_USE_CONSTEXPR                                           \
-    (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || \
+    (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1912 || \
      (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) &&           \
         !FMT_NVCC && !FMT_ICC_VERSION
 #endif
@@ -95,17 +107,32 @@
 #  define FMT_CONSTEXPR constexpr
 #  define FMT_CONSTEXPR_DECL constexpr
 #else
-#  define FMT_CONSTEXPR inline
+#  define FMT_CONSTEXPR
 #  define FMT_CONSTEXPR_DECL
 #endif
 
-#ifndef FMT_OVERRIDE
-#  if FMT_HAS_FEATURE(cxx_override_control) || \
-      (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
-#    define FMT_OVERRIDE override
-#  else
-#    define FMT_OVERRIDE
+#if ((__cplusplus >= 202002L) &&                              \
+     (!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE > 9)) || \
+    (__cplusplus >= 201709L && FMT_GCC_VERSION >= 1002)
+#  define FMT_CONSTEXPR20 constexpr
+#else
+#  define FMT_CONSTEXPR20
+#endif
+
+// Check if constexpr std::char_traits<>::compare,length is supported.
+#if defined(__GLIBCXX__)
+#  if __cplusplus >= 201703L && defined(_GLIBCXX_RELEASE) && \
+      _GLIBCXX_RELEASE >= 7  // GCC 7+ libstdc++ has _GLIBCXX_RELEASE.
+#    define FMT_CONSTEXPR_CHAR_TRAITS constexpr
 #  endif
+#elif defined(_LIBCPP_VERSION) && __cplusplus >= 201703L && \
+    _LIBCPP_VERSION >= 4000
+#  define FMT_CONSTEXPR_CHAR_TRAITS constexpr
+#elif FMT_MSC_VER >= 1914 && _MSVC_LANG >= 201703L
+#  define FMT_CONSTEXPR_CHAR_TRAITS constexpr
+#endif
+#ifndef FMT_CONSTEXPR_CHAR_TRAITS
+#  define FMT_CONSTEXPR_CHAR_TRAITS
 #endif
 
 // Check if exceptions are disabled.
@@ -124,7 +151,7 @@
 #endif
 
 #if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
-    (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
+    FMT_GCC_VERSION >= 408 || FMT_MSC_VER >= 1900
 #  define FMT_DETECTED_NOEXCEPT noexcept
 #  define FMT_HAS_CXX11_NOEXCEPT 1
 #else
@@ -149,6 +176,49 @@
 #  define FMT_NORETURN
 #endif
 
+#if __cplusplus == 201103L || __cplusplus == 201402L
+#  if defined(__INTEL_COMPILER) || defined(__PGI)
+#    define FMT_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
+#elif FMT_HAS_CPP17_ATTRIBUTE(fallthrough)
+#  define FMT_FALLTHROUGH [[fallthrough]]
+#else
+#  define FMT_FALLTHROUGH
+#endif
+
+#ifndef FMT_NODISCARD
+#  if FMT_HAS_CPP17_ATTRIBUTE(nodiscard)
+#    define FMT_NODISCARD [[nodiscard]]
+#  else
+#    define FMT_NODISCARD
+#  endif
+#endif
+
+#ifndef FMT_USE_FLOAT
+#  define FMT_USE_FLOAT 1
+#endif
+#ifndef FMT_USE_DOUBLE
+#  define FMT_USE_DOUBLE 1
+#endif
+#ifndef FMT_USE_LONG_DOUBLE
+#  define FMT_USE_LONG_DOUBLE 1
+#endif
+
+#ifndef FMT_INLINE
+#  if FMT_GCC_VERSION || FMT_CLANG_VERSION
+#    define FMT_INLINE inline __attribute__((always_inline))
+#  else
+#    define FMT_INLINE inline
+#  endif
+#endif
+
 #ifndef FMT_DEPRECATED
 #  if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VER >= 1900
 #    define FMT_DEPRECATED [[deprecated]]
@@ -163,76 +233,41 @@
 #  endif
 #endif
 
-// Workaround broken [[deprecated]] in the Intel, PGI and NVCC compilers.
-#if FMT_ICC_VERSION || defined(__PGI) || FMT_NVCC
-#  define FMT_DEPRECATED_ALIAS
-#else
-#  define FMT_DEPRECATED_ALIAS FMT_DEPRECATED
-#endif
-
-#ifndef FMT_INLINE
-#  if FMT_GCC_VERSION || FMT_CLANG_VERSION
-#    define FMT_INLINE inline __attribute__((always_inline))
-#  else
-#    define FMT_INLINE inline
-#  endif
-#endif
-
-#ifndef FMT_USE_INLINE_NAMESPACES
-#  if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || \
-      (FMT_MSC_VER >= 1900 && !_MANAGED)
-#    define FMT_USE_INLINE_NAMESPACES 1
-#  else
-#    define FMT_USE_INLINE_NAMESPACES 0
-#  endif
-#endif
-
 #ifndef FMT_BEGIN_NAMESPACE
-#  if FMT_USE_INLINE_NAMESPACES
-#    define FMT_INLINE_NAMESPACE inline namespace
-#    define FMT_END_NAMESPACE \
-      }                       \
-      }
-#  else
-#    define FMT_INLINE_NAMESPACE namespace
-#    define FMT_END_NAMESPACE \
-      }                       \
-      using namespace v7;     \
-      }
-#  endif
 #  define FMT_BEGIN_NAMESPACE \
     namespace fmt {           \
-    FMT_INLINE_NAMESPACE v7 {
+    inline namespace v8 {
+#  define FMT_END_NAMESPACE \
+    }                       \
+    }
+#endif
+
+#ifndef FMT_MODULE_EXPORT
+#  define FMT_MODULE_EXPORT
+#  define FMT_MODULE_EXPORT_BEGIN
+#  define FMT_MODULE_EXPORT_END
+#  define FMT_BEGIN_DETAIL_NAMESPACE namespace detail {
+#  define FMT_END_DETAIL_NAMESPACE }
 #endif
 
 #if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
-#  define FMT_CLASS_API FMT_SUPPRESS_MSC_WARNING(4275)
+#  define FMT_CLASS_API FMT_MSC_WARNING(suppress : 4275)
 #  ifdef FMT_EXPORT
 #    define FMT_API __declspec(dllexport)
-#    define FMT_EXTERN_TEMPLATE_API FMT_API
-#    define FMT_EXPORTED
 #  elif defined(FMT_SHARED)
 #    define FMT_API __declspec(dllimport)
-#    define FMT_EXTERN_TEMPLATE_API FMT_API
 #  endif
 #else
 #  define FMT_CLASS_API
+#  if defined(FMT_EXPORT) || defined(FMT_SHARED)
+#    if defined(__GNUC__) || defined(__clang__)
+#      define FMT_API __attribute__((visibility("default")))
+#    endif
+#  endif
 #endif
 #ifndef FMT_API
 #  define FMT_API
 #endif
-#ifndef FMT_EXTERN_TEMPLATE_API
-#  define FMT_EXTERN_TEMPLATE_API
-#endif
-#ifndef FMT_INSTANTIATION_DEF_API
-#  define FMT_INSTANTIATION_DEF_API FMT_API
-#endif
-
-#ifndef FMT_HEADER_ONLY
-#  define FMT_EXTERN extern
-#else
-#  define FMT_EXTERN
-#endif
 
 // libc++ supports string_view in pre-c++17.
 #if (FMT_HAS_INCLUDE(<string_view>) &&                       \
@@ -248,16 +283,43 @@
 #ifndef FMT_UNICODE
 #  define FMT_UNICODE !FMT_MSC_VER
 #endif
-#if FMT_UNICODE && FMT_MSC_VER
-#  pragma execution_character_set("utf-8")
+
+#ifndef FMT_CONSTEVAL
+#  if ((FMT_GCC_VERSION >= 1000 || FMT_CLANG_VERSION >= 1101) &&      \
+       __cplusplus > 201703L && !defined(__apple_build_version__)) || \
+      (defined(__cpp_consteval) &&                                    \
+       (!FMT_MSC_VER || _MSC_FULL_VER >= 193030704))
+// consteval is broken in MSVC before VS2022 and Apple clang 13.
+#    define FMT_CONSTEVAL consteval
+#    define FMT_HAS_CONSTEVAL
+#  else
+#    define FMT_CONSTEVAL
+#  endif
+#endif
+
+#ifndef FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+#  if defined(__cpp_nontype_template_args) &&                \
+      ((FMT_GCC_VERSION >= 903 && __cplusplus >= 201709L) || \
+       __cpp_nontype_template_args >= 201911L)
+#    define FMT_USE_NONTYPE_TEMPLATE_PARAMETERS 1
+#  else
+#    define FMT_USE_NONTYPE_TEMPLATE_PARAMETERS 0
+#  endif
+#endif
+
+// Enable minimal optimizations for more compact code in debug mode.
+FMT_GCC_PRAGMA("GCC push_options")
+#ifndef __OPTIMIZE__
+FMT_GCC_PRAGMA("GCC optimize(\"Og\")")
 #endif
 
 FMT_BEGIN_NAMESPACE
+FMT_MODULE_EXPORT_BEGIN
 
 // Implementations of enable_if_t and other metafunctions for older systems.
-template <bool B, class T = void>
+template <bool B, typename T = void>
 using enable_if_t = typename std::enable_if<B, T>::type;
-template <bool B, class T, class F>
+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>
@@ -269,17 +331,40 @@ using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
 template <typename T> struct type_identity { using type = T; };
 template <typename T> using type_identity_t = typename type_identity<T>::type;
 
-struct monostate {};
+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).
-#define FMT_ENABLE_IF(...) enable_if_t<(__VA_ARGS__), int> = 0
+#ifdef FMT_DOC
+#  define FMT_ENABLE_IF(...)
+#else
+#  define FMT_ENABLE_IF(...) enable_if_t<(__VA_ARGS__), int> = 0
+#endif
 
-namespace detail {
+FMT_BEGIN_DETAIL_NAMESPACE
 
-// A helper function to suppress "conditional expression is constant" warnings.
-template <typename T> constexpr T const_check(T value) { return value; }
+// Suppress "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 FMT_INLINE auto is_constant_evaluated(bool default_value = false)
+    FMT_NOEXCEPT -> bool {
+#ifdef __cpp_lib_is_constant_evaluated
+  ignore_unused(default_value);
+  return std::is_constant_evaluated();
+#else
+  return default_value;
+#endif
+}
+
+// A function to suppress "conditional expression is constant" warnings.
+template <typename T> constexpr FMT_INLINE auto const_check(T value) -> T {
+  return value;
+}
 
 FMT_NORETURN FMT_API void assert_fail(const char* file, int line,
                                       const char* message);
@@ -287,7 +372,8 @@ FMT_NORETURN FMT_API void assert_fail(const char* file, int line,
 #ifndef FMT_ASSERT
 #  ifdef NDEBUG
 // FMT_ASSERT is not empty to avoid -Werror=empty-body.
-#    define FMT_ASSERT(condition, message) ((void)0)
+#    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 */ \
@@ -296,6 +382,12 @@ FMT_NORETURN FMT_API void assert_fail(const char* file, int line,
 #  endif
 #endif
 
+#ifdef __cpp_lib_byte
+using byte = std::byte;
+#else
+enum class byte : unsigned char {};
+#endif
+
 #if defined(FMT_USE_STRING_VIEW)
 template <typename Char> using std_string_view = std::basic_string_view<Char>;
 #elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW)
@@ -312,38 +404,39 @@ template <typename T> struct std_string_view {};
 #  define FMT_USE_INT128 1
 using int128_t = __int128_t;
 using uint128_t = __uint128_t;
+template <typename T> inline auto convert_for_visit(T value) -> T {
+  return value;
+}
 #else
 #  define FMT_USE_INT128 0
 #endif
 #if !FMT_USE_INT128
-struct int128_t {};
-struct uint128_t {};
+enum class int128_t {};
+enum class uint128_t {};
+// Reduce template instantiations.
+template <typename T> inline auto convert_for_visit(T) -> monostate {
+  return {};
+}
 #endif
 
 // Casts a nonnegative integer to unsigned.
 template <typename Int>
-FMT_CONSTEXPR typename std::make_unsigned<Int>::type to_unsigned(Int value) {
+FMT_CONSTEXPR auto to_unsigned(Int value) ->
+    typename std::make_unsigned<Int>::type {
   FMT_ASSERT(value >= 0, "negative value");
   return static_cast<typename std::make_unsigned<Int>::type>(value);
 }
 
-FMT_SUPPRESS_MSC_WARNING(4566) constexpr unsigned char micro[] = "\u00B5";
+FMT_MSC_WARNING(suppress : 4566) constexpr unsigned char micro[] = "\u00B5";
 
-template <typename Char> constexpr bool is_unicode() {
-  return FMT_UNICODE || sizeof(Char) != 1 ||
-         (sizeof(micro) == 3 && micro[0] == 0xC2 && micro[1] == 0xB5);
+constexpr auto is_utf8() -> bool {
+  // Avoid buggy sign extensions in MSVC's constant evaluation mode.
+  // https://developercommunity.visualstudio.com/t/C-difference-in-behavior-for-unsigned/1233612
+  using uchar = unsigned char;
+  return FMT_UNICODE || (sizeof(micro) == 3 && uchar(micro[0]) == 0xC2 &&
+                         uchar(micro[1]) == 0xB5);
 }
-
-#ifdef __cpp_char8_t
-using char8_type = char8_t;
-#else
-enum char8_type : unsigned char {};
-#endif
-}  // namespace detail
-
-#ifdef FMT_USE_INTERNAL
-namespace internal = detail;  // DEPRECATED
-#endif
+FMT_END_DETAIL_NAMESPACE
 
 /**
   An implementation of ``std::basic_string_view`` for pre-C++17. It provides a
@@ -374,11 +467,14 @@ template <typename Char> class basic_string_view {
     the size with ``std::char_traits<Char>::length``.
     \endrst
    */
-#if __cplusplus >= 201703L  // C++17's char_traits::length() is constexpr.
-  FMT_CONSTEXPR
-#endif
+  FMT_CONSTEXPR_CHAR_TRAITS
+  FMT_INLINE
   basic_string_view(const Char* s)
-      : data_(s), size_(std::char_traits<Char>::length(s)) {}
+      : data_(s),
+        size_(detail::const_check(std::is_same<Char, char>::value &&
+                                  !detail::is_constant_evaluated(true))
+                  ? std::strlen(reinterpret_cast<const char*>(s))
+                  : std::char_traits<Char>::length(s)) {}
 
   /** Constructs a string reference from a ``std::basic_string`` object. */
   template <typename Traits, typename Alloc>
@@ -393,23 +489,25 @@ template <typename Char> class basic_string_view {
                                                       size_(s.size()) {}
 
   /** Returns a pointer to the string data. */
-  constexpr const Char* data() const { return data_; }
+  constexpr auto data() const FMT_NOEXCEPT -> const Char* { return data_; }
 
   /** Returns the string size. */
-  constexpr size_t size() const { return size_; }
+  constexpr auto size() const FMT_NOEXCEPT -> size_t { return size_; }
 
-  constexpr iterator begin() const { return data_; }
-  constexpr iterator end() const { return data_ + size_; }
+  constexpr auto begin() const FMT_NOEXCEPT -> iterator { return data_; }
+  constexpr auto end() const FMT_NOEXCEPT -> iterator { return data_ + size_; }
 
-  constexpr const Char& operator[](size_t pos) const { return data_[pos]; }
+  constexpr auto operator[](size_t pos) const FMT_NOEXCEPT -> const Char& {
+    return data_[pos];
+  }
 
-  FMT_CONSTEXPR void remove_prefix(size_t n) {
+  FMT_CONSTEXPR void remove_prefix(size_t n) FMT_NOEXCEPT {
     data_ += n;
     size_ -= n;
   }
 
   // Lexicographically compare this string reference to other.
-  int compare(basic_string_view other) const {
+  FMT_CONSTEXPR_CHAR_TRAITS auto compare(basic_string_view other) const -> int {
     size_t str_size = size_ < other.size_ ? size_ : other.size_;
     int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
     if (result == 0)
@@ -417,72 +515,53 @@ template <typename Char> class basic_string_view {
     return result;
   }
 
-  friend bool operator==(basic_string_view lhs, basic_string_view rhs) {
+  FMT_CONSTEXPR_CHAR_TRAITS friend auto operator==(basic_string_view lhs,
+                                                   basic_string_view rhs)
+      -> bool {
     return lhs.compare(rhs) == 0;
   }
-  friend bool operator!=(basic_string_view lhs, basic_string_view rhs) {
+  friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool {
     return lhs.compare(rhs) != 0;
   }
-  friend bool operator<(basic_string_view lhs, basic_string_view rhs) {
+  friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool {
     return lhs.compare(rhs) < 0;
   }
-  friend bool operator<=(basic_string_view lhs, basic_string_view rhs) {
+  friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool {
     return lhs.compare(rhs) <= 0;
   }
-  friend bool operator>(basic_string_view lhs, basic_string_view rhs) {
+  friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool {
     return lhs.compare(rhs) > 0;
   }
-  friend bool operator>=(basic_string_view lhs, basic_string_view rhs) {
+  friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool {
     return lhs.compare(rhs) >= 0;
   }
 };
 
 using string_view = basic_string_view<char>;
-using wstring_view = basic_string_view<wchar_t>;
 
 /** 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 <> struct is_char<wchar_t> : std::true_type {};
-template <> struct is_char<detail::char8_type> : std::true_type {};
-template <> struct is_char<char16_t> : std::true_type {};
-template <> struct is_char<char32_t> : std::true_type {};
 
-/**
-  \rst
-  Returns a string view of `s`. In order to add custom string type support to
-  {fmt} provide an overload of `to_string_view` for it in the same namespace as
-  the type for the argument-dependent lookup to work.
-
-  **Example**::
-
-    namespace my_ns {
-    inline string_view to_string_view(const my_string& s) {
-      return {s.data(), s.length()};
-    }
-    }
-    std::string message = fmt::format(my_string("The answer is {}"), 42);
-  \endrst
- */
+// Returns a string view of `s`.
 template <typename Char, FMT_ENABLE_IF(is_char<Char>::value)>
-inline basic_string_view<Char> to_string_view(const Char* s) {
+FMT_INLINE auto to_string_view(const Char* s) -> basic_string_view<Char> {
   return s;
 }
-
 template <typename Char, typename Traits, typename Alloc>
-inline basic_string_view<Char> to_string_view(
-    const std::basic_string<Char, Traits, Alloc>& s) {
+inline auto to_string_view(const std::basic_string<Char, Traits, Alloc>& s)
+    -> basic_string_view<Char> {
   return s;
 }
-
 template <typename Char>
-inline basic_string_view<Char> to_string_view(basic_string_view<Char> s) {
+constexpr auto to_string_view(basic_string_view<Char> s)
+    -> basic_string_view<Char> {
   return s;
 }
-
 template <typename Char,
           FMT_ENABLE_IF(!std::is_empty<detail::std_string_view<Char>>::value)>
-inline basic_string_view<Char> to_string_view(detail::std_string_view<Char> s) {
+inline auto to_string_view(detail::std_string_view<Char> s)
+    -> basic_string_view<Char> {
   return s;
 }
 
@@ -494,13 +573,15 @@ template <typename S>
 struct is_compile_string : std::is_base_of<compile_string, S> {};
 
 template <typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
-constexpr basic_string_view<typename S::char_type> to_string_view(const S& s) {
-  return s;
+constexpr auto to_string_view(const S& s)
+    -> basic_string_view<typename S::char_type> {
+  return basic_string_view<typename S::char_type>(s);
 }
 
-namespace detail {
+FMT_BEGIN_DETAIL_NAMESPACE
+
 void to_string_view(...);
-using fmt::v7::to_string_view;
+using fmt::to_string_view;
 
 // Specifies whether S is a string type convertible to fmt::basic_string_view.
 // It should be a constexpr function but MSVC 2017 fails to compile it in
@@ -527,6 +608,8 @@ FMT_INLINE void check_format_string(const S&) {
 template <typename..., typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
 void check_format_string(S);
 
+FMT_NORETURN FMT_API void throw_format_error(const char* message);
+
 struct error_handler {
   constexpr error_handler() = default;
   constexpr error_handler(const error_handler&) = default;
@@ -534,7 +617,7 @@ struct error_handler {
   // This function is intentionally not constexpr to give a compile-time error.
   FMT_NORETURN FMT_API void on_error(const char* message);
 };
-}  // namespace detail
+FMT_END_DETAIL_NAMESPACE
 
 /** String's character type. */
 template <typename S> using char_t = typename detail::char_t_impl<S>::type;
@@ -543,16 +626,7 @@ template <typename S> using char_t = typename detail::char_t_impl<S>::type;
   \rst
   Parsing context consisting of a format string range being parsed and an
   argument counter for automatic indexing.
-
-  You can use one of the following type aliases for common character types:
-
-  +-----------------------+-------------------------------------+
-  | Type                  | Definition                          |
-  +=======================+=====================================+
-  | format_parse_context  | basic_format_parse_context<char>    |
-  +-----------------------+-------------------------------------+
-  | wformat_parse_context | basic_format_parse_context<wchar_t> |
-  +-----------------------+-------------------------------------+
+  You can use the ``format_parse_context`` type alias for ``char`` instead.
   \endrst
  */
 template <typename Char, typename ErrorHandler = detail::error_handler>
@@ -574,12 +648,16 @@ class basic_format_parse_context : private ErrorHandler {
     Returns an iterator to the beginning of the format string range being
     parsed.
    */
-  constexpr iterator begin() const FMT_NOEXCEPT { return format_str_.begin(); }
+  constexpr auto begin() const FMT_NOEXCEPT -> iterator {
+    return format_str_.begin();
+  }
 
   /**
     Returns an iterator past the end of the format string range being parsed.
    */
-  constexpr iterator end() const FMT_NOEXCEPT { return format_str_.end(); }
+  constexpr auto end() const FMT_NOEXCEPT -> iterator {
+    return format_str_.end();
+  }
 
   /** Advances the begin iterator to ``it``. */
   FMT_CONSTEXPR void advance_to(iterator it) {
@@ -590,7 +668,7 @@ class basic_format_parse_context : private ErrorHandler {
     Reports an error if using the manual argument indexing; otherwise returns
     the next argument index and switches to the automatic indexing.
    */
-  FMT_CONSTEXPR int next_arg_id() {
+  FMT_CONSTEXPR auto next_arg_id() -> int {
     // Don't check if the argument id is valid to avoid overhead and because it
     // will be checked during formatting anyway.
     if (next_arg_id_ >= 0) return next_arg_id_++;
@@ -615,11 +693,10 @@ class basic_format_parse_context : private ErrorHandler {
     ErrorHandler::on_error(message);
   }
 
-  constexpr ErrorHandler error_handler() const { return *this; }
+  constexpr auto error_handler() const -> ErrorHandler { return *this; }
 };
 
 using format_parse_context = basic_format_parse_context<char>;
-using wformat_parse_context = basic_format_parse_context<wchar_t>;
 
 template <typename Context> class basic_format_arg;
 template <typename Context> class basic_format_args;
@@ -643,11 +720,30 @@ template <typename T> struct is_contiguous : std::false_type {};
 template <typename Char>
 struct is_contiguous<std::basic_string<Char>> : std::true_type {};
 
-namespace detail {
+class appender;
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+template <typename Context, typename T>
+constexpr auto has_const_formatter_impl(T*)
+    -> decltype(typename Context::template formatter_type<T>().format(
+                    std::declval<const T&>(), std::declval<Context&>()),
+                true) {
+  return true;
+}
+template <typename Context>
+constexpr auto has_const_formatter_impl(...) -> bool {
+  return false;
+}
+template <typename T, typename Context>
+constexpr auto has_const_formatter() -> bool {
+  return has_const_formatter_impl<Context>(static_cast<T*>(nullptr));
+}
 
 // Extracts a reference to the container from back_insert_iterator.
 template <typename Container>
-inline Container& get_container(std::back_insert_iterator<Container> it) {
+inline auto get_container(std::back_insert_iterator<Container> it)
+    -> Container& {
   using bi_iterator = std::back_insert_iterator<Container>;
   struct accessor : bi_iterator {
     accessor(bi_iterator iter) : bi_iterator(iter) {}
@@ -656,6 +752,23 @@ inline Container& get_container(std::back_insert_iterator<Container> it) {
   return *accessor(it).container;
 }
 
+template <typename Char, typename InputIt, typename OutputIt>
+FMT_CONSTEXPR auto copy_str(InputIt begin, InputIt end, OutputIt out)
+    -> OutputIt {
+  while (begin != end) *out++ = static_cast<Char>(*begin++);
+  return out;
+}
+
+template <typename Char, typename T, typename U,
+          FMT_ENABLE_IF(
+              std::is_same<remove_const_t<T>, U>::value&& is_char<U>::value)>
+FMT_CONSTEXPR auto copy_str(T* begin, T* end, U* out) -> U* {
+  if (is_constant_evaluated()) return copy_str<Char, T*, U*>(begin, end, out);
+  auto size = to_unsigned(end - begin);
+  memcpy(out, begin, size * sizeof(U));
+  return out + size;
+}
+
 /**
   \rst
   A contiguous memory buffer with an optional growing ability. It is an internal
@@ -670,24 +783,25 @@ template <typename T> class buffer {
 
  protected:
   // Don't initialize ptr_ since it is not accessed to save a few cycles.
-  FMT_SUPPRESS_MSC_WARNING(26495)
+  FMT_MSC_WARNING(suppress : 26495)
   buffer(size_t sz) FMT_NOEXCEPT : size_(sz), capacity_(sz) {}
 
-  buffer(T* p = nullptr, size_t sz = 0, size_t cap = 0) FMT_NOEXCEPT
-      : ptr_(p),
-        size_(sz),
-        capacity_(cap) {}
+  FMT_CONSTEXPR20 buffer(T* p = nullptr, size_t sz = 0,
+                         size_t cap = 0) FMT_NOEXCEPT : ptr_(p),
+                                                        size_(sz),
+                                                        capacity_(cap) {}
 
-  ~buffer() = default;
+  FMT_CONSTEXPR20 ~buffer() = default;
+  buffer(buffer&&) = default;
 
   /** Sets the buffer data and capacity. */
-  void set(T* buf_data, size_t buf_capacity) FMT_NOEXCEPT {
+  FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) FMT_NOEXCEPT {
     ptr_ = buf_data;
     capacity_ = buf_capacity;
   }
 
   /** Increases the buffer capacity to hold at least *capacity* elements. */
-  virtual void grow(size_t capacity) = 0;
+  virtual FMT_CONSTEXPR20 void grow(size_t capacity) = 0;
 
  public:
   using value_type = T;
@@ -696,30 +810,30 @@ template <typename T> class buffer {
   buffer(const buffer&) = delete;
   void operator=(const buffer&) = delete;
 
-  T* begin() FMT_NOEXCEPT { return ptr_; }
-  T* end() FMT_NOEXCEPT { return ptr_ + size_; }
+  auto begin() FMT_NOEXCEPT -> T* { return ptr_; }
+  auto end() FMT_NOEXCEPT -> T* { return ptr_ + size_; }
 
-  const T* begin() const FMT_NOEXCEPT { return ptr_; }
-  const T* end() const FMT_NOEXCEPT { return ptr_ + size_; }
+  auto begin() const FMT_NOEXCEPT -> const T* { return ptr_; }
+  auto end() const FMT_NOEXCEPT -> const T* { return ptr_ + size_; }
 
   /** Returns the size of this buffer. */
-  size_t size() const FMT_NOEXCEPT { return size_; }
+  constexpr auto size() const FMT_NOEXCEPT -> size_t { return size_; }
 
   /** Returns the capacity of this buffer. */
-  size_t capacity() const FMT_NOEXCEPT { return capacity_; }
+  constexpr auto capacity() const FMT_NOEXCEPT -> size_t { return capacity_; }
 
   /** Returns a pointer to the buffer data. */
-  T* data() FMT_NOEXCEPT { return ptr_; }
+  FMT_CONSTEXPR auto data() FMT_NOEXCEPT -> T* { return ptr_; }
 
   /** Returns a pointer to the buffer data. */
-  const T* data() const FMT_NOEXCEPT { return ptr_; }
+  FMT_CONSTEXPR auto data() const FMT_NOEXCEPT -> const T* { return ptr_; }
 
   /** Clears this buffer. */
   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.
-  void try_resize(size_t count) {
+  FMT_CONSTEXPR20 void try_resize(size_t count) {
     try_reserve(count);
     size_ = count <= capacity_ ? count : capacity_;
   }
@@ -728,11 +842,11 @@ template <typename T> class buffer {
   // 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.
-  void try_reserve(size_t new_capacity) {
+  FMT_CONSTEXPR20 void try_reserve(size_t new_capacity) {
     if (new_capacity > capacity_) grow(new_capacity);
   }
 
-  void push_back(const T& value) {
+  FMT_CONSTEXPR20 void push_back(const T& value) {
     try_reserve(size_ + 1);
     ptr_[size_++] = value;
   }
@@ -740,16 +854,19 @@ template <typename T> class buffer {
   /** Appends data to the end of the buffer. */
   template <typename U> void append(const U* begin, const U* end);
 
-  template <typename I> T& operator[](I index) { return ptr_[index]; }
-  template <typename I> const T& operator[](I index) const {
+  template <typename I> FMT_CONSTEXPR auto operator[](I index) -> T& {
+    return ptr_[index];
+  }
+  template <typename I>
+  FMT_CONSTEXPR auto operator[](I index) const -> const T& {
     return ptr_[index];
   }
 };
 
 struct buffer_traits {
   explicit buffer_traits(size_t) {}
-  size_t count() const { return 0; }
-  size_t limit(size_t size) { return size; }
+  auto count() const -> size_t { return 0; }
+  auto limit(size_t size) -> size_t { return size; }
 };
 
 class fixed_buffer_traits {
@@ -759,8 +876,8 @@ class fixed_buffer_traits {
 
  public:
   explicit fixed_buffer_traits(size_t limit) : limit_(limit) {}
-  size_t count() const { return count_; }
-  size_t limit(size_t size) {
+  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;
@@ -776,33 +893,84 @@ class iterator_buffer final : public Traits, public buffer<T> {
   T data_[buffer_size];
 
  protected:
-  void grow(size_t) final FMT_OVERRIDE {
+  FMT_CONSTEXPR20 void grow(size_t) override {
     if (this->size() == buffer_size) flush();
   }
-  void flush();
+
+  void flush() {
+    auto size = this->size();
+    this->clear();
+    out_ = copy_str<T>(data_, data_ + this->limit(size), out_);
+  }
 
  public:
   explicit iterator_buffer(OutputIt out, size_t n = buffer_size)
-      : Traits(n),
-        buffer<T>(data_, 0, buffer_size),
-        out_(out) {}
+      : Traits(n), buffer<T>(data_, 0, buffer_size), out_(out) {}
+  iterator_buffer(iterator_buffer&& other)
+      : Traits(other), buffer<T>(data_, 0, buffer_size), out_(other.out_) {}
   ~iterator_buffer() { flush(); }
 
-  OutputIt out() {
+  auto out() -> OutputIt {
     flush();
     return out_;
   }
-  size_t count() const { return Traits::count() + this->size(); }
+  auto count() const -> size_t { return Traits::count() + this->size(); }
+};
+
+template <typename T>
+class iterator_buffer<T*, T, fixed_buffer_traits> final
+    : public fixed_buffer_traits,
+      public buffer<T> {
+ private:
+  T* out_;
+  enum { buffer_size = 256 };
+  T data_[buffer_size];
+
+ protected:
+  FMT_CONSTEXPR20 void grow(size_t) override {
+    if (this->size() == this->capacity()) 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>(out, 0, n), out_(out) {}
+  iterator_buffer(iterator_buffer&& other)
+      : fixed_buffer_traits(other),
+        buffer<T>(std::move(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> final : public buffer<T> {
  protected:
-  void grow(size_t) final FMT_OVERRIDE {}
+  FMT_CONSTEXPR20 void grow(size_t) override {}
 
  public:
   explicit iterator_buffer(T* out, size_t = 0) : buffer<T>(out, 0, ~size_t()) {}
 
-  T* out() { return &*this->end(); }
+  auto out() -> T* { return &*this->end(); }
 };
 
 // A buffer that writes to a container with the contiguous storage.
@@ -815,7 +983,7 @@ class iterator_buffer<std::back_insert_iterator<Container>,
   Container& container_;
 
  protected:
-  void grow(size_t capacity) final FMT_OVERRIDE {
+  FMT_CONSTEXPR20 void grow(size_t capacity) override {
     container_.resize(capacity);
     this->set(&container_[0], capacity);
   }
@@ -825,7 +993,7 @@ class iterator_buffer<std::back_insert_iterator<Container>,
       : buffer<typename Container::value_type>(c.size()), container_(c) {}
   explicit iterator_buffer(std::back_insert_iterator<Container> out, size_t = 0)
       : iterator_buffer(get_container(out)) {}
-  std::back_insert_iterator<Container> out() {
+  auto out() -> std::back_insert_iterator<Container> {
     return std::back_inserter(container_);
   }
 };
@@ -838,7 +1006,7 @@ template <typename T = char> class counting_buffer final : public buffer<T> {
   size_t count_ = 0;
 
  protected:
-  void grow(size_t) final FMT_OVERRIDE {
+  FMT_CONSTEXPR20 void grow(size_t) override {
     if (this->size() != buffer_size) return;
     count_ += this->size();
     this->clear();
@@ -847,48 +1015,24 @@ template <typename T = char> class counting_buffer final : public buffer<T> {
  public:
   counting_buffer() : buffer<T>(data_, 0, buffer_size) {}
 
-  size_t count() { return count_ + this->size(); }
+  auto count() -> size_t { return count_ + this->size(); }
 };
 
-// An output iterator that appends to the buffer.
-// It is used to reduce symbol sizes for the common case.
 template <typename T>
-class buffer_appender : public std::back_insert_iterator<buffer<T>> {
-  using base = std::back_insert_iterator<buffer<T>>;
+using buffer_appender = conditional_t<std::is_same<T, char>::value, appender,
+                                      std::back_insert_iterator<buffer<T>>>;
 
- public:
-  explicit buffer_appender(buffer<T>& buf) : base(buf) {}
-  buffer_appender(base it) : base(it) {}
-
-  buffer_appender& operator++() {
-    base::operator++();
-    return *this;
-  }
-
-  buffer_appender operator++(int) {
-    buffer_appender tmp = *this;
-    ++*this;
-    return tmp;
-  }
-};
-
-// Maps an output iterator into a buffer.
+// Maps an output iterator to a buffer.
 template <typename T, typename OutputIt>
-iterator_buffer<OutputIt, T> get_buffer(OutputIt);
-template <typename T> buffer<T>& get_buffer(buffer_appender<T>);
-
-template <typename OutputIt> OutputIt get_buffer_init(OutputIt out) {
-  return out;
-}
-template <typename T> buffer<T>& get_buffer_init(buffer_appender<T> out) {
-  return get_container(out);
+auto get_buffer(OutputIt out) -> iterator_buffer<OutputIt, T> {
+  return iterator_buffer<OutputIt, T>(out);
 }
 
 template <typename Buffer>
 auto get_iterator(Buffer& buf) -> decltype(buf.out()) {
   return buf.out();
 }
-template <typename T> buffer_appender<T> get_iterator(buffer<T>& buf) {
+template <typename T> auto get_iterator(buffer<T>& buf) -> buffer_appender<T> {
   return buffer_appender<T>(buf);
 }
 
@@ -898,9 +1042,9 @@ struct fallback_formatter {
 };
 
 // Specifies if T has an enabled fallback_formatter specialization.
-template <typename T, typename Context>
+template <typename T, typename Char>
 using has_fallback_formatter =
-    std::is_constructible<fallback_formatter<T, typename Context::char_type>>;
+    std::is_constructible<fallback_formatter<T, Char>>;
 
 struct view {};
 
@@ -925,8 +1069,8 @@ struct arg_data {
   template <typename... U>
   arg_data(const U&... init) : args_{T(named_args_, NUM_NAMED_ARGS), init...} {}
   arg_data(const arg_data& other) = delete;
-  const T* args() const { return args_ + 1; }
-  named_arg_info<Char>* named_args() { return named_args_; }
+  auto args() const -> const T* { return args_ + 1; }
+  auto named_args() -> named_arg_info<Char>* { return named_args_; }
 };
 
 template <typename T, typename Char, size_t NUM_ARGS>
@@ -935,45 +1079,55 @@ struct arg_data<T, Char, NUM_ARGS, 0> {
   T args_[NUM_ARGS != 0 ? NUM_ARGS : +1];
 
   template <typename... U>
-  FMT_INLINE arg_data(const U&... init) : args_{init...} {}
-  FMT_INLINE const T* args() const { return args_; }
-  FMT_INLINE std::nullptr_t named_args() { return nullptr; }
+  FMT_CONSTEXPR FMT_INLINE arg_data(const U&... init) : args_{init...} {}
+  FMT_CONSTEXPR FMT_INLINE auto args() const -> const T* { return args_; }
+  FMT_CONSTEXPR FMT_INLINE auto named_args() -> std::nullptr_t {
+    return nullptr;
+  }
 };
 
 template <typename Char>
 inline void init_named_args(named_arg_info<Char>*, int, int) {}
 
-template <typename Char, typename T, typename... Tail>
+template <typename T> struct is_named_arg : std::false_type {};
+template <typename T> struct is_statically_named_arg : std::false_type {};
+
+template <typename T, typename Char>
+struct is_named_arg<named_arg<Char, T>> : std::true_type {};
+
+template <typename Char, typename T, typename... Tail,
+          FMT_ENABLE_IF(!is_named_arg<T>::value)>
 void init_named_args(named_arg_info<Char>* named_args, int arg_count,
                      int named_arg_count, const T&, const Tail&... args) {
   init_named_args(named_args, arg_count + 1, named_arg_count, args...);
 }
 
-template <typename Char, typename T, typename... Tail>
+template <typename Char, typename T, typename... Tail,
+          FMT_ENABLE_IF(is_named_arg<T>::value)>
 void init_named_args(named_arg_info<Char>* named_args, int arg_count,
-                     int named_arg_count, const named_arg<Char, T>& arg,
-                     const Tail&... args) {
+                     int named_arg_count, const T& arg, const Tail&... args) {
   named_args[named_arg_count++] = {arg.name, arg_count};
   init_named_args(named_args, arg_count + 1, named_arg_count, args...);
 }
 
 template <typename... Args>
-FMT_INLINE void init_named_args(std::nullptr_t, int, int, const Args&...) {}
+FMT_CONSTEXPR FMT_INLINE void init_named_args(std::nullptr_t, int, int,
+                                              const Args&...) {}
 
-template <typename T> struct is_named_arg : std::false_type {};
-
-template <typename T, typename Char>
-struct is_named_arg<named_arg<Char, T>> : std::true_type {};
-
-template <bool B = false> constexpr size_t count() { return B ? 1 : 0; }
-template <bool B1, bool B2, bool... Tail> constexpr size_t count() {
+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 size_t count_named_args() {
+template <typename... Args> constexpr auto count_named_args() -> size_t {
   return count<is_named_arg<Args>::value...>();
 }
 
+template <typename... Args>
+constexpr auto count_statically_named_args() -> size_t {
+  return count<is_statically_named_arg<Args>::value...>();
+}
+
 enum class type {
   none_type,
   // Integer types should go first,
@@ -1029,6 +1183,11 @@ constexpr bool is_arithmetic_type(type t) {
   return t > type::none_type && t <= type::last_numeric_type;
 }
 
+struct unformattable {};
+struct unformattable_char : unformattable {};
+struct unformattable_const : unformattable {};
+struct unformattable_pointer : unformattable {};
+
 template <typename Char> struct string_value {
   const Char* data;
   size_t size;
@@ -1041,8 +1200,8 @@ template <typename Char> struct named_arg_value {
 
 template <typename Context> struct custom_value {
   using parse_context = typename Context::parse_context_type;
-  const void* value;
-  void (*format)(const void* arg, parse_context& parse_ctx, Context& ctx);
+  void* value;
+  void (*format)(void* arg, parse_context& parse_ctx, Context& ctx);
 };
 
 // A formatting argument value.
@@ -1051,6 +1210,7 @@ template <typename Context> class value {
   using char_type = typename Context::char_type;
 
   union {
+    monostate no_value;
     int int_value;
     unsigned uint_value;
     long long long_long_value;
@@ -1068,19 +1228,23 @@ template <typename Context> class value {
     named_arg_value<char_type> named_args;
   };
 
-  constexpr FMT_INLINE value(int val = 0) : int_value(val) {}
+  constexpr FMT_INLINE value() : no_value() {}
+  constexpr FMT_INLINE value(int val) : int_value(val) {}
   constexpr FMT_INLINE value(unsigned val) : uint_value(val) {}
-  FMT_INLINE value(long long val) : long_long_value(val) {}
-  FMT_INLINE value(unsigned long long val) : ulong_long_value(val) {}
+  constexpr FMT_INLINE value(long long val) : long_long_value(val) {}
+  constexpr FMT_INLINE value(unsigned long long val) : ulong_long_value(val) {}
   FMT_INLINE value(int128_t val) : int128_value(val) {}
   FMT_INLINE value(uint128_t val) : uint128_value(val) {}
-  FMT_INLINE value(float val) : float_value(val) {}
-  FMT_INLINE value(double val) : double_value(val) {}
+  constexpr FMT_INLINE value(float val) : float_value(val) {}
+  constexpr FMT_INLINE value(double val) : double_value(val) {}
   FMT_INLINE value(long double val) : long_double_value(val) {}
-  FMT_INLINE value(bool val) : bool_value(val) {}
-  FMT_INLINE value(char_type val) : char_value(val) {}
-  FMT_INLINE value(const char_type* val) { string.data = val; }
-  FMT_INLINE value(basic_string_view<char_type> val) {
+  constexpr FMT_INLINE value(bool val) : bool_value(val) {}
+  constexpr FMT_INLINE value(char_type val) : char_value(val) {}
+  FMT_CONSTEXPR FMT_INLINE value(const char_type* val) {
+    string.data = val;
+    if (is_constant_evaluated()) string.size = {};
+  }
+  FMT_CONSTEXPR FMT_INLINE value(basic_string_view<char_type> val) {
     string.data = val.data();
     string.size = val.size();
   }
@@ -1088,31 +1252,39 @@ template <typename Context> class value {
   FMT_INLINE value(const named_arg_info<char_type>* args, size_t size)
       : named_args{args, size} {}
 
-  template <typename T> FMT_INLINE value(const T& val) {
-    custom.value = &val;
+  template <typename T> FMT_CONSTEXPR FMT_INLINE value(T& val) {
+    using value_type = remove_cvref_t<T>;
+    custom.value = const_cast<value_type*>(&val);
     // 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_arg<
-        T, conditional_t<has_formatter<T, Context>::value,
-                         typename Context::template formatter_type<T>,
-                         fallback_formatter<T, char_type>>>;
+        value_type,
+        conditional_t<has_formatter<value_type, Context>::value,
+                      typename Context::template formatter_type<value_type>,
+                      fallback_formatter<value_type, char_type>>>;
   }
+  value(unformattable);
+  value(unformattable_char);
+  value(unformattable_const);
+  value(unformattable_pointer);
 
  private:
   // Formats an argument of a custom type, such as a user-defined class.
   template <typename T, typename Formatter>
-  static void format_custom_arg(const void* arg,
+  static void format_custom_arg(void* arg,
                                 typename Context::parse_context_type& parse_ctx,
                                 Context& ctx) {
-    Formatter f;
+    auto f = Formatter();
     parse_ctx.advance_to(f.parse(parse_ctx));
-    ctx.advance_to(f.format(*static_cast<const T*>(arg), ctx));
+    using qualified_type =
+        conditional_t<has_const_formatter<T, Context>(), const T, T>;
+    ctx.advance_to(f.format(*static_cast<qualified_type*>(arg), ctx));
   }
 };
 
 template <typename Context, typename T>
-FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T& value);
+FMT_CONSTEXPR auto make_arg(const T& value) -> basic_format_arg<Context>;
 
 // 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.
@@ -1120,52 +1292,84 @@ 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>;
 
-struct unformattable {};
-
 // Maps formatting arguments to core types.
+// arg_mapper reports errors by returning unformattable instead of using
+// static_assert because it's used in the is_formattable trait.
 template <typename Context> struct arg_mapper {
   using char_type = typename Context::char_type;
 
-  FMT_CONSTEXPR int map(signed char val) { return val; }
-  FMT_CONSTEXPR unsigned map(unsigned char val) { return val; }
-  FMT_CONSTEXPR int map(short val) { return val; }
-  FMT_CONSTEXPR unsigned map(unsigned short val) { return val; }
-  FMT_CONSTEXPR int map(int val) { return val; }
-  FMT_CONSTEXPR unsigned map(unsigned val) { return val; }
-  FMT_CONSTEXPR long_type map(long val) { return val; }
-  FMT_CONSTEXPR ulong_type map(unsigned long val) { return val; }
-  FMT_CONSTEXPR long long map(long long val) { return val; }
-  FMT_CONSTEXPR unsigned long long map(unsigned long long val) { return val; }
-  FMT_CONSTEXPR int128_t map(int128_t val) { return val; }
-  FMT_CONSTEXPR uint128_t map(uint128_t val) { return val; }
-  FMT_CONSTEXPR bool map(bool val) { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(signed char val) -> int { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(unsigned char val) -> unsigned {
+    return val;
+  }
+  FMT_CONSTEXPR FMT_INLINE auto map(short val) -> int { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(unsigned short val) -> unsigned {
+    return val;
+  }
+  FMT_CONSTEXPR FMT_INLINE auto map(int val) -> int { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(unsigned val) -> unsigned { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(long val) -> long_type { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(unsigned long val) -> ulong_type {
+    return val;
+  }
+  FMT_CONSTEXPR FMT_INLINE auto map(long long val) -> long long { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(unsigned long long val)
+      -> unsigned long long {
+    return val;
+  }
+  FMT_CONSTEXPR FMT_INLINE auto map(int128_t val) -> int128_t { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(uint128_t val) -> uint128_t { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(bool val) -> bool { return val; }
 
-  template <typename T, FMT_ENABLE_IF(is_char<T>::value)>
-  FMT_CONSTEXPR char_type map(T val) {
-    static_assert(
-        std::is_same<T, char>::value || std::is_same<T, char_type>::value,
-        "mixing character types is disallowed");
+  template <typename T, FMT_ENABLE_IF(std::is_same<T, char>::value ||
+                                      std::is_same<T, char_type>::value)>
+  FMT_CONSTEXPR FMT_INLINE auto map(T val) -> char_type {
+    return val;
+  }
+  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_type>::value,
+                                    int> = 0>
+  FMT_CONSTEXPR FMT_INLINE auto map(T) -> unformattable_char {
+    return {};
+  }
+
+  FMT_CONSTEXPR FMT_INLINE auto map(float val) -> float { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(double val) -> double { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(long double val) -> long double {
     return val;
   }
 
-  FMT_CONSTEXPR float map(float val) { return val; }
-  FMT_CONSTEXPR double map(double val) { return val; }
-  FMT_CONSTEXPR long double map(long double val) { return val; }
-
-  FMT_CONSTEXPR const char_type* map(char_type* val) { return val; }
-  FMT_CONSTEXPR const char_type* map(const char_type* val) { return val; }
-  template <typename T, FMT_ENABLE_IF(is_string<T>::value)>
-  FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
-    static_assert(std::is_same<char_type, char_t<T>>::value,
-                  "mixing character types is disallowed");
+  FMT_CONSTEXPR FMT_INLINE auto map(char_type* val) -> const char_type* {
+    return val;
+  }
+  FMT_CONSTEXPR FMT_INLINE auto map(const char_type* val) -> const char_type* {
+    return val;
+  }
+  template <typename T,
+            FMT_ENABLE_IF(is_string<T>::value && !std::is_pointer<T>::value &&
+                          std::is_same<char_type, char_t<T>>::value)>
+  FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
+      -> basic_string_view<char_type> {
     return to_string_view(val);
   }
+  template <typename T,
+            FMT_ENABLE_IF(is_string<T>::value && !std::is_pointer<T>::value &&
+                          !std::is_same<char_type, char_t<T>>::value)>
+  FMT_CONSTEXPR FMT_INLINE auto map(const T&) -> unformattable_char {
+    return {};
+  }
   template <typename T,
             FMT_ENABLE_IF(
                 std::is_constructible<basic_string_view<char_type>, T>::value &&
                 !is_string<T>::value && !has_formatter<T, Context>::value &&
-                !has_fallback_formatter<T, Context>::value)>
-  FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
+                !has_fallback_formatter<T, char_type>::value)>
+  FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
+      -> basic_string_view<char_type> {
     return basic_string_view<char_type>(val);
   }
   template <
@@ -1174,63 +1378,113 @@ template <typename Context> struct arg_mapper {
           std::is_constructible<std_string_view<char_type>, T>::value &&
           !std::is_constructible<basic_string_view<char_type>, T>::value &&
           !is_string<T>::value && !has_formatter<T, Context>::value &&
-          !has_fallback_formatter<T, Context>::value)>
-  FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
+          !has_fallback_formatter<T, char_type>::value)>
+  FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
+      -> basic_string_view<char_type> {
     return std_string_view<char_type>(val);
   }
-  FMT_CONSTEXPR const char* map(const signed char* val) {
-    static_assert(std::is_same<char_type, char>::value, "invalid string type");
-    return reinterpret_cast<const char*>(val);
+
+  using cstring_result = conditional_t<std::is_same<char_type, char>::value,
+                                       const char*, unformattable_pointer>;
+
+  FMT_DEPRECATED FMT_CONSTEXPR FMT_INLINE auto map(const signed char* val)
+      -> cstring_result {
+    return map(reinterpret_cast<const char*>(val));
   }
-  FMT_CONSTEXPR const char* map(const unsigned char* val) {
-    static_assert(std::is_same<char_type, char>::value, "invalid string type");
-    return reinterpret_cast<const char*>(val);
+  FMT_DEPRECATED FMT_CONSTEXPR FMT_INLINE auto map(const unsigned char* val)
+      -> cstring_result {
+    return map(reinterpret_cast<const char*>(val));
   }
-  FMT_CONSTEXPR const char* map(signed char* val) {
-    const auto* const_val = val;
-    return map(const_val);
+  FMT_DEPRECATED FMT_CONSTEXPR FMT_INLINE auto map(signed char* val)
+      -> cstring_result {
+    return map(reinterpret_cast<const char*>(val));
   }
-  FMT_CONSTEXPR const char* map(unsigned char* val) {
-    const auto* const_val = val;
-    return map(const_val);
+  FMT_DEPRECATED FMT_CONSTEXPR FMT_INLINE auto map(unsigned char* val)
+      -> cstring_result {
+    return map(reinterpret_cast<const char*>(val));
   }
 
-  FMT_CONSTEXPR const void* map(void* val) { return val; }
-  FMT_CONSTEXPR const void* map(const void* val) { return val; }
-  FMT_CONSTEXPR const void* map(std::nullptr_t val) { return val; }
-  template <typename T> FMT_CONSTEXPR int map(const T*) {
-    // Formatting of arbitrary pointers is disallowed. If you want to output
-    // a pointer cast it to "void *" or "const void *". In particular, this
-    // forbids formatting of "[const] volatile char *" which is printed as bool
-    // by iostreams.
-    static_assert(!sizeof(T), "formatting of non-void pointers is disallowed");
-    return 0;
+  FMT_CONSTEXPR FMT_INLINE auto map(void* val) -> const void* { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(const void* val) -> const void* {
+    return val;
+  }
+  FMT_CONSTEXPR FMT_INLINE auto map(std::nullptr_t val) -> const void* {
+    return val;
+  }
+
+  // We use SFINAE instead of a const T* parameter to avoid conflicting with
+  // the C array overload.
+  template <
+      typename T,
+      FMT_ENABLE_IF(
+          std::is_member_pointer<T>::value ||
+          std::is_function<typename std::remove_pointer<T>::type>::value ||
+          (std::is_convertible<const T&, const void*>::value &&
+           !std::is_convertible<const T&, const char_type*>::value))>
+  FMT_CONSTEXPR 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_CONSTEXPR FMT_INLINE auto map(const T (&values)[N]) -> const T (&)[N] {
+    return values;
   }
 
   template <typename T,
-            FMT_ENABLE_IF(std::is_enum<T>::value &&
-                          !has_formatter<T, Context>::value &&
-                          !has_fallback_formatter<T, Context>::value)>
-  FMT_CONSTEXPR auto map(const T& val)
+            FMT_ENABLE_IF(
+                std::is_enum<T>::value&& std::is_convertible<T, int>::value &&
+                !has_formatter<T, Context>::value &&
+                !has_fallback_formatter<T, char_type>::value)>
+  FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
       -> decltype(std::declval<arg_mapper>().map(
           static_cast<typename std::underlying_type<T>::type>(val))) {
     return map(static_cast<typename std::underlying_type<T>::type>(val));
   }
-  template <typename T,
-            FMT_ENABLE_IF(!is_string<T>::value && !is_char<T>::value &&
-                          (has_formatter<T, Context>::value ||
-                           has_fallback_formatter<T, Context>::value))>
-  FMT_CONSTEXPR const T& map(const T& val) {
+
+  FMT_CONSTEXPR FMT_INLINE auto map(detail::byte val) -> unsigned {
+    return map(static_cast<unsigned char>(val));
+  }
+
+  template <typename T, typename U = remove_cvref_t<T>>
+  struct formattable
+      : bool_constant<has_const_formatter<U, Context>() ||
+                      !std::is_const<remove_reference_t<T>>::value ||
+                      has_fallback_formatter<U, char_type>::value> {};
+
+#if FMT_MSC_VER != 0 && FMT_MSC_VER < 1910
+  // Workaround a bug in MSVC.
+  template <typename T> FMT_CONSTEXPR FMT_INLINE auto do_map(T&& val) -> T& {
     return val;
   }
+#else
+  template <typename T, FMT_ENABLE_IF(formattable<T>::value)>
+  FMT_CONSTEXPR FMT_INLINE auto do_map(T&& val) -> T& {
+    return val;
+  }
+  template <typename T, FMT_ENABLE_IF(!formattable<T>::value)>
+  FMT_CONSTEXPR FMT_INLINE auto do_map(T&&) -> unformattable_const {
+    return {};
+  }
+#endif
 
-  template <typename T>
-  FMT_CONSTEXPR auto map(const named_arg<char_type, T>& val)
-      -> decltype(std::declval<arg_mapper>().map(val.value)) {
-    return map(val.value);
+  template <typename T, typename U = remove_cvref_t<T>,
+            FMT_ENABLE_IF(!is_string<U>::value && !is_char<U>::value &&
+                          !std::is_array<U>::value &&
+                          (has_formatter<U, Context>::value ||
+                           has_fallback_formatter<U, char_type>::value))>
+  FMT_CONSTEXPR FMT_INLINE auto map(T&& val)
+      -> decltype(this->do_map(std::forward<T>(val))) {
+    return do_map(std::forward<T>(val));
   }
 
-  unformattable map(...) { return {}; }
+  template <typename T, FMT_ENABLE_IF(is_named_arg<T>::value)>
+  FMT_CONSTEXPR FMT_INLINE auto map(const T& named_arg)
+      -> decltype(std::declval<arg_mapper>().map(named_arg.value)) {
+    return map(named_arg.value);
+  }
+
+  auto map(...) -> unformattable { return {}; }
 };
 
 // A type constant after applying arg_mapper<Context>.
@@ -1244,7 +1498,28 @@ enum { packed_arg_bits = 4 };
 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 };
-}  // namespace detail
+
+FMT_END_DETAIL_NAMESPACE
+
+// An output iterator that appends to a buffer.
+// It is used to reduce symbol sizes for the common case.
+class appender : public std::back_insert_iterator<detail::buffer<char>> {
+  using base = std::back_insert_iterator<detail::buffer<char>>;
+
+  template <typename T>
+  friend auto get_buffer(appender out) -> detail::buffer<char>& {
+    return detail::get_container(out);
+  }
+
+ public:
+  using std::back_insert_iterator<detail::buffer<char>>::back_insert_iterator;
+  appender(base it) FMT_NOEXCEPT : base(it) {}
+  using _Unchecked_type = appender;  // Mark iterator as checked.
+
+  auto operator++() FMT_NOEXCEPT -> appender& { return *this; }
+
+  auto operator++(int) FMT_NOEXCEPT -> appender { return *this; }
+};
 
 // A formatting argument. It is a trivially copyable/constructible type to
 // allow storage in basic_memory_buffer.
@@ -1254,8 +1529,8 @@ template <typename Context> class basic_format_arg {
   detail::type type_;
 
   template <typename ContextType, typename T>
-  friend FMT_CONSTEXPR basic_format_arg<ContextType> detail::make_arg(
-      const T& value);
+  friend FMT_CONSTEXPR auto detail::make_arg(const T& value)
+      -> basic_format_arg<ContextType>;
 
   template <typename Visitor, typename Ctx>
   friend FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,
@@ -1293,10 +1568,12 @@ template <typename Context> class basic_format_arg {
     return type_ != detail::type::none_type;
   }
 
-  detail::type type() const { return type_; }
+  auto type() const -> detail::type { return type_; }
 
-  bool is_integral() const { return detail::is_integral_type(type_); }
-  bool is_arithmetic() const { return detail::is_arithmetic_type(type_); }
+  auto is_integral() const -> bool { return detail::is_integral_type(type_); }
+  auto is_arithmetic() const -> bool {
+    return detail::is_arithmetic_type(type_);
+  }
 };
 
 /**
@@ -1307,9 +1584,8 @@ template <typename Context> class basic_format_arg {
   \endrst
  */
 template <typename Visitor, typename Context>
-FMT_CONSTEXPR_DECL FMT_INLINE auto visit_format_arg(
+FMT_CONSTEXPR FMT_INLINE auto visit_format_arg(
     Visitor&& vis, const basic_format_arg<Context>& arg) -> decltype(vis(0)) {
-  using char_type = typename Context::char_type;
   switch (arg.type_) {
   case detail::type::none_type:
     break;
@@ -1321,16 +1597,10 @@ FMT_CONSTEXPR_DECL FMT_INLINE auto visit_format_arg(
     return vis(arg.value_.long_long_value);
   case detail::type::ulong_long_type:
     return vis(arg.value_.ulong_long_value);
-#if FMT_USE_INT128
   case detail::type::int128_type:
-    return vis(arg.value_.int128_value);
+    return vis(detail::convert_for_visit(arg.value_.int128_value));
   case detail::type::uint128_type:
-    return vis(arg.value_.uint128_value);
-#else
-  case detail::type::int128_type:
-  case detail::type::uint128_type:
-    break;
-#endif
+    return vis(detail::convert_for_visit(arg.value_.uint128_value));
   case detail::type::bool_type:
     return vis(arg.value_.bool_value);
   case detail::type::char_type:
@@ -1344,8 +1614,8 @@ FMT_CONSTEXPR_DECL FMT_INLINE auto visit_format_arg(
   case detail::type::cstring_type:
     return vis(arg.value_.string.data);
   case detail::type::string_type:
-    return vis(basic_string_view<char_type>(arg.value_.string.data,
-                                            arg.value_.string.size));
+    using sv = basic_string_view<typename Context::char_type>;
+    return vis(sv(arg.value_.string.data, arg.value_.string.size));
   case detail::type::pointer_type:
     return vis(arg.value_.pointer);
   case detail::type::custom_type:
@@ -1354,14 +1624,22 @@ FMT_CONSTEXPR_DECL FMT_INLINE auto visit_format_arg(
   return vis(monostate());
 }
 
-template <typename T> struct formattable : std::false_type {};
+FMT_BEGIN_DETAIL_NAMESPACE
 
-namespace detail {
+template <typename Char, typename InputIt>
+auto copy_str(InputIt begin, InputIt end, appender out) -> appender {
+  get_container(out).append(begin, end);
+  return out;
+}
 
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500
 // A workaround for gcc 4.8 to make void_t work in a SFINAE context.
 template <typename... Ts> struct void_t_impl { using type = void; };
 template <typename... Ts>
 using void_t = typename detail::void_t_impl<Ts...>::type;
+#else
+template <typename...> using void_t = void;
+#endif
 
 template <typename It, typename T, typename Enable = void>
 struct is_output_iterator : std::false_type {};
@@ -1384,9 +1662,8 @@ struct is_contiguous_back_insert_iterator : std::false_type {};
 template <typename Container>
 struct is_contiguous_back_insert_iterator<std::back_insert_iterator<Container>>
     : is_contiguous<Container> {};
-template <typename Char>
-struct is_contiguous_back_insert_iterator<buffer_appender<Char>>
-    : std::true_type {};
+template <>
+struct is_contiguous_back_insert_iterator<appender> : std::true_type {};
 
 // A type-erased reference to an std::locale to avoid heavy <locale> include.
 class locale_ref {
@@ -1394,97 +1671,72 @@ class locale_ref {
   const void* locale_;  // A type-erased pointer to std::locale.
 
  public:
-  locale_ref() : locale_(nullptr) {}
+  constexpr locale_ref() : locale_(nullptr) {}
   template <typename Locale> explicit locale_ref(const Locale& loc);
 
   explicit operator bool() const FMT_NOEXCEPT { return locale_ != nullptr; }
 
-  template <typename Locale> Locale get() const;
+  template <typename Locale> auto get() const -> Locale;
 };
 
-template <typename> constexpr unsigned long long encode_types() { return 0; }
+template <typename> constexpr auto encode_types() -> unsigned long long {
+  return 0;
+}
 
 template <typename Context, typename Arg, typename... Args>
-constexpr unsigned long long encode_types() {
+constexpr auto encode_types() -> unsigned long long {
   return static_cast<unsigned>(mapped_type_constant<Arg, Context>::value) |
          (encode_types<Context, Args...>() << packed_arg_bits);
 }
 
 template <typename Context, typename T>
-FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T& value) {
+FMT_CONSTEXPR auto make_arg(const T& value) -> basic_format_arg<Context> {
   basic_format_arg<Context> arg;
   arg.type_ = mapped_type_constant<T, Context>::value;
   arg.value_ = arg_mapper<Context>().map(value);
   return arg;
 }
 
-template <typename T> int check(unformattable) {
-  static_assert(
-      formattable<T>(),
-      "Cannot format an argument. To make type T formattable provide a "
-      "formatter<T> specialization: https://fmt.dev/latest/api.html#udt");
-  return 0;
-}
-template <typename T, typename U> inline const U& check(const U& val) {
-  return val;
-}
-
 // The type template parameter is there to avoid an ODR violation when using
 // a fallback formatter in one translation unit and an implicit conversion in
 // another (not recommended).
 template <bool IS_PACKED, typename Context, type, typename T,
           FMT_ENABLE_IF(IS_PACKED)>
-inline value<Context> make_arg(const T& val) {
-  return check<T>(arg_mapper<Context>().map(val));
+FMT_CONSTEXPR FMT_INLINE auto make_arg(T&& val) -> value<Context> {
+  const auto& arg = arg_mapper<Context>().map(std::forward<T>(val));
+
+  constexpr bool formattable_char =
+      !std::is_same<decltype(arg), const unformattable_char&>::value;
+  static_assert(formattable_char, "Mixing character types is disallowed.");
+
+  constexpr bool formattable_const =
+      !std::is_same<decltype(arg), const unformattable_const&>::value;
+  static_assert(formattable_const, "Cannot format a const argument.");
+
+  // Formatting of arbitrary pointers is disallowed. If you want to output
+  // a pointer cast it to "void *" or "const void *". In particular, this
+  // forbids formatting of "[const] volatile char *" which is printed as bool
+  // by iostreams.
+  constexpr bool formattable_pointer =
+      !std::is_same<decltype(arg), const unformattable_pointer&>::value;
+  static_assert(formattable_pointer,
+                "Formatting of non-void pointers is disallowed.");
+
+  constexpr bool formattable =
+      !std::is_same<decltype(arg), const unformattable&>::value;
+  static_assert(
+      formattable,
+      "Cannot format an argument. To make type T formattable provide a "
+      "formatter<T> specialization: https://fmt.dev/latest/api.html#udt");
+  return {arg};
 }
 
 template <bool IS_PACKED, typename Context, type, typename T,
           FMT_ENABLE_IF(!IS_PACKED)>
-inline basic_format_arg<Context> make_arg(const T& value) {
+inline auto make_arg(const T& value) -> basic_format_arg<Context> {
   return make_arg<Context>(value);
 }
-
-template <typename T> struct is_reference_wrapper : std::false_type {};
-template <typename T>
-struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
-
-template <typename T> const T& unwrap(const T& v) { return v; }
-template <typename T> const T& unwrap(const std::reference_wrapper<T>& v) {
-  return static_cast<const T&>(v);
-}
-
-class dynamic_arg_list {
-  // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
-  // templates it doesn't complain about inability to deduce single translation
-  // unit for placing vtable. So storage_node_base is made a fake template.
-  template <typename = void> struct node {
-    virtual ~node() = default;
-    std::unique_ptr<node<>> next;
-  };
-
-  template <typename T> struct typed_node : node<> {
-    T value;
-
-    template <typename Arg>
-    FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {}
-
-    template <typename Char>
-    FMT_CONSTEXPR typed_node(const basic_string_view<Char>& arg)
-        : value(arg.data(), arg.size()) {}
-  };
-
-  std::unique_ptr<node<>> head_;
-
- public:
-  template <typename T, typename Arg> const T& push(const Arg& arg) {
-    auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
-    auto& value = new_node->value;
-    new_node->next = std::move(head_);
-    head_ = std::move(new_node);
-    return value;
-  }
-};
-}  // namespace detail
+FMT_END_DETAIL_NAMESPACE
 
 // Formatting context.
 template <typename OutputIt, typename Char> class basic_format_context {
@@ -1503,46 +1755,59 @@ template <typename OutputIt, typename Char> class basic_format_context {
   using parse_context_type = basic_format_parse_context<Char>;
   template <typename T> using formatter_type = formatter<T, char_type>;
 
+  basic_format_context(basic_format_context&&) = default;
   basic_format_context(const basic_format_context&) = delete;
   void operator=(const basic_format_context&) = delete;
   /**
    Constructs a ``basic_format_context`` object. References to the arguments are
    stored in the object so make sure they have appropriate lifetimes.
    */
-  basic_format_context(OutputIt out,
-                       basic_format_args<basic_format_context> ctx_args,
-                       detail::locale_ref loc = detail::locale_ref())
+  constexpr basic_format_context(
+      OutputIt out, basic_format_args<basic_format_context> ctx_args,
+      detail::locale_ref loc = detail::locale_ref())
       : out_(out), args_(ctx_args), loc_(loc) {}
 
-  format_arg arg(int id) const { return args_.get(id); }
-  format_arg arg(basic_string_view<char_type> name) { return args_.get(name); }
-  int arg_id(basic_string_view<char_type> name) { return args_.get_id(name); }
-  const basic_format_args<basic_format_context>& args() const { return args_; }
+  constexpr auto arg(int id) const -> format_arg { return args_.get(id); }
+  FMT_CONSTEXPR auto arg(basic_string_view<char_type> name) -> format_arg {
+    return args_.get(name);
+  }
+  FMT_CONSTEXPR auto arg_id(basic_string_view<char_type> name) -> int {
+    return args_.get_id(name);
+  }
+  auto args() const -> const basic_format_args<basic_format_context>& {
+    return args_;
+  }
 
-  detail::error_handler error_handler() { return {}; }
+  FMT_CONSTEXPR auto error_handler() -> detail::error_handler { return {}; }
   void on_error(const char* message) { error_handler().on_error(message); }
 
   // Returns an iterator to the beginning of the output range.
-  iterator out() { return out_; }
+  FMT_CONSTEXPR auto out() -> iterator { return out_; }
 
   // Advances the begin iterator to ``it``.
   void advance_to(iterator it) {
     if (!detail::is_back_insert_iterator<iterator>()) out_ = it;
   }
 
-  detail::locale_ref locale() { return loc_; }
+  FMT_CONSTEXPR auto locale() -> detail::locale_ref { return loc_; }
 };
 
 template <typename Char>
 using buffer_context =
     basic_format_context<detail::buffer_appender<Char>, Char>;
 using format_context = buffer_context<char>;
-using wformat_context = buffer_context<wchar_t>;
 
 // Workaround an alias issue: https://stackoverflow.com/q/62767544/471164.
 #define FMT_BUFFER_CONTEXT(Char) \
   basic_format_context<detail::buffer_appender<Char>, Char>
 
+template <typename T, typename Char = char>
+using is_formattable = bool_constant<
+    !std::is_base_of<detail::unformattable,
+                     decltype(detail::arg_mapper<buffer_context<Char>>().map(
+                         std::declval<T>()))>::value &&
+    !detail::has_fallback_formatter<T, Char>::value>;
+
 /**
   \rst
   An array of references to arguments. It can be implicitly converted into
@@ -1579,14 +1844,16 @@ class format_arg_store
            : 0);
 
  public:
-  format_arg_store(const Args&... args)
+  template <typename... T>
+  FMT_CONSTEXPR FMT_INLINE format_arg_store(T&&... args)
       :
 #if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
         basic_format_args<Context>(*this),
 #endif
         data_{detail::make_arg<
             is_packed, Context,
-            detail::mapped_type_constant<Args, Context>::value>(args)...} {
+            detail::mapped_type_constant<remove_cvref_t<T>, Context>::value>(
+            std::forward<T>(args))...} {
     detail::init_named_args(data_.named_args(), 0, 0, args...);
   }
 };
@@ -1600,36 +1867,16 @@ class format_arg_store
   \endrst
  */
 template <typename Context = format_context, typename... Args>
-inline format_arg_store<Context, Args...> make_format_args(
-    const Args&... args) {
-  return {args...};
+constexpr auto make_format_args(Args&&... args)
+    -> format_arg_store<Context, remove_cvref_t<Args>...> {
+  return {std::forward<Args>(args)...};
 }
 
 /**
   \rst
-  Constructs a `~fmt::format_arg_store` object that contains references
-  to arguments and can be implicitly converted to `~fmt::format_args`.
-  If ``format_str`` is a compile-time string then `make_args_checked` checks
-  its validity at compile time.
-  \endrst
- */
-template <typename... Args, typename S, typename Char = char_t<S>>
-inline auto make_args_checked(const S& format_str,
-                              const remove_reference_t<Args>&... args)
-    -> format_arg_store<buffer_context<Char>, remove_reference_t<Args>...> {
-  static_assert(
-      detail::count<(
-              std::is_base_of<detail::view, remove_reference_t<Args>>::value &&
-              std::is_reference<Args>::value)...>() == 0,
-      "passing views as lvalues is disallowed");
-  detail::check_format_string<Args...>(format_str);
-  return {args...};
-}
-
-/**
-  \rst
-  Returns a named argument to be used in a formatting function. It should only
-  be used in a call to a formatting function.
+  Returns a named argument to be used in a formatting function.
+  It should only be used in a call to a formatting function or
+  `dynamic_format_arg_store::push_back`.
 
   **Example**::
 
@@ -1637,184 +1884,11 @@ inline auto make_args_checked(const S& format_str,
   \endrst
  */
 template <typename Char, typename T>
-inline detail::named_arg<Char, T> arg(const Char* name, const T& arg) {
+inline auto arg(const Char* name, const T& arg) -> detail::named_arg<Char, T> {
   static_assert(!detail::is_named_arg<T>(), "nested named arguments");
   return {name, arg};
 }
 
-/**
-  \rst
-  A dynamic version of `fmt::format_arg_store`.
-  It's equipped with a storage to potentially temporary objects which lifetimes
-  could be shorter than the format arguments object.
-
-  It can be implicitly converted into `~fmt::basic_format_args` for passing
-  into type-erased formatting functions such as `~fmt::vformat`.
-  \endrst
- */
-template <typename Context>
-class dynamic_format_arg_store
-#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
-    // Workaround a GCC template argument substitution bug.
-    : public basic_format_args<Context>
-#endif
-{
- private:
-  using char_type = typename Context::char_type;
-
-  template <typename T> struct need_copy {
-    static constexpr detail::type mapped_type =
-        detail::mapped_type_constant<T, Context>::value;
-
-    enum {
-      value = !(detail::is_reference_wrapper<T>::value ||
-                std::is_same<T, basic_string_view<char_type>>::value ||
-                std::is_same<T, detail::std_string_view<char_type>>::value ||
-                (mapped_type != detail::type::cstring_type &&
-                 mapped_type != detail::type::string_type &&
-                 mapped_type != detail::type::custom_type))
-    };
-  };
-
-  template <typename T>
-  using stored_type = conditional_t<detail::is_string<T>::value,
-                                    std::basic_string<char_type>, T>;
-
-  // Storage of basic_format_arg must be contiguous.
-  std::vector<basic_format_arg<Context>> data_;
-  std::vector<detail::named_arg_info<char_type>> named_info_;
-
-  // Storage of arguments not fitting into basic_format_arg must grow
-  // without relocation because items in data_ refer to it.
-  detail::dynamic_arg_list dynamic_args_;
-
-  friend class basic_format_args<Context>;
-
-  unsigned long long get_types() const {
-    return detail::is_unpacked_bit | data_.size() |
-           (named_info_.empty()
-                ? 0ULL
-                : static_cast<unsigned long long>(detail::has_named_args_bit));
-  }
-
-  const basic_format_arg<Context>* data() const {
-    return named_info_.empty() ? data_.data() : data_.data() + 1;
-  }
-
-  template <typename T> void emplace_arg(const T& arg) {
-    data_.emplace_back(detail::make_arg<Context>(arg));
-  }
-
-  template <typename T>
-  void emplace_arg(const detail::named_arg<char_type, T>& arg) {
-    if (named_info_.empty()) {
-      constexpr const detail::named_arg_info<char_type>* zero_ptr{nullptr};
-      data_.insert(data_.begin(), {zero_ptr, 0});
-    }
-    data_.emplace_back(detail::make_arg<Context>(detail::unwrap(arg.value)));
-    auto pop_one = [](std::vector<basic_format_arg<Context>>* data) {
-      data->pop_back();
-    };
-    std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)>
-        guard{&data_, pop_one};
-    named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)});
-    data_[0].value_.named_args = {named_info_.data(), named_info_.size()};
-    guard.release();
-  }
-
- public:
-  /**
-    \rst
-    Adds an argument into the dynamic store for later passing to a formatting
-    function.
-
-    Note that custom types and string types (but not string views) are copied
-    into the store dynamically allocating memory if necessary.
-
-    **Example**::
-
-      fmt::dynamic_format_arg_store<fmt::format_context> store;
-      store.push_back(42);
-      store.push_back("abc");
-      store.push_back(1.5f);
-      std::string result = fmt::vformat("{} and {} and {}", store);
-    \endrst
-  */
-  template <typename T> void push_back(const T& arg) {
-    if (detail::const_check(need_copy<T>::value))
-      emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
-    else
-      emplace_arg(detail::unwrap(arg));
-  }
-
-  /**
-    \rst
-    Adds a reference to the argument into the dynamic store for later passing to
-    a formatting function. Supports named arguments wrapped in
-    ``std::reference_wrapper`` via ``std::ref()``/``std::cref()``.
-
-    **Example**::
-
-      fmt::dynamic_format_arg_store<fmt::format_context> store;
-      char str[] = "1234567890";
-      store.push_back(std::cref(str));
-      int a1_val{42};
-      auto a1 = fmt::arg("a1_", a1_val);
-      store.push_back(std::cref(a1));
-
-      // Changing str affects the output but only for string and custom types.
-      str[0] = 'X';
-
-      std::string result = fmt::vformat("{} and {a1_}");
-      assert(result == "X234567890 and 42");
-    \endrst
-  */
-  template <typename T> void push_back(std::reference_wrapper<T> arg) {
-    static_assert(
-        detail::is_named_arg<typename std::remove_cv<T>::type>::value ||
-            need_copy<T>::value,
-        "objects of built-in types and string views are always copied");
-    emplace_arg(arg.get());
-  }
-
-  /**
-    Adds named argument into the dynamic store for later passing to a formatting
-    function. ``std::reference_wrapper`` is supported to avoid copying of the
-    argument.
-  */
-  template <typename T>
-  void push_back(const detail::named_arg<char_type, T>& arg) {
-    const char_type* arg_name =
-        dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();
-    if (detail::const_check(need_copy<T>::value)) {
-      emplace_arg(
-          fmt::arg(arg_name, dynamic_args_.push<stored_type<T>>(arg.value)));
-    } else {
-      emplace_arg(fmt::arg(arg_name, arg.value));
-    }
-  }
-
-  /** Erase all elements from the store */
-  void clear() {
-    data_.clear();
-    named_info_.clear();
-    dynamic_args_ = detail::dynamic_arg_list();
-  }
-
-  /**
-    \rst
-    Reserves space to store at least *new_cap* arguments including
-    *new_cap_named* named arguments.
-    \endrst
-  */
-  void reserve(size_t new_cap, size_t new_cap_named) {
-    FMT_ASSERT(new_cap >= new_cap_named,
-               "Set of arguments includes set of named arguments");
-    data_.reserve(new_cap);
-    named_info_.reserve(new_cap_named);
-  }
-};
-
 /**
   \rst
   A view of a collection of formatting arguments. To avoid lifetime issues it
@@ -1846,25 +1920,27 @@ template <typename Context> class basic_format_args {
     const format_arg* args_;
   };
 
-  bool is_packed() const { return (desc_ & detail::is_unpacked_bit) == 0; }
-  bool has_named_args() const {
+  constexpr auto is_packed() const -> bool {
+    return (desc_ & detail::is_unpacked_bit) == 0;
+  }
+  auto has_named_args() const -> bool {
     return (desc_ & detail::has_named_args_bit) != 0;
   }
 
-  detail::type type(int index) const {
+  FMT_CONSTEXPR auto type(int index) const -> detail::type {
     int shift = index * detail::packed_arg_bits;
     unsigned int mask = (1 << detail::packed_arg_bits) - 1;
     return static_cast<detail::type>((desc_ >> shift) & mask);
   }
 
-  basic_format_args(unsigned long long desc,
-                    const detail::value<Context>* values)
+  constexpr FMT_INLINE basic_format_args(unsigned long long desc,
+                                         const detail::value<Context>* values)
       : desc_(desc), values_(values) {}
-  basic_format_args(unsigned long long desc, const format_arg* args)
+  constexpr basic_format_args(unsigned long long desc, const format_arg* args)
       : desc_(desc), args_(args) {}
 
  public:
-  basic_format_args() : desc_(0) {}
+  constexpr basic_format_args() : desc_(0), args_(nullptr) {}
 
   /**
    \rst
@@ -1872,8 +1948,10 @@ template <typename Context> class basic_format_args {
    \endrst
    */
   template <typename... Args>
-  FMT_INLINE basic_format_args(const format_arg_store<Context, Args...>& store)
-      : basic_format_args(store.desc, store.data_.args()) {}
+  constexpr FMT_INLINE basic_format_args(
+      const format_arg_store<Context, Args...>& store)
+      : basic_format_args(format_arg_store<Context, Args...>::desc,
+                          store.data_.args()) {}
 
   /**
    \rst
@@ -1881,7 +1959,8 @@ template <typename Context> class basic_format_args {
    `~fmt::dynamic_format_arg_store`.
    \endrst
    */
-  FMT_INLINE basic_format_args(const dynamic_format_arg_store<Context>& store)
+  constexpr FMT_INLINE basic_format_args(
+      const dynamic_format_arg_store<Context>& store)
       : basic_format_args(store.get_types(), store.data()) {}
 
   /**
@@ -1889,12 +1968,12 @@ template <typename Context> class basic_format_args {
    Constructs a `basic_format_args` object from a dynamic set of arguments.
    \endrst
    */
-  basic_format_args(const format_arg* args, int count)
+  constexpr basic_format_args(const format_arg* args, int count)
       : basic_format_args(detail::is_unpacked_bit | detail::to_unsigned(count),
                           args) {}
 
   /** Returns the argument with the specified id. */
-  format_arg get(int id) const {
+  FMT_CONSTEXPR auto get(int id) const -> format_arg {
     format_arg arg;
     if (!is_packed()) {
       if (id < max_size()) arg = args_[id];
@@ -1907,12 +1986,14 @@ template <typename Context> class basic_format_args {
     return arg;
   }
 
-  template <typename Char> format_arg get(basic_string_view<Char> name) const {
+  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> int get_id(basic_string_view<Char> name) const {
+  template <typename Char>
+  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;
@@ -1922,87 +2003,1149 @@ template <typename Context> class basic_format_args {
     return -1;
   }
 
-  int max_size() const {
+  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);
   }
 };
 
-#ifdef FMT_ARM_ABI_COMPATIBILITY
 /** An alias to ``basic_format_args<format_context>``. */
-// Separate types would result in shorter symbols but break ABI compatibility
+// 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<format_context>;
-using wformat_args = basic_format_args<wformat_context>;
-#else
-// DEPRECATED! These are kept for ABI compatibility.
-// It is a separate type rather than an alias to make symbols readable.
-struct format_args : basic_format_args<format_context> {
-  template <typename... Args>
-  FMT_INLINE format_args(const Args&... args) : basic_format_args(args...) {}
+
+// We cannot use enum classes as bit fields because of a gcc bug
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414.
+namespace align {
+enum type { none, left, right, center, numeric };
+}
+using align_t = align::type;
+namespace sign {
+enum type { none, minus, plus, space };
+}
+using sign_t = sign::type;
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+// Workaround an array initialization issue in gcc 4.8.
+template <typename Char> struct fill_t {
+ private:
+  enum { max_size = 4 };
+  Char data_[max_size] = {Char(' '), Char(0), Char(0), Char(0)};
+  unsigned char size_ = 1;
+
+ public:
+  FMT_CONSTEXPR void operator=(basic_string_view<Char> s) {
+    auto size = s.size();
+    if (size > max_size) return throw_format_error("invalid fill");
+    for (size_t i = 0; i < size; ++i) data_[i] = s[i];
+    size_ = static_cast<unsigned char>(size);
+  }
+
+  constexpr auto size() const -> size_t { return size_; }
+  constexpr auto data() const -> const Char* { return data_; }
+
+  FMT_CONSTEXPR auto operator[](size_t index) -> Char& { return data_[index]; }
+  FMT_CONSTEXPR auto operator[](size_t index) const -> const Char& {
+    return data_[index];
+  }
 };
-struct wformat_args : basic_format_args<wformat_context> {
-  using basic_format_args::basic_format_args;
+FMT_END_DETAIL_NAMESPACE
+
+enum class presentation_type : unsigned char {
+  none,
+  // Integer types should go first,
+  dec,             // 'd'
+  oct,             // 'o'
+  hex_lower,       // 'x'
+  hex_upper,       // 'X'
+  bin_lower,       // 'b'
+  bin_upper,       // 'B'
+  hexfloat_lower,  // 'a'
+  hexfloat_upper,  // 'A'
+  exp_lower,       // 'e'
+  exp_upper,       // 'E'
+  fixed_lower,     // 'f'
+  fixed_upper,     // 'F'
+  general_lower,   // 'g'
+  general_upper,   // 'G'
+  chr,             // 'c'
+  string,          // 's'
+  pointer          // 'p'
 };
+
+// Format specifiers for built-in and string types.
+template <typename Char> struct basic_format_specs {
+  int width;
+  int precision;
+  presentation_type type;
+  align_t align : 4;
+  sign_t sign : 3;
+  bool alt : 1;  // Alternate form ('#').
+  bool localized : 1;
+  detail::fill_t<Char> fill;
+
+  constexpr basic_format_specs()
+      : width(0),
+        precision(-1),
+        type(presentation_type::none),
+        align(align::none),
+        sign(sign::none),
+        alt(false),
+        localized(false) {}
+};
+
+using format_specs = basic_format_specs<char>;
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+enum class arg_id_kind { none, index, name };
+
+// An argument reference.
+template <typename Char> struct arg_ref {
+  FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {}
+
+  FMT_CONSTEXPR explicit arg_ref(int index)
+      : kind(arg_id_kind::index), val(index) {}
+  FMT_CONSTEXPR explicit arg_ref(basic_string_view<Char> name)
+      : kind(arg_id_kind::name), val(name) {}
+
+  FMT_CONSTEXPR auto operator=(int idx) -> arg_ref& {
+    kind = arg_id_kind::index;
+    val.index = idx;
+    return *this;
+  }
+
+  arg_id_kind kind;
+  union value {
+    FMT_CONSTEXPR value(int id = 0) : index{id} {}
+    FMT_CONSTEXPR value(basic_string_view<Char> n) : name(n) {}
+
+    int index;
+    basic_string_view<Char> name;
+  } val;
+};
+
+// Format specifiers with width and precision resolved at formatting rather
+// than parsing time to allow re-using the same parsed specifiers with
+// different sets of arguments (precompilation of format strings).
+template <typename Char>
+struct dynamic_format_specs : basic_format_specs<Char> {
+  arg_ref<Char> width_ref;
+  arg_ref<Char> precision_ref;
+};
+
+struct auto_id {};
+
+// A format specifier handler that sets fields in basic_format_specs.
+template <typename Char> class specs_setter {
+ protected:
+  basic_format_specs<Char>& specs_;
+
+ public:
+  explicit FMT_CONSTEXPR specs_setter(basic_format_specs<Char>& specs)
+      : specs_(specs) {}
+
+  FMT_CONSTEXPR specs_setter(const specs_setter& other)
+      : specs_(other.specs_) {}
+
+  FMT_CONSTEXPR void on_align(align_t align) { specs_.align = align; }
+  FMT_CONSTEXPR void on_fill(basic_string_view<Char> fill) {
+    specs_.fill = fill;
+  }
+  FMT_CONSTEXPR void on_sign(sign_t s) { specs_.sign = s; }
+  FMT_CONSTEXPR void on_hash() { specs_.alt = true; }
+  FMT_CONSTEXPR void on_localized() { specs_.localized = true; }
+
+  FMT_CONSTEXPR void on_zero() {
+    if (specs_.align == align::none) specs_.align = align::numeric;
+    specs_.fill[0] = Char('0');
+  }
+
+  FMT_CONSTEXPR void on_width(int width) { specs_.width = width; }
+  FMT_CONSTEXPR void on_precision(int precision) {
+    specs_.precision = precision;
+  }
+  FMT_CONSTEXPR void end_precision() {}
+
+  FMT_CONSTEXPR void on_type(presentation_type type) { specs_.type = type; }
+};
+
+// Format spec handler that saves references to arguments representing dynamic
+// width and precision to be resolved at formatting time.
+template <typename ParseContext>
+class dynamic_specs_handler
+    : public specs_setter<typename ParseContext::char_type> {
+ public:
+  using char_type = typename ParseContext::char_type;
+
+  FMT_CONSTEXPR dynamic_specs_handler(dynamic_format_specs<char_type>& specs,
+                                      ParseContext& ctx)
+      : specs_setter<char_type>(specs), specs_(specs), context_(ctx) {}
+
+  FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler& other)
+      : specs_setter<char_type>(other),
+        specs_(other.specs_),
+        context_(other.context_) {}
+
+  template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
+    specs_.width_ref = make_arg_ref(arg_id);
+  }
+
+  template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
+    specs_.precision_ref = make_arg_ref(arg_id);
+  }
+
+  FMT_CONSTEXPR void on_error(const char* message) {
+    context_.on_error(message);
+  }
+
+ private:
+  dynamic_format_specs<char_type>& specs_;
+  ParseContext& context_;
+
+  using arg_ref_type = arg_ref<char_type>;
+
+  FMT_CONSTEXPR auto make_arg_ref(int arg_id) -> arg_ref_type {
+    context_.check_arg_id(arg_id);
+    return arg_ref_type(arg_id);
+  }
+
+  FMT_CONSTEXPR auto make_arg_ref(auto_id) -> arg_ref_type {
+    return arg_ref_type(context_.next_arg_id());
+  }
+
+  FMT_CONSTEXPR auto make_arg_ref(basic_string_view<char_type> arg_id)
+      -> arg_ref_type {
+    context_.check_arg_id(arg_id);
+    basic_string_view<char_type> format_str(
+        context_.begin(), to_unsigned(context_.end() - context_.begin()));
+    return arg_ref_type(arg_id);
+  }
+};
+
+template <typename Char> constexpr bool is_ascii_letter(Char c) {
+  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+}
+
+// Converts a character to ASCII. Returns a number > 127 on conversion failure.
+template <typename Char, FMT_ENABLE_IF(std::is_integral<Char>::value)>
+constexpr auto to_ascii(Char value) -> Char {
+  return value;
+}
+template <typename Char, FMT_ENABLE_IF(std::is_enum<Char>::value)>
+constexpr auto to_ascii(Char value) ->
+    typename std::underlying_type<Char>::type {
+  return value;
+}
+
+template <typename Char>
+FMT_CONSTEXPR auto code_point_length(const Char* begin) -> int {
+  if (const_check(sizeof(Char) != 1)) return 1;
+  auto lengths =
+      "\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";
+  int len = lengths[static_cast<unsigned char>(*begin) >> 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.
+  return len + !len;
+}
+
+// Return the result via the out param to workaround gcc bug 77539.
+template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
+FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool {
+  for (out = first; out != last; ++out) {
+    if (*out == value) return true;
+  }
+  return false;
+}
+
+template <>
+inline auto find<false, char>(const char* first, const char* last, char value,
+                              const char*& out) -> bool {
+  out = static_cast<const char*>(
+      std::memchr(first, value, to_unsigned(last - first)));
+  return out != nullptr;
+}
+
+// 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;
+  if (num_digits <= std::numeric_limits<int>::digits10)
+    return static_cast<int>(value);
+  // Check for overflow.
+  const unsigned max = to_unsigned((std::numeric_limits<int>::max)());
+  return num_digits == std::numeric_limits<int>::digits10 + 1 &&
+                 prev * 10ull + unsigned(p[-1] - '0') <= max
+             ? static_cast<int>(value)
+             : error_value;
+}
+
+// Parses fill and alignment.
+template <typename Char, typename Handler>
+FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end,
+                               Handler&& handler) -> const Char* {
+  FMT_ASSERT(begin != end, "");
+  auto align = align::none;
+  auto p = begin + code_point_length(begin);
+  if (p >= end) p = begin;
+  for (;;) {
+    switch (to_ascii(*p)) {
+    case '<':
+      align = align::left;
+      break;
+    case '>':
+      align = align::right;
+      break;
+    case '^':
+      align = align::center;
+      break;
+    default:
+      break;
+    }
+    if (align != align::none) {
+      if (p != begin) {
+        auto c = *begin;
+        if (c == '{')
+          return handler.on_error("invalid fill character '{'"), begin;
+        handler.on_fill(basic_string_view<Char>(begin, to_unsigned(p - begin)));
+        begin = p + 1;
+      } else
+        ++begin;
+      handler.on_align(align);
+      break;
+    } else if (p == begin) {
+      break;
+    }
+    p = begin;
+  }
+  return begin;
+}
+
+template <typename Char> FMT_CONSTEXPR bool is_name_start(Char c) {
+  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
+}
+
+template <typename Char, typename IDHandler>
+FMT_CONSTEXPR auto do_parse_arg_id(const Char* begin, const Char* end,
+                                   IDHandler&& handler) -> const Char* {
+  FMT_ASSERT(begin != end, "");
+  Char c = *begin;
+  if (c >= '0' && c <= '9') {
+    int index = 0;
+    if (c != '0')
+      index =
+          parse_nonnegative_int(begin, end, (std::numeric_limits<int>::max)());
+    else
+      ++begin;
+    if (begin == end || (*begin != '}' && *begin != ':'))
+      handler.on_error("invalid format string");
+    else
+      handler(index);
+    return begin;
+  }
+  if (!is_name_start(c)) {
+    handler.on_error("invalid format string");
+    return begin;
+  }
+  auto it = begin;
+  do {
+    ++it;
+  } while (it != end && (is_name_start(c = *it) || ('0' <= c && c <= '9')));
+  handler(basic_string_view<Char>(begin, to_unsigned(it - begin)));
+  return it;
+}
+
+template <typename Char, typename IDHandler>
+FMT_CONSTEXPR FMT_INLINE auto parse_arg_id(const Char* begin, const Char* end,
+                                           IDHandler&& handler) -> const Char* {
+  Char c = *begin;
+  if (c != '}' && c != ':') return do_parse_arg_id(begin, end, handler);
+  handler();
+  return begin;
+}
+
+template <typename Char, typename Handler>
+FMT_CONSTEXPR auto parse_width(const Char* begin, const Char* end,
+                               Handler&& handler) -> const Char* {
+  using detail::auto_id;
+  struct width_adapter {
+    Handler& handler;
+
+    FMT_CONSTEXPR void operator()() { handler.on_dynamic_width(auto_id()); }
+    FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_width(id); }
+    FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
+      handler.on_dynamic_width(id);
+    }
+    FMT_CONSTEXPR void on_error(const char* message) {
+      if (message) handler.on_error(message);
+    }
+  };
+
+  FMT_ASSERT(begin != end, "");
+  if ('0' <= *begin && *begin <= '9') {
+    int width = parse_nonnegative_int(begin, end, -1);
+    if (width != -1)
+      handler.on_width(width);
+    else
+      handler.on_error("number is too big");
+  } else if (*begin == '{') {
+    ++begin;
+    if (begin != end) begin = parse_arg_id(begin, end, width_adapter{handler});
+    if (begin == end || *begin != '}')
+      return handler.on_error("invalid format string"), begin;
+    ++begin;
+  }
+  return begin;
+}
+
+template <typename Char, typename Handler>
+FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end,
+                                   Handler&& handler) -> const Char* {
+  using detail::auto_id;
+  struct precision_adapter {
+    Handler& handler;
+
+    FMT_CONSTEXPR void operator()() { handler.on_dynamic_precision(auto_id()); }
+    FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_precision(id); }
+    FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
+      handler.on_dynamic_precision(id);
+    }
+    FMT_CONSTEXPR void on_error(const char* message) {
+      if (message) handler.on_error(message);
+    }
+  };
+
+  ++begin;
+  auto c = begin != end ? *begin : Char();
+  if ('0' <= c && c <= '9') {
+    auto precision = parse_nonnegative_int(begin, end, -1);
+    if (precision != -1)
+      handler.on_precision(precision);
+    else
+      handler.on_error("number is too big");
+  } else if (c == '{') {
+    ++begin;
+    if (begin != end)
+      begin = parse_arg_id(begin, end, precision_adapter{handler});
+    if (begin == end || *begin++ != '}')
+      return handler.on_error("invalid format string"), begin;
+  } else {
+    return handler.on_error("missing precision specifier"), begin;
+  }
+  handler.end_precision();
+  return begin;
+}
+
+template <typename Char>
+FMT_CONSTEXPR auto parse_presentation_type(Char type) -> presentation_type {
+  switch (to_ascii(type)) {
+  case 'd':
+    return presentation_type::dec;
+  case 'o':
+    return presentation_type::oct;
+  case 'x':
+    return presentation_type::hex_lower;
+  case 'X':
+    return presentation_type::hex_upper;
+  case 'b':
+    return presentation_type::bin_lower;
+  case 'B':
+    return presentation_type::bin_upper;
+  case 'a':
+    return presentation_type::hexfloat_lower;
+  case 'A':
+    return presentation_type::hexfloat_upper;
+  case 'e':
+    return presentation_type::exp_lower;
+  case 'E':
+    return presentation_type::exp_upper;
+  case 'f':
+    return presentation_type::fixed_lower;
+  case 'F':
+    return presentation_type::fixed_upper;
+  case 'g':
+    return presentation_type::general_lower;
+  case 'G':
+    return presentation_type::general_upper;
+  case 'c':
+    return presentation_type::chr;
+  case 's':
+    return presentation_type::string;
+  case 'p':
+    return presentation_type::pointer;
+  default:
+    return presentation_type::none;
+  }
+}
+
+// Parses standard format specifiers and sends notifications about parsed
+// components to handler.
+template <typename Char, typename SpecHandler>
+FMT_CONSTEXPR FMT_INLINE auto parse_format_specs(const Char* begin,
+                                                 const Char* end,
+                                                 SpecHandler&& handler)
+    -> const Char* {
+  if (1 < end - begin && begin[1] == '}' && is_ascii_letter(*begin) &&
+      *begin != 'L') {
+    presentation_type type = parse_presentation_type(*begin++);
+    if (type == presentation_type::none)
+      handler.on_error("invalid type specifier");
+    handler.on_type(type);
+    return begin;
+  }
+
+  if (begin == end) return begin;
+
+  begin = parse_align(begin, end, handler);
+  if (begin == end) return begin;
+
+  // Parse sign.
+  switch (to_ascii(*begin)) {
+  case '+':
+    handler.on_sign(sign::plus);
+    ++begin;
+    break;
+  case '-':
+    handler.on_sign(sign::minus);
+    ++begin;
+    break;
+  case ' ':
+    handler.on_sign(sign::space);
+    ++begin;
+    break;
+  default:
+    break;
+  }
+  if (begin == end) return begin;
+
+  if (*begin == '#') {
+    handler.on_hash();
+    if (++begin == end) return begin;
+  }
+
+  // Parse zero flag.
+  if (*begin == '0') {
+    handler.on_zero();
+    if (++begin == end) return begin;
+  }
+
+  begin = parse_width(begin, end, handler);
+  if (begin == end) return begin;
+
+  // Parse precision.
+  if (*begin == '.') {
+    begin = parse_precision(begin, end, handler);
+    if (begin == end) return begin;
+  }
+
+  if (*begin == 'L') {
+    handler.on_localized();
+    ++begin;
+  }
+
+  // Parse type.
+  if (begin != end && *begin != '}') {
+    presentation_type type = parse_presentation_type(*begin++);
+    if (type == presentation_type::none)
+      handler.on_error("invalid type specifier");
+    handler.on_type(type);
+  }
+  return begin;
+}
+
+template <typename Char, typename Handler>
+FMT_CONSTEXPR auto parse_replacement_field(const Char* begin, const Char* end,
+                                           Handler&& handler) -> const Char* {
+  struct id_adapter {
+    Handler& handler;
+    int arg_id;
+
+    FMT_CONSTEXPR void operator()() { arg_id = handler.on_arg_id(); }
+    FMT_CONSTEXPR void operator()(int id) { arg_id = handler.on_arg_id(id); }
+    FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
+      arg_id = handler.on_arg_id(id);
+    }
+    FMT_CONSTEXPR void on_error(const char* message) {
+      if (message) handler.on_error(message);
+    }
+  };
+
+  ++begin;
+  if (begin == end) return handler.on_error("invalid format string"), end;
+  if (*begin == '}') {
+    handler.on_replacement_field(handler.on_arg_id(), begin);
+  } else if (*begin == '{') {
+    handler.on_text(begin, begin + 1);
+  } else {
+    auto adapter = id_adapter{handler, 0};
+    begin = parse_arg_id(begin, end, adapter);
+    Char c = begin != end ? *begin : Char();
+    if (c == '}') {
+      handler.on_replacement_field(adapter.arg_id, begin);
+    } else if (c == ':') {
+      begin = handler.on_format_specs(adapter.arg_id, begin + 1, end);
+      if (begin == end || *begin != '}')
+        return handler.on_error("unknown format specifier"), end;
+    } else {
+      return handler.on_error("missing '}' in format string"), end;
+    }
+  }
+  return begin + 1;
+}
+
+template <bool IS_CONSTEXPR, typename Char, typename Handler>
+FMT_CONSTEXPR FMT_INLINE void parse_format_string(
+    basic_string_view<Char> format_str, Handler&& handler) {
+  // Workaround a name-lookup bug in MSVC's modules implementation.
+  using detail::find;
+
+  auto begin = format_str.data();
+  auto end = begin + format_str.size();
+  if (end - begin < 32) {
+    // Use a simple loop instead of memchr for small strings.
+    const Char* 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);
+    return;
+  }
+  struct writer {
+    FMT_CONSTEXPR void operator()(const Char* pbegin, const Char* pend) {
+      if (pbegin == pend) return;
+      for (;;) {
+        const Char* p = nullptr;
+        if (!find<IS_CONSTEXPR>(pbegin, pend, Char('}'), p))
+          return handler_.on_text(pbegin, pend);
+        ++p;
+        if (p == pend || *p != '}')
+          return handler_.on_error("unmatched '}' in format string");
+        handler_.on_text(pbegin, p);
+        pbegin = p + 1;
+      }
+    }
+    Handler& handler_;
+  } write{handler};
+  while (begin != end) {
+    // Doing two passes with memchr (one for '{' and another for '}') is up to
+    // 2.5x faster than the naive one-pass implementation on big format strings.
+    const Char* p = begin;
+    if (*begin != '{' && !find<IS_CONSTEXPR>(begin + 1, end, Char('{'), p))
+      return write(begin, end);
+    write(begin, p);
+    begin = parse_replacement_field(p, end, handler);
+  }
+}
+
+template <typename T, typename ParseContext>
+FMT_CONSTEXPR auto parse_format_specs(ParseContext& ctx)
+    -> decltype(ctx.begin()) {
+  using char_type = typename ParseContext::char_type;
+  using context = buffer_context<char_type>;
+  using mapped_type = conditional_t<
+      mapped_type_constant<T, context>::value != type::custom_type,
+      decltype(arg_mapper<context>().map(std::declval<const T&>())), T>;
+  auto f = conditional_t<has_formatter<mapped_type, context>::value,
+                         formatter<mapped_type, char_type>,
+                         fallback_formatter<T, char_type>>();
+  return f.parse(ctx);
+}
+
+// A parse context with extra argument id checks. It is only used at compile
+// time because adding checks at runtime would introduce substantial overhead
+// and would be redundant since argument ids are checked when arguments are
+// retrieved anyway.
+template <typename Char, typename ErrorHandler = error_handler>
+class compile_parse_context
+    : public basic_format_parse_context<Char, ErrorHandler> {
+ private:
+  int num_args_;
+  using base = basic_format_parse_context<Char, ErrorHandler>;
+
+ public:
+  explicit FMT_CONSTEXPR compile_parse_context(
+      basic_string_view<Char> format_str,
+      int num_args = (std::numeric_limits<int>::max)(), ErrorHandler eh = {})
+      : base(format_str, eh), num_args_(num_args) {}
+
+  FMT_CONSTEXPR auto next_arg_id() -> int {
+    int id = base::next_arg_id();
+    if (id >= num_args_) this->on_error("argument not found");
+    return id;
+  }
+
+  FMT_CONSTEXPR void check_arg_id(int id) {
+    base::check_arg_id(id);
+    if (id >= num_args_) this->on_error("argument not found");
+  }
+  using base::check_arg_id;
+};
+
+template <typename ErrorHandler>
+FMT_CONSTEXPR void check_int_type_spec(presentation_type type,
+                                       ErrorHandler&& eh) {
+  if (type > presentation_type::bin_upper && type != presentation_type::chr)
+    eh.on_error("invalid type specifier");
+}
+
+// Checks char specs and returns true if the type spec is char (and not int).
+template <typename Char, typename ErrorHandler = error_handler>
+FMT_CONSTEXPR auto check_char_specs(const basic_format_specs<Char>& specs,
+                                    ErrorHandler&& eh = {}) -> bool {
+  if (specs.type != presentation_type::none &&
+      specs.type != presentation_type::chr) {
+    check_int_type_spec(specs.type, eh);
+    return false;
+  }
+  if (specs.align == align::numeric || specs.sign != sign::none || specs.alt)
+    eh.on_error("invalid format specifier for char");
+  return true;
+}
+
+// A floating-point presentation format.
+enum class float_format : unsigned char {
+  general,  // General: exponent notation or fixed point based on magnitude.
+  exp,      // Exponent notation with the default precision of 6, e.g. 1.2e-3.
+  fixed,    // Fixed point with the default precision of 6, e.g. 0.0012.
+  hex
+};
+
+struct float_specs {
+  int precision;
+  float_format format : 8;
+  sign_t sign : 8;
+  bool upper : 1;
+  bool locale : 1;
+  bool binary32 : 1;
+  bool fallback : 1;
+  bool showpoint : 1;
+};
+
+template <typename ErrorHandler = error_handler, typename Char>
+FMT_CONSTEXPR auto parse_float_type_spec(const basic_format_specs<Char>& specs,
+                                         ErrorHandler&& eh = {})
+    -> float_specs {
+  auto result = float_specs();
+  result.showpoint = specs.alt;
+  result.locale = specs.localized;
+  switch (specs.type) {
+  case presentation_type::none:
+    result.format = float_format::general;
+    break;
+  case presentation_type::general_upper:
+    result.upper = true;
+    FMT_FALLTHROUGH;
+  case presentation_type::general_lower:
+    result.format = float_format::general;
+    break;
+  case presentation_type::exp_upper:
+    result.upper = true;
+    FMT_FALLTHROUGH;
+  case presentation_type::exp_lower:
+    result.format = float_format::exp;
+    result.showpoint |= specs.precision != 0;
+    break;
+  case presentation_type::fixed_upper:
+    result.upper = true;
+    FMT_FALLTHROUGH;
+  case presentation_type::fixed_lower:
+    result.format = float_format::fixed;
+    result.showpoint |= specs.precision != 0;
+    break;
+  case presentation_type::hexfloat_upper:
+    result.upper = true;
+    FMT_FALLTHROUGH;
+  case presentation_type::hexfloat_lower:
+    result.format = float_format::hex;
+    break;
+  default:
+    eh.on_error("invalid type specifier");
+    break;
+  }
+  return result;
+}
+
+template <typename ErrorHandler = error_handler>
+FMT_CONSTEXPR auto check_cstring_type_spec(presentation_type type,
+                                           ErrorHandler&& eh = {}) -> bool {
+  if (type == presentation_type::none || type == presentation_type::string)
+    return true;
+  if (type != presentation_type::pointer) eh.on_error("invalid type specifier");
+  return false;
+}
+
+template <typename ErrorHandler = error_handler>
+FMT_CONSTEXPR void check_string_type_spec(presentation_type type,
+                                          ErrorHandler&& eh = {}) {
+  if (type != presentation_type::none && type != presentation_type::string)
+    eh.on_error("invalid type specifier");
+}
+
+template <typename ErrorHandler>
+FMT_CONSTEXPR void check_pointer_type_spec(presentation_type type,
+                                           ErrorHandler&& eh) {
+  if (type != presentation_type::none && type != presentation_type::pointer)
+    eh.on_error("invalid type specifier");
+}
+
+// A parse_format_specs handler that checks if specifiers are consistent with
+// the argument type.
+template <typename Handler> class specs_checker : public Handler {
+ private:
+  detail::type arg_type_;
+
+  FMT_CONSTEXPR void require_numeric_argument() {
+    if (!is_arithmetic_type(arg_type_))
+      this->on_error("format specifier requires numeric argument");
+  }
+
+ public:
+  FMT_CONSTEXPR specs_checker(const Handler& handler, detail::type arg_type)
+      : Handler(handler), arg_type_(arg_type) {}
+
+  FMT_CONSTEXPR void on_align(align_t align) {
+    if (align == align::numeric) require_numeric_argument();
+    Handler::on_align(align);
+  }
+
+  FMT_CONSTEXPR void on_sign(sign_t s) {
+    require_numeric_argument();
+    if (is_integral_type(arg_type_) && arg_type_ != type::int_type &&
+        arg_type_ != type::long_long_type && arg_type_ != type::char_type) {
+      this->on_error("format specifier requires signed argument");
+    }
+    Handler::on_sign(s);
+  }
+
+  FMT_CONSTEXPR void on_hash() {
+    require_numeric_argument();
+    Handler::on_hash();
+  }
+
+  FMT_CONSTEXPR void on_localized() {
+    require_numeric_argument();
+    Handler::on_localized();
+  }
+
+  FMT_CONSTEXPR void on_zero() {
+    require_numeric_argument();
+    Handler::on_zero();
+  }
+
+  FMT_CONSTEXPR void end_precision() {
+    if (is_integral_type(arg_type_) || arg_type_ == type::pointer_type)
+      this->on_error("precision not allowed for this argument type");
+  }
+};
+
+constexpr int invalid_arg_index = -1;
+
+#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+template <int N, typename T, typename... Args, typename Char>
+constexpr auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
+  if constexpr (detail::is_statically_named_arg<T>()) {
+    if (name == T::name) return N;
+  }
+  if constexpr (sizeof...(Args) > 0)
+    return get_arg_index_by_name<N + 1, Args...>(name);
+  (void)name;  // Workaround an MSVC bug about "unused" parameter.
+  return invalid_arg_index;
+}
 #endif
 
-namespace detail {
+template <typename... Args, typename Char>
+FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
+#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+  if constexpr (sizeof...(Args) > 0)
+    return get_arg_index_by_name<0, Args...>(name);
+#endif
+  (void)name;
+  return invalid_arg_index;
+}
 
-template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
-std::basic_string<Char> vformat(
-    basic_string_view<Char> format_str,
-    basic_format_args<buffer_context<type_identity_t<Char>>> args);
+template <typename Char, typename ErrorHandler, typename... Args>
+class format_string_checker {
+ private:
+  using parse_context_type = compile_parse_context<Char, ErrorHandler>;
+  enum { num_args = sizeof...(Args) };
 
-FMT_API std::string vformat(string_view format_str, format_args args);
+  // Format specifier parsing function.
+  using parse_func = const Char* (*)(parse_context_type&);
+
+  parse_context_type context_;
+  parse_func parse_funcs_[num_args > 0 ? num_args : 1];
+
+ public:
+  explicit FMT_CONSTEXPR format_string_checker(
+      basic_string_view<Char> format_str, ErrorHandler eh)
+      : context_(format_str, num_args, eh),
+        parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
+
+  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 {
+    return context_.check_arg_id(id), id;
+  }
+  FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int {
+#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+    auto index = get_arg_index_by_name<Args...>(id);
+    if (index == invalid_arg_index) on_error("named argument is not found");
+    return context_.check_arg_id(index), index;
+#else
+    (void)id;
+    on_error("compile-time checks for named arguments require C++20 support");
+    return 0;
+#endif
+  }
+
+  FMT_CONSTEXPR void on_replacement_field(int, const Char*) {}
+
+  FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char*)
+      -> const Char* {
+    context_.advance_to(context_.begin() + (begin - &*context_.begin()));
+    // id >= 0 check is a workaround for gcc 10 bug (#2065).
+    return id >= 0 && id < num_args ? parse_funcs_[id](context_) : begin;
+  }
+
+  FMT_CONSTEXPR void on_error(const char* message) {
+    context_.on_error(message);
+  }
+};
+
+template <typename... Args, typename S,
+          enable_if_t<(is_compile_string<S>::value), int>>
+void check_format_string(S format_str) {
+  FMT_CONSTEXPR auto s = to_string_view(format_str);
+  using checker = format_string_checker<typename S::char_type, error_handler,
+                                        remove_cvref_t<Args>...>;
+  FMT_CONSTEXPR bool invalid_format =
+      (parse_format_string<true>(s, checker(s, {})), true);
+  ignore_unused(invalid_format);
+}
 
 template <typename Char>
 void vformat_to(
-    buffer<Char>& buf, basic_string_view<Char> format_str,
+    buffer<Char>& buf, basic_string_view<Char> fmt,
     basic_format_args<FMT_BUFFER_CONTEXT(type_identity_t<Char>)> args,
-    detail::locale_ref loc = {});
-
-template <typename Char, typename Args,
-          FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
-inline void vprint_mojibake(std::FILE*, basic_string_view<Char>, const Args&) {}
+    locale_ref loc = {});
 
 FMT_API void vprint_mojibake(std::FILE*, string_view, format_args);
 #ifndef _WIN32
 inline void vprint_mojibake(std::FILE*, string_view, format_args) {}
 #endif
-}  // namespace detail
+FMT_END_DETAIL_NAMESPACE
+
+// A formatter specialization for the core types corresponding to detail::type
+// constants.
+template <typename T, typename Char>
+struct formatter<T, Char,
+                 enable_if_t<detail::type_constant<T, Char>::value !=
+                             detail::type::custom_type>> {
+ private:
+  detail::dynamic_format_specs<Char> specs_;
+
+ public:
+  // Parses format specifiers stopping either at the end of the range or at the
+  // terminating '}'.
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    auto begin = ctx.begin(), end = ctx.end();
+    if (begin == end) return begin;
+    using handler_type = detail::dynamic_specs_handler<ParseContext>;
+    auto type = detail::type_constant<T, Char>::value;
+    auto checker =
+        detail::specs_checker<handler_type>(handler_type(specs_, ctx), type);
+    auto it = detail::parse_format_specs(begin, end, checker);
+    auto eh = ctx.error_handler();
+    switch (type) {
+    case detail::type::none_type:
+      FMT_ASSERT(false, "invalid argument type");
+      break;
+    case detail::type::bool_type:
+      if (specs_.type == presentation_type::none ||
+          specs_.type == presentation_type::string) {
+        break;
+      }
+      FMT_FALLTHROUGH;
+    case detail::type::int_type:
+    case detail::type::uint_type:
+    case detail::type::long_long_type:
+    case detail::type::ulong_long_type:
+    case detail::type::int128_type:
+    case detail::type::uint128_type:
+      detail::check_int_type_spec(specs_.type, eh);
+      break;
+    case detail::type::char_type:
+      detail::check_char_specs(specs_, eh);
+      break;
+    case detail::type::float_type:
+      if (detail::const_check(FMT_USE_FLOAT))
+        detail::parse_float_type_spec(specs_, eh);
+      else
+        FMT_ASSERT(false, "float support disabled");
+      break;
+    case detail::type::double_type:
+      if (detail::const_check(FMT_USE_DOUBLE))
+        detail::parse_float_type_spec(specs_, eh);
+      else
+        FMT_ASSERT(false, "double support disabled");
+      break;
+    case detail::type::long_double_type:
+      if (detail::const_check(FMT_USE_LONG_DOUBLE))
+        detail::parse_float_type_spec(specs_, eh);
+      else
+        FMT_ASSERT(false, "long double support disabled");
+      break;
+    case detail::type::cstring_type:
+      detail::check_cstring_type_spec(specs_.type, eh);
+      break;
+    case detail::type::string_type:
+      detail::check_string_type_spec(specs_.type, eh);
+      break;
+    case detail::type::pointer_type:
+      detail::check_pointer_type_spec(specs_.type, eh);
+      break;
+    case detail::type::custom_type:
+      // Custom format specifiers are checked in parse functions of
+      // formatter specializations.
+      break;
+    }
+    return it;
+  }
+
+  template <typename FormatContext>
+  FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const
+      -> decltype(ctx.out());
+};
+
+template <typename Char> struct basic_runtime { basic_string_view<Char> str; };
+
+/** A compile-time format string. */
+template <typename Char, typename... Args> class basic_format_string {
+ private:
+  basic_string_view<Char> str_;
+
+ public:
+  template <typename S,
+            FMT_ENABLE_IF(
+                std::is_convertible<const S&, basic_string_view<Char>>::value)>
+  FMT_CONSTEVAL FMT_INLINE basic_format_string(const S& s) : str_(s) {
+    static_assert(
+        detail::count<
+            (std::is_base_of<detail::view, remove_reference_t<Args>>::value &&
+             std::is_reference<Args>::value)...>() == 0,
+        "passing views as lvalues is disallowed");
+#ifdef FMT_HAS_CONSTEVAL
+    if constexpr (detail::count_named_args<Args...>() ==
+                  detail::count_statically_named_args<Args...>()) {
+      using checker = detail::format_string_checker<Char, detail::error_handler,
+                                                    remove_cvref_t<Args>...>;
+      detail::parse_format_string<true>(str_, checker(s, {}));
+    }
+#else
+    detail::check_format_string<Args...>(s);
+#endif
+  }
+  basic_format_string(basic_runtime<Char> r) : str_(r.str) {}
+
+  FMT_INLINE operator basic_string_view<Char>() const { return str_; }
+};
+
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+// Workaround broken conversion on older gcc.
+template <typename... Args> using format_string = string_view;
+template <typename S> auto runtime(const S& s) -> basic_string_view<char_t<S>> {
+  return s;
+}
+#else
+template <typename... Args>
+using format_string = basic_format_string<char, type_identity_t<Args>...>;
+/**
+  \rst
+  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");
+  \endrst
+ */
+template <typename S> auto runtime(const S& s) -> basic_runtime<char_t<S>> {
+  return {{s}};
+}
+#endif
+
+FMT_API auto vformat(string_view fmt, format_args args) -> std::string;
+
+/**
+  \rst
+  Formats ``args`` according to specifications in ``fmt`` and returns the result
+  as a string.
+
+  **Example**::
+
+    #include <fmt/core.h>
+    std::string message = fmt::format("The answer is {}.", 42);
+  \endrst
+*/
+template <typename... T>
+FMT_NODISCARD FMT_INLINE auto format(format_string<T...> fmt, T&&... args)
+    -> std::string {
+  return vformat(fmt, fmt::make_format_args(args...));
+}
 
 /** Formats a string and writes the output to ``out``. */
-// GCC 8 and earlier cannot handle std::back_insert_iterator<Container> with
-// vformat_to<ArgFormatter>(...) overload, so SFINAE on iterator type instead.
-template <typename OutputIt, typename S, typename Char = char_t<S>,
-          bool enable = detail::is_output_iterator<OutputIt, Char>::value>
-auto vformat_to(OutputIt out, const S& format_str,
-                basic_format_args<buffer_context<type_identity_t<Char>>> args)
-    -> typename std::enable_if<enable, OutputIt>::type {
-  decltype(detail::get_buffer<Char>(out)) buf(detail::get_buffer_init(out));
-  detail::vformat_to(buf, to_string_view(format_str), args);
+template <typename OutputIt,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+auto vformat_to(OutputIt out, string_view fmt, format_args args) -> OutputIt {
+  using detail::get_buffer;
+  auto&& buf = get_buffer<char>(out);
+  detail::vformat_to(buf, fmt, args, {});
   return detail::get_iterator(buf);
 }
 
 /**
  \rst
- Formats arguments, writes the result to the output iterator ``out`` and returns
- the iterator past the end of the output range.
+ 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**::
 
-   std::vector<char> out;
+   auto out = std::vector<char>();
    fmt::format_to(std::back_inserter(out), "{}", 42);
  \endrst
  */
-// We cannot use FMT_ENABLE_IF because of a bug in gcc 8.3.
-template <typename OutputIt, typename S, typename... Args,
-          bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value>
-inline auto format_to(OutputIt out, const S& format_str, Args&&... args) ->
-    typename std::enable_if<enable, OutputIt>::type {
-  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
-  return vformat_to(out, to_string_view(format_str), vargs);
+template <typename OutputIt, typename... T,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+FMT_INLINE auto format_to(OutputIt out, format_string<T...> fmt, T&&... args)
+    -> OutputIt {
+  return vformat_to(out, fmt, fmt::make_format_args(args...));
 }
 
 template <typename OutputIt> struct format_to_n_result {
@@ -2012,111 +3155,82 @@ template <typename OutputIt> struct format_to_n_result {
   size_t size;
 };
 
-template <typename OutputIt, typename Char, typename... Args,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)>
-inline format_to_n_result<OutputIt> vformat_to_n(
-    OutputIt out, size_t n, basic_string_view<Char> format_str,
-    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
-  detail::iterator_buffer<OutputIt, Char, detail::fixed_buffer_traits> buf(out,
-                                                                           n);
-  detail::vformat_to(buf, format_str, args);
+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()};
 }
 
 /**
- \rst
- Formats arguments, writes up to ``n`` characters of the result to the output
- iterator ``out`` and returns the total output size and the iterator past the
- end of the output range.
- \endrst
+  \rst
+  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.
+  \endrst
  */
-template <typename OutputIt, typename S, typename... Args,
-          bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value>
-inline auto format_to_n(OutputIt out, size_t n, const S& format_str,
-                        const Args&... args) ->
-    typename std::enable_if<enable, format_to_n_result<OutputIt>>::type {
-  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
-  return vformat_to_n(out, n, to_string_view(format_str), vargs);
+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, fmt::make_format_args(args...));
 }
 
-/**
-  Returns the number of characters in the output of
-  ``format(format_str, args...)``.
- */
-template <typename... Args>
-inline size_t formatted_size(string_view format_str, Args&&... args) {
-  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
-  detail::counting_buffer<> buf;
-  detail::vformat_to(buf, format_str, vargs);
+/** 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, string_view(fmt), fmt::make_format_args(args...), {});
   return buf.count();
 }
 
-template <typename S, typename Char = char_t<S>>
-FMT_INLINE std::basic_string<Char> vformat(
-    const S& format_str,
-    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
-  return detail::vformat(to_string_view(format_str), args);
-}
+FMT_API void vprint(string_view fmt, format_args args);
+FMT_API void vprint(std::FILE* f, string_view fmt, format_args args);
 
 /**
   \rst
-  Formats arguments and returns the result as a string.
-
-  **Example**::
-
-    #include <fmt/core.h>
-    std::string message = fmt::format("The answer is {}", 42);
-  \endrst
-*/
-// Pass char_t as a default template parameter instead of using
-// std::basic_string<char_t<S>> to reduce the symbol size.
-template <typename S, typename... Args, typename Char = char_t<S>>
-FMT_INLINE std::basic_string<Char> format(const S& format_str, Args&&... args) {
-  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
-  return detail::vformat(to_string_view(format_str), vargs);
-}
-
-FMT_API void vprint(string_view, format_args);
-FMT_API void vprint(std::FILE*, string_view, format_args);
-
-/**
-  \rst
-  Formats ``args`` according to specifications in ``format_str`` and writes the
-  output to the file ``f``. Strings are assumed to be Unicode-encoded unless the
-  ``FMT_UNICODE`` macro is set to 0.
-
-  **Example**::
-
-    fmt::print(stderr, "Don't {}!", "panic");
-  \endrst
- */
-template <typename S, typename... Args, typename Char = char_t<S>>
-inline void print(std::FILE* f, const S& format_str, Args&&... args) {
-  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
-  return detail::is_unicode<Char>()
-             ? vprint(f, to_string_view(format_str), vargs)
-             : detail::vprint_mojibake(f, to_string_view(format_str), vargs);
-}
-
-/**
-  \rst
-  Formats ``args`` according to specifications in ``format_str`` and writes
-  the output to ``stdout``. Strings are assumed to be Unicode-encoded unless
-  the ``FMT_UNICODE`` macro is set to 0.
+  Formats ``args`` according to specifications in ``fmt`` and writes the output
+  to ``stdout``.
 
   **Example**::
 
     fmt::print("Elapsed time: {0:.2f} seconds", 1.23);
   \endrst
  */
-template <typename S, typename... Args, typename Char = char_t<S>>
-inline void print(const S& format_str, Args&&... args) {
-  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
-  return detail::is_unicode<Char>()
-             ? vprint(to_string_view(format_str), vargs)
-             : detail::vprint_mojibake(stdout, to_string_view(format_str),
-                                       vargs);
+template <typename... T>
+FMT_INLINE void print(format_string<T...> fmt, T&&... args) {
+  const auto& vargs = fmt::make_format_args(args...);
+  return detail::is_utf8() ? vprint(fmt, vargs)
+                           : detail::vprint_mojibake(stdout, fmt, vargs);
 }
+
+/**
+  \rst
+  Formats ``args`` according to specifications in ``fmt`` and writes the
+  output to the file ``f``.
+
+  **Example**::
+
+    fmt::print(stderr, "Don't {}!", "panic");
+  \endrst
+ */
+template <typename... T>
+FMT_INLINE void print(std::FILE* f, format_string<T...> fmt, T&&... args) {
+  const auto& vargs = fmt::make_format_args(args...);
+  return detail::is_utf8() ? vprint(f, fmt, vargs)
+                           : detail::vprint_mojibake(f, fmt, vargs);
+}
+
+FMT_MODULE_EXPORT_END
+FMT_GCC_PRAGMA("GCC pop_options")
 FMT_END_NAMESPACE
 
+#ifdef FMT_HEADER_ONLY
+#  include "format.h"
+#endif
 #endif  // FMT_CORE_H_
diff --git a/deps/fmt/include/fmt/format-inl.h b/deps/fmt/include/fmt/format-inl.h
index 8f2fe735..2c51c50a 100644
--- a/deps/fmt/include/fmt/format-inl.h
+++ b/deps/fmt/include/fmt/format-inl.h
@@ -8,8 +8,9 @@
 #ifndef FMT_FORMAT_INL_H_
 #define FMT_FORMAT_INL_H_
 
-#include <cassert>
+#include <algorithm>
 #include <cctype>
+#include <cerrno>  // errno
 #include <climits>
 #include <cmath>
 #include <cstdarg>
@@ -27,11 +28,6 @@
 
 #include "format.h"
 
-// Dummy implementations of strerror_r and strerror_s called if corresponding
-// system functions are not available.
-inline fmt::detail::null<> strerror_r(int, char*, ...) { return {}; }
-inline fmt::detail::null<> strerror_s(char*, size_t, ...) { return {}; }
-
 FMT_BEGIN_NAMESPACE
 namespace detail {
 
@@ -44,6 +40,10 @@ FMT_FUNC void assert_fail(const char* file, int line, const char* message) {
   std::terminate();
 }
 
+FMT_FUNC void throw_format_error(const char* message) {
+  FMT_THROW(format_error(message));
+}
+
 #ifndef _MSC_VER
 #  define FMT_SNPRINTF snprintf
 #else  // _MSC_VER
@@ -57,76 +57,6 @@ inline int fmt_snprintf(char* buffer, size_t size, const char* format, ...) {
 #  define FMT_SNPRINTF fmt_snprintf
 #endif  // _MSC_VER
 
-// A portable thread-safe version of strerror.
-// Sets buffer to point to a string describing the error code.
-// This can be either a pointer to a string stored in buffer,
-// or a pointer to some static immutable string.
-// Returns one of the following values:
-//   0      - success
-//   ERANGE - buffer is not large enough to store the error message
-//   other  - failure
-// Buffer should be at least of size 1.
-inline int safe_strerror(int error_code, char*& buffer,
-                         size_t buffer_size) FMT_NOEXCEPT {
-  FMT_ASSERT(buffer != nullptr && buffer_size != 0, "invalid buffer");
-
-  class dispatcher {
-   private:
-    int error_code_;
-    char*& buffer_;
-    size_t buffer_size_;
-
-    // A noop assignment operator to avoid bogus warnings.
-    void operator=(const dispatcher&) {}
-
-    // Handle the result of XSI-compliant version of strerror_r.
-    int handle(int result) {
-      // glibc versions before 2.13 return result in errno.
-      return result == -1 ? errno : result;
-    }
-
-    // Handle the result of GNU-specific version of strerror_r.
-    FMT_MAYBE_UNUSED
-    int handle(char* message) {
-      // If the buffer is full then the message is probably truncated.
-      if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
-        return ERANGE;
-      buffer_ = message;
-      return 0;
-    }
-
-    // Handle the case when strerror_r is not available.
-    FMT_MAYBE_UNUSED
-    int handle(detail::null<>) {
-      return fallback(strerror_s(buffer_, buffer_size_, error_code_));
-    }
-
-    // Fallback to strerror_s when strerror_r is not available.
-    FMT_MAYBE_UNUSED
-    int fallback(int result) {
-      // If the buffer is full then the message is probably truncated.
-      return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? ERANGE
-                                                                : result;
-    }
-
-#if !FMT_MSC_VER
-    // Fallback to strerror if strerror_r and strerror_s are not available.
-    int fallback(detail::null<>) {
-      errno = 0;
-      buffer_ = strerror(error_code_);
-      return errno;
-    }
-#endif
-
-   public:
-    dispatcher(int err_code, char*& buf, size_t buf_size)
-        : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
-
-    int run() { return handle(strerror_r(error_code_, buffer_, buffer_size_)); }
-  };
-  return dispatcher(error_code, buffer, buffer_size).run();
-}
-
 FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
                                 string_view message) FMT_NOEXCEPT {
   // Report error code making sure that the output fits into
@@ -145,18 +75,18 @@ FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
   error_code_size += detail::to_unsigned(detail::count_digits(abs_value));
   auto it = buffer_appender<char>(out);
   if (message.size() <= inline_buffer_size - error_code_size)
-    format_to(it, "{}{}", message, SEP);
-  format_to(it, "{}{}", ERROR_STR, error_code);
-  assert(out.size() <= inline_buffer_size);
+    format_to(it, FMT_STRING("{}{}"), message, SEP);
+  format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
+  FMT_ASSERT(out.size() <= inline_buffer_size, "");
 }
 
 FMT_FUNC void report_error(format_func func, int error_code,
-                           string_view message) FMT_NOEXCEPT {
+                           const char* message) FMT_NOEXCEPT {
   memory_buffer full_message;
   func(full_message, error_code, message);
   // Don't use fwrite_fully because the latter may throw.
-  (void)std::fwrite(full_message.data(), full_message.size(), 1, stderr);
-  std::fputc('\n', stderr);
+  if (std::fwrite(full_message.data(), full_message.size(), 1, stderr) > 0)
+    std::fputc('\n', stderr);
 }
 
 // A wrapper around fwrite that throws on error.
@@ -165,11 +95,8 @@ inline void fwrite_fully(const void* ptr, size_t size, size_t count,
   size_t written = std::fwrite(ptr, size, count, stream);
   if (written < count) FMT_THROW(system_error(errno, "cannot write to file"));
 }
-}  // namespace detail
-
-#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
-namespace detail {
 
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
 template <typename Locale>
 locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
   static_assert(std::is_same<Locale, std::locale>::value, "");
@@ -180,41 +107,36 @@ template <typename Locale> Locale locale_ref::get() const {
   return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
 }
 
-template <typename Char> FMT_FUNC std::string grouping_impl(locale_ref loc) {
-  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>()).grouping();
-}
-template <typename Char> FMT_FUNC Char thousands_sep_impl(locale_ref loc) {
-  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
-      .thousands_sep();
+template <typename Char>
+FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> {
+  auto& facet = std::use_facet<std::numpunct<Char>>(loc.get<std::locale>());
+  auto grouping = facet.grouping();
+  auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
+  return {std::move(grouping), thousands_sep};
 }
 template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) {
   return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
       .decimal_point();
 }
-}  // namespace detail
 #else
 template <typename Char>
-FMT_FUNC std::string detail::grouping_impl(locale_ref) {
-  return "\03";
+FMT_FUNC auto thousands_sep_impl(locale_ref) -> thousands_sep_result<Char> {
+  return {"\03", FMT_STATIC_THOUSANDS_SEPARATOR};
 }
-template <typename Char> FMT_FUNC Char detail::thousands_sep_impl(locale_ref) {
-  return FMT_STATIC_THOUSANDS_SEPARATOR;
-}
-template <typename Char> FMT_FUNC Char detail::decimal_point_impl(locale_ref) {
+template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref) {
   return '.';
 }
 #endif
+}  // namespace detail
 
+#if !FMT_MSC_VER
 FMT_API FMT_FUNC format_error::~format_error() FMT_NOEXCEPT = default;
-FMT_API FMT_FUNC system_error::~system_error() FMT_NOEXCEPT = default;
+#endif
 
-FMT_FUNC void system_error::init(int err_code, string_view format_str,
-                                 format_args args) {
-  error_code_ = err_code;
-  memory_buffer buffer;
-  format_system_error(buffer, err_code, vformat(format_str, args));
-  std::runtime_error& base = *this;
-  base = std::runtime_error(to_string(buffer));
+FMT_FUNC std::system_error vsystem_error(int error_code, string_view format_str,
+                                         format_args args) {
+  auto ec = std::error_code(error_code, std::generic_category());
+  return std::system_error(ec, vformat(format_str, args));
 }
 
 namespace detail {
@@ -227,946 +149,153 @@ template <> FMT_FUNC int count_digits<4>(detail::fallback_uintptr n) {
   return i >= 0 ? i * char_digits + count_digits<4, unsigned>(n.value[i]) : 1;
 }
 
-template <typename T>
-const typename basic_data<T>::digit_pair basic_data<T>::digits[] = {
-    {'0', '0'}, {'0', '1'}, {'0', '2'}, {'0', '3'}, {'0', '4'}, {'0', '5'},
-    {'0', '6'}, {'0', '7'}, {'0', '8'}, {'0', '9'}, {'1', '0'}, {'1', '1'},
-    {'1', '2'}, {'1', '3'}, {'1', '4'}, {'1', '5'}, {'1', '6'}, {'1', '7'},
-    {'1', '8'}, {'1', '9'}, {'2', '0'}, {'2', '1'}, {'2', '2'}, {'2', '3'},
-    {'2', '4'}, {'2', '5'}, {'2', '6'}, {'2', '7'}, {'2', '8'}, {'2', '9'},
-    {'3', '0'}, {'3', '1'}, {'3', '2'}, {'3', '3'}, {'3', '4'}, {'3', '5'},
-    {'3', '6'}, {'3', '7'}, {'3', '8'}, {'3', '9'}, {'4', '0'}, {'4', '1'},
-    {'4', '2'}, {'4', '3'}, {'4', '4'}, {'4', '5'}, {'4', '6'}, {'4', '7'},
-    {'4', '8'}, {'4', '9'}, {'5', '0'}, {'5', '1'}, {'5', '2'}, {'5', '3'},
-    {'5', '4'}, {'5', '5'}, {'5', '6'}, {'5', '7'}, {'5', '8'}, {'5', '9'},
-    {'6', '0'}, {'6', '1'}, {'6', '2'}, {'6', '3'}, {'6', '4'}, {'6', '5'},
-    {'6', '6'}, {'6', '7'}, {'6', '8'}, {'6', '9'}, {'7', '0'}, {'7', '1'},
-    {'7', '2'}, {'7', '3'}, {'7', '4'}, {'7', '5'}, {'7', '6'}, {'7', '7'},
-    {'7', '8'}, {'7', '9'}, {'8', '0'}, {'8', '1'}, {'8', '2'}, {'8', '3'},
-    {'8', '4'}, {'8', '5'}, {'8', '6'}, {'8', '7'}, {'8', '8'}, {'8', '9'},
-    {'9', '0'}, {'9', '1'}, {'9', '2'}, {'9', '3'}, {'9', '4'}, {'9', '5'},
-    {'9', '6'}, {'9', '7'}, {'9', '8'}, {'9', '9'}};
+// log10(2) = 0x0.4d104d427de7fbcc...
+static constexpr uint64_t log10_2_significand = 0x4d104d427de7fbcc;
 
-template <typename T>
-const char basic_data<T>::hex_digits[] = "0123456789abcdef";
+template <typename T = void> struct basic_impl_data {
+  // Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
+  // These are generated by support/compute-powers.py.
+  static constexpr uint64_t pow10_significands[87] = {
+      0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76,
+      0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df,
+      0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c,
+      0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
+      0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57,
+      0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7,
+      0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e,
+      0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
+      0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126,
+      0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053,
+      0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f,
+      0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
+      0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06,
+      0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb,
+      0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000,
+      0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
+      0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068,
+      0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8,
+      0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758,
+      0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
+      0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d,
+      0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25,
+      0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2,
+      0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
+      0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410,
+      0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129,
+      0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85,
+      0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
+      0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,
+  };
 
-#define FMT_POWERS_OF_10(factor)                                             \
-  factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000, \
-      (factor)*1000000, (factor)*10000000, (factor)*100000000,               \
-      (factor)*1000000000
-
-template <typename T>
-const uint64_t basic_data<T>::powers_of_10_64[] = {
-    1, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ULL),
-    10000000000000000000ULL};
-
-template <typename T>
-const uint32_t basic_data<T>::zero_or_powers_of_10_32[] = {0,
-                                                           FMT_POWERS_OF_10(1)};
-template <typename T>
-const uint64_t basic_data<T>::zero_or_powers_of_10_64[] = {
-    0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ULL),
-    10000000000000000000ULL};
-
-template <typename T>
-const uint32_t basic_data<T>::zero_or_powers_of_10_32_new[] = {
-    0, 0, FMT_POWERS_OF_10(1)};
-
-template <typename T>
-const uint64_t basic_data<T>::zero_or_powers_of_10_64_new[] = {
-    0, 0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ULL),
-    10000000000000000000ULL};
-
-// Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
-// These are generated by support/compute-powers.py.
-template <typename T>
-const uint64_t basic_data<T>::grisu_pow10_significands[] = {
-    0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76,
-    0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df,
-    0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c,
-    0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
-    0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57,
-    0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7,
-    0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e,
-    0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
-    0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126,
-    0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053,
-    0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f,
-    0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
-    0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06,
-    0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb,
-    0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000,
-    0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
-    0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068,
-    0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8,
-    0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758,
-    0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
-    0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d,
-    0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25,
-    0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2,
-    0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
-    0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410,
-    0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129,
-    0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85,
-    0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
-    0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,
-};
-
-// Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
-// to significands above.
-template <typename T>
-const int16_t basic_data<T>::grisu_pow10_exponents[] = {
-    -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954,
-    -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688, -661,
-    -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,  -422,  -396, -369,
-    -343,  -316,  -289,  -263,  -236,  -210,  -183,  -157,  -130,  -103, -77,
-    -50,   -24,   3,     30,    56,    83,    109,   136,   162,   189,  216,
-    242,   269,   295,   322,   348,   375,   402,   428,   455,   481,  508,
-    534,   561,   588,   614,   641,   667,   694,   720,   747,   774,  800,
-    827,   853,   880,   907,   933,   960,   986,   1013,  1039,  1066};
-
-template <typename T>
-const divtest_table_entry<uint32_t> basic_data<T>::divtest_table_for_pow5_32[] =
-    {{0x00000001, 0xffffffff}, {0xcccccccd, 0x33333333},
-     {0xc28f5c29, 0x0a3d70a3}, {0x26e978d5, 0x020c49ba},
-     {0x3afb7e91, 0x0068db8b}, {0x0bcbe61d, 0x0014f8b5},
-     {0x68c26139, 0x000431bd}, {0xae8d46a5, 0x0000d6bf},
-     {0x22e90e21, 0x00002af3}, {0x3a2e9c6d, 0x00000897},
-     {0x3ed61f49, 0x000001b7}};
-
-template <typename T>
-const divtest_table_entry<uint64_t> basic_data<T>::divtest_table_for_pow5_64[] =
-    {{0x0000000000000001, 0xffffffffffffffff},
-     {0xcccccccccccccccd, 0x3333333333333333},
-     {0x8f5c28f5c28f5c29, 0x0a3d70a3d70a3d70},
-     {0x1cac083126e978d5, 0x020c49ba5e353f7c},
-     {0xd288ce703afb7e91, 0x0068db8bac710cb2},
-     {0x5d4e8fb00bcbe61d, 0x0014f8b588e368f0},
-     {0x790fb65668c26139, 0x000431bde82d7b63},
-     {0xe5032477ae8d46a5, 0x0000d6bf94d5e57a},
-     {0xc767074b22e90e21, 0x00002af31dc46118},
-     {0x8e47ce423a2e9c6d, 0x0000089705f4136b},
-     {0x4fa7f60d3ed61f49, 0x000001b7cdfd9d7b},
-     {0x0fee64690c913975, 0x00000057f5ff85e5},
-     {0x3662e0e1cf503eb1, 0x000000119799812d},
-     {0xa47a2cf9f6433fbd, 0x0000000384b84d09},
-     {0x54186f653140a659, 0x00000000b424dc35},
-     {0x7738164770402145, 0x0000000024075f3d},
-     {0xe4a4d1417cd9a041, 0x000000000734aca5},
-     {0xc75429d9e5c5200d, 0x000000000170ef54},
-     {0xc1773b91fac10669, 0x000000000049c977},
-     {0x26b172506559ce15, 0x00000000000ec1e4},
-     {0xd489e3a9addec2d1, 0x000000000002f394},
-     {0x90e860bb892c8d5d, 0x000000000000971d},
-     {0x502e79bf1b6f4f79, 0x0000000000001e39},
-     {0xdcd618596be30fe5, 0x000000000000060b}};
-
-template <typename T>
-const uint64_t basic_data<T>::dragonbox_pow10_significands_64[] = {
-    0x81ceb32c4b43fcf5, 0xa2425ff75e14fc32, 0xcad2f7f5359a3b3f,
-    0xfd87b5f28300ca0e, 0x9e74d1b791e07e49, 0xc612062576589ddb,
-    0xf79687aed3eec552, 0x9abe14cd44753b53, 0xc16d9a0095928a28,
-    0xf1c90080baf72cb2, 0x971da05074da7bef, 0xbce5086492111aeb,
-    0xec1e4a7db69561a6, 0x9392ee8e921d5d08, 0xb877aa3236a4b44a,
-    0xe69594bec44de15c, 0x901d7cf73ab0acda, 0xb424dc35095cd810,
-    0xe12e13424bb40e14, 0x8cbccc096f5088cc, 0xafebff0bcb24aaff,
-    0xdbe6fecebdedd5bf, 0x89705f4136b4a598, 0xabcc77118461cefd,
-    0xd6bf94d5e57a42bd, 0x8637bd05af6c69b6, 0xa7c5ac471b478424,
-    0xd1b71758e219652c, 0x83126e978d4fdf3c, 0xa3d70a3d70a3d70b,
-    0xcccccccccccccccd, 0x8000000000000000, 0xa000000000000000,
-    0xc800000000000000, 0xfa00000000000000, 0x9c40000000000000,
-    0xc350000000000000, 0xf424000000000000, 0x9896800000000000,
-    0xbebc200000000000, 0xee6b280000000000, 0x9502f90000000000,
-    0xba43b74000000000, 0xe8d4a51000000000, 0x9184e72a00000000,
-    0xb5e620f480000000, 0xe35fa931a0000000, 0x8e1bc9bf04000000,
-    0xb1a2bc2ec5000000, 0xde0b6b3a76400000, 0x8ac7230489e80000,
-    0xad78ebc5ac620000, 0xd8d726b7177a8000, 0x878678326eac9000,
-    0xa968163f0a57b400, 0xd3c21bcecceda100, 0x84595161401484a0,
-    0xa56fa5b99019a5c8, 0xcecb8f27f4200f3a, 0x813f3978f8940984,
-    0xa18f07d736b90be5, 0xc9f2c9cd04674ede, 0xfc6f7c4045812296,
-    0x9dc5ada82b70b59d, 0xc5371912364ce305, 0xf684df56c3e01bc6,
-    0x9a130b963a6c115c, 0xc097ce7bc90715b3, 0xf0bdc21abb48db20,
-    0x96769950b50d88f4, 0xbc143fa4e250eb31, 0xeb194f8e1ae525fd,
-    0x92efd1b8d0cf37be, 0xb7abc627050305ad, 0xe596b7b0c643c719,
-    0x8f7e32ce7bea5c6f, 0xb35dbf821ae4f38b, 0xe0352f62a19e306e};
-
-template <typename T>
-const uint128_wrapper basic_data<T>::dragonbox_pow10_significands_128[] = {
-#if FMT_USE_FULL_CACHE_DRAGONBOX
-    {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
-    {0x9faacf3df73609b1, 0x77b191618c54e9ad},
-    {0xc795830d75038c1d, 0xd59df5b9ef6a2418},
-    {0xf97ae3d0d2446f25, 0x4b0573286b44ad1e},
-    {0x9becce62836ac577, 0x4ee367f9430aec33},
-    {0xc2e801fb244576d5, 0x229c41f793cda740},
-    {0xf3a20279ed56d48a, 0x6b43527578c11110},
-    {0x9845418c345644d6, 0x830a13896b78aaaa},
-    {0xbe5691ef416bd60c, 0x23cc986bc656d554},
-    {0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa9},
-    {0x94b3a202eb1c3f39, 0x7bf7d71432f3d6aa},
-    {0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc54},
-    {0xe858ad248f5c22c9, 0xd1b3400f8f9cff69},
-    {0x91376c36d99995be, 0x23100809b9c21fa2},
-    {0xb58547448ffffb2d, 0xabd40a0c2832a78b},
-    {0xe2e69915b3fff9f9, 0x16c90c8f323f516d},
-    {0x8dd01fad907ffc3b, 0xae3da7d97f6792e4},
-    {0xb1442798f49ffb4a, 0x99cd11cfdf41779d},
-    {0xdd95317f31c7fa1d, 0x40405643d711d584},
-    {0x8a7d3eef7f1cfc52, 0x482835ea666b2573},
-    {0xad1c8eab5ee43b66, 0xda3243650005eed0},
-    {0xd863b256369d4a40, 0x90bed43e40076a83},
-    {0x873e4f75e2224e68, 0x5a7744a6e804a292},
-    {0xa90de3535aaae202, 0x711515d0a205cb37},
-    {0xd3515c2831559a83, 0x0d5a5b44ca873e04},
-    {0x8412d9991ed58091, 0xe858790afe9486c3},
-    {0xa5178fff668ae0b6, 0x626e974dbe39a873},
-    {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
-    {0x80fa687f881c7f8e, 0x7ce66634bc9d0b9a},
-    {0xa139029f6a239f72, 0x1c1fffc1ebc44e81},
-    {0xc987434744ac874e, 0xa327ffb266b56221},
-    {0xfbe9141915d7a922, 0x4bf1ff9f0062baa9},
-    {0x9d71ac8fada6c9b5, 0x6f773fc3603db4aa},
-    {0xc4ce17b399107c22, 0xcb550fb4384d21d4},
-    {0xf6019da07f549b2b, 0x7e2a53a146606a49},
-    {0x99c102844f94e0fb, 0x2eda7444cbfc426e},
-    {0xc0314325637a1939, 0xfa911155fefb5309},
-    {0xf03d93eebc589f88, 0x793555ab7eba27cb},
-    {0x96267c7535b763b5, 0x4bc1558b2f3458df},
-    {0xbbb01b9283253ca2, 0x9eb1aaedfb016f17},
-    {0xea9c227723ee8bcb, 0x465e15a979c1cadd},
-    {0x92a1958a7675175f, 0x0bfacd89ec191eca},
-    {0xb749faed14125d36, 0xcef980ec671f667c},
-    {0xe51c79a85916f484, 0x82b7e12780e7401b},
-    {0x8f31cc0937ae58d2, 0xd1b2ecb8b0908811},
-    {0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa16},
-    {0xdfbdcece67006ac9, 0x67a791e093e1d49b},
-    {0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e1},
-    {0xaecc49914078536d, 0x58fae9f773886e19},
-    {0xda7f5bf590966848, 0xaf39a475506a899f},
-    {0x888f99797a5e012d, 0x6d8406c952429604},
-    {0xaab37fd7d8f58178, 0xc8e5087ba6d33b84},
-    {0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a65},
-    {0x855c3be0a17fcd26, 0x5cf2eea09a550680},
-    {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
-    {0xd0601d8efc57b08b, 0xf13b94daf124da27},
-    {0x823c12795db6ce57, 0x76c53d08d6b70859},
-    {0xa2cb1717b52481ed, 0x54768c4b0c64ca6f},
-    {0xcb7ddcdda26da268, 0xa9942f5dcf7dfd0a},
-    {0xfe5d54150b090b02, 0xd3f93b35435d7c4d},
-    {0x9efa548d26e5a6e1, 0xc47bc5014a1a6db0},
-    {0xc6b8e9b0709f109a, 0x359ab6419ca1091c},
-    {0xf867241c8cc6d4c0, 0xc30163d203c94b63},
-    {0x9b407691d7fc44f8, 0x79e0de63425dcf1e},
-    {0xc21094364dfb5636, 0x985915fc12f542e5},
-    {0xf294b943e17a2bc4, 0x3e6f5b7b17b2939e},
-    {0x979cf3ca6cec5b5a, 0xa705992ceecf9c43},
-    {0xbd8430bd08277231, 0x50c6ff782a838354},
-    {0xece53cec4a314ebd, 0xa4f8bf5635246429},
-    {0x940f4613ae5ed136, 0x871b7795e136be9a},
-    {0xb913179899f68584, 0x28e2557b59846e40},
-    {0xe757dd7ec07426e5, 0x331aeada2fe589d0},
-    {0x9096ea6f3848984f, 0x3ff0d2c85def7622},
-    {0xb4bca50b065abe63, 0x0fed077a756b53aa},
-    {0xe1ebce4dc7f16dfb, 0xd3e8495912c62895},
-    {0x8d3360f09cf6e4bd, 0x64712dd7abbbd95d},
-    {0xb080392cc4349dec, 0xbd8d794d96aacfb4},
-    {0xdca04777f541c567, 0xecf0d7a0fc5583a1},
-    {0x89e42caaf9491b60, 0xf41686c49db57245},
-    {0xac5d37d5b79b6239, 0x311c2875c522ced6},
-    {0xd77485cb25823ac7, 0x7d633293366b828c},
-    {0x86a8d39ef77164bc, 0xae5dff9c02033198},
-    {0xa8530886b54dbdeb, 0xd9f57f830283fdfd},
-    {0xd267caa862a12d66, 0xd072df63c324fd7c},
-    {0x8380dea93da4bc60, 0x4247cb9e59f71e6e},
-    {0xa46116538d0deb78, 0x52d9be85f074e609},
-    {0xcd795be870516656, 0x67902e276c921f8c},
-    {0x806bd9714632dff6, 0x00ba1cd8a3db53b7},
-    {0xa086cfcd97bf97f3, 0x80e8a40eccd228a5},
-    {0xc8a883c0fdaf7df0, 0x6122cd128006b2ce},
-    {0xfad2a4b13d1b5d6c, 0x796b805720085f82},
-    {0x9cc3a6eec6311a63, 0xcbe3303674053bb1},
-    {0xc3f490aa77bd60fc, 0xbedbfc4411068a9d},
-    {0xf4f1b4d515acb93b, 0xee92fb5515482d45},
-    {0x991711052d8bf3c5, 0x751bdd152d4d1c4b},
-    {0xbf5cd54678eef0b6, 0xd262d45a78a0635e},
-    {0xef340a98172aace4, 0x86fb897116c87c35},
-    {0x9580869f0e7aac0e, 0xd45d35e6ae3d4da1},
-    {0xbae0a846d2195712, 0x8974836059cca10a},
-    {0xe998d258869facd7, 0x2bd1a438703fc94c},
-    {0x91ff83775423cc06, 0x7b6306a34627ddd0},
-    {0xb67f6455292cbf08, 0x1a3bc84c17b1d543},
-    {0xe41f3d6a7377eeca, 0x20caba5f1d9e4a94},
-    {0x8e938662882af53e, 0x547eb47b7282ee9d},
-    {0xb23867fb2a35b28d, 0xe99e619a4f23aa44},
-    {0xdec681f9f4c31f31, 0x6405fa00e2ec94d5},
-    {0x8b3c113c38f9f37e, 0xde83bc408dd3dd05},
-    {0xae0b158b4738705e, 0x9624ab50b148d446},
-    {0xd98ddaee19068c76, 0x3badd624dd9b0958},
-    {0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d7},
-    {0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4d},
-    {0xd47487cc8470652b, 0x7647c32000696720},
-    {0x84c8d4dfd2c63f3b, 0x29ecd9f40041e074},
-    {0xa5fb0a17c777cf09, 0xf468107100525891},
-    {0xcf79cc9db955c2cc, 0x7182148d4066eeb5},
-    {0x81ac1fe293d599bf, 0xc6f14cd848405531},
-    {0xa21727db38cb002f, 0xb8ada00e5a506a7d},
-    {0xca9cf1d206fdc03b, 0xa6d90811f0e4851d},
-    {0xfd442e4688bd304a, 0x908f4a166d1da664},
-    {0x9e4a9cec15763e2e, 0x9a598e4e043287ff},
-    {0xc5dd44271ad3cdba, 0x40eff1e1853f29fe},
-    {0xf7549530e188c128, 0xd12bee59e68ef47d},
-    {0x9a94dd3e8cf578b9, 0x82bb74f8301958cf},
-    {0xc13a148e3032d6e7, 0xe36a52363c1faf02},
-    {0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac2},
-    {0x96f5600f15a7b7e5, 0x29ab103a5ef8c0ba},
-    {0xbcb2b812db11a5de, 0x7415d448f6b6f0e8},
-    {0xebdf661791d60f56, 0x111b495b3464ad22},
-    {0x936b9fcebb25c995, 0xcab10dd900beec35},
-    {0xb84687c269ef3bfb, 0x3d5d514f40eea743},
-    {0xe65829b3046b0afa, 0x0cb4a5a3112a5113},
-    {0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ac},
-    {0xb3f4e093db73a093, 0x59ed216765690f57},
-    {0xe0f218b8d25088b8, 0x306869c13ec3532d},
-    {0x8c974f7383725573, 0x1e414218c73a13fc},
-    {0xafbd2350644eeacf, 0xe5d1929ef90898fb},
-    {0xdbac6c247d62a583, 0xdf45f746b74abf3a},
-    {0x894bc396ce5da772, 0x6b8bba8c328eb784},
-    {0xab9eb47c81f5114f, 0x066ea92f3f326565},
-    {0xd686619ba27255a2, 0xc80a537b0efefebe},
-    {0x8613fd0145877585, 0xbd06742ce95f5f37},
-    {0xa798fc4196e952e7, 0x2c48113823b73705},
-    {0xd17f3b51fca3a7a0, 0xf75a15862ca504c6},
-    {0x82ef85133de648c4, 0x9a984d73dbe722fc},
-    {0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebbb},
-    {0xcc963fee10b7d1b3, 0x318df905079926a9},
-    {0xffbbcfe994e5c61f, 0xfdf17746497f7053},
-    {0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa634},
-    {0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc1},
-    {0xf9bd690a1b68637b, 0x3dfdce7aa3c673b1},
-    {0x9c1661a651213e2d, 0x06bea10ca65c084f},
-    {0xc31bfa0fe5698db8, 0x486e494fcff30a63},
-    {0xf3e2f893dec3f126, 0x5a89dba3c3efccfb},
-    {0x986ddb5c6b3a76b7, 0xf89629465a75e01d},
-    {0xbe89523386091465, 0xf6bbb397f1135824},
-    {0xee2ba6c0678b597f, 0x746aa07ded582e2d},
-    {0x94db483840b717ef, 0xa8c2a44eb4571cdd},
-    {0xba121a4650e4ddeb, 0x92f34d62616ce414},
-    {0xe896a0d7e51e1566, 0x77b020baf9c81d18},
-    {0x915e2486ef32cd60, 0x0ace1474dc1d122f},
-    {0xb5b5ada8aaff80b8, 0x0d819992132456bb},
-    {0xe3231912d5bf60e6, 0x10e1fff697ed6c6a},
-    {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
-    {0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb3},
-    {0xddd0467c64bce4a0, 0xac7cb3f6d05ddbdf},
-    {0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96c},
-    {0xad4ab7112eb3929d, 0x86c16c98d2c953c7},
-    {0xd89d64d57a607744, 0xe871c7bf077ba8b8},
-    {0x87625f056c7c4a8b, 0x11471cd764ad4973},
-    {0xa93af6c6c79b5d2d, 0xd598e40d3dd89bd0},
-    {0xd389b47879823479, 0x4aff1d108d4ec2c4},
-    {0x843610cb4bf160cb, 0xcedf722a585139bb},
-    {0xa54394fe1eedb8fe, 0xc2974eb4ee658829},
-    {0xce947a3da6a9273e, 0x733d226229feea33},
-    {0x811ccc668829b887, 0x0806357d5a3f5260},
-    {0xa163ff802a3426a8, 0xca07c2dcb0cf26f8},
-    {0xc9bcff6034c13052, 0xfc89b393dd02f0b6},
-    {0xfc2c3f3841f17c67, 0xbbac2078d443ace3},
-    {0x9d9ba7832936edc0, 0xd54b944b84aa4c0e},
-    {0xc5029163f384a931, 0x0a9e795e65d4df12},
-    {0xf64335bcf065d37d, 0x4d4617b5ff4a16d6},
-    {0x99ea0196163fa42e, 0x504bced1bf8e4e46},
-    {0xc06481fb9bcf8d39, 0xe45ec2862f71e1d7},
-    {0xf07da27a82c37088, 0x5d767327bb4e5a4d},
-    {0x964e858c91ba2655, 0x3a6a07f8d510f870},
-    {0xbbe226efb628afea, 0x890489f70a55368c},
-    {0xeadab0aba3b2dbe5, 0x2b45ac74ccea842f},
-    {0x92c8ae6b464fc96f, 0x3b0b8bc90012929e},
-    {0xb77ada0617e3bbcb, 0x09ce6ebb40173745},
-    {0xe55990879ddcaabd, 0xcc420a6a101d0516},
-    {0x8f57fa54c2a9eab6, 0x9fa946824a12232e},
-    {0xb32df8e9f3546564, 0x47939822dc96abfa},
-    {0xdff9772470297ebd, 0x59787e2b93bc56f8},
-    {0x8bfbea76c619ef36, 0x57eb4edb3c55b65b},
-    {0xaefae51477a06b03, 0xede622920b6b23f2},
-    {0xdab99e59958885c4, 0xe95fab368e45ecee},
-    {0x88b402f7fd75539b, 0x11dbcb0218ebb415},
-    {0xaae103b5fcd2a881, 0xd652bdc29f26a11a},
-    {0xd59944a37c0752a2, 0x4be76d3346f04960},
-    {0x857fcae62d8493a5, 0x6f70a4400c562ddc},
-    {0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb953},
-    {0xd097ad07a71f26b2, 0x7e2000a41346a7a8},
-    {0x825ecc24c873782f, 0x8ed400668c0c28c9},
-    {0xa2f67f2dfa90563b, 0x728900802f0f32fb},
-    {0xcbb41ef979346bca, 0x4f2b40a03ad2ffba},
-    {0xfea126b7d78186bc, 0xe2f610c84987bfa9},
-    {0x9f24b832e6b0f436, 0x0dd9ca7d2df4d7ca},
-    {0xc6ede63fa05d3143, 0x91503d1c79720dbc},
-    {0xf8a95fcf88747d94, 0x75a44c6397ce912b},
-    {0x9b69dbe1b548ce7c, 0xc986afbe3ee11abb},
-    {0xc24452da229b021b, 0xfbe85badce996169},
-    {0xf2d56790ab41c2a2, 0xfae27299423fb9c4},
-    {0x97c560ba6b0919a5, 0xdccd879fc967d41b},
-    {0xbdb6b8e905cb600f, 0x5400e987bbc1c921},
-    {0xed246723473e3813, 0x290123e9aab23b69},
-    {0x9436c0760c86e30b, 0xf9a0b6720aaf6522},
-    {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
-    {0xe7958cb87392c2c2, 0xb60b1d1230b20e05},
-    {0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c3},
-    {0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af4},
-    {0xe2280b6c20dd5232, 0x25c6da63c38de1b1},
-    {0x8d590723948a535f, 0x579c487e5a38ad0f},
-    {0xb0af48ec79ace837, 0x2d835a9df0c6d852},
-    {0xdcdb1b2798182244, 0xf8e431456cf88e66},
-    {0x8a08f0f8bf0f156b, 0x1b8e9ecb641b5900},
-    {0xac8b2d36eed2dac5, 0xe272467e3d222f40},
-    {0xd7adf884aa879177, 0x5b0ed81dcc6abb10},
-    {0x86ccbb52ea94baea, 0x98e947129fc2b4ea},
-    {0xa87fea27a539e9a5, 0x3f2398d747b36225},
-    {0xd29fe4b18e88640e, 0x8eec7f0d19a03aae},
-    {0x83a3eeeef9153e89, 0x1953cf68300424ad},
-    {0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd8},
-    {0xcdb02555653131b6, 0x3792f412cb06794e},
-    {0x808e17555f3ebf11, 0xe2bbd88bbee40bd1},
-    {0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec5},
-    {0xc8de047564d20a8b, 0xf245825a5a445276},
-    {0xfb158592be068d2e, 0xeed6e2f0f0d56713},
-    {0x9ced737bb6c4183d, 0x55464dd69685606c},
-    {0xc428d05aa4751e4c, 0xaa97e14c3c26b887},
-    {0xf53304714d9265df, 0xd53dd99f4b3066a9},
-    {0x993fe2c6d07b7fab, 0xe546a8038efe402a},
-    {0xbf8fdb78849a5f96, 0xde98520472bdd034},
-    {0xef73d256a5c0f77c, 0x963e66858f6d4441},
-    {0x95a8637627989aad, 0xdde7001379a44aa9},
-    {0xbb127c53b17ec159, 0x5560c018580d5d53},
-    {0xe9d71b689dde71af, 0xaab8f01e6e10b4a7},
-    {0x9226712162ab070d, 0xcab3961304ca70e9},
-    {0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d23},
-    {0xe45c10c42a2b3b05, 0x8cb89a7db77c506b},
-    {0x8eb98a7a9a5b04e3, 0x77f3608e92adb243},
-    {0xb267ed1940f1c61c, 0x55f038b237591ed4},
-    {0xdf01e85f912e37a3, 0x6b6c46dec52f6689},
-    {0x8b61313bbabce2c6, 0x2323ac4b3b3da016},
-    {0xae397d8aa96c1b77, 0xabec975e0a0d081b},
-    {0xd9c7dced53c72255, 0x96e7bd358c904a22},
-    {0x881cea14545c7575, 0x7e50d64177da2e55},
-    {0xaa242499697392d2, 0xdde50bd1d5d0b9ea},
-    {0xd4ad2dbfc3d07787, 0x955e4ec64b44e865},
-    {0x84ec3c97da624ab4, 0xbd5af13bef0b113f},
-    {0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58f},
-    {0xcfb11ead453994ba, 0x67de18eda5814af3},
-    {0x81ceb32c4b43fcf4, 0x80eacf948770ced8},
-    {0xa2425ff75e14fc31, 0xa1258379a94d028e},
-    {0xcad2f7f5359a3b3e, 0x096ee45813a04331},
-    {0xfd87b5f28300ca0d, 0x8bca9d6e188853fd},
-    {0x9e74d1b791e07e48, 0x775ea264cf55347e},
-    {0xc612062576589dda, 0x95364afe032a819e},
-    {0xf79687aed3eec551, 0x3a83ddbd83f52205},
-    {0x9abe14cd44753b52, 0xc4926a9672793543},
-    {0xc16d9a0095928a27, 0x75b7053c0f178294},
-    {0xf1c90080baf72cb1, 0x5324c68b12dd6339},
-    {0x971da05074da7bee, 0xd3f6fc16ebca5e04},
-    {0xbce5086492111aea, 0x88f4bb1ca6bcf585},
-    {0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6},
-    {0x9392ee8e921d5d07, 0x3aff322e62439fd0},
-    {0xb877aa3236a4b449, 0x09befeb9fad487c3},
-    {0xe69594bec44de15b, 0x4c2ebe687989a9b4},
-    {0x901d7cf73ab0acd9, 0x0f9d37014bf60a11},
-    {0xb424dc35095cd80f, 0x538484c19ef38c95},
-    {0xe12e13424bb40e13, 0x2865a5f206b06fba},
-    {0x8cbccc096f5088cb, 0xf93f87b7442e45d4},
-    {0xafebff0bcb24aafe, 0xf78f69a51539d749},
-    {0xdbe6fecebdedd5be, 0xb573440e5a884d1c},
-    {0x89705f4136b4a597, 0x31680a88f8953031},
-    {0xabcc77118461cefc, 0xfdc20d2b36ba7c3e},
-    {0xd6bf94d5e57a42bc, 0x3d32907604691b4d},
-    {0x8637bd05af6c69b5, 0xa63f9a49c2c1b110},
-    {0xa7c5ac471b478423, 0x0fcf80dc33721d54},
-    {0xd1b71758e219652b, 0xd3c36113404ea4a9},
-    {0x83126e978d4fdf3b, 0x645a1cac083126ea},
-    {0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4},
-    {0xcccccccccccccccc, 0xcccccccccccccccd},
-    {0x8000000000000000, 0x0000000000000000},
-    {0xa000000000000000, 0x0000000000000000},
-    {0xc800000000000000, 0x0000000000000000},
-    {0xfa00000000000000, 0x0000000000000000},
-    {0x9c40000000000000, 0x0000000000000000},
-    {0xc350000000000000, 0x0000000000000000},
-    {0xf424000000000000, 0x0000000000000000},
-    {0x9896800000000000, 0x0000000000000000},
-    {0xbebc200000000000, 0x0000000000000000},
-    {0xee6b280000000000, 0x0000000000000000},
-    {0x9502f90000000000, 0x0000000000000000},
-    {0xba43b74000000000, 0x0000000000000000},
-    {0xe8d4a51000000000, 0x0000000000000000},
-    {0x9184e72a00000000, 0x0000000000000000},
-    {0xb5e620f480000000, 0x0000000000000000},
-    {0xe35fa931a0000000, 0x0000000000000000},
-    {0x8e1bc9bf04000000, 0x0000000000000000},
-    {0xb1a2bc2ec5000000, 0x0000000000000000},
-    {0xde0b6b3a76400000, 0x0000000000000000},
-    {0x8ac7230489e80000, 0x0000000000000000},
-    {0xad78ebc5ac620000, 0x0000000000000000},
-    {0xd8d726b7177a8000, 0x0000000000000000},
-    {0x878678326eac9000, 0x0000000000000000},
-    {0xa968163f0a57b400, 0x0000000000000000},
-    {0xd3c21bcecceda100, 0x0000000000000000},
-    {0x84595161401484a0, 0x0000000000000000},
-    {0xa56fa5b99019a5c8, 0x0000000000000000},
-    {0xcecb8f27f4200f3a, 0x0000000000000000},
-    {0x813f3978f8940984, 0x4000000000000000},
-    {0xa18f07d736b90be5, 0x5000000000000000},
-    {0xc9f2c9cd04674ede, 0xa400000000000000},
-    {0xfc6f7c4045812296, 0x4d00000000000000},
-    {0x9dc5ada82b70b59d, 0xf020000000000000},
-    {0xc5371912364ce305, 0x6c28000000000000},
-    {0xf684df56c3e01bc6, 0xc732000000000000},
-    {0x9a130b963a6c115c, 0x3c7f400000000000},
-    {0xc097ce7bc90715b3, 0x4b9f100000000000},
-    {0xf0bdc21abb48db20, 0x1e86d40000000000},
-    {0x96769950b50d88f4, 0x1314448000000000},
-    {0xbc143fa4e250eb31, 0x17d955a000000000},
-    {0xeb194f8e1ae525fd, 0x5dcfab0800000000},
-    {0x92efd1b8d0cf37be, 0x5aa1cae500000000},
-    {0xb7abc627050305ad, 0xf14a3d9e40000000},
-    {0xe596b7b0c643c719, 0x6d9ccd05d0000000},
-    {0x8f7e32ce7bea5c6f, 0xe4820023a2000000},
-    {0xb35dbf821ae4f38b, 0xdda2802c8a800000},
-    {0xe0352f62a19e306e, 0xd50b2037ad200000},
-    {0x8c213d9da502de45, 0x4526f422cc340000},
-    {0xaf298d050e4395d6, 0x9670b12b7f410000},
-    {0xdaf3f04651d47b4c, 0x3c0cdd765f114000},
-    {0x88d8762bf324cd0f, 0xa5880a69fb6ac800},
-    {0xab0e93b6efee0053, 0x8eea0d047a457a00},
-    {0xd5d238a4abe98068, 0x72a4904598d6d880},
-    {0x85a36366eb71f041, 0x47a6da2b7f864750},
-    {0xa70c3c40a64e6c51, 0x999090b65f67d924},
-    {0xd0cf4b50cfe20765, 0xfff4b4e3f741cf6d},
-    {0x82818f1281ed449f, 0xbff8f10e7a8921a4},
-    {0xa321f2d7226895c7, 0xaff72d52192b6a0d},
-    {0xcbea6f8ceb02bb39, 0x9bf4f8a69f764490},
-    {0xfee50b7025c36a08, 0x02f236d04753d5b4},
-    {0x9f4f2726179a2245, 0x01d762422c946590},
-    {0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef5},
-    {0xf8ebad2b84e0d58b, 0xd2e0898765a7deb2},
-    {0x9b934c3b330c8577, 0x63cc55f49f88eb2f},
-    {0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fb},
-    {0xf316271c7fc3908a, 0x8bef464e3945ef7a},
-    {0x97edd871cfda3a56, 0x97758bf0e3cbb5ac},
-    {0xbde94e8e43d0c8ec, 0x3d52eeed1cbea317},
-    {0xed63a231d4c4fb27, 0x4ca7aaa863ee4bdd},
-    {0x945e455f24fb1cf8, 0x8fe8caa93e74ef6a},
-    {0xb975d6b6ee39e436, 0xb3e2fd538e122b44},
-    {0xe7d34c64a9c85d44, 0x60dbbca87196b616},
-    {0x90e40fbeea1d3a4a, 0xbc8955e946fe31cd},
-    {0xb51d13aea4a488dd, 0x6babab6398bdbe41},
-    {0xe264589a4dcdab14, 0xc696963c7eed2dd1},
-    {0x8d7eb76070a08aec, 0xfc1e1de5cf543ca2},
-    {0xb0de65388cc8ada8, 0x3b25a55f43294bcb},
-    {0xdd15fe86affad912, 0x49ef0eb713f39ebe},
-    {0x8a2dbf142dfcc7ab, 0x6e3569326c784337},
-    {0xacb92ed9397bf996, 0x49c2c37f07965404},
-    {0xd7e77a8f87daf7fb, 0xdc33745ec97be906},
-    {0x86f0ac99b4e8dafd, 0x69a028bb3ded71a3},
-    {0xa8acd7c0222311bc, 0xc40832ea0d68ce0c},
-    {0xd2d80db02aabd62b, 0xf50a3fa490c30190},
-    {0x83c7088e1aab65db, 0x792667c6da79e0fa},
-    {0xa4b8cab1a1563f52, 0x577001b891185938},
-    {0xcde6fd5e09abcf26, 0xed4c0226b55e6f86},
-    {0x80b05e5ac60b6178, 0x544f8158315b05b4},
-    {0xa0dc75f1778e39d6, 0x696361ae3db1c721},
-    {0xc913936dd571c84c, 0x03bc3a19cd1e38e9},
-    {0xfb5878494ace3a5f, 0x04ab48a04065c723},
-    {0x9d174b2dcec0e47b, 0x62eb0d64283f9c76},
-    {0xc45d1df942711d9a, 0x3ba5d0bd324f8394},
-    {0xf5746577930d6500, 0xca8f44ec7ee36479},
-    {0x9968bf6abbe85f20, 0x7e998b13cf4e1ecb},
-    {0xbfc2ef456ae276e8, 0x9e3fedd8c321a67e},
-    {0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101e},
-    {0x95d04aee3b80ece5, 0xbba1f1d158724a12},
-    {0xbb445da9ca61281f, 0x2a8a6e45ae8edc97},
-    {0xea1575143cf97226, 0xf52d09d71a3293bd},
-    {0x924d692ca61be758, 0x593c2626705f9c56},
-    {0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836c},
-    {0xe498f455c38b997a, 0x0b6dfb9c0f956447},
-    {0x8edf98b59a373fec, 0x4724bd4189bd5eac},
-    {0xb2977ee300c50fe7, 0x58edec91ec2cb657},
-    {0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ed},
-    {0x8b865b215899f46c, 0xbd79e0d20082ee74},
-    {0xae67f1e9aec07187, 0xecd8590680a3aa11},
-    {0xda01ee641a708de9, 0xe80e6f4820cc9495},
-    {0x884134fe908658b2, 0x3109058d147fdcdd},
-    {0xaa51823e34a7eede, 0xbd4b46f0599fd415},
-    {0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91a},
-    {0x850fadc09923329e, 0x03e2cf6bc604ddb0},
-    {0xa6539930bf6bff45, 0x84db8346b786151c},
-    {0xcfe87f7cef46ff16, 0xe612641865679a63},
-    {0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07e},
-    {0xa26da3999aef7749, 0xe3be5e330f38f09d},
-    {0xcb090c8001ab551c, 0x5cadf5bfd3072cc5},
-    {0xfdcb4fa002162a63, 0x73d9732fc7c8f7f6},
-    {0x9e9f11c4014dda7e, 0x2867e7fddcdd9afa},
-    {0xc646d63501a1511d, 0xb281e1fd541501b8},
-    {0xf7d88bc24209a565, 0x1f225a7ca91a4226},
-    {0x9ae757596946075f, 0x3375788de9b06958},
-    {0xc1a12d2fc3978937, 0x0052d6b1641c83ae},
-    {0xf209787bb47d6b84, 0xc0678c5dbd23a49a},
-    {0x9745eb4d50ce6332, 0xf840b7ba963646e0},
-    {0xbd176620a501fbff, 0xb650e5a93bc3d898},
-    {0xec5d3fa8ce427aff, 0xa3e51f138ab4cebe},
-    {0x93ba47c980e98cdf, 0xc66f336c36b10137},
-    {0xb8a8d9bbe123f017, 0xb80b0047445d4184},
-    {0xe6d3102ad96cec1d, 0xa60dc059157491e5},
-    {0x9043ea1ac7e41392, 0x87c89837ad68db2f},
-    {0xb454e4a179dd1877, 0x29babe4598c311fb},
-    {0xe16a1dc9d8545e94, 0xf4296dd6fef3d67a},
-    {0x8ce2529e2734bb1d, 0x1899e4a65f58660c},
-    {0xb01ae745b101e9e4, 0x5ec05dcff72e7f8f},
-    {0xdc21a1171d42645d, 0x76707543f4fa1f73},
-    {0x899504ae72497eba, 0x6a06494a791c53a8},
-    {0xabfa45da0edbde69, 0x0487db9d17636892},
-    {0xd6f8d7509292d603, 0x45a9d2845d3c42b6},
-    {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b2},
-    {0xa7f26836f282b732, 0x8e6cac7768d7141e},
-    {0xd1ef0244af2364ff, 0x3207d795430cd926},
-    {0x8335616aed761f1f, 0x7f44e6bd49e807b8},
-    {0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a6},
-    {0xcd036837130890a1, 0x36dba887c37a8c0f},
-    {0x802221226be55a64, 0xc2494954da2c9789},
-    {0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6c},
-    {0xc83553c5c8965d3d, 0x6f92829494e5acc7},
-    {0xfa42a8b73abbf48c, 0xcb772339ba1f17f9},
-    {0x9c69a97284b578d7, 0xff2a760414536efb},
-    {0xc38413cf25e2d70d, 0xfef5138519684aba},
-    {0xf46518c2ef5b8cd1, 0x7eb258665fc25d69},
-    {0x98bf2f79d5993802, 0xef2f773ffbd97a61},
-    {0xbeeefb584aff8603, 0xaafb550ffacfd8fa},
-    {0xeeaaba2e5dbf6784, 0x95ba2a53f983cf38},
-    {0x952ab45cfa97a0b2, 0xdd945a747bf26183},
-    {0xba756174393d88df, 0x94f971119aeef9e4},
-    {0xe912b9d1478ceb17, 0x7a37cd5601aab85d},
-    {0x91abb422ccb812ee, 0xac62e055c10ab33a},
-    {0xb616a12b7fe617aa, 0x577b986b314d6009},
-    {0xe39c49765fdf9d94, 0xed5a7e85fda0b80b},
-    {0x8e41ade9fbebc27d, 0x14588f13be847307},
-    {0xb1d219647ae6b31c, 0x596eb2d8ae258fc8},
-    {0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bb},
-    {0x8aec23d680043bee, 0x25de7bb9480d5854},
-    {0xada72ccc20054ae9, 0xaf561aa79a10ae6a},
-    {0xd910f7ff28069da4, 0x1b2ba1518094da04},
-    {0x87aa9aff79042286, 0x90fb44d2f05d0842},
-    {0xa99541bf57452b28, 0x353a1607ac744a53},
-    {0xd3fa922f2d1675f2, 0x42889b8997915ce8},
-    {0x847c9b5d7c2e09b7, 0x69956135febada11},
-    {0xa59bc234db398c25, 0x43fab9837e699095},
-    {0xcf02b2c21207ef2e, 0x94f967e45e03f4bb},
-    {0x8161afb94b44f57d, 0x1d1be0eebac278f5},
-    {0xa1ba1ba79e1632dc, 0x6462d92a69731732},
-    {0xca28a291859bbf93, 0x7d7b8f7503cfdcfe},
-    {0xfcb2cb35e702af78, 0x5cda735244c3d43e},
-    {0x9defbf01b061adab, 0x3a0888136afa64a7},
-    {0xc56baec21c7a1916, 0x088aaa1845b8fdd0},
-    {0xf6c69a72a3989f5b, 0x8aad549e57273d45},
-    {0x9a3c2087a63f6399, 0x36ac54e2f678864b},
-    {0xc0cb28a98fcf3c7f, 0x84576a1bb416a7dd},
-    {0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d5},
-    {0x969eb7c47859e743, 0x9f644ae5a4b1b325},
-    {0xbc4665b596706114, 0x873d5d9f0dde1fee},
-    {0xeb57ff22fc0c7959, 0xa90cb506d155a7ea},
-    {0x9316ff75dd87cbd8, 0x09a7f12442d588f2},
-    {0xb7dcbf5354e9bece, 0x0c11ed6d538aeb2f},
-    {0xe5d3ef282a242e81, 0x8f1668c8a86da5fa},
-    {0x8fa475791a569d10, 0xf96e017d694487bc},
-    {0xb38d92d760ec4455, 0x37c981dcc395a9ac},
-    {0xe070f78d3927556a, 0x85bbe253f47b1417},
-    {0x8c469ab843b89562, 0x93956d7478ccec8e},
-    {0xaf58416654a6babb, 0x387ac8d1970027b2},
-    {0xdb2e51bfe9d0696a, 0x06997b05fcc0319e},
-    {0x88fcf317f22241e2, 0x441fece3bdf81f03},
-    {0xab3c2fddeeaad25a, 0xd527e81cad7626c3},
-    {0xd60b3bd56a5586f1, 0x8a71e223d8d3b074},
-    {0x85c7056562757456, 0xf6872d5667844e49},
-    {0xa738c6bebb12d16c, 0xb428f8ac016561db},
-    {0xd106f86e69d785c7, 0xe13336d701beba52},
-    {0x82a45b450226b39c, 0xecc0024661173473},
-    {0xa34d721642b06084, 0x27f002d7f95d0190},
-    {0xcc20ce9bd35c78a5, 0x31ec038df7b441f4},
-    {0xff290242c83396ce, 0x7e67047175a15271},
-    {0x9f79a169bd203e41, 0x0f0062c6e984d386},
-    {0xc75809c42c684dd1, 0x52c07b78a3e60868},
-    {0xf92e0c3537826145, 0xa7709a56ccdf8a82},
-    {0x9bbcc7a142b17ccb, 0x88a66076400bb691},
-    {0xc2abf989935ddbfe, 0x6acff893d00ea435},
-    {0xf356f7ebf83552fe, 0x0583f6b8c4124d43},
-    {0x98165af37b2153de, 0xc3727a337a8b704a},
-    {0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5c},
-    {0xeda2ee1c7064130c, 0x1162def06f79df73},
-    {0x9485d4d1c63e8be7, 0x8addcb5645ac2ba8},
-    {0xb9a74a0637ce2ee1, 0x6d953e2bd7173692},
-    {0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0437},
-    {0x910ab1d4db9914a0, 0x1d9c9892400a22a2},
-    {0xb54d5e4a127f59c8, 0x2503beb6d00cab4b},
-    {0xe2a0b5dc971f303a, 0x2e44ae64840fd61d},
-    {0x8da471a9de737e24, 0x5ceaecfed289e5d2},
-    {0xb10d8e1456105dad, 0x7425a83e872c5f47},
-    {0xdd50f1996b947518, 0xd12f124e28f77719},
-    {0x8a5296ffe33cc92f, 0x82bd6b70d99aaa6f},
-    {0xace73cbfdc0bfb7b, 0x636cc64d1001550b},
-    {0xd8210befd30efa5a, 0x3c47f7e05401aa4e},
-    {0x8714a775e3e95c78, 0x65acfaec34810a71},
-    {0xa8d9d1535ce3b396, 0x7f1839a741a14d0d},
-    {0xd31045a8341ca07c, 0x1ede48111209a050},
-    {0x83ea2b892091e44d, 0x934aed0aab460432},
-    {0xa4e4b66b68b65d60, 0xf81da84d5617853f},
-    {0xce1de40642e3f4b9, 0x36251260ab9d668e},
-    {0x80d2ae83e9ce78f3, 0xc1d72b7c6b426019},
-    {0xa1075a24e4421730, 0xb24cf65b8612f81f},
-    {0xc94930ae1d529cfc, 0xdee033f26797b627},
-    {0xfb9b7cd9a4a7443c, 0x169840ef017da3b1},
-    {0x9d412e0806e88aa5, 0x8e1f289560ee864e},
-    {0xc491798a08a2ad4e, 0xf1a6f2bab92a27e2},
-    {0xf5b5d7ec8acb58a2, 0xae10af696774b1db},
-    {0x9991a6f3d6bf1765, 0xacca6da1e0a8ef29},
-    {0xbff610b0cc6edd3f, 0x17fd090a58d32af3},
-    {0xeff394dcff8a948e, 0xddfc4b4cef07f5b0},
-    {0x95f83d0a1fb69cd9, 0x4abdaf101564f98e},
-    {0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f1},
-    {0xea53df5fd18d5513, 0x84c86189216dc5ed},
-    {0x92746b9be2f8552c, 0x32fd3cf5b4e49bb4},
-    {0xb7118682dbb66a77, 0x3fbc8c33221dc2a1},
-    {0xe4d5e82392a40515, 0x0fabaf3feaa5334a},
-    {0x8f05b1163ba6832d, 0x29cb4d87f2a7400e},
-    {0xb2c71d5bca9023f8, 0x743e20e9ef511012},
-    {0xdf78e4b2bd342cf6, 0x914da9246b255416},
-    {0x8bab8eefb6409c1a, 0x1ad089b6c2f7548e},
-    {0xae9672aba3d0c320, 0xa184ac2473b529b1},
-    {0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741e},
-    {0x8865899617fb1871, 0x7e2fa67c7a658892},
-    {0xaa7eebfb9df9de8d, 0xddbb901b98feeab7},
-    {0xd51ea6fa85785631, 0x552a74227f3ea565},
-    {0x8533285c936b35de, 0xd53a88958f87275f},
-    {0xa67ff273b8460356, 0x8a892abaf368f137},
-    {0xd01fef10a657842c, 0x2d2b7569b0432d85},
-    {0x8213f56a67f6b29b, 0x9c3b29620e29fc73},
-    {0xa298f2c501f45f42, 0x8349f3ba91b47b8f},
-    {0xcb3f2f7642717713, 0x241c70a936219a73},
-    {0xfe0efb53d30dd4d7, 0xed238cd383aa0110},
-    {0x9ec95d1463e8a506, 0xf4363804324a40aa},
-    {0xc67bb4597ce2ce48, 0xb143c6053edcd0d5},
-    {0xf81aa16fdc1b81da, 0xdd94b7868e94050a},
-    {0x9b10a4e5e9913128, 0xca7cf2b4191c8326},
-    {0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f0},
-    {0xf24a01a73cf2dccf, 0xbc633b39673c8cec},
-    {0x976e41088617ca01, 0xd5be0503e085d813},
-    {0xbd49d14aa79dbc82, 0x4b2d8644d8a74e18},
-    {0xec9c459d51852ba2, 0xddf8e7d60ed1219e},
-    {0x93e1ab8252f33b45, 0xcabb90e5c942b503},
-    {0xb8da1662e7b00a17, 0x3d6a751f3b936243},
-    {0xe7109bfba19c0c9d, 0x0cc512670a783ad4},
-    {0x906a617d450187e2, 0x27fb2b80668b24c5},
-    {0xb484f9dc9641e9da, 0xb1f9f660802dedf6},
-    {0xe1a63853bbd26451, 0x5e7873f8a0396973},
-    {0x8d07e33455637eb2, 0xdb0b487b6423e1e8},
-    {0xb049dc016abc5e5f, 0x91ce1a9a3d2cda62},
-    {0xdc5c5301c56b75f7, 0x7641a140cc7810fb},
-    {0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9d},
-    {0xac2820d9623bf429, 0x546345fa9fbdcd44},
-    {0xd732290fbacaf133, 0xa97c177947ad4095},
-    {0x867f59a9d4bed6c0, 0x49ed8eabcccc485d},
-    {0xa81f301449ee8c70, 0x5c68f256bfff5a74},
-    {0xd226fc195c6a2f8c, 0x73832eec6fff3111},
-    {0x83585d8fd9c25db7, 0xc831fd53c5ff7eab},
-    {0xa42e74f3d032f525, 0xba3e7ca8b77f5e55},
-    {0xcd3a1230c43fb26f, 0x28ce1bd2e55f35eb},
-    {0x80444b5e7aa7cf85, 0x7980d163cf5b81b3},
-    {0xa0555e361951c366, 0xd7e105bcc332621f},
-    {0xc86ab5c39fa63440, 0x8dd9472bf3fefaa7},
-    {0xfa856334878fc150, 0xb14f98f6f0feb951},
-    {0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d3},
-    {0xc3b8358109e84f07, 0x0a862f80ec4700c8},
-    {0xf4a642e14c6262c8, 0xcd27bb612758c0fa},
-    {0x98e7e9cccfbd7dbd, 0x8038d51cb897789c},
-    {0xbf21e44003acdd2c, 0xe0470a63e6bd56c3},
-    {0xeeea5d5004981478, 0x1858ccfce06cac74},
-    {0x95527a5202df0ccb, 0x0f37801e0c43ebc8},
-    {0xbaa718e68396cffd, 0xd30560258f54e6ba},
-    {0xe950df20247c83fd, 0x47c6b82ef32a2069},
-    {0x91d28b7416cdd27e, 0x4cdc331d57fa5441},
-    {0xb6472e511c81471d, 0xe0133fe4adf8e952},
-    {0xe3d8f9e563a198e5, 0x58180fddd97723a6},
-    {0x8e679c2f5e44ff8f, 0x570f09eaa7ea7648},
-    {0xb201833b35d63f73, 0x2cd2cc6551e513da},
-    {0xde81e40a034bcf4f, 0xf8077f7ea65e58d1},
-    {0x8b112e86420f6191, 0xfb04afaf27faf782},
-    {0xadd57a27d29339f6, 0x79c5db9af1f9b563},
-    {0xd94ad8b1c7380874, 0x18375281ae7822bc},
-    {0x87cec76f1c830548, 0x8f2293910d0b15b5},
-    {0xa9c2794ae3a3c69a, 0xb2eb3875504ddb22},
-    {0xd433179d9c8cb841, 0x5fa60692a46151eb},
-    {0x849feec281d7f328, 0xdbc7c41ba6bcd333},
-    {0xa5c7ea73224deff3, 0x12b9b522906c0800},
-    {0xcf39e50feae16bef, 0xd768226b34870a00},
-    {0x81842f29f2cce375, 0xe6a1158300d46640},
-    {0xa1e53af46f801c53, 0x60495ae3c1097fd0},
-    {0xca5e89b18b602368, 0x385bb19cb14bdfc4},
-    {0xfcf62c1dee382c42, 0x46729e03dd9ed7b5},
-    {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d1},
-    {0xc5a05277621be293, 0xc7098b7305241885},
-    {0xf70867153aa2db38, 0xb8cbee4fc66d1ea7}
-#else
-    {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
-    {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
-    {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
-    {0x86a8d39ef77164bc, 0xae5dff9c02033198},
-    {0xd98ddaee19068c76, 0x3badd624dd9b0958},
-    {0xafbd2350644eeacf, 0xe5d1929ef90898fb},
-    {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
-    {0xe55990879ddcaabd, 0xcc420a6a101d0516},
-    {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
-    {0x95a8637627989aad, 0xdde7001379a44aa9},
-    {0xf1c90080baf72cb1, 0x5324c68b12dd6339},
-    {0xc350000000000000, 0x0000000000000000},
-    {0x9dc5ada82b70b59d, 0xf020000000000000},
-    {0xfee50b7025c36a08, 0x02f236d04753d5b4},
-    {0xcde6fd5e09abcf26, 0xed4c0226b55e6f86},
-    {0xa6539930bf6bff45, 0x84db8346b786151c},
-    {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b2},
-    {0xd910f7ff28069da4, 0x1b2ba1518094da04},
-    {0xaf58416654a6babb, 0x387ac8d1970027b2},
-    {0x8da471a9de737e24, 0x5ceaecfed289e5d2},
-    {0xe4d5e82392a40515, 0x0fabaf3feaa5334a},
-    {0xb8da1662e7b00a17, 0x3d6a751f3b936243},
-    {0x95527a5202df0ccb, 0x0f37801e0c43ebc8}
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wnarrowing"
 #endif
-};
-
-#if !FMT_USE_FULL_CACHE_DRAGONBOX
-template <typename T>
-const uint64_t basic_data<T>::powers_of_5_64[] = {
-    0x0000000000000001, 0x0000000000000005, 0x0000000000000019,
-    0x000000000000007d, 0x0000000000000271, 0x0000000000000c35,
-    0x0000000000003d09, 0x000000000001312d, 0x000000000005f5e1,
-    0x00000000001dcd65, 0x00000000009502f9, 0x0000000002e90edd,
-    0x000000000e8d4a51, 0x0000000048c27395, 0x000000016bcc41e9,
-    0x000000071afd498d, 0x0000002386f26fc1, 0x000000b1a2bc2ec5,
-    0x000003782dace9d9, 0x00001158e460913d, 0x000056bc75e2d631,
-    0x0001b1ae4d6e2ef5, 0x000878678326eac9, 0x002a5a058fc295ed,
-    0x00d3c21bcecceda1, 0x0422ca8b0a00a425, 0x14adf4b7320334b9};
-
-template <typename T>
-const uint32_t basic_data<T>::dragonbox_pow10_recovery_errors[] = {
-    0x50001400, 0x54044100, 0x54014555, 0x55954415, 0x54115555, 0x00000001,
-    0x50000000, 0x00104000, 0x54010004, 0x05004001, 0x55555544, 0x41545555,
-    0x54040551, 0x15445545, 0x51555514, 0x10000015, 0x00101100, 0x01100015,
-    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x04450514, 0x45414110,
-    0x55555145, 0x50544050, 0x15040155, 0x11054140, 0x50111514, 0x11451454,
-    0x00400541, 0x00000000, 0x55555450, 0x10056551, 0x10054011, 0x55551014,
-    0x69514555, 0x05151109, 0x00155555};
+  // Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
+  // to significands above.
+  static constexpr int16_t pow10_exponents[87] = {
+      -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954,
+      -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688, -661,
+      -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,  -422,  -396, -369,
+      -343,  -316,  -289,  -263,  -236,  -210,  -183,  -157,  -130,  -103, -77,
+      -50,   -24,   3,     30,    56,    83,    109,   136,   162,   189,  216,
+      242,   269,   295,   322,   348,   375,   402,   428,   455,   481,  508,
+      534,   561,   588,   614,   641,   667,   694,   720,   747,   774,  800,
+      827,   853,   880,   907,   933,   960,   986,   1013,  1039,  1066};
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+#  pragma GCC diagnostic pop
 #endif
 
+  static constexpr uint64_t power_of_10_64[20] = {
+      1, FMT_POWERS_OF_10(1ULL), FMT_POWERS_OF_10(1000000000ULL),
+      10000000000000000000ULL};
+};
+
+// This is a struct rather than an alias to avoid shadowing warnings in gcc.
+struct impl_data : basic_impl_data<> {};
+
+#if __cplusplus < 201703L
 template <typename T>
-const char basic_data<T>::foreground_color[] = "\x1b[38;2;";
-template <typename T>
-const char basic_data<T>::background_color[] = "\x1b[48;2;";
-template <typename T> const char basic_data<T>::reset_color[] = "\x1b[0m";
-template <typename T> const wchar_t basic_data<T>::wreset_color[] = L"\x1b[0m";
-template <typename T> const char basic_data<T>::signs[] = {0, '-', '+', ' '};
-template <typename T>
-const char basic_data<T>::left_padding_shifts[] = {31, 31, 0, 1, 0};
-template <typename T>
-const char basic_data<T>::right_padding_shifts[] = {0, 31, 0, 1, 0};
+constexpr uint64_t basic_impl_data<T>::pow10_significands[];
+template <typename T> constexpr int16_t basic_impl_data<T>::pow10_exponents[];
+template <typename T> constexpr uint64_t basic_impl_data<T>::power_of_10_64[];
+#endif
 
 template <typename T> struct bits {
   static FMT_CONSTEXPR_DECL const int value =
       static_cast<int>(sizeof(T) * std::numeric_limits<unsigned char>::digits);
 };
 
-class fp;
-template <int SHIFT = 0> fp normalize(fp value);
-
-// Lower (upper) boundary is a value half way between a floating-point value
-// and its predecessor (successor). Boundaries have the same exponent as the
-// value so only significands are stored.
-struct boundaries {
-  uint64_t lower;
-  uint64_t upper;
-};
-
-// A handmade floating-point number f * pow(2, e).
-class fp {
- private:
-  using significand_type = uint64_t;
-
-  template <typename Float>
-  using is_supported_float = bool_constant<sizeof(Float) == sizeof(uint64_t) ||
-                                           sizeof(Float) == sizeof(uint32_t)>;
-
- public:
-  significand_type f;
-  int e;
-
-  // All sizes are in bits.
+// Returns the number of significand bits in Float excluding the implicit bit.
+template <typename Float> constexpr int num_significand_bits() {
   // Subtract 1 to account for an implicit most significant bit in the
   // normalized form.
-  static FMT_CONSTEXPR_DECL const int double_significand_size =
-      std::numeric_limits<double>::digits - 1;
-  static FMT_CONSTEXPR_DECL const uint64_t implicit_bit =
-      1ULL << double_significand_size;
-  static FMT_CONSTEXPR_DECL const int significand_size =
-      bits<significand_type>::value;
+  return std::numeric_limits<Float>::digits - 1;
+}
 
-  fp() : f(0), e(0) {}
-  fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}
+// A floating-point number f * pow(2, e).
+struct fp {
+  uint64_t f;
+  int e;
 
-  // Constructs fp from an IEEE754 double. It is a template to prevent compile
-  // errors on platforms where double is not IEEE754.
-  template <typename Double> explicit fp(Double d) { assign(d); }
+  static constexpr const int num_significand_bits = bits<decltype(f)>::value;
+
+  constexpr fp() : f(0), e(0) {}
+  constexpr fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}
+
+  // Constructs fp from an IEEE754 floating-point number. It is a template to
+  // prevent compile errors on systems where n is not IEEE754.
+  template <typename Float> explicit FMT_CONSTEXPR fp(Float n) { assign(n); }
+
+  template <typename Float>
+  using is_supported = bool_constant<sizeof(Float) == sizeof(uint64_t) ||
+                                     sizeof(Float) == sizeof(uint32_t)>;
 
   // Assigns d to this and return true iff predecessor is closer than successor.
-  template <typename Float, FMT_ENABLE_IF(is_supported_float<Float>::value)>
-  bool assign(Float d) {
+  template <typename Float, FMT_ENABLE_IF(is_supported<Float>::value)>
+  FMT_CONSTEXPR bool assign(Float n) {
     // Assume float is in the format [sign][exponent][significand].
-    using limits = std::numeric_limits<Float>;
-    const int float_significand_size = limits::digits - 1;
-    const int exponent_size =
-        bits<Float>::value - float_significand_size - 1;  // -1 for sign
-    const uint64_t float_implicit_bit = 1ULL << float_significand_size;
-    const uint64_t significand_mask = float_implicit_bit - 1;
-    const uint64_t exponent_mask = (~0ULL >> 1) & ~significand_mask;
-    const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1;
+    const int num_float_significand_bits =
+        detail::num_significand_bits<Float>();
+    const uint64_t implicit_bit = 1ULL << num_float_significand_bits;
+    const uint64_t significand_mask = implicit_bit - 1;
     constexpr bool is_double = sizeof(Float) == sizeof(uint64_t);
-    auto u = bit_cast<conditional_t<is_double, uint64_t, uint32_t>>(d);
+    auto u = bit_cast<conditional_t<is_double, uint64_t, uint32_t>>(n);
     f = u & significand_mask;
+    const uint64_t exponent_mask = (~0ULL >> 1) & ~significand_mask;
     int biased_e =
-        static_cast<int>((u & exponent_mask) >> float_significand_size);
-    // Predecessor is closer if d is a normalized power of 2 (f == 0) other than
-    // the smallest normalized number (biased_e > 1).
+        static_cast<int>((u & exponent_mask) >> 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).
     bool is_predecessor_closer = f == 0 && biased_e > 1;
     if (biased_e != 0)
-      f += float_implicit_bit;
+      f += implicit_bit;
     else
       biased_e = 1;  // Subnormals use biased exponent 1 (min exponent).
-    e = biased_e - exponent_bias - float_significand_size;
+    const int exponent_bias = std::numeric_limits<Float>::max_exponent - 1;
+    e = biased_e - exponent_bias - num_float_significand_bits;
     return is_predecessor_closer;
   }
 
-  template <typename Float, FMT_ENABLE_IF(!is_supported_float<Float>::value)>
+  template <typename Float, FMT_ENABLE_IF(!is_supported<Float>::value)>
   bool assign(Float) {
-    *this = fp();
+    FMT_ASSERT(false, "");
     return false;
   }
 };
 
 // Normalizes the value converted from double and multiplied by (1 << SHIFT).
-template <int SHIFT> fp normalize(fp value) {
+template <int SHIFT = 0> FMT_CONSTEXPR fp normalize(fp value) {
   // Handle subnormals.
-  const auto shifted_implicit_bit = fp::implicit_bit << SHIFT;
+  const uint64_t implicit_bit = 1ULL << 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 =
-      fp::significand_size - fp::double_significand_size - SHIFT - 1;
+      fp::num_significand_bits - num_significand_bits<double>() - SHIFT - 1;
   value.f <<= offset;
   value.e -= offset;
   return value;
@@ -1175,7 +304,7 @@ template <int SHIFT> fp normalize(fp value) {
 inline bool operator==(fp x, fp y) { return x.f == y.f && x.e == y.e; }
 
 // Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking.
-inline uint64_t multiply(uint64_t lhs, uint64_t rhs) {
+FMT_CONSTEXPR inline uint64_t multiply(uint64_t lhs, uint64_t rhs) {
 #if FMT_USE_INT128
   auto product = static_cast<__uint128_t>(lhs) * rhs;
   auto f = static_cast<uint64_t>(product >> 64);
@@ -1192,15 +321,18 @@ inline uint64_t multiply(uint64_t lhs, uint64_t rhs) {
 #endif
 }
 
-inline fp operator*(fp x, fp y) { return {multiply(x.f, y.f), x.e + y.e + 64}; }
+FMT_CONSTEXPR inline fp operator*(fp x, fp y) {
+  return {multiply(x.f, y.f), x.e + y.e + 64};
+}
 
 // Returns a cached power of 10 `c_k = c_k.f * pow(2, c_k.e)` such that its
 // (binary) exponent satisfies `min_exponent <= c_k.e <= min_exponent + 28`.
-inline fp get_cached_power(int min_exponent, int& pow10_exponent) {
+FMT_CONSTEXPR inline fp get_cached_power(int min_exponent,
+                                         int& pow10_exponent) {
   const int shift = 32;
-  const auto significand = static_cast<int64_t>(data::log10_2_significand);
+  const auto significand = static_cast<int64_t>(log10_2_significand);
   int index = static_cast<int>(
-      ((min_exponent + fp::significand_size - 1) * (significand >> shift) +
+      ((min_exponent + fp::num_significand_bits - 1) * (significand >> shift) +
        ((int64_t(1) << shift) - 1))  // ceil
       >> 32                          // arithmetic shift
   );
@@ -1210,8 +342,8 @@ inline fp get_cached_power(int min_exponent, int& pow10_exponent) {
   const int dec_exp_step = 8;
   index = (index - first_dec_exp - 1) / dec_exp_step + 1;
   pow10_exponent = first_dec_exp + index * dec_exp_step;
-  return {data::grisu_pow10_significands[index],
-          data::grisu_pow10_exponents[index]};
+  return {impl_data::pow10_significands[index],
+          impl_data::pow10_exponents[index]};
 }
 
 // A simple accumulator to hold the sums of terms in bigint::square if uint128_t
@@ -1220,15 +352,17 @@ struct accumulator {
   uint64_t lower;
   uint64_t upper;
 
-  accumulator() : lower(0), upper(0) {}
-  explicit operator uint32_t() const { return static_cast<uint32_t>(lower); }
+  constexpr accumulator() : lower(0), upper(0) {}
+  constexpr explicit operator uint32_t() const {
+    return static_cast<uint32_t>(lower);
+  }
 
-  void operator+=(uint64_t n) {
+  FMT_CONSTEXPR void operator+=(uint64_t n) {
     lower += n;
     if (lower < n) ++upper;
   }
-  void operator>>=(int shift) {
-    assert(shift == 32);
+  FMT_CONSTEXPR void operator>>=(int shift) {
+    FMT_ASSERT(shift == 32, "");
     (void)shift;
     lower = (upper << 32) | (lower >> 32);
     upper >>= 32;
@@ -1245,27 +379,31 @@ class bigint {
   basic_memory_buffer<bigit, bigits_capacity> bigits_;
   int exp_;
 
-  bigit operator[](int index) const { return bigits_[to_unsigned(index)]; }
-  bigit& operator[](int index) { return bigits_[to_unsigned(index)]; }
+  FMT_CONSTEXPR20 bigit operator[](int index) const {
+    return bigits_[to_unsigned(index)];
+  }
+  FMT_CONSTEXPR20 bigit& operator[](int index) {
+    return bigits_[to_unsigned(index)];
+  }
 
   static FMT_CONSTEXPR_DECL const int bigit_bits = bits<bigit>::value;
 
   friend struct formatter<bigint>;
 
-  void subtract_bigits(int index, bigit other, bigit& borrow) {
+  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));
   }
 
-  void remove_leading_zeros() {
+  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.
-  void subtract_aligned(const bigint& 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;
@@ -1276,7 +414,7 @@ class bigint {
     remove_leading_zeros();
   }
 
-  void multiply(uint32_t value) {
+  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) {
@@ -1287,7 +425,7 @@ class bigint {
     if (carry != 0) bigits_.push_back(carry);
   }
 
-  void multiply(uint64_t value) {
+  FMT_CONSTEXPR20 void multiply(uint64_t value) {
     const bigit mask = ~bigit(0);
     const double_bigit lower = value & mask;
     const double_bigit upper = value >> bigit_bits;
@@ -1305,14 +443,16 @@ class bigint {
   }
 
  public:
-  bigint() : exp_(0) {}
+  FMT_CONSTEXPR20 bigint() : exp_(0) {}
   explicit bigint(uint64_t n) { assign(n); }
-  ~bigint() { assert(bigits_.capacity() <= bigits_capacity); }
+  FMT_CONSTEXPR20 ~bigint() {
+    FMT_ASSERT(bigits_.capacity() <= bigits_capacity, "");
+  }
 
   bigint(const bigint&) = delete;
   void operator=(const bigint&) = delete;
 
-  void assign(const bigint& other) {
+  FMT_CONSTEXPR20 void assign(const bigint& other) {
     auto size = other.bigits_.size();
     bigits_.resize(size);
     auto data = other.bigits_.data();
@@ -1320,7 +460,7 @@ class bigint {
     exp_ = other.exp_;
   }
 
-  void assign(uint64_t n) {
+  FMT_CONSTEXPR20 void assign(uint64_t n) {
     size_t num_bigits = 0;
     do {
       bigits_[num_bigits++] = n & ~bigit(0);
@@ -1330,10 +470,12 @@ class bigint {
     exp_ = 0;
   }
 
-  int num_bigits() const { return static_cast<int>(bigits_.size()) + exp_; }
+  FMT_CONSTEXPR20 int num_bigits() const {
+    return static_cast<int>(bigits_.size()) + exp_;
+  }
 
-  FMT_NOINLINE bigint& operator<<=(int shift) {
-    assert(shift >= 0);
+  FMT_NOINLINE FMT_CONSTEXPR20 bigint& operator<<=(int shift) {
+    FMT_ASSERT(shift >= 0, "");
     exp_ += shift / bigit_bits;
     shift %= bigit_bits;
     if (shift == 0) return *this;
@@ -1347,13 +489,13 @@ class bigint {
     return *this;
   }
 
-  template <typename Int> bigint& operator*=(Int value) {
+  template <typename Int> FMT_CONSTEXPR20 bigint& operator*=(Int value) {
     FMT_ASSERT(value > 0, "");
     multiply(uint32_or_64_or_128_t<Int>(value));
     return *this;
   }
 
-  friend int compare(const bigint& lhs, const bigint& rhs) {
+  friend FMT_CONSTEXPR20 int compare(const bigint& lhs, const bigint& rhs) {
     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;
@@ -1370,8 +512,8 @@ class bigint {
   }
 
   // Returns compare(lhs1 + lhs2, rhs).
-  friend int add_compare(const bigint& lhs1, const bigint& lhs2,
-                         const bigint& rhs) {
+  friend FMT_CONSTEXPR20 int add_compare(const bigint& lhs1, const bigint& lhs2,
+                                         const bigint& rhs) {
     int max_lhs_bigits = (std::max)(lhs1.num_bigits(), lhs2.num_bigits());
     int num_rhs_bigits = rhs.num_bigits();
     if (max_lhs_bigits + 1 < num_rhs_bigits) return -1;
@@ -1394,8 +536,8 @@ class bigint {
   }
 
   // Assigns pow(10, exp) to this bigint.
-  void assign_pow10(int exp) {
-    assert(exp >= 0);
+  FMT_CONSTEXPR20 void assign_pow10(int exp) {
+    FMT_ASSERT(exp >= 0, "");
     if (exp == 0) return assign(1);
     // Find the top bit.
     int bitmask = 1;
@@ -1413,10 +555,10 @@ class bigint {
     *this <<= exp;  // Multiply by pow(2, exp) by shifting.
   }
 
-  void square() {
-    basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
+  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));
     using accumulator_t = conditional_t<FMT_USE_INT128, uint128_t, accumulator>;
     auto sum = accumulator_t();
@@ -1438,14 +580,13 @@ class bigint {
       (*this)[bigit_index] = static_cast<bigit>(sum);
       sum >>= bits<bigit>::value;
     }
-    --num_result_bigits;
     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.
-  void align(const bigint& other) {
+  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());
@@ -1458,7 +599,7 @@ class bigint {
 
   // Divides this bignum by divisor, assigning the remainder to this and
   // returning the quotient.
-  int divmod_assign(const bigint& divisor) {
+  FMT_CONSTEXPR20 int divmod_assign(const bigint& divisor) {
     FMT_ASSERT(this != &divisor, "");
     if (compare(*this, divisor) < 0) return 0;
     FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
@@ -1478,8 +619,9 @@ enum class round_direction { unknown, up, down };
 // some number v and the error, returns whether v should be rounded up, down, or
 // whether the rounding direction can't be determined due to error.
 // error should be less than divisor / 2.
-inline round_direction get_round_direction(uint64_t divisor, uint64_t remainder,
-                                           uint64_t error) {
+FMT_CONSTEXPR inline round_direction get_round_direction(uint64_t divisor,
+                                                         uint64_t remainder,
+                                                         uint64_t error) {
   FMT_ASSERT(remainder < divisor, "");  // divisor - remainder won't overflow.
   FMT_ASSERT(error < divisor, "");      // divisor - error won't overflow.
   FMT_ASSERT(error < divisor - error, "");  // error * 2 won't overflow.
@@ -1502,12 +644,52 @@ enum result {
 };
 }
 
+struct gen_digits_handler {
+  char* buf;
+  int size;
+  int precision;
+  int exp10;
+  bool fixed;
+
+  FMT_CONSTEXPR digits::result on_digit(char digit, uint64_t divisor,
+                                        uint64_t remainder, uint64_t error,
+                                        bool integral) {
+    FMT_ASSERT(remainder < divisor, "");
+    buf[size++] = digit;
+    if (!integral && error >= remainder) return digits::error;
+    if (size < precision) return digits::more;
+    if (!integral) {
+      // Check if error * 2 < divisor with overflow prevention.
+      // The check is not needed for the integral part because error = 1
+      // and divisor > (1 << 32) there.
+      if (error >= divisor || error >= divisor - error) return digits::error;
+    } else {
+      FMT_ASSERT(error == 1 && divisor > 2, "");
+    }
+    auto dir = get_round_direction(divisor, remainder, error);
+    if (dir != round_direction::up)
+      return dir == round_direction::down ? digits::done : digits::error;
+    ++buf[size - 1];
+    for (int i = size - 1; i > 0 && buf[i] > '9'; --i) {
+      buf[i] = '0';
+      ++buf[i - 1];
+    }
+    if (buf[0] > '9') {
+      buf[0] = '1';
+      if (fixed)
+        buf[size++] = '0';
+      else
+        ++exp10;
+    }
+    return digits::done;
+  }
+};
+
 // Generates output using the Grisu digit-gen algorithm.
 // error: the size of the region (lower, upper) outside of which numbers
 // definitely do not round to value (Delta in Grisu3).
-template <typename Handler>
-FMT_ALWAYS_INLINE digits::result grisu_gen_digits(fp value, uint64_t error,
-                                                  int& exp, Handler& handler) {
+FMT_INLINE FMT_CONSTEXPR20 digits::result grisu_gen_digits(
+    fp value, uint64_t error, int& exp, gen_digits_handler& handler) {
   const fp one(1ULL << -value.e, value.e);
   // The integral part of scaled value (p1 in Grisu) = value / one. It cannot be
   // zero because it contains a product of two 64-bit numbers with MSB set (due
@@ -1518,10 +700,28 @@ FMT_ALWAYS_INLINE digits::result grisu_gen_digits(fp value, uint64_t error,
   // The fractional part of scaled value (p2 in Grisu) c = value % one.
   uint64_t fractional = value.f & (one.f - 1);
   exp = count_digits(integral);  // kappa in Grisu.
-  // Divide by 10 to prevent overflow.
-  auto result = handler.on_start(data::powers_of_10_64[exp - 1] << -one.e,
-                                 value.f / 10, error * 10, exp);
-  if (result != digits::more) return result;
+  // Non-fixed formats require at least one digit and no precision adjustment.
+  if (handler.fixed) {
+    // Adjust fixed precision by exponent because it is relative to decimal
+    // point.
+    int precision_offset = exp + handler.exp10;
+    if (precision_offset > 0 &&
+        handler.precision > max_value<int>() - precision_offset) {
+      FMT_THROW(format_error("number is too big"));
+    }
+    handler.precision += precision_offset;
+    // Check if precision is satisfied just by leading zeros, e.g.
+    // format("{:.2f}", 0.001) gives "0.00" without generating any digits.
+    if (handler.precision <= 0) {
+      if (handler.precision < 0) return digits::done;
+      // Divide by 10 to prevent overflow.
+      uint64_t divisor = impl_data::power_of_10_64[exp - 1] << -one.e;
+      auto dir = get_round_direction(divisor, value.f / 10, error * 10);
+      if (dir == round_direction::unknown) return digits::error;
+      handler.buf[handler.size++] = dir == round_direction::up ? '1' : '0';
+      return digits::done;
+    }
+  }
   // Generate digits for the integral part. This can produce up to 10 digits.
   do {
     uint32_t digit = 0;
@@ -1568,9 +768,9 @@ FMT_ALWAYS_INLINE digits::result grisu_gen_digits(fp value, uint64_t error,
     }
     --exp;
     auto remainder = (static_cast<uint64_t>(integral) << -one.e) + fractional;
-    result = handler.on_digit(static_cast<char>('0' + digit),
-                              data::powers_of_10_64[exp] << -one.e, remainder,
-                              error, exp, true);
+    auto result = handler.on_digit(static_cast<char>('0' + digit),
+                                   impl_data::power_of_10_64[exp] << -one.e,
+                                   remainder, error, true);
     if (result != digits::more) return result;
   } while (exp > 0);
   // Generate digits for the fractional part.
@@ -1580,74 +780,63 @@ FMT_ALWAYS_INLINE digits::result grisu_gen_digits(fp value, uint64_t error,
     char digit = static_cast<char>('0' + (fractional >> -one.e));
     fractional &= one.f - 1;
     --exp;
-    result = handler.on_digit(digit, one.f, fractional, error, exp, false);
+    auto result = handler.on_digit(digit, one.f, fractional, error, false);
     if (result != digits::more) return result;
   }
 }
 
-// The fixed precision digit handler.
-struct fixed_handler {
-  char* buf;
-  int size;
-  int precision;
-  int exp10;
-  bool fixed;
+// A 128-bit integer type used internally,
+struct uint128_wrapper {
+  uint128_wrapper() = default;
 
-  digits::result on_start(uint64_t divisor, uint64_t remainder, uint64_t error,
-                          int& exp) {
-    // Non-fixed formats require at least one digit and no precision adjustment.
-    if (!fixed) return digits::more;
-    // Adjust fixed precision by exponent because it is relative to decimal
-    // point.
-    precision += exp + exp10;
-    // Check if precision is satisfied just by leading zeros, e.g.
-    // format("{:.2f}", 0.001) gives "0.00" without generating any digits.
-    if (precision > 0) return digits::more;
-    if (precision < 0) return digits::done;
-    auto dir = get_round_direction(divisor, remainder, error);
-    if (dir == round_direction::unknown) return digits::error;
-    buf[size++] = dir == round_direction::up ? '1' : '0';
-    return digits::done;
-  }
+#if FMT_USE_INT128
+  uint128_t internal_;
 
-  digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,
-                          uint64_t error, int, bool integral) {
-    FMT_ASSERT(remainder < divisor, "");
-    buf[size++] = digit;
-    if (!integral && error >= remainder) return digits::error;
-    if (size < precision) return digits::more;
-    if (!integral) {
-      // Check if error * 2 < divisor with overflow prevention.
-      // The check is not needed for the integral part because error = 1
-      // and divisor > (1 << 32) there.
-      if (error >= divisor || error >= divisor - error) return digits::error;
-    } else {
-      FMT_ASSERT(error == 1 && divisor > 2, "");
-    }
-    auto dir = get_round_direction(divisor, remainder, error);
-    if (dir != round_direction::up)
-      return dir == round_direction::down ? digits::done : digits::error;
-    ++buf[size - 1];
-    for (int i = size - 1; i > 0 && buf[i] > '9'; --i) {
-      buf[i] = '0';
-      ++buf[i - 1];
-    }
-    if (buf[0] > '9') {
-      buf[0] = '1';
-      if (fixed)
-        buf[size++] = '0';
-      else
-        ++exp10;
-    }
-    return digits::done;
+  constexpr uint128_wrapper(uint64_t high, uint64_t low) FMT_NOEXCEPT
+      : internal_{static_cast<uint128_t>(low) |
+                  (static_cast<uint128_t>(high) << 64)} {}
+
+  constexpr uint128_wrapper(uint128_t u) : internal_{u} {}
+
+  constexpr uint64_t high() const FMT_NOEXCEPT {
+    return uint64_t(internal_ >> 64);
   }
+  constexpr uint64_t low() const FMT_NOEXCEPT { return uint64_t(internal_); }
+
+  uint128_wrapper& operator+=(uint64_t n) FMT_NOEXCEPT {
+    internal_ += n;
+    return *this;
+  }
+#else
+  uint64_t high_;
+  uint64_t low_;
+
+  constexpr uint128_wrapper(uint64_t high, uint64_t low) FMT_NOEXCEPT
+      : high_{high},
+        low_{low} {}
+
+  constexpr uint64_t high() const FMT_NOEXCEPT { return high_; }
+  constexpr uint64_t low() const FMT_NOEXCEPT { return low_; }
+
+  uint128_wrapper& operator+=(uint64_t n) FMT_NOEXCEPT {
+#  if defined(_MSC_VER) && defined(_M_X64)
+    unsigned char carry = _addcarry_u64(0, low_, n, &low_);
+    _addcarry_u64(carry, high_, 0, &high_);
+    return *this;
+#  else
+    uint64_t sum = low_ + n;
+    high_ += (sum < low_ ? 1 : 0);
+    low_ = sum;
+    return *this;
+#  endif
+  }
+#endif
 };
 
 // Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox.
 namespace dragonbox {
 // Computes 128-bit result of multiplication of two 64-bit unsigned integers.
-FMT_SAFEBUFFERS inline uint128_wrapper umul128(uint64_t x,
-                                               uint64_t y) FMT_NOEXCEPT {
+inline uint128_wrapper umul128(uint64_t x, uint64_t y) FMT_NOEXCEPT {
 #if FMT_USE_INT128
   return static_cast<uint128_t>(x) * static_cast<uint128_t>(y);
 #elif defined(_MSC_VER) && defined(_M_X64)
@@ -1675,8 +864,7 @@ FMT_SAFEBUFFERS inline uint128_wrapper umul128(uint64_t x,
 }
 
 // Computes upper 64 bits of multiplication of two 64-bit unsigned integers.
-FMT_SAFEBUFFERS inline uint64_t umul128_upper64(uint64_t x,
-                                                uint64_t y) FMT_NOEXCEPT {
+inline uint64_t umul128_upper64(uint64_t x, uint64_t y) FMT_NOEXCEPT {
 #if FMT_USE_INT128
   auto p = static_cast<uint128_t>(x) * static_cast<uint128_t>(y);
   return static_cast<uint64_t>(p >> 64);
@@ -1689,8 +877,7 @@ FMT_SAFEBUFFERS inline uint64_t umul128_upper64(uint64_t x,
 
 // Computes upper 64 bits of multiplication of a 64-bit unsigned integer and a
 // 128-bit unsigned integer.
-FMT_SAFEBUFFERS inline uint64_t umul192_upper64(uint64_t x, uint128_wrapper y)
-    FMT_NOEXCEPT {
+inline uint64_t umul192_upper64(uint64_t x, uint128_wrapper y) FMT_NOEXCEPT {
   uint128_wrapper g0 = umul128(x, y.high());
   g0 += umul128_upper64(x, y.low());
   return g0.high();
@@ -1704,8 +891,7 @@ inline uint32_t umul96_upper32(uint32_t x, uint64_t y) FMT_NOEXCEPT {
 
 // Computes middle 64 bits of multiplication of a 64-bit unsigned integer and a
 // 128-bit unsigned integer.
-FMT_SAFEBUFFERS inline uint64_t umul192_middle64(uint64_t x, uint128_wrapper y)
-    FMT_NOEXCEPT {
+inline uint64_t umul192_middle64(uint64_t x, uint128_wrapper y) FMT_NOEXCEPT {
   uint64_t g01 = x * y.high();
   uint64_t g10 = umul128_upper64(x, y.low());
   return g01 + g10;
@@ -1722,8 +908,7 @@ inline uint64_t umul96_lower64(uint32_t x, uint64_t y) FMT_NOEXCEPT {
 inline int floor_log10_pow2(int e) FMT_NOEXCEPT {
   FMT_ASSERT(e <= 1700 && e >= -1700, "too large exponent");
   const int shift = 22;
-  return (e * static_cast<int>(data::log10_2_significand >> (64 - shift))) >>
-         shift;
+  return (e * static_cast<int>(log10_2_significand >> (64 - shift))) >> shift;
 }
 
 // Various fast log computations.
@@ -1741,8 +926,7 @@ inline int floor_log10_pow2_minus_log10_4_over_3(int e) FMT_NOEXCEPT {
   FMT_ASSERT(e <= 1700 && e >= -1700, "too large exponent");
   const uint64_t log10_4_over_3_fractional_digits = 0x1ffbfc2bbc780375;
   const int shift_amount = 22;
-  return (e * static_cast<int>(data::log10_2_significand >>
-                               (64 - shift_amount)) -
+  return (e * static_cast<int>(log10_2_significand >> (64 - shift_amount)) -
           static_cast<int>(log10_4_over_3_fractional_digits >>
                            (64 - shift_amount))) >>
          shift_amount;
@@ -1768,16 +952,52 @@ inline bool divisible_by_power_of_2(uint64_t x, int exp) FMT_NOEXCEPT {
 #endif
 }
 
+// Table entry type for divisibility test.
+template <typename T> struct divtest_table_entry {
+  T mod_inv;
+  T max_quotient;
+};
+
 // Returns true iff x is divisible by pow(5, exp).
 inline bool divisible_by_power_of_5(uint32_t x, int exp) FMT_NOEXCEPT {
   FMT_ASSERT(exp <= 10, "too large exponent");
-  return x * data::divtest_table_for_pow5_32[exp].mod_inv <=
-         data::divtest_table_for_pow5_32[exp].max_quotient;
+  static constexpr const divtest_table_entry<uint32_t> divtest_table[] = {
+      {0x00000001, 0xffffffff}, {0xcccccccd, 0x33333333},
+      {0xc28f5c29, 0x0a3d70a3}, {0x26e978d5, 0x020c49ba},
+      {0x3afb7e91, 0x0068db8b}, {0x0bcbe61d, 0x0014f8b5},
+      {0x68c26139, 0x000431bd}, {0xae8d46a5, 0x0000d6bf},
+      {0x22e90e21, 0x00002af3}, {0x3a2e9c6d, 0x00000897},
+      {0x3ed61f49, 0x000001b7}};
+  return x * divtest_table[exp].mod_inv <= divtest_table[exp].max_quotient;
 }
 inline bool divisible_by_power_of_5(uint64_t x, int exp) FMT_NOEXCEPT {
   FMT_ASSERT(exp <= 23, "too large exponent");
-  return x * data::divtest_table_for_pow5_64[exp].mod_inv <=
-         data::divtest_table_for_pow5_64[exp].max_quotient;
+  static constexpr const divtest_table_entry<uint64_t> divtest_table[] = {
+      {0x0000000000000001, 0xffffffffffffffff},
+      {0xcccccccccccccccd, 0x3333333333333333},
+      {0x8f5c28f5c28f5c29, 0x0a3d70a3d70a3d70},
+      {0x1cac083126e978d5, 0x020c49ba5e353f7c},
+      {0xd288ce703afb7e91, 0x0068db8bac710cb2},
+      {0x5d4e8fb00bcbe61d, 0x0014f8b588e368f0},
+      {0x790fb65668c26139, 0x000431bde82d7b63},
+      {0xe5032477ae8d46a5, 0x0000d6bf94d5e57a},
+      {0xc767074b22e90e21, 0x00002af31dc46118},
+      {0x8e47ce423a2e9c6d, 0x0000089705f4136b},
+      {0x4fa7f60d3ed61f49, 0x000001b7cdfd9d7b},
+      {0x0fee64690c913975, 0x00000057f5ff85e5},
+      {0x3662e0e1cf503eb1, 0x000000119799812d},
+      {0xa47a2cf9f6433fbd, 0x0000000384b84d09},
+      {0x54186f653140a659, 0x00000000b424dc35},
+      {0x7738164770402145, 0x0000000024075f3d},
+      {0xe4a4d1417cd9a041, 0x000000000734aca5},
+      {0xc75429d9e5c5200d, 0x000000000170ef54},
+      {0xc1773b91fac10669, 0x000000000049c977},
+      {0x26b172506559ce15, 0x00000000000ec1e4},
+      {0xd489e3a9addec2d1, 0x000000000002f394},
+      {0x90e860bb892c8d5d, 0x000000000000971d},
+      {0x502e79bf1b6f4f79, 0x0000000000001e39},
+      {0xdcd618596be30fe5, 0x000000000000060b}};
+  return x * divtest_table[exp].mod_inv <= divtest_table[exp].max_quotient;
 }
 
 // Replaces n by floor(n / pow(5, N)) returning true if and only if n is
@@ -1831,7 +1051,34 @@ template <> struct cache_accessor<float> {
   static uint64_t get_cached_power(int k) FMT_NOEXCEPT {
     FMT_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k,
                "k is out of range");
-    return data::dragonbox_pow10_significands_64[k - float_info<float>::min_k];
+    static constexpr const uint64_t pow10_significands[] = {
+        0x81ceb32c4b43fcf5, 0xa2425ff75e14fc32, 0xcad2f7f5359a3b3f,
+        0xfd87b5f28300ca0e, 0x9e74d1b791e07e49, 0xc612062576589ddb,
+        0xf79687aed3eec552, 0x9abe14cd44753b53, 0xc16d9a0095928a28,
+        0xf1c90080baf72cb2, 0x971da05074da7bef, 0xbce5086492111aeb,
+        0xec1e4a7db69561a6, 0x9392ee8e921d5d08, 0xb877aa3236a4b44a,
+        0xe69594bec44de15c, 0x901d7cf73ab0acda, 0xb424dc35095cd810,
+        0xe12e13424bb40e14, 0x8cbccc096f5088cc, 0xafebff0bcb24aaff,
+        0xdbe6fecebdedd5bf, 0x89705f4136b4a598, 0xabcc77118461cefd,
+        0xd6bf94d5e57a42bd, 0x8637bd05af6c69b6, 0xa7c5ac471b478424,
+        0xd1b71758e219652c, 0x83126e978d4fdf3c, 0xa3d70a3d70a3d70b,
+        0xcccccccccccccccd, 0x8000000000000000, 0xa000000000000000,
+        0xc800000000000000, 0xfa00000000000000, 0x9c40000000000000,
+        0xc350000000000000, 0xf424000000000000, 0x9896800000000000,
+        0xbebc200000000000, 0xee6b280000000000, 0x9502f90000000000,
+        0xba43b74000000000, 0xe8d4a51000000000, 0x9184e72a00000000,
+        0xb5e620f480000000, 0xe35fa931a0000000, 0x8e1bc9bf04000000,
+        0xb1a2bc2ec5000000, 0xde0b6b3a76400000, 0x8ac7230489e80000,
+        0xad78ebc5ac620000, 0xd8d726b7177a8000, 0x878678326eac9000,
+        0xa968163f0a57b400, 0xd3c21bcecceda100, 0x84595161401484a0,
+        0xa56fa5b99019a5c8, 0xcecb8f27f4200f3a, 0x813f3978f8940984,
+        0xa18f07d736b90be5, 0xc9f2c9cd04674ede, 0xfc6f7c4045812296,
+        0x9dc5ada82b70b59d, 0xc5371912364ce305, 0xf684df56c3e01bc6,
+        0x9a130b963a6c115c, 0xc097ce7bc90715b3, 0xf0bdc21abb48db20,
+        0x96769950b50d88f4, 0xbc143fa4e250eb31, 0xeb194f8e1ae525fd,
+        0x92efd1b8d0cf37be, 0xb7abc627050305ad, 0xe596b7b0c643c719,
+        0x8f7e32ce7bea5c6f, 0xb35dbf821ae4f38b, 0xe0352f62a19e306e};
+    return pow10_significands[k - float_info<float>::min_k];
   }
 
   static carrier_uint compute_mul(carrier_uint u,
@@ -1885,10 +1132,679 @@ template <> struct cache_accessor<double> {
     FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k,
                "k is out of range");
 
+    static constexpr const uint128_wrapper pow10_significands[] = {
 #if FMT_USE_FULL_CACHE_DRAGONBOX
-    return data::dragonbox_pow10_significands_128[k -
-                                                  float_info<double>::min_k];
+      {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
+      {0x9faacf3df73609b1, 0x77b191618c54e9ad},
+      {0xc795830d75038c1d, 0xd59df5b9ef6a2418},
+      {0xf97ae3d0d2446f25, 0x4b0573286b44ad1e},
+      {0x9becce62836ac577, 0x4ee367f9430aec33},
+      {0xc2e801fb244576d5, 0x229c41f793cda740},
+      {0xf3a20279ed56d48a, 0x6b43527578c11110},
+      {0x9845418c345644d6, 0x830a13896b78aaaa},
+      {0xbe5691ef416bd60c, 0x23cc986bc656d554},
+      {0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa9},
+      {0x94b3a202eb1c3f39, 0x7bf7d71432f3d6aa},
+      {0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc54},
+      {0xe858ad248f5c22c9, 0xd1b3400f8f9cff69},
+      {0x91376c36d99995be, 0x23100809b9c21fa2},
+      {0xb58547448ffffb2d, 0xabd40a0c2832a78b},
+      {0xe2e69915b3fff9f9, 0x16c90c8f323f516d},
+      {0x8dd01fad907ffc3b, 0xae3da7d97f6792e4},
+      {0xb1442798f49ffb4a, 0x99cd11cfdf41779d},
+      {0xdd95317f31c7fa1d, 0x40405643d711d584},
+      {0x8a7d3eef7f1cfc52, 0x482835ea666b2573},
+      {0xad1c8eab5ee43b66, 0xda3243650005eed0},
+      {0xd863b256369d4a40, 0x90bed43e40076a83},
+      {0x873e4f75e2224e68, 0x5a7744a6e804a292},
+      {0xa90de3535aaae202, 0x711515d0a205cb37},
+      {0xd3515c2831559a83, 0x0d5a5b44ca873e04},
+      {0x8412d9991ed58091, 0xe858790afe9486c3},
+      {0xa5178fff668ae0b6, 0x626e974dbe39a873},
+      {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
+      {0x80fa687f881c7f8e, 0x7ce66634bc9d0b9a},
+      {0xa139029f6a239f72, 0x1c1fffc1ebc44e81},
+      {0xc987434744ac874e, 0xa327ffb266b56221},
+      {0xfbe9141915d7a922, 0x4bf1ff9f0062baa9},
+      {0x9d71ac8fada6c9b5, 0x6f773fc3603db4aa},
+      {0xc4ce17b399107c22, 0xcb550fb4384d21d4},
+      {0xf6019da07f549b2b, 0x7e2a53a146606a49},
+      {0x99c102844f94e0fb, 0x2eda7444cbfc426e},
+      {0xc0314325637a1939, 0xfa911155fefb5309},
+      {0xf03d93eebc589f88, 0x793555ab7eba27cb},
+      {0x96267c7535b763b5, 0x4bc1558b2f3458df},
+      {0xbbb01b9283253ca2, 0x9eb1aaedfb016f17},
+      {0xea9c227723ee8bcb, 0x465e15a979c1cadd},
+      {0x92a1958a7675175f, 0x0bfacd89ec191eca},
+      {0xb749faed14125d36, 0xcef980ec671f667c},
+      {0xe51c79a85916f484, 0x82b7e12780e7401b},
+      {0x8f31cc0937ae58d2, 0xd1b2ecb8b0908811},
+      {0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa16},
+      {0xdfbdcece67006ac9, 0x67a791e093e1d49b},
+      {0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e1},
+      {0xaecc49914078536d, 0x58fae9f773886e19},
+      {0xda7f5bf590966848, 0xaf39a475506a899f},
+      {0x888f99797a5e012d, 0x6d8406c952429604},
+      {0xaab37fd7d8f58178, 0xc8e5087ba6d33b84},
+      {0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a65},
+      {0x855c3be0a17fcd26, 0x5cf2eea09a550680},
+      {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
+      {0xd0601d8efc57b08b, 0xf13b94daf124da27},
+      {0x823c12795db6ce57, 0x76c53d08d6b70859},
+      {0xa2cb1717b52481ed, 0x54768c4b0c64ca6f},
+      {0xcb7ddcdda26da268, 0xa9942f5dcf7dfd0a},
+      {0xfe5d54150b090b02, 0xd3f93b35435d7c4d},
+      {0x9efa548d26e5a6e1, 0xc47bc5014a1a6db0},
+      {0xc6b8e9b0709f109a, 0x359ab6419ca1091c},
+      {0xf867241c8cc6d4c0, 0xc30163d203c94b63},
+      {0x9b407691d7fc44f8, 0x79e0de63425dcf1e},
+      {0xc21094364dfb5636, 0x985915fc12f542e5},
+      {0xf294b943e17a2bc4, 0x3e6f5b7b17b2939e},
+      {0x979cf3ca6cec5b5a, 0xa705992ceecf9c43},
+      {0xbd8430bd08277231, 0x50c6ff782a838354},
+      {0xece53cec4a314ebd, 0xa4f8bf5635246429},
+      {0x940f4613ae5ed136, 0x871b7795e136be9a},
+      {0xb913179899f68584, 0x28e2557b59846e40},
+      {0xe757dd7ec07426e5, 0x331aeada2fe589d0},
+      {0x9096ea6f3848984f, 0x3ff0d2c85def7622},
+      {0xb4bca50b065abe63, 0x0fed077a756b53aa},
+      {0xe1ebce4dc7f16dfb, 0xd3e8495912c62895},
+      {0x8d3360f09cf6e4bd, 0x64712dd7abbbd95d},
+      {0xb080392cc4349dec, 0xbd8d794d96aacfb4},
+      {0xdca04777f541c567, 0xecf0d7a0fc5583a1},
+      {0x89e42caaf9491b60, 0xf41686c49db57245},
+      {0xac5d37d5b79b6239, 0x311c2875c522ced6},
+      {0xd77485cb25823ac7, 0x7d633293366b828c},
+      {0x86a8d39ef77164bc, 0xae5dff9c02033198},
+      {0xa8530886b54dbdeb, 0xd9f57f830283fdfd},
+      {0xd267caa862a12d66, 0xd072df63c324fd7c},
+      {0x8380dea93da4bc60, 0x4247cb9e59f71e6e},
+      {0xa46116538d0deb78, 0x52d9be85f074e609},
+      {0xcd795be870516656, 0x67902e276c921f8c},
+      {0x806bd9714632dff6, 0x00ba1cd8a3db53b7},
+      {0xa086cfcd97bf97f3, 0x80e8a40eccd228a5},
+      {0xc8a883c0fdaf7df0, 0x6122cd128006b2ce},
+      {0xfad2a4b13d1b5d6c, 0x796b805720085f82},
+      {0x9cc3a6eec6311a63, 0xcbe3303674053bb1},
+      {0xc3f490aa77bd60fc, 0xbedbfc4411068a9d},
+      {0xf4f1b4d515acb93b, 0xee92fb5515482d45},
+      {0x991711052d8bf3c5, 0x751bdd152d4d1c4b},
+      {0xbf5cd54678eef0b6, 0xd262d45a78a0635e},
+      {0xef340a98172aace4, 0x86fb897116c87c35},
+      {0x9580869f0e7aac0e, 0xd45d35e6ae3d4da1},
+      {0xbae0a846d2195712, 0x8974836059cca10a},
+      {0xe998d258869facd7, 0x2bd1a438703fc94c},
+      {0x91ff83775423cc06, 0x7b6306a34627ddd0},
+      {0xb67f6455292cbf08, 0x1a3bc84c17b1d543},
+      {0xe41f3d6a7377eeca, 0x20caba5f1d9e4a94},
+      {0x8e938662882af53e, 0x547eb47b7282ee9d},
+      {0xb23867fb2a35b28d, 0xe99e619a4f23aa44},
+      {0xdec681f9f4c31f31, 0x6405fa00e2ec94d5},
+      {0x8b3c113c38f9f37e, 0xde83bc408dd3dd05},
+      {0xae0b158b4738705e, 0x9624ab50b148d446},
+      {0xd98ddaee19068c76, 0x3badd624dd9b0958},
+      {0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d7},
+      {0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4d},
+      {0xd47487cc8470652b, 0x7647c32000696720},
+      {0x84c8d4dfd2c63f3b, 0x29ecd9f40041e074},
+      {0xa5fb0a17c777cf09, 0xf468107100525891},
+      {0xcf79cc9db955c2cc, 0x7182148d4066eeb5},
+      {0x81ac1fe293d599bf, 0xc6f14cd848405531},
+      {0xa21727db38cb002f, 0xb8ada00e5a506a7d},
+      {0xca9cf1d206fdc03b, 0xa6d90811f0e4851d},
+      {0xfd442e4688bd304a, 0x908f4a166d1da664},
+      {0x9e4a9cec15763e2e, 0x9a598e4e043287ff},
+      {0xc5dd44271ad3cdba, 0x40eff1e1853f29fe},
+      {0xf7549530e188c128, 0xd12bee59e68ef47d},
+      {0x9a94dd3e8cf578b9, 0x82bb74f8301958cf},
+      {0xc13a148e3032d6e7, 0xe36a52363c1faf02},
+      {0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac2},
+      {0x96f5600f15a7b7e5, 0x29ab103a5ef8c0ba},
+      {0xbcb2b812db11a5de, 0x7415d448f6b6f0e8},
+      {0xebdf661791d60f56, 0x111b495b3464ad22},
+      {0x936b9fcebb25c995, 0xcab10dd900beec35},
+      {0xb84687c269ef3bfb, 0x3d5d514f40eea743},
+      {0xe65829b3046b0afa, 0x0cb4a5a3112a5113},
+      {0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ac},
+      {0xb3f4e093db73a093, 0x59ed216765690f57},
+      {0xe0f218b8d25088b8, 0x306869c13ec3532d},
+      {0x8c974f7383725573, 0x1e414218c73a13fc},
+      {0xafbd2350644eeacf, 0xe5d1929ef90898fb},
+      {0xdbac6c247d62a583, 0xdf45f746b74abf3a},
+      {0x894bc396ce5da772, 0x6b8bba8c328eb784},
+      {0xab9eb47c81f5114f, 0x066ea92f3f326565},
+      {0xd686619ba27255a2, 0xc80a537b0efefebe},
+      {0x8613fd0145877585, 0xbd06742ce95f5f37},
+      {0xa798fc4196e952e7, 0x2c48113823b73705},
+      {0xd17f3b51fca3a7a0, 0xf75a15862ca504c6},
+      {0x82ef85133de648c4, 0x9a984d73dbe722fc},
+      {0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebbb},
+      {0xcc963fee10b7d1b3, 0x318df905079926a9},
+      {0xffbbcfe994e5c61f, 0xfdf17746497f7053},
+      {0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa634},
+      {0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc1},
+      {0xf9bd690a1b68637b, 0x3dfdce7aa3c673b1},
+      {0x9c1661a651213e2d, 0x06bea10ca65c084f},
+      {0xc31bfa0fe5698db8, 0x486e494fcff30a63},
+      {0xf3e2f893dec3f126, 0x5a89dba3c3efccfb},
+      {0x986ddb5c6b3a76b7, 0xf89629465a75e01d},
+      {0xbe89523386091465, 0xf6bbb397f1135824},
+      {0xee2ba6c0678b597f, 0x746aa07ded582e2d},
+      {0x94db483840b717ef, 0xa8c2a44eb4571cdd},
+      {0xba121a4650e4ddeb, 0x92f34d62616ce414},
+      {0xe896a0d7e51e1566, 0x77b020baf9c81d18},
+      {0x915e2486ef32cd60, 0x0ace1474dc1d122f},
+      {0xb5b5ada8aaff80b8, 0x0d819992132456bb},
+      {0xe3231912d5bf60e6, 0x10e1fff697ed6c6a},
+      {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
+      {0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb3},
+      {0xddd0467c64bce4a0, 0xac7cb3f6d05ddbdf},
+      {0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96c},
+      {0xad4ab7112eb3929d, 0x86c16c98d2c953c7},
+      {0xd89d64d57a607744, 0xe871c7bf077ba8b8},
+      {0x87625f056c7c4a8b, 0x11471cd764ad4973},
+      {0xa93af6c6c79b5d2d, 0xd598e40d3dd89bd0},
+      {0xd389b47879823479, 0x4aff1d108d4ec2c4},
+      {0x843610cb4bf160cb, 0xcedf722a585139bb},
+      {0xa54394fe1eedb8fe, 0xc2974eb4ee658829},
+      {0xce947a3da6a9273e, 0x733d226229feea33},
+      {0x811ccc668829b887, 0x0806357d5a3f5260},
+      {0xa163ff802a3426a8, 0xca07c2dcb0cf26f8},
+      {0xc9bcff6034c13052, 0xfc89b393dd02f0b6},
+      {0xfc2c3f3841f17c67, 0xbbac2078d443ace3},
+      {0x9d9ba7832936edc0, 0xd54b944b84aa4c0e},
+      {0xc5029163f384a931, 0x0a9e795e65d4df12},
+      {0xf64335bcf065d37d, 0x4d4617b5ff4a16d6},
+      {0x99ea0196163fa42e, 0x504bced1bf8e4e46},
+      {0xc06481fb9bcf8d39, 0xe45ec2862f71e1d7},
+      {0xf07da27a82c37088, 0x5d767327bb4e5a4d},
+      {0x964e858c91ba2655, 0x3a6a07f8d510f870},
+      {0xbbe226efb628afea, 0x890489f70a55368c},
+      {0xeadab0aba3b2dbe5, 0x2b45ac74ccea842f},
+      {0x92c8ae6b464fc96f, 0x3b0b8bc90012929e},
+      {0xb77ada0617e3bbcb, 0x09ce6ebb40173745},
+      {0xe55990879ddcaabd, 0xcc420a6a101d0516},
+      {0x8f57fa54c2a9eab6, 0x9fa946824a12232e},
+      {0xb32df8e9f3546564, 0x47939822dc96abfa},
+      {0xdff9772470297ebd, 0x59787e2b93bc56f8},
+      {0x8bfbea76c619ef36, 0x57eb4edb3c55b65b},
+      {0xaefae51477a06b03, 0xede622920b6b23f2},
+      {0xdab99e59958885c4, 0xe95fab368e45ecee},
+      {0x88b402f7fd75539b, 0x11dbcb0218ebb415},
+      {0xaae103b5fcd2a881, 0xd652bdc29f26a11a},
+      {0xd59944a37c0752a2, 0x4be76d3346f04960},
+      {0x857fcae62d8493a5, 0x6f70a4400c562ddc},
+      {0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb953},
+      {0xd097ad07a71f26b2, 0x7e2000a41346a7a8},
+      {0x825ecc24c873782f, 0x8ed400668c0c28c9},
+      {0xa2f67f2dfa90563b, 0x728900802f0f32fb},
+      {0xcbb41ef979346bca, 0x4f2b40a03ad2ffba},
+      {0xfea126b7d78186bc, 0xe2f610c84987bfa9},
+      {0x9f24b832e6b0f436, 0x0dd9ca7d2df4d7ca},
+      {0xc6ede63fa05d3143, 0x91503d1c79720dbc},
+      {0xf8a95fcf88747d94, 0x75a44c6397ce912b},
+      {0x9b69dbe1b548ce7c, 0xc986afbe3ee11abb},
+      {0xc24452da229b021b, 0xfbe85badce996169},
+      {0xf2d56790ab41c2a2, 0xfae27299423fb9c4},
+      {0x97c560ba6b0919a5, 0xdccd879fc967d41b},
+      {0xbdb6b8e905cb600f, 0x5400e987bbc1c921},
+      {0xed246723473e3813, 0x290123e9aab23b69},
+      {0x9436c0760c86e30b, 0xf9a0b6720aaf6522},
+      {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
+      {0xe7958cb87392c2c2, 0xb60b1d1230b20e05},
+      {0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c3},
+      {0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af4},
+      {0xe2280b6c20dd5232, 0x25c6da63c38de1b1},
+      {0x8d590723948a535f, 0x579c487e5a38ad0f},
+      {0xb0af48ec79ace837, 0x2d835a9df0c6d852},
+      {0xdcdb1b2798182244, 0xf8e431456cf88e66},
+      {0x8a08f0f8bf0f156b, 0x1b8e9ecb641b5900},
+      {0xac8b2d36eed2dac5, 0xe272467e3d222f40},
+      {0xd7adf884aa879177, 0x5b0ed81dcc6abb10},
+      {0x86ccbb52ea94baea, 0x98e947129fc2b4ea},
+      {0xa87fea27a539e9a5, 0x3f2398d747b36225},
+      {0xd29fe4b18e88640e, 0x8eec7f0d19a03aae},
+      {0x83a3eeeef9153e89, 0x1953cf68300424ad},
+      {0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd8},
+      {0xcdb02555653131b6, 0x3792f412cb06794e},
+      {0x808e17555f3ebf11, 0xe2bbd88bbee40bd1},
+      {0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec5},
+      {0xc8de047564d20a8b, 0xf245825a5a445276},
+      {0xfb158592be068d2e, 0xeed6e2f0f0d56713},
+      {0x9ced737bb6c4183d, 0x55464dd69685606c},
+      {0xc428d05aa4751e4c, 0xaa97e14c3c26b887},
+      {0xf53304714d9265df, 0xd53dd99f4b3066a9},
+      {0x993fe2c6d07b7fab, 0xe546a8038efe402a},
+      {0xbf8fdb78849a5f96, 0xde98520472bdd034},
+      {0xef73d256a5c0f77c, 0x963e66858f6d4441},
+      {0x95a8637627989aad, 0xdde7001379a44aa9},
+      {0xbb127c53b17ec159, 0x5560c018580d5d53},
+      {0xe9d71b689dde71af, 0xaab8f01e6e10b4a7},
+      {0x9226712162ab070d, 0xcab3961304ca70e9},
+      {0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d23},
+      {0xe45c10c42a2b3b05, 0x8cb89a7db77c506b},
+      {0x8eb98a7a9a5b04e3, 0x77f3608e92adb243},
+      {0xb267ed1940f1c61c, 0x55f038b237591ed4},
+      {0xdf01e85f912e37a3, 0x6b6c46dec52f6689},
+      {0x8b61313bbabce2c6, 0x2323ac4b3b3da016},
+      {0xae397d8aa96c1b77, 0xabec975e0a0d081b},
+      {0xd9c7dced53c72255, 0x96e7bd358c904a22},
+      {0x881cea14545c7575, 0x7e50d64177da2e55},
+      {0xaa242499697392d2, 0xdde50bd1d5d0b9ea},
+      {0xd4ad2dbfc3d07787, 0x955e4ec64b44e865},
+      {0x84ec3c97da624ab4, 0xbd5af13bef0b113f},
+      {0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58f},
+      {0xcfb11ead453994ba, 0x67de18eda5814af3},
+      {0x81ceb32c4b43fcf4, 0x80eacf948770ced8},
+      {0xa2425ff75e14fc31, 0xa1258379a94d028e},
+      {0xcad2f7f5359a3b3e, 0x096ee45813a04331},
+      {0xfd87b5f28300ca0d, 0x8bca9d6e188853fd},
+      {0x9e74d1b791e07e48, 0x775ea264cf55347e},
+      {0xc612062576589dda, 0x95364afe032a819e},
+      {0xf79687aed3eec551, 0x3a83ddbd83f52205},
+      {0x9abe14cd44753b52, 0xc4926a9672793543},
+      {0xc16d9a0095928a27, 0x75b7053c0f178294},
+      {0xf1c90080baf72cb1, 0x5324c68b12dd6339},
+      {0x971da05074da7bee, 0xd3f6fc16ebca5e04},
+      {0xbce5086492111aea, 0x88f4bb1ca6bcf585},
+      {0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6},
+      {0x9392ee8e921d5d07, 0x3aff322e62439fd0},
+      {0xb877aa3236a4b449, 0x09befeb9fad487c3},
+      {0xe69594bec44de15b, 0x4c2ebe687989a9b4},
+      {0x901d7cf73ab0acd9, 0x0f9d37014bf60a11},
+      {0xb424dc35095cd80f, 0x538484c19ef38c95},
+      {0xe12e13424bb40e13, 0x2865a5f206b06fba},
+      {0x8cbccc096f5088cb, 0xf93f87b7442e45d4},
+      {0xafebff0bcb24aafe, 0xf78f69a51539d749},
+      {0xdbe6fecebdedd5be, 0xb573440e5a884d1c},
+      {0x89705f4136b4a597, 0x31680a88f8953031},
+      {0xabcc77118461cefc, 0xfdc20d2b36ba7c3e},
+      {0xd6bf94d5e57a42bc, 0x3d32907604691b4d},
+      {0x8637bd05af6c69b5, 0xa63f9a49c2c1b110},
+      {0xa7c5ac471b478423, 0x0fcf80dc33721d54},
+      {0xd1b71758e219652b, 0xd3c36113404ea4a9},
+      {0x83126e978d4fdf3b, 0x645a1cac083126ea},
+      {0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4},
+      {0xcccccccccccccccc, 0xcccccccccccccccd},
+      {0x8000000000000000, 0x0000000000000000},
+      {0xa000000000000000, 0x0000000000000000},
+      {0xc800000000000000, 0x0000000000000000},
+      {0xfa00000000000000, 0x0000000000000000},
+      {0x9c40000000000000, 0x0000000000000000},
+      {0xc350000000000000, 0x0000000000000000},
+      {0xf424000000000000, 0x0000000000000000},
+      {0x9896800000000000, 0x0000000000000000},
+      {0xbebc200000000000, 0x0000000000000000},
+      {0xee6b280000000000, 0x0000000000000000},
+      {0x9502f90000000000, 0x0000000000000000},
+      {0xba43b74000000000, 0x0000000000000000},
+      {0xe8d4a51000000000, 0x0000000000000000},
+      {0x9184e72a00000000, 0x0000000000000000},
+      {0xb5e620f480000000, 0x0000000000000000},
+      {0xe35fa931a0000000, 0x0000000000000000},
+      {0x8e1bc9bf04000000, 0x0000000000000000},
+      {0xb1a2bc2ec5000000, 0x0000000000000000},
+      {0xde0b6b3a76400000, 0x0000000000000000},
+      {0x8ac7230489e80000, 0x0000000000000000},
+      {0xad78ebc5ac620000, 0x0000000000000000},
+      {0xd8d726b7177a8000, 0x0000000000000000},
+      {0x878678326eac9000, 0x0000000000000000},
+      {0xa968163f0a57b400, 0x0000000000000000},
+      {0xd3c21bcecceda100, 0x0000000000000000},
+      {0x84595161401484a0, 0x0000000000000000},
+      {0xa56fa5b99019a5c8, 0x0000000000000000},
+      {0xcecb8f27f4200f3a, 0x0000000000000000},
+      {0x813f3978f8940984, 0x4000000000000000},
+      {0xa18f07d736b90be5, 0x5000000000000000},
+      {0xc9f2c9cd04674ede, 0xa400000000000000},
+      {0xfc6f7c4045812296, 0x4d00000000000000},
+      {0x9dc5ada82b70b59d, 0xf020000000000000},
+      {0xc5371912364ce305, 0x6c28000000000000},
+      {0xf684df56c3e01bc6, 0xc732000000000000},
+      {0x9a130b963a6c115c, 0x3c7f400000000000},
+      {0xc097ce7bc90715b3, 0x4b9f100000000000},
+      {0xf0bdc21abb48db20, 0x1e86d40000000000},
+      {0x96769950b50d88f4, 0x1314448000000000},
+      {0xbc143fa4e250eb31, 0x17d955a000000000},
+      {0xeb194f8e1ae525fd, 0x5dcfab0800000000},
+      {0x92efd1b8d0cf37be, 0x5aa1cae500000000},
+      {0xb7abc627050305ad, 0xf14a3d9e40000000},
+      {0xe596b7b0c643c719, 0x6d9ccd05d0000000},
+      {0x8f7e32ce7bea5c6f, 0xe4820023a2000000},
+      {0xb35dbf821ae4f38b, 0xdda2802c8a800000},
+      {0xe0352f62a19e306e, 0xd50b2037ad200000},
+      {0x8c213d9da502de45, 0x4526f422cc340000},
+      {0xaf298d050e4395d6, 0x9670b12b7f410000},
+      {0xdaf3f04651d47b4c, 0x3c0cdd765f114000},
+      {0x88d8762bf324cd0f, 0xa5880a69fb6ac800},
+      {0xab0e93b6efee0053, 0x8eea0d047a457a00},
+      {0xd5d238a4abe98068, 0x72a4904598d6d880},
+      {0x85a36366eb71f041, 0x47a6da2b7f864750},
+      {0xa70c3c40a64e6c51, 0x999090b65f67d924},
+      {0xd0cf4b50cfe20765, 0xfff4b4e3f741cf6d},
+      {0x82818f1281ed449f, 0xbff8f10e7a8921a4},
+      {0xa321f2d7226895c7, 0xaff72d52192b6a0d},
+      {0xcbea6f8ceb02bb39, 0x9bf4f8a69f764490},
+      {0xfee50b7025c36a08, 0x02f236d04753d5b4},
+      {0x9f4f2726179a2245, 0x01d762422c946590},
+      {0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef5},
+      {0xf8ebad2b84e0d58b, 0xd2e0898765a7deb2},
+      {0x9b934c3b330c8577, 0x63cc55f49f88eb2f},
+      {0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fb},
+      {0xf316271c7fc3908a, 0x8bef464e3945ef7a},
+      {0x97edd871cfda3a56, 0x97758bf0e3cbb5ac},
+      {0xbde94e8e43d0c8ec, 0x3d52eeed1cbea317},
+      {0xed63a231d4c4fb27, 0x4ca7aaa863ee4bdd},
+      {0x945e455f24fb1cf8, 0x8fe8caa93e74ef6a},
+      {0xb975d6b6ee39e436, 0xb3e2fd538e122b44},
+      {0xe7d34c64a9c85d44, 0x60dbbca87196b616},
+      {0x90e40fbeea1d3a4a, 0xbc8955e946fe31cd},
+      {0xb51d13aea4a488dd, 0x6babab6398bdbe41},
+      {0xe264589a4dcdab14, 0xc696963c7eed2dd1},
+      {0x8d7eb76070a08aec, 0xfc1e1de5cf543ca2},
+      {0xb0de65388cc8ada8, 0x3b25a55f43294bcb},
+      {0xdd15fe86affad912, 0x49ef0eb713f39ebe},
+      {0x8a2dbf142dfcc7ab, 0x6e3569326c784337},
+      {0xacb92ed9397bf996, 0x49c2c37f07965404},
+      {0xd7e77a8f87daf7fb, 0xdc33745ec97be906},
+      {0x86f0ac99b4e8dafd, 0x69a028bb3ded71a3},
+      {0xa8acd7c0222311bc, 0xc40832ea0d68ce0c},
+      {0xd2d80db02aabd62b, 0xf50a3fa490c30190},
+      {0x83c7088e1aab65db, 0x792667c6da79e0fa},
+      {0xa4b8cab1a1563f52, 0x577001b891185938},
+      {0xcde6fd5e09abcf26, 0xed4c0226b55e6f86},
+      {0x80b05e5ac60b6178, 0x544f8158315b05b4},
+      {0xa0dc75f1778e39d6, 0x696361ae3db1c721},
+      {0xc913936dd571c84c, 0x03bc3a19cd1e38e9},
+      {0xfb5878494ace3a5f, 0x04ab48a04065c723},
+      {0x9d174b2dcec0e47b, 0x62eb0d64283f9c76},
+      {0xc45d1df942711d9a, 0x3ba5d0bd324f8394},
+      {0xf5746577930d6500, 0xca8f44ec7ee36479},
+      {0x9968bf6abbe85f20, 0x7e998b13cf4e1ecb},
+      {0xbfc2ef456ae276e8, 0x9e3fedd8c321a67e},
+      {0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101e},
+      {0x95d04aee3b80ece5, 0xbba1f1d158724a12},
+      {0xbb445da9ca61281f, 0x2a8a6e45ae8edc97},
+      {0xea1575143cf97226, 0xf52d09d71a3293bd},
+      {0x924d692ca61be758, 0x593c2626705f9c56},
+      {0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836c},
+      {0xe498f455c38b997a, 0x0b6dfb9c0f956447},
+      {0x8edf98b59a373fec, 0x4724bd4189bd5eac},
+      {0xb2977ee300c50fe7, 0x58edec91ec2cb657},
+      {0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ed},
+      {0x8b865b215899f46c, 0xbd79e0d20082ee74},
+      {0xae67f1e9aec07187, 0xecd8590680a3aa11},
+      {0xda01ee641a708de9, 0xe80e6f4820cc9495},
+      {0x884134fe908658b2, 0x3109058d147fdcdd},
+      {0xaa51823e34a7eede, 0xbd4b46f0599fd415},
+      {0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91a},
+      {0x850fadc09923329e, 0x03e2cf6bc604ddb0},
+      {0xa6539930bf6bff45, 0x84db8346b786151c},
+      {0xcfe87f7cef46ff16, 0xe612641865679a63},
+      {0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07e},
+      {0xa26da3999aef7749, 0xe3be5e330f38f09d},
+      {0xcb090c8001ab551c, 0x5cadf5bfd3072cc5},
+      {0xfdcb4fa002162a63, 0x73d9732fc7c8f7f6},
+      {0x9e9f11c4014dda7e, 0x2867e7fddcdd9afa},
+      {0xc646d63501a1511d, 0xb281e1fd541501b8},
+      {0xf7d88bc24209a565, 0x1f225a7ca91a4226},
+      {0x9ae757596946075f, 0x3375788de9b06958},
+      {0xc1a12d2fc3978937, 0x0052d6b1641c83ae},
+      {0xf209787bb47d6b84, 0xc0678c5dbd23a49a},
+      {0x9745eb4d50ce6332, 0xf840b7ba963646e0},
+      {0xbd176620a501fbff, 0xb650e5a93bc3d898},
+      {0xec5d3fa8ce427aff, 0xa3e51f138ab4cebe},
+      {0x93ba47c980e98cdf, 0xc66f336c36b10137},
+      {0xb8a8d9bbe123f017, 0xb80b0047445d4184},
+      {0xe6d3102ad96cec1d, 0xa60dc059157491e5},
+      {0x9043ea1ac7e41392, 0x87c89837ad68db2f},
+      {0xb454e4a179dd1877, 0x29babe4598c311fb},
+      {0xe16a1dc9d8545e94, 0xf4296dd6fef3d67a},
+      {0x8ce2529e2734bb1d, 0x1899e4a65f58660c},
+      {0xb01ae745b101e9e4, 0x5ec05dcff72e7f8f},
+      {0xdc21a1171d42645d, 0x76707543f4fa1f73},
+      {0x899504ae72497eba, 0x6a06494a791c53a8},
+      {0xabfa45da0edbde69, 0x0487db9d17636892},
+      {0xd6f8d7509292d603, 0x45a9d2845d3c42b6},
+      {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b2},
+      {0xa7f26836f282b732, 0x8e6cac7768d7141e},
+      {0xd1ef0244af2364ff, 0x3207d795430cd926},
+      {0x8335616aed761f1f, 0x7f44e6bd49e807b8},
+      {0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a6},
+      {0xcd036837130890a1, 0x36dba887c37a8c0f},
+      {0x802221226be55a64, 0xc2494954da2c9789},
+      {0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6c},
+      {0xc83553c5c8965d3d, 0x6f92829494e5acc7},
+      {0xfa42a8b73abbf48c, 0xcb772339ba1f17f9},
+      {0x9c69a97284b578d7, 0xff2a760414536efb},
+      {0xc38413cf25e2d70d, 0xfef5138519684aba},
+      {0xf46518c2ef5b8cd1, 0x7eb258665fc25d69},
+      {0x98bf2f79d5993802, 0xef2f773ffbd97a61},
+      {0xbeeefb584aff8603, 0xaafb550ffacfd8fa},
+      {0xeeaaba2e5dbf6784, 0x95ba2a53f983cf38},
+      {0x952ab45cfa97a0b2, 0xdd945a747bf26183},
+      {0xba756174393d88df, 0x94f971119aeef9e4},
+      {0xe912b9d1478ceb17, 0x7a37cd5601aab85d},
+      {0x91abb422ccb812ee, 0xac62e055c10ab33a},
+      {0xb616a12b7fe617aa, 0x577b986b314d6009},
+      {0xe39c49765fdf9d94, 0xed5a7e85fda0b80b},
+      {0x8e41ade9fbebc27d, 0x14588f13be847307},
+      {0xb1d219647ae6b31c, 0x596eb2d8ae258fc8},
+      {0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bb},
+      {0x8aec23d680043bee, 0x25de7bb9480d5854},
+      {0xada72ccc20054ae9, 0xaf561aa79a10ae6a},
+      {0xd910f7ff28069da4, 0x1b2ba1518094da04},
+      {0x87aa9aff79042286, 0x90fb44d2f05d0842},
+      {0xa99541bf57452b28, 0x353a1607ac744a53},
+      {0xd3fa922f2d1675f2, 0x42889b8997915ce8},
+      {0x847c9b5d7c2e09b7, 0x69956135febada11},
+      {0xa59bc234db398c25, 0x43fab9837e699095},
+      {0xcf02b2c21207ef2e, 0x94f967e45e03f4bb},
+      {0x8161afb94b44f57d, 0x1d1be0eebac278f5},
+      {0xa1ba1ba79e1632dc, 0x6462d92a69731732},
+      {0xca28a291859bbf93, 0x7d7b8f7503cfdcfe},
+      {0xfcb2cb35e702af78, 0x5cda735244c3d43e},
+      {0x9defbf01b061adab, 0x3a0888136afa64a7},
+      {0xc56baec21c7a1916, 0x088aaa1845b8fdd0},
+      {0xf6c69a72a3989f5b, 0x8aad549e57273d45},
+      {0x9a3c2087a63f6399, 0x36ac54e2f678864b},
+      {0xc0cb28a98fcf3c7f, 0x84576a1bb416a7dd},
+      {0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d5},
+      {0x969eb7c47859e743, 0x9f644ae5a4b1b325},
+      {0xbc4665b596706114, 0x873d5d9f0dde1fee},
+      {0xeb57ff22fc0c7959, 0xa90cb506d155a7ea},
+      {0x9316ff75dd87cbd8, 0x09a7f12442d588f2},
+      {0xb7dcbf5354e9bece, 0x0c11ed6d538aeb2f},
+      {0xe5d3ef282a242e81, 0x8f1668c8a86da5fa},
+      {0x8fa475791a569d10, 0xf96e017d694487bc},
+      {0xb38d92d760ec4455, 0x37c981dcc395a9ac},
+      {0xe070f78d3927556a, 0x85bbe253f47b1417},
+      {0x8c469ab843b89562, 0x93956d7478ccec8e},
+      {0xaf58416654a6babb, 0x387ac8d1970027b2},
+      {0xdb2e51bfe9d0696a, 0x06997b05fcc0319e},
+      {0x88fcf317f22241e2, 0x441fece3bdf81f03},
+      {0xab3c2fddeeaad25a, 0xd527e81cad7626c3},
+      {0xd60b3bd56a5586f1, 0x8a71e223d8d3b074},
+      {0x85c7056562757456, 0xf6872d5667844e49},
+      {0xa738c6bebb12d16c, 0xb428f8ac016561db},
+      {0xd106f86e69d785c7, 0xe13336d701beba52},
+      {0x82a45b450226b39c, 0xecc0024661173473},
+      {0xa34d721642b06084, 0x27f002d7f95d0190},
+      {0xcc20ce9bd35c78a5, 0x31ec038df7b441f4},
+      {0xff290242c83396ce, 0x7e67047175a15271},
+      {0x9f79a169bd203e41, 0x0f0062c6e984d386},
+      {0xc75809c42c684dd1, 0x52c07b78a3e60868},
+      {0xf92e0c3537826145, 0xa7709a56ccdf8a82},
+      {0x9bbcc7a142b17ccb, 0x88a66076400bb691},
+      {0xc2abf989935ddbfe, 0x6acff893d00ea435},
+      {0xf356f7ebf83552fe, 0x0583f6b8c4124d43},
+      {0x98165af37b2153de, 0xc3727a337a8b704a},
+      {0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5c},
+      {0xeda2ee1c7064130c, 0x1162def06f79df73},
+      {0x9485d4d1c63e8be7, 0x8addcb5645ac2ba8},
+      {0xb9a74a0637ce2ee1, 0x6d953e2bd7173692},
+      {0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0437},
+      {0x910ab1d4db9914a0, 0x1d9c9892400a22a2},
+      {0xb54d5e4a127f59c8, 0x2503beb6d00cab4b},
+      {0xe2a0b5dc971f303a, 0x2e44ae64840fd61d},
+      {0x8da471a9de737e24, 0x5ceaecfed289e5d2},
+      {0xb10d8e1456105dad, 0x7425a83e872c5f47},
+      {0xdd50f1996b947518, 0xd12f124e28f77719},
+      {0x8a5296ffe33cc92f, 0x82bd6b70d99aaa6f},
+      {0xace73cbfdc0bfb7b, 0x636cc64d1001550b},
+      {0xd8210befd30efa5a, 0x3c47f7e05401aa4e},
+      {0x8714a775e3e95c78, 0x65acfaec34810a71},
+      {0xa8d9d1535ce3b396, 0x7f1839a741a14d0d},
+      {0xd31045a8341ca07c, 0x1ede48111209a050},
+      {0x83ea2b892091e44d, 0x934aed0aab460432},
+      {0xa4e4b66b68b65d60, 0xf81da84d5617853f},
+      {0xce1de40642e3f4b9, 0x36251260ab9d668e},
+      {0x80d2ae83e9ce78f3, 0xc1d72b7c6b426019},
+      {0xa1075a24e4421730, 0xb24cf65b8612f81f},
+      {0xc94930ae1d529cfc, 0xdee033f26797b627},
+      {0xfb9b7cd9a4a7443c, 0x169840ef017da3b1},
+      {0x9d412e0806e88aa5, 0x8e1f289560ee864e},
+      {0xc491798a08a2ad4e, 0xf1a6f2bab92a27e2},
+      {0xf5b5d7ec8acb58a2, 0xae10af696774b1db},
+      {0x9991a6f3d6bf1765, 0xacca6da1e0a8ef29},
+      {0xbff610b0cc6edd3f, 0x17fd090a58d32af3},
+      {0xeff394dcff8a948e, 0xddfc4b4cef07f5b0},
+      {0x95f83d0a1fb69cd9, 0x4abdaf101564f98e},
+      {0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f1},
+      {0xea53df5fd18d5513, 0x84c86189216dc5ed},
+      {0x92746b9be2f8552c, 0x32fd3cf5b4e49bb4},
+      {0xb7118682dbb66a77, 0x3fbc8c33221dc2a1},
+      {0xe4d5e82392a40515, 0x0fabaf3feaa5334a},
+      {0x8f05b1163ba6832d, 0x29cb4d87f2a7400e},
+      {0xb2c71d5bca9023f8, 0x743e20e9ef511012},
+      {0xdf78e4b2bd342cf6, 0x914da9246b255416},
+      {0x8bab8eefb6409c1a, 0x1ad089b6c2f7548e},
+      {0xae9672aba3d0c320, 0xa184ac2473b529b1},
+      {0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741e},
+      {0x8865899617fb1871, 0x7e2fa67c7a658892},
+      {0xaa7eebfb9df9de8d, 0xddbb901b98feeab7},
+      {0xd51ea6fa85785631, 0x552a74227f3ea565},
+      {0x8533285c936b35de, 0xd53a88958f87275f},
+      {0xa67ff273b8460356, 0x8a892abaf368f137},
+      {0xd01fef10a657842c, 0x2d2b7569b0432d85},
+      {0x8213f56a67f6b29b, 0x9c3b29620e29fc73},
+      {0xa298f2c501f45f42, 0x8349f3ba91b47b8f},
+      {0xcb3f2f7642717713, 0x241c70a936219a73},
+      {0xfe0efb53d30dd4d7, 0xed238cd383aa0110},
+      {0x9ec95d1463e8a506, 0xf4363804324a40aa},
+      {0xc67bb4597ce2ce48, 0xb143c6053edcd0d5},
+      {0xf81aa16fdc1b81da, 0xdd94b7868e94050a},
+      {0x9b10a4e5e9913128, 0xca7cf2b4191c8326},
+      {0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f0},
+      {0xf24a01a73cf2dccf, 0xbc633b39673c8cec},
+      {0x976e41088617ca01, 0xd5be0503e085d813},
+      {0xbd49d14aa79dbc82, 0x4b2d8644d8a74e18},
+      {0xec9c459d51852ba2, 0xddf8e7d60ed1219e},
+      {0x93e1ab8252f33b45, 0xcabb90e5c942b503},
+      {0xb8da1662e7b00a17, 0x3d6a751f3b936243},
+      {0xe7109bfba19c0c9d, 0x0cc512670a783ad4},
+      {0x906a617d450187e2, 0x27fb2b80668b24c5},
+      {0xb484f9dc9641e9da, 0xb1f9f660802dedf6},
+      {0xe1a63853bbd26451, 0x5e7873f8a0396973},
+      {0x8d07e33455637eb2, 0xdb0b487b6423e1e8},
+      {0xb049dc016abc5e5f, 0x91ce1a9a3d2cda62},
+      {0xdc5c5301c56b75f7, 0x7641a140cc7810fb},
+      {0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9d},
+      {0xac2820d9623bf429, 0x546345fa9fbdcd44},
+      {0xd732290fbacaf133, 0xa97c177947ad4095},
+      {0x867f59a9d4bed6c0, 0x49ed8eabcccc485d},
+      {0xa81f301449ee8c70, 0x5c68f256bfff5a74},
+      {0xd226fc195c6a2f8c, 0x73832eec6fff3111},
+      {0x83585d8fd9c25db7, 0xc831fd53c5ff7eab},
+      {0xa42e74f3d032f525, 0xba3e7ca8b77f5e55},
+      {0xcd3a1230c43fb26f, 0x28ce1bd2e55f35eb},
+      {0x80444b5e7aa7cf85, 0x7980d163cf5b81b3},
+      {0xa0555e361951c366, 0xd7e105bcc332621f},
+      {0xc86ab5c39fa63440, 0x8dd9472bf3fefaa7},
+      {0xfa856334878fc150, 0xb14f98f6f0feb951},
+      {0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d3},
+      {0xc3b8358109e84f07, 0x0a862f80ec4700c8},
+      {0xf4a642e14c6262c8, 0xcd27bb612758c0fa},
+      {0x98e7e9cccfbd7dbd, 0x8038d51cb897789c},
+      {0xbf21e44003acdd2c, 0xe0470a63e6bd56c3},
+      {0xeeea5d5004981478, 0x1858ccfce06cac74},
+      {0x95527a5202df0ccb, 0x0f37801e0c43ebc8},
+      {0xbaa718e68396cffd, 0xd30560258f54e6ba},
+      {0xe950df20247c83fd, 0x47c6b82ef32a2069},
+      {0x91d28b7416cdd27e, 0x4cdc331d57fa5441},
+      {0xb6472e511c81471d, 0xe0133fe4adf8e952},
+      {0xe3d8f9e563a198e5, 0x58180fddd97723a6},
+      {0x8e679c2f5e44ff8f, 0x570f09eaa7ea7648},
+      {0xb201833b35d63f73, 0x2cd2cc6551e513da},
+      {0xde81e40a034bcf4f, 0xf8077f7ea65e58d1},
+      {0x8b112e86420f6191, 0xfb04afaf27faf782},
+      {0xadd57a27d29339f6, 0x79c5db9af1f9b563},
+      {0xd94ad8b1c7380874, 0x18375281ae7822bc},
+      {0x87cec76f1c830548, 0x8f2293910d0b15b5},
+      {0xa9c2794ae3a3c69a, 0xb2eb3875504ddb22},
+      {0xd433179d9c8cb841, 0x5fa60692a46151eb},
+      {0x849feec281d7f328, 0xdbc7c41ba6bcd333},
+      {0xa5c7ea73224deff3, 0x12b9b522906c0800},
+      {0xcf39e50feae16bef, 0xd768226b34870a00},
+      {0x81842f29f2cce375, 0xe6a1158300d46640},
+      {0xa1e53af46f801c53, 0x60495ae3c1097fd0},
+      {0xca5e89b18b602368, 0x385bb19cb14bdfc4},
+      {0xfcf62c1dee382c42, 0x46729e03dd9ed7b5},
+      {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d1},
+      {0xc5a05277621be293, 0xc7098b7305241885},
+      { 0xf70867153aa2db38,
+        0xb8cbee4fc66d1ea7 }
 #else
+      {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
+      {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
+      {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
+      {0x86a8d39ef77164bc, 0xae5dff9c02033198},
+      {0xd98ddaee19068c76, 0x3badd624dd9b0958},
+      {0xafbd2350644eeacf, 0xe5d1929ef90898fb},
+      {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
+      {0xe55990879ddcaabd, 0xcc420a6a101d0516},
+      {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
+      {0x95a8637627989aad, 0xdde7001379a44aa9},
+      {0xf1c90080baf72cb1, 0x5324c68b12dd6339},
+      {0xc350000000000000, 0x0000000000000000},
+      {0x9dc5ada82b70b59d, 0xf020000000000000},
+      {0xfee50b7025c36a08, 0x02f236d04753d5b4},
+      {0xcde6fd5e09abcf26, 0xed4c0226b55e6f86},
+      {0xa6539930bf6bff45, 0x84db8346b786151c},
+      {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b2},
+      {0xd910f7ff28069da4, 0x1b2ba1518094da04},
+      {0xaf58416654a6babb, 0x387ac8d1970027b2},
+      {0x8da471a9de737e24, 0x5ceaecfed289e5d2},
+      {0xe4d5e82392a40515, 0x0fabaf3feaa5334a},
+      {0xb8da1662e7b00a17, 0x3d6a751f3b936243},
+      { 0x95527a5202df0ccb,
+        0x0f37801e0c43ebc8 }
+#endif
+    };
+
+#if FMT_USE_FULL_CACHE_DRAGONBOX
+    return pow10_significands[k - float_info<double>::min_k];
+#else
+    static constexpr const uint64_t powers_of_5_64[] = {
+        0x0000000000000001, 0x0000000000000005, 0x0000000000000019,
+        0x000000000000007d, 0x0000000000000271, 0x0000000000000c35,
+        0x0000000000003d09, 0x000000000001312d, 0x000000000005f5e1,
+        0x00000000001dcd65, 0x00000000009502f9, 0x0000000002e90edd,
+        0x000000000e8d4a51, 0x0000000048c27395, 0x000000016bcc41e9,
+        0x000000071afd498d, 0x0000002386f26fc1, 0x000000b1a2bc2ec5,
+        0x000003782dace9d9, 0x00001158e460913d, 0x000056bc75e2d631,
+        0x0001b1ae4d6e2ef5, 0x000878678326eac9, 0x002a5a058fc295ed,
+        0x00d3c21bcecceda1, 0x0422ca8b0a00a425, 0x14adf4b7320334b9};
+
+    static constexpr const uint32_t pow10_recovery_errors[] = {
+        0x50001400, 0x54044100, 0x54014555, 0x55954415, 0x54115555, 0x00000001,
+        0x50000000, 0x00104000, 0x54010004, 0x05004001, 0x55555544, 0x41545555,
+        0x54040551, 0x15445545, 0x51555514, 0x10000015, 0x00101100, 0x01100015,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x04450514, 0x45414110,
+        0x55555145, 0x50544050, 0x15040155, 0x11054140, 0x50111514, 0x11451454,
+        0x00400541, 0x00000000, 0x55555450, 0x10056551, 0x10054011, 0x55551014,
+        0x69514555, 0x05151109, 0x00155555};
+
     static const int compression_ratio = 27;
 
     // Compute base index.
@@ -1897,8 +1813,7 @@ template <> struct cache_accessor<double> {
     int offset = k - kb;
 
     // Get base cache.
-    uint128_wrapper base_cache =
-        data::dragonbox_pow10_significands_128[cache_index];
+    uint128_wrapper base_cache = pow10_significands[cache_index];
     if (offset == 0) return base_cache;
 
     // Compute the required amount of bit-shift.
@@ -1906,7 +1821,7 @@ template <> struct cache_accessor<double> {
     FMT_ASSERT(alpha > 0 && alpha < 64, "shifting error detected");
 
     // Try to recover the real cache.
-    uint64_t pow5 = data::powers_of_5_64[offset];
+    uint64_t pow5 = powers_of_5_64[offset];
     uint128_wrapper recovered_cache = umul128(base_cache.high(), pow5);
     uint128_wrapper middle_low =
         umul128(base_cache.low() - (kb < 0 ? 1u : 0u), pow5);
@@ -1924,7 +1839,7 @@ template <> struct cache_accessor<double> {
 
     // Get error.
     int error_idx = (k - float_info<double>::min_k) / 16;
-    uint32_t error = (data::dragonbox_pow10_recovery_errors[error_idx] >>
+    uint32_t error = (pow10_recovery_errors[error_idx] >>
                       ((k - float_info<double>::min_k) % 16) * 2) &
                      0x3;
 
@@ -2010,7 +1925,7 @@ bool is_center_integer(typename float_info<T>::carrier_uint two_f, int exponent,
 }
 
 // Remove trailing zeros from n and return the number of zeros removed (float)
-FMT_ALWAYS_INLINE int remove_trailing_zeros(uint32_t& n) FMT_NOEXCEPT {
+FMT_INLINE int remove_trailing_zeros(uint32_t& n) FMT_NOEXCEPT {
 #ifdef FMT_BUILTIN_CTZ
   int t = FMT_BUILTIN_CTZ(n);
 #else
@@ -2038,7 +1953,7 @@ FMT_ALWAYS_INLINE int remove_trailing_zeros(uint32_t& n) FMT_NOEXCEPT {
 }
 
 // Removes trailing zeros and returns the number of zeros removed (double)
-FMT_ALWAYS_INLINE int remove_trailing_zeros(uint64_t& n) FMT_NOEXCEPT {
+FMT_INLINE int remove_trailing_zeros(uint64_t& n) FMT_NOEXCEPT {
 #ifdef FMT_BUILTIN_CTZLL
   int t = FMT_BUILTIN_CTZLL(n);
 #else
@@ -2124,8 +2039,7 @@ FMT_ALWAYS_INLINE int remove_trailing_zeros(uint64_t& n) FMT_NOEXCEPT {
 
 // The main algorithm for shorter interval case
 template <class T>
-FMT_ALWAYS_INLINE FMT_SAFEBUFFERS decimal_fp<T> shorter_interval_case(
-    int exponent) FMT_NOEXCEPT {
+FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) FMT_NOEXCEPT {
   decimal_fp<T> ret_value;
   // Compute k and beta
   const int minus_k = floor_log10_pow2_minus_log10_4_over_3(exponent);
@@ -2171,8 +2085,7 @@ FMT_ALWAYS_INLINE FMT_SAFEBUFFERS decimal_fp<T> shorter_interval_case(
   return ret_value;
 }
 
-template <typename T>
-FMT_SAFEBUFFERS decimal_fp<T> to_decimal(T x) FMT_NOEXCEPT {
+template <typename T> decimal_fp<T> to_decimal(T x) FMT_NOEXCEPT {
   // Step 1: integer promotion & Schubfach multiplier calculation.
 
   using carrier_uint = typename float_info<T>::carrier_uint;
@@ -2306,24 +2219,21 @@ small_divisor_case_label:
 }
 }  // namespace dragonbox
 
-// Formats value using a variation of the Fixed-Precision Positive
-// Floating-Point Printout ((FPP)^2) algorithm by Steele & White:
-// https://fmt.dev/p372-steele.pdf.
-template <typename Double>
-void fallback_format(Double d, int num_digits, bool binary32, buffer<char>& buf,
-                     int& exp10) {
+// 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(fp value, bool is_predecessor_closer,
+                                          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).
-  fp value;
   // 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.
-  const bool is_predecessor_closer =
-      binary32 ? value.assign(static_cast<float>(d)) : value.assign(d);
   int shift = is_predecessor_closer ? 2 : 1;
   uint64_t significand = value.f << shift;
   if (value.e >= 0) {
@@ -2393,9 +2303,9 @@ void fallback_format(Double d, int num_digits, bool binary32, buffer<char>& buf,
   // Generate the given number of digits.
   exp10 -= num_digits - 1;
   if (num_digits == 0) {
-    buf.try_resize(1);
     denominator *= 10;
-    buf[0] = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0';
+    auto digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0';
+    buf.push_back(digit);
     return;
   }
   buf.try_resize(to_unsigned(num_digits));
@@ -2426,9 +2336,12 @@ void fallback_format(Double d, int num_digits, bool binary32, buffer<char>& buf,
   buf[num_digits - 1] = static_cast<char>('0' + digit);
 }
 
-template <typename T>
-int format_float(T value, int precision, float_specs specs, buffer<char>& buf) {
-  static_assert(!std::is_same<T, float>::value, "");
+template <typename Float>
+FMT_HEADER_ONLY_CONSTEXPR20 int format_float(Float value, int precision,
+                                             float_specs specs,
+                                             buffer<char>& buf) {
+  // float is passed as double to reduce the number of instantiations.
+  static_assert(!std::is_same<Float, float>::value, "");
   FMT_ASSERT(value >= 0, "value is negative");
 
   const bool fixed = specs.format == float_format::fixed;
@@ -2438,13 +2351,13 @@ int format_float(T value, int precision, float_specs specs, buffer<char>& buf) {
       return 0;
     }
     buf.try_resize(to_unsigned(precision));
-    std::uninitialized_fill_n(buf.data(), precision, '0');
+    fill_n(buf.data(), precision, '0');
     return -precision;
   }
 
-  if (!specs.use_grisu) return snprintf_float(value, precision, specs, buf);
+  if (specs.fallback) return snprintf_float(value, precision, specs, buf);
 
-  if (precision < 0) {
+  if (!is_constant_evaluated() && precision < 0) {
     // Use Dragonbox for the shortest format.
     if (specs.binary32) {
       auto dec = dragonbox::to_decimal(static_cast<float>(value));
@@ -2456,26 +2369,37 @@ int format_float(T value, int precision, float_specs specs, buffer<char>& buf) {
     return dec.exponent;
   }
 
-  // Use Grisu + Dragon4 for the given precision:
-  // https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf.
   int exp = 0;
-  const int min_exp = -60;  // alpha in Grisu.
-  int cached_exp10 = 0;     // K in Grisu.
-  fp normalized = normalize(fp(value));
-  const auto cached_pow = get_cached_power(
-      min_exp - (normalized.e + fp::significand_size), cached_exp10);
-  normalized = normalized * cached_pow;
-  // 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;
-  fixed_handler handler{buf.data(), 0, precision, -cached_exp10, fixed};
-  if (grisu_gen_digits(normalized, 1, exp, handler) == digits::error) {
-    exp += handler.size - cached_exp10 - 1;
-    fallback_format(value, handler.precision, specs.binary32, buf, exp);
-  } else {
-    exp += handler.exp10;
-    buf.try_resize(to_unsigned(handler.size));
+  bool use_dragon = true;
+  if (is_fast_float<Float>()) {
+    // Use Grisu + Dragon4 for the given precision:
+    // https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf.
+    const int min_exp = -60;  // alpha in Grisu.
+    int cached_exp10 = 0;     // K in Grisu.
+    fp normalized = normalize(fp(value));
+    const auto cached_pow = get_cached_power(
+        min_exp - (normalized.e + fp::num_significand_bits), cached_exp10);
+    normalized = normalized * cached_pow;
+    gen_digits_handler handler{buf.data(), 0, precision, -cached_exp10, fixed};
+    if (grisu_gen_digits(normalized, 1, exp, handler) != digits::error &&
+        !is_constant_evaluated()) {
+      exp += handler.exp10;
+      buf.try_resize(to_unsigned(handler.size));
+      use_dragon = false;
+    } else {
+      exp += handler.size - cached_exp10 - 1;
+      precision = handler.precision;
+    }
+  }
+  if (use_dragon) {
+    auto f = fp();
+    bool is_predecessor_closer =
+        specs.binary32 ? f.assign(static_cast<float>(value)) : f.assign(value);
+    // 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, is_predecessor_closer, precision, buf, exp);
   }
   if (!fixed && !specs.showpoint) {
     // Remove trailing zeros.
@@ -2487,7 +2411,7 @@ int format_float(T value, int precision, float_specs specs, buffer<char>& buf) {
     buf.try_resize(num_digits);
   }
   return exp;
-}  // namespace detail
+}
 
 template <typename T>
 int snprintf_float(T value, int precision, float_specs specs,
@@ -2571,11 +2495,11 @@ int snprintf_float(T value, int precision, float_specs specs,
       --exp_pos;
     } while (*exp_pos != 'e');
     char sign = exp_pos[1];
-    assert(sign == '+' || sign == '-');
+    FMT_ASSERT(sign == '+' || sign == '-', "");
     int exp = 0;
     auto p = exp_pos + 2;  // Skip 'e' and sign.
     do {
-      assert(is_digit(*p));
+      FMT_ASSERT(is_digit(*p), "");
       exp = exp * 10 + (*p++ - '0');
     } while (p != end);
     if (sign == '-') exp = -exp;
@@ -2592,71 +2516,11 @@ int snprintf_float(T value, int precision, float_specs specs,
     return exp - fraction_size;
   }
 }
-
-// A public domain branchless UTF-8 decoder by Christopher Wellons:
-// https://github.com/skeeto/branchless-utf8
-/* Decode the next character, c, from buf, 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.
- */
-inline const char* utf8_decode(const char* buf, uint32_t* c, int* e) {
-  static const int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07};
-  static const uint32_t mins[] = {4194304, 0, 128, 2048, 65536};
-  static const int shiftc[] = {0, 18, 12, 6, 0};
-  static const int shifte[] = {0, 6, 4, 2, 0};
-
-  int len = code_point_length(buf);
-  const char* next = buf + len;
-
-  // Assume a four-byte character and load four bytes. Unused bits are
-  // shifted out.
-  auto s = reinterpret_cast<const unsigned char*>(buf);
-  *c = uint32_t(s[0] & masks[len]) << 18;
-  *c |= uint32_t(s[1] & 0x3f) << 12;
-  *c |= uint32_t(s[2] & 0x3f) << 6;
-  *c |= uint32_t(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 |= (s[1] & 0xc0) >> 2;
-  *e |= (s[2] & 0xc0) >> 4;
-  *e |= (s[3]) >> 6;
-  *e ^= 0x2a;  // top two bits of each tail byte correct?
-  *e >>= shifte[len];
-
-  return next;
-}
-
-struct stringifier {
-  template <typename T> FMT_INLINE std::string operator()(T value) const {
-    return to_string(value);
-  }
-  std::string operator()(basic_format_arg<format_context>::handle h) const {
-    memory_buffer buf;
-    format_parse_context parse_ctx({});
-    format_context format_ctx(buffer_appender<char>(buf), {}, {});
-    h.format(parse_ctx, format_ctx);
-    return to_string(buf);
-  }
-};
 }  // namespace detail
 
 template <> struct formatter<detail::bigint> {
-  format_parse_context::iterator parse(format_parse_context& ctx) {
+  FMT_CONSTEXPR format_parse_context::iterator parse(
+      format_parse_context& ctx) {
     return ctx.begin();
   }
 
@@ -2667,24 +2531,22 @@ template <> struct formatter<detail::bigint> {
     for (auto i = n.bigits_.size(); i > 0; --i) {
       auto value = n.bigits_[i - 1u];
       if (first) {
-        out = format_to(out, "{:x}", value);
+        out = format_to(out, FMT_STRING("{:x}"), value);
         first = false;
         continue;
       }
-      out = format_to(out, "{:08x}", value);
+      out = format_to(out, FMT_STRING("{:08x}"), value);
     }
     if (n.exp_ > 0)
-      out = format_to(out, "p{}", n.exp_ * detail::bigint::bigit_bits);
+      out = format_to(out, FMT_STRING("p{}"),
+                      n.exp_ * detail::bigint::bigit_bits);
     return out;
   }
 };
 
 FMT_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s) {
-  auto transcode = [this](const char* p) {
-    auto cp = uint32_t();
-    auto error = 0;
-    p = utf8_decode(p, &cp, &error);
-    if (error != 0) FMT_THROW(std::runtime_error("invalid utf8"));
+  for_each_codepoint(s, [this](uint32_t cp, string_view) {
+    if (cp == invalid_code_point) FMT_THROW(std::runtime_error("invalid utf8"));
     if (cp <= 0xFFFF) {
       buffer_.push_back(static_cast<wchar_t>(cp));
     } else {
@@ -2692,64 +2554,38 @@ FMT_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s) {
       buffer_.push_back(static_cast<wchar_t>(0xD800 + (cp >> 10)));
       buffer_.push_back(static_cast<wchar_t>(0xDC00 + (cp & 0x3FF)));
     }
-    return p;
-  };
-  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 = transcode(p);
-  }
-  if (auto num_chars_left = s.data() + s.size() - p) {
-    char buf[2 * block_size - 1] = {};
-    memcpy(buf, p, to_unsigned(num_chars_left));
-    p = buf;
-    do {
-      p = transcode(p);
-    } while (p - buf < num_chars_left);
-  }
+    return true;
+  });
   buffer_.push_back(0);
 }
 
 FMT_FUNC void format_system_error(detail::buffer<char>& out, int error_code,
-                                  string_view message) FMT_NOEXCEPT {
+                                  const char* message) FMT_NOEXCEPT {
   FMT_TRY {
-    memory_buffer buf;
-    buf.resize(inline_buffer_size);
-    for (;;) {
-      char* system_message = &buf[0];
-      int result =
-          detail::safe_strerror(error_code, system_message, buf.size());
-      if (result == 0) {
-        format_to(detail::buffer_appender<char>(out), "{}: {}", message,
-                  system_message);
-        return;
-      }
-      if (result != ERANGE)
-        break;  // Can't get error message, report error code instead.
-      buf.resize(buf.size() * 2);
-    }
+    auto ec = std::error_code(error_code, std::generic_category());
+    write(std::back_inserter(out), std::system_error(ec, message).what());
+    return;
   }
   FMT_CATCH(...) {}
   format_error_code(out, error_code, message);
 }
 
-FMT_FUNC void detail::error_handler::on_error(const char* message) {
-  FMT_THROW(format_error(message));
-}
-
 FMT_FUNC void report_system_error(int error_code,
-                                  fmt::string_view message) FMT_NOEXCEPT {
+                                  const char* message) FMT_NOEXCEPT {
   report_error(format_system_error, error_code, message);
 }
 
-FMT_FUNC std::string detail::vformat(string_view format_str, format_args args) {
-  if (format_str.size() == 2 && equal2(format_str.data(), "{}")) {
-    auto arg = args.get(0);
-    if (!arg) error_handler().on_error("argument not found");
-    return visit_format_arg(stringifier(), arg);
-  }
-  memory_buffer buffer;
-  detail::vformat_to(buffer, format_str, args);
+// DEPRECATED!
+// This function is defined here and not inline for ABI compatiblity.
+FMT_FUNC void detail::error_handler::on_error(const char* message) {
+  throw_format_error(message);
+}
+
+FMT_FUNC std::string vformat(string_view fmt, format_args args) {
+  // Don't optimize the "{}" case to keep the binary size small and because it
+  // can be better optimized in fmt::format anyway.
+  auto buffer = memory_buffer();
+  detail::vformat_to(buffer, fmt, args);
   return to_string(buffer);
 }
 
@@ -2761,24 +2597,30 @@ extern "C" __declspec(dllimport) int __stdcall WriteConsoleW(  //
 }  // namespace detail
 #endif
 
-FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) {
-  memory_buffer buffer;
-  detail::vformat_to(buffer, format_str,
-                     basic_format_args<buffer_context<char>>(args));
+namespace detail {
+FMT_FUNC void print(std::FILE* f, string_view text) {
 #ifdef _WIN32
   auto fd = _fileno(f);
   if (_isatty(fd)) {
-    detail::utf8_to_utf16 u16(string_view(buffer.data(), buffer.size()));
+    detail::utf8_to_utf16 u16(string_view(text.data(), text.size()));
     auto written = detail::dword();
-    if (!detail::WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)),
-                               u16.c_str(), static_cast<uint32_t>(u16.size()),
-                               &written, nullptr)) {
-      FMT_THROW(format_error("failed to write to console"));
+    if (detail::WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)),
+                              u16.c_str(), static_cast<uint32_t>(u16.size()),
+                              &written, nullptr)) {
+      return;
     }
-    return;
+    // Fallback to fwrite on failure. It can happen if the output has been
+    // redirected to NUL.
   }
 #endif
-  detail::fwrite_fully(buffer.data(), 1, buffer.size(), f);
+  detail::fwrite_fully(text.data(), 1, text.size(), f);
+}
+}  // namespace detail
+
+FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) {
+  memory_buffer buffer;
+  detail::vformat_to(buffer, format_str, args);
+  detail::print(f, {buffer.data(), buffer.size()});
 }
 
 #ifdef _WIN32
diff --git a/deps/fmt/include/fmt/format.h b/deps/fmt/include/fmt/format.h
index 1a037b02..ee69651c 100644
--- a/deps/fmt/include/fmt/format.h
+++ b/deps/fmt/include/fmt/format.h
@@ -33,22 +33,24 @@
 #ifndef FMT_FORMAT_H_
 #define FMT_FORMAT_H_
 
-#include <algorithm>
-#include <cerrno>
-#include <cmath>
-#include <cstdint>
-#include <limits>
-#include <memory>
-#include <stdexcept>
+#include <cmath>         // std::signbit
+#include <cstdint>       // uint32_t
+#include <limits>        // std::numeric_limits
+#include <memory>        // std::uninitialized_copy
+#include <stdexcept>     // std::runtime_error
+#include <system_error>  // std::system_error
+#include <utility>       // std::swap
+
+#ifdef __cpp_lib_bit_cast
+#  include <bit>  // std::bitcast
+#endif
 
 #include "core.h"
 
-#ifdef __INTEL_COMPILER
-#  define FMT_ICC_VERSION __INTEL_COMPILER
-#elif defined(__ICL)
-#  define FMT_ICC_VERSION __ICL
+#if FMT_GCC_VERSION
+#  define FMT_GCC_VISIBILITY_HIDDEN __attribute__((visibility("hidden")))
 #else
-#  define FMT_ICC_VERSION 0
+#  define FMT_GCC_VISIBILITY_HIDDEN
 #endif
 
 #ifdef __NVCC__
@@ -69,30 +71,10 @@
 #  define FMT_NOINLINE
 #endif
 
-#if __cplusplus == 201103L || __cplusplus == 201402L
-#  if defined(__INTEL_COMPILER) || defined(__PGI)
-#    define FMT_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
-#elif FMT_HAS_CPP17_ATTRIBUTE(fallthrough) || \
-    (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-#  define FMT_FALLTHROUGH [[fallthrough]]
+#if FMT_MSC_VER
+#  define FMT_MSC_DEFAULT = default
 #else
-#  define FMT_FALLTHROUGH
-#endif
-
-#ifndef FMT_MAYBE_UNUSED
-#  if FMT_HAS_CPP17_ATTRIBUTE(maybe_unused)
-#    define FMT_MAYBE_UNUSED [[maybe_unused]]
-#  else
-#    define FMT_MAYBE_UNUSED
-#  endif
+#  define FMT_MSC_DEFAULT
 #endif
 
 #ifndef FMT_THROW
@@ -113,10 +95,9 @@ FMT_END_NAMESPACE
 #      define FMT_THROW(x) throw x
 #    endif
 #  else
-#    define FMT_THROW(x)              \
-      do {                            \
-        static_cast<void>(sizeof(x)); \
-        FMT_ASSERT(false, "");        \
+#    define FMT_THROW(x)               \
+      do {                             \
+        FMT_ASSERT(false, (x).what()); \
       } while (false)
 #  endif
 #endif
@@ -129,6 +110,21 @@ FMT_END_NAMESPACE
 #  define FMT_CATCH(x) if (false)
 #endif
 
+#ifndef FMT_MAYBE_UNUSED
+#  if FMT_HAS_CPP17_ATTRIBUTE(maybe_unused)
+#    define FMT_MAYBE_UNUSED [[maybe_unused]]
+#  else
+#    define FMT_MAYBE_UNUSED
+#  endif
+#endif
+
+// Workaround broken [[deprecated]] in the Intel, PGI and NVCC compilers.
+#if FMT_ICC_VERSION || defined(__PGI) || FMT_NVCC
+#  define FMT_DEPRECATED_ALIAS
+#else
+#  define FMT_DEPRECATED_ALIAS FMT_DEPRECATED
+#endif
+
 #ifndef FMT_USE_USER_DEFINED_LITERALS
 // EDG based compilers (Intel, NVIDIA, Elbrus, etc), GCC and MSVC support UDLs.
 #  if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || \
@@ -140,53 +136,34 @@ FMT_END_NAMESPACE
 #  endif
 #endif
 
-#ifndef FMT_USE_UDL_TEMPLATE
-// EDG frontend based compilers (icc, nvcc, PGI, etc) and GCC < 6.4 do not
-// properly support UDL templates and GCC >= 9 warns about them.
-#  if FMT_USE_USER_DEFINED_LITERALS &&                         \
-      (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 501) && \
-      ((FMT_GCC_VERSION >= 604 && __cplusplus >= 201402L) ||   \
-       FMT_CLANG_VERSION >= 304) &&                            \
-      !defined(__PGI) && !defined(__NVCC__)
-#    define FMT_USE_UDL_TEMPLATE 1
-#  else
-#    define FMT_USE_UDL_TEMPLATE 0
-#  endif
-#endif
-
-#ifndef FMT_USE_FLOAT
-#  define FMT_USE_FLOAT 1
-#endif
-
-#ifndef FMT_USE_DOUBLE
-#  define FMT_USE_DOUBLE 1
-#endif
-
-#ifndef FMT_USE_LONG_DOUBLE
-#  define FMT_USE_LONG_DOUBLE 1
-#endif
-
 // Defining FMT_REDUCE_INT_INSTANTIATIONS to 1, will reduce the number of
-// int_writer template instances 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.
+// 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_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clz)) && !FMT_MSC_VER
-#  define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
+// https://github.com/fmtlib/fmt/issues/519.
+#if !FMT_MSC_VER
+#  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
-#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clzll)) && !FMT_MSC_VER
-#  define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
-#endif
-#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_ctz))
-#  define FMT_BUILTIN_CTZ(n) __builtin_ctz(n)
-#endif
-#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_ctzll))
-#  define FMT_BUILTIN_CTZLL(n) __builtin_ctzll(n)
+
+// __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
+#    define FMT_BUILTIN_CTZ(n) __builtin_ctz(n)
+#  endif
+#  if FMT_HAS_BUILTIN(__builtin_ctzll) || FMT_GCC_VERSION || FMT_ICC_VERSION
+#    define FMT_BUILTIN_CTZLL(n) __builtin_ctzll(n)
+#  endif
 #endif
 
 #if FMT_MSC_VER
@@ -196,33 +173,32 @@ FMT_END_NAMESPACE
 // 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_VER && !defined(FMT_BUILTIN_CLZLL) && \
-    !defined(FMT_BUILTIN_CTZLL) && !defined(_MANAGED)
+#if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(FMT_BUILTIN_CTZLL)
 FMT_BEGIN_NAMESPACE
 namespace detail {
 // Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning.
-#  ifndef __clang__
+#  if !defined(__clang__)
 #    pragma intrinsic(_BitScanForward)
 #    pragma intrinsic(_BitScanReverse)
-#  endif
-#  if defined(_WIN64) && !defined(__clang__)
-#    pragma intrinsic(_BitScanForward64)
-#    pragma intrinsic(_BitScanReverse64)
+#    if defined(_WIN64)
+#      pragma intrinsic(_BitScanForward64)
+#      pragma intrinsic(_BitScanReverse64)
+#    endif
 #  endif
 
-inline int clz(uint32_t x) {
+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_SUPPRESS_MSC_WARNING(6102)
+  FMT_MSC_WARNING(suppress : 6102)
   return 31 ^ static_cast<int>(r);
 }
 #  define FMT_BUILTIN_CLZ(n) detail::clz(n)
 
-inline int clzll(uint64_t x) {
+inline auto clzll(uint64_t x) -> int {
   unsigned long r = 0;
 #  ifdef _WIN64
   _BitScanReverse64(&r, x);
@@ -233,24 +209,24 @@ inline int clzll(uint64_t x) {
   _BitScanReverse(&r, static_cast<uint32_t>(x));
 #  endif
   FMT_ASSERT(x != 0, "");
-  FMT_SUPPRESS_MSC_WARNING(6102)  // Suppress a bogus static analysis warning.
+  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 int ctz(uint32_t x) {
+inline auto ctz(uint32_t x) -> int {
   unsigned long r = 0;
   _BitScanForward(&r, x);
   FMT_ASSERT(x != 0, "");
-  FMT_SUPPRESS_MSC_WARNING(6102)  // Suppress a bogus static analysis warning.
+  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 int ctzll(uint64_t x) {
+inline auto ctzll(uint64_t x) -> int {
   unsigned long r = 0;
   FMT_ASSERT(x != 0, "");
-  FMT_SUPPRESS_MSC_WARNING(6102)  // Suppress a bogus static analysis warning.
+  FMT_MSC_WARNING(suppress : 6102)  // Suppress a bogus static analysis warning.
 #  ifdef _WIN64
   _BitScanForward64(&r, x);
 #  else
@@ -267,31 +243,71 @@ inline int ctzll(uint64_t x) {
 FMT_END_NAMESPACE
 #endif
 
-// Enable the deprecated numeric alignment.
-#ifndef FMT_DEPRECATED_NUMERIC_ALIGN
-#  define FMT_DEPRECATED_NUMERIC_ALIGN 0
+#ifdef FMT_HEADER_ONLY
+#  define FMT_HEADER_ONLY_CONSTEXPR20 FMT_CONSTEXPR20
+#else
+#  define FMT_HEADER_ONLY_CONSTEXPR20
 #endif
 
 FMT_BEGIN_NAMESPACE
 namespace detail {
 
-// An equivalent of `*reinterpret_cast<Dest*>(&source)` that doesn't have
-// undefined behavior (e.g. due to type aliasing).
-// Example: uint64_t d = bit_cast<uint64_t>(2.718);
-template <typename Dest, typename Source>
-inline Dest bit_cast(const Source& source) {
-  static_assert(sizeof(Dest) == sizeof(Source), "size mismatch");
-  Dest dest;
-  std::memcpy(&dest, &source, sizeof(dest));
-  return dest;
+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;
+  }
+};
+
+// Implementation of std::bit_cast for pre-C++20.
+template <typename To, typename From>
+FMT_CONSTEXPR20 auto bit_cast(const From& from) -> To {
+  static_assert(sizeof(To) == sizeof(From), "size mismatch");
+#ifdef __cpp_lib_bit_cast
+  if (is_constant_evaluated()) return std::bit_cast<To>(from);
+#endif
+  auto to = To();
+  std::memcpy(&to, &from, sizeof(to));
+  return to;
 }
 
-inline bool is_big_endian() {
-  const auto u = 1u;
+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(u)];
+    char data[sizeof(int)];
   };
-  return bit_cast<bytes>(u).data[0] == 0;
+  return bit_cast<bytes>(1).data[0] == 0;
+#endif
 }
 
 // A fallback implementation of uintptr_t for systems that lack it.
@@ -301,7 +317,7 @@ struct fallback_uintptr {
   fallback_uintptr() = default;
   explicit fallback_uintptr(const void* p) {
     *this = bit_cast<fallback_uintptr>(p);
-    if (is_big_endian()) {
+    if (const_check(is_big_endian())) {
       for (size_t i = 0, j = sizeof(void*) - 1; i < j; ++i, --j)
         std::swap(value[i], value[j]);
     }
@@ -309,26 +325,28 @@ struct fallback_uintptr {
 };
 #ifdef UINTPTR_MAX
 using uintptr_t = ::uintptr_t;
-inline uintptr_t to_uintptr(const void* p) { return bit_cast<uintptr_t>(p); }
+inline auto to_uintptr(const void* p) -> uintptr_t {
+  return bit_cast<uintptr_t>(p);
+}
 #else
 using uintptr_t = fallback_uintptr;
-inline fallback_uintptr to_uintptr(const void* p) {
+inline auto to_uintptr(const void* p) -> fallback_uintptr {
   return fallback_uintptr(p);
 }
 #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 T max_value() {
+template <typename T> constexpr auto max_value() -> T {
   return (std::numeric_limits<T>::max)();
 }
-template <typename T> constexpr int num_bits() {
+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 int num_bits<int128_t>() { return 128; }
-template <> constexpr int num_bits<uint128_t>() { return 128; }
-template <> constexpr int num_bits<fallback_uintptr>() {
+template <> constexpr auto num_bits<int128_t>() -> int { return 128; }
+template <> constexpr auto num_bits<uint128_t>() -> int { return 128; }
+template <> constexpr auto num_bits<fallback_uintptr>() -> int {
   return static_cast<int>(sizeof(void*) *
                           std::numeric_limits<unsigned char>::digits);
 }
@@ -346,31 +364,38 @@ using iterator_t = decltype(std::begin(std::declval<T&>()));
 template <typename T> using sentinel_t = decltype(std::end(std::declval<T&>()));
 
 // A workaround for std::string not having mutable data() until C++17.
-template <typename Char> inline Char* get_data(std::basic_string<Char>& s) {
+template <typename Char>
+inline auto get_data(std::basic_string<Char>& s) -> Char* {
   return &s[0];
 }
 template <typename Container>
-inline typename Container::value_type* get_data(Container& c) {
+inline auto get_data(Container& c) -> typename Container::value_type* {
   return c.data();
 }
 
 #if defined(_SECURE_SCL) && _SECURE_SCL
 // Make a checked iterator to avoid MSVC warnings.
 template <typename T> using checked_ptr = stdext::checked_array_iterator<T*>;
-template <typename T> checked_ptr<T> make_checked(T* p, size_t size) {
+template <typename T>
+constexpr auto make_checked(T* p, size_t size) -> checked_ptr<T> {
   return {p, size};
 }
 #else
 template <typename T> using checked_ptr = T*;
-template <typename T> inline T* make_checked(T* p, size_t) { return p; }
+template <typename T> constexpr auto make_checked(T* p, size_t) -> T* {
+  return p;
+}
 #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 Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
-#if FMT_CLANG_VERSION
+#if FMT_CLANG_VERSION >= 307 && !FMT_ICC_VERSION
 __attribute__((no_sanitize("undefined")))
 #endif
-inline checked_ptr<typename Container::value_type>
-reserve(std::back_insert_iterator<Container> it, size_t n) {
+inline auto
+reserve(std::back_insert_iterator<Container> it, size_t n)
+    -> checked_ptr<typename Container::value_type> {
   Container& c = get_container(it);
   size_t size = c.size();
   c.resize(size + n);
@@ -378,21 +403,26 @@ reserve(std::back_insert_iterator<Container> it, size_t n) {
 }
 
 template <typename T>
-inline buffer_appender<T> reserve(buffer_appender<T> it, size_t n) {
+inline auto reserve(buffer_appender<T> it, size_t n) -> buffer_appender<T> {
   buffer<T>& buf = get_container(it);
   buf.try_reserve(buf.size() + n);
   return it;
 }
 
-template <typename Iterator> inline Iterator& reserve(Iterator& it, size_t) {
+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 T* to_pointer(OutputIt, size_t) {
+constexpr auto to_pointer(OutputIt, size_t) -> T* {
   return nullptr;
 }
-template <typename T> T* to_pointer(buffer_appender<T> it, size_t n) {
+template <typename T> auto to_pointer(buffer_appender<T> it, size_t n) -> T* {
   buffer<T>& buf = get_container(it);
   auto size = buf.size();
   if (buf.capacity() < size + n) return nullptr;
@@ -401,195 +431,195 @@ template <typename T> T* to_pointer(buffer_appender<T> it, size_t n) {
 }
 
 template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
-inline std::back_insert_iterator<Container> base_iterator(
-    std::back_insert_iterator<Container>& it,
-    checked_ptr<typename Container::value_type>) {
+inline auto base_iterator(std::back_insert_iterator<Container>& it,
+                          checked_ptr<typename Container::value_type>)
+    -> std::back_insert_iterator<Container> {
   return it;
 }
 
 template <typename Iterator>
-inline Iterator base_iterator(Iterator, Iterator it) {
+constexpr auto base_iterator(Iterator, Iterator it) -> Iterator {
   return it;
 }
 
-// An output iterator that counts the number of objects written to it and
-// discards them.
-class counting_iterator {
- private:
-  size_t count_;
+// <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;
+}
 
- public:
-  using iterator_category = std::output_iterator_tag;
-  using difference_type = std::ptrdiff_t;
-  using pointer = void;
-  using reference = void;
-  using _Unchecked_type = counting_iterator;  // Mark iterator as checked.
+#ifdef __cpp_char8_t
+using char8_type = char8_t;
+#else
+enum char8_type : unsigned char {};
+#endif
 
-  struct value_type {
-    template <typename T> void operator=(const T&) {}
+template <typename OutChar, typename InputIt, typename OutputIt>
+FMT_CONSTEXPR FMT_NOINLINE auto copy_str_noinline(InputIt begin, InputIt end,
+                                                  OutputIt out) -> OutputIt {
+  return copy_str<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 = code_point_length(s);
+  const char* next = s + len;
+
+  // Assume a four-byte character and load four bytes. Unused bits are
+  // shifted out.
+  *c = uint32_t(s[0] & masks[len]) << 18;
+  *c |= uint32_t(s[1] & 0x3f) << 12;
+  *c |= uint32_t(s[2] & 0x3f) << 6;
+  *c |= uint32_t(s[3] & 0x3f) << 0;
+  *c >>= shiftc[len];
+
+  // Accumulate the various error conditions.
+  using uchar = unsigned char;
+  *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 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, to_unsigned(end - buf_ptr)));
+    return result ? end : nullptr;
   };
-
-  counting_iterator() : count_(0) {}
-
-  size_t count() const { return count_; }
-
-  counting_iterator& operator++() {
-    ++count_;
-    return *this;
+  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;
+    }
   }
-  counting_iterator operator++(int) {
-    auto it = *this;
-    ++*this;
-    return it;
+  if (auto num_chars_left = s.data() + s.size() - p) {
+    char buf[2 * block_size - 1] = {};
+    copy_str<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);
   }
-
-  friend counting_iterator operator+(counting_iterator it, difference_type n) {
-    it.count_ += static_cast<size_t>(n);
-    return it;
-  }
-
-  value_type operator*() const { return {}; }
-};
-
-template <typename OutputIt> class truncating_iterator_base {
- protected:
-  OutputIt out_;
-  size_t limit_;
-  size_t count_;
-
-  truncating_iterator_base(OutputIt out, size_t limit)
-      : out_(out), limit_(limit), count_(0) {}
-
- public:
-  using iterator_category = std::output_iterator_tag;
-  using value_type = typename std::iterator_traits<OutputIt>::value_type;
-  using difference_type = void;
-  using pointer = void;
-  using reference = void;
-  using _Unchecked_type =
-      truncating_iterator_base;  // Mark iterator as checked.
-
-  OutputIt base() const { return out_; }
-  size_t count() const { return count_; }
-};
-
-// An output iterator that truncates the output and counts the number of objects
-// written to it.
-template <typename OutputIt,
-          typename Enable = typename std::is_void<
-              typename std::iterator_traits<OutputIt>::value_type>::type>
-class truncating_iterator;
-
-template <typename OutputIt>
-class truncating_iterator<OutputIt, std::false_type>
-    : public truncating_iterator_base<OutputIt> {
-  mutable typename truncating_iterator_base<OutputIt>::value_type blackhole_;
-
- public:
-  using value_type = typename truncating_iterator_base<OutputIt>::value_type;
-
-  truncating_iterator(OutputIt out, size_t limit)
-      : truncating_iterator_base<OutputIt>(out, limit) {}
-
-  truncating_iterator& operator++() {
-    if (this->count_++ < this->limit_) ++this->out_;
-    return *this;
-  }
-
-  truncating_iterator operator++(int) {
-    auto it = *this;
-    ++*this;
-    return it;
-  }
-
-  value_type& operator*() const {
-    return this->count_ < this->limit_ ? *this->out_ : blackhole_;
-  }
-};
-
-template <typename OutputIt>
-class truncating_iterator<OutputIt, std::true_type>
-    : public truncating_iterator_base<OutputIt> {
- public:
-  truncating_iterator(OutputIt out, size_t limit)
-      : truncating_iterator_base<OutputIt>(out, limit) {}
-
-  template <typename T> truncating_iterator& operator=(T val) {
-    if (this->count_++ < this->limit_) *this->out_++ = val;
-    return *this;
-  }
-
-  truncating_iterator& operator++() { return *this; }
-  truncating_iterator& operator++(int) { return *this; }
-  truncating_iterator& operator*() { return *this; }
-};
+}
 
 template <typename Char>
-inline size_t count_code_points(basic_string_view<Char> s) {
+inline auto compute_width(basic_string_view<Char> s) -> size_t {
   return s.size();
 }
 
-// Counts the number of code points in a UTF-8 string.
-inline size_t count_code_points(basic_string_view<char> s) {
-  const char* data = s.data();
+// Computes approximate display width of a UTF-8 string.
+FMT_CONSTEXPR inline size_t compute_width(string_view s) {
   size_t num_code_points = 0;
-  for (size_t i = 0, size = s.size(); i != size; ++i) {
-    if ((data[i] & 0xc0) != 0x80) ++num_code_points;
-  }
+  // 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 += detail::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;
+    }
+  };
+  for_each_codepoint(s, count_code_points{&num_code_points});
   return num_code_points;
 }
 
-inline size_t count_code_points(basic_string_view<char8_type> s) {
-  return count_code_points(basic_string_view<char>(
+inline auto compute_width(basic_string_view<char8_type> s) -> size_t {
+  return compute_width(basic_string_view<char>(
       reinterpret_cast<const char*>(s.data()), s.size()));
 }
 
 template <typename Char>
-inline size_t code_point_index(basic_string_view<Char> s, size_t n) {
+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 size_t code_point_index(basic_string_view<char8_type> s, size_t n) {
+inline auto code_point_index(basic_string_view<char8_type> s, size_t n)
+    -> size_t {
   const char8_type* data = s.data();
   size_t num_code_points = 0;
   for (size_t i = 0, size = s.size(); i != size; ++i) {
-    if ((data[i] & 0xc0) != 0x80 && ++num_code_points > n) {
-      return i;
-    }
+    if ((data[i] & 0xc0) != 0x80 && ++num_code_points > n) return i;
   }
   return s.size();
 }
 
-template <typename InputIt, typename OutChar>
-using needs_conversion = bool_constant<
-    std::is_same<typename std::iterator_traits<InputIt>::value_type,
-                 char>::value &&
-    std::is_same<OutChar, char8_type>::value>;
-
-template <typename OutChar, typename InputIt, typename OutputIt,
-          FMT_ENABLE_IF(!needs_conversion<InputIt, OutChar>::value)>
-OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
-  return std::copy(begin, end, it);
-}
-
-template <typename OutChar, typename InputIt, typename OutputIt,
-          FMT_ENABLE_IF(needs_conversion<InputIt, OutChar>::value)>
-OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
-  return std::transform(begin, end, it,
-                        [](char c) { return static_cast<char8_type>(c); });
-}
-
-template <typename Char, typename InputIt>
-inline counting_iterator copy_str(InputIt begin, InputIt end,
-                                  counting_iterator it) {
-  return it + (end - begin);
-}
-
-template <typename T>
-using is_fast_float = bool_constant<std::numeric_limits<T>::is_iec559 &&
-                                    sizeof(T) <= sizeof(double)>;
+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 {};
 
 #ifndef FMT_USE_FULL_CACHE_DRAGONBOX
 #  define FMT_USE_FULL_CACHE_DRAGONBOX 0
@@ -598,7 +628,7 @@ using is_fast_float = bool_constant<std::numeric_limits<T>::is_iec559 &&
 template <typename T>
 template <typename U>
 void buffer<T>::append(const U* begin, const U* end) {
-  do {
+  while (begin != end) {
     auto count = to_unsigned(end - begin);
     try_reserve(size_ + count);
     auto free_cap = capacity_ - size_;
@@ -606,16 +636,17 @@ void buffer<T>::append(const U* begin, const U* end) {
     std::uninitialized_copy_n(begin, count, make_checked(ptr_ + size_, count));
     size_ += count;
     begin += count;
-  } while (begin != end);
+  }
 }
 
-template <typename OutputIt, typename T, typename Traits>
-void iterator_buffer<OutputIt, T, Traits>::flush() {
-  out_ = std::copy_n(data_, this->limit(this->size()), out_);
-  this->clear();
-}
+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 {};
 }  // namespace detail
 
+FMT_MODULE_EXPORT_BEGIN
+
 // The number of characters to store in the basic_memory_buffer object itself
 // to avoid dynamic memory allocation.
 enum { inline_buffer_size = 500 };
@@ -625,20 +656,12 @@ 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.
 
-  You can use one of the following type aliases for common character types:
-
-  +----------------+------------------------------+
-  | Type           | Definition                   |
-  +================+==============================+
-  | memory_buffer  | basic_memory_buffer<char>    |
-  +----------------+------------------------------+
-  | wmemory_buffer | basic_memory_buffer<wchar_t> |
-  +----------------+------------------------------+
+  You can use the ``memory_buffer`` type alias for ``char`` instead.
 
   **Example**::
 
-     fmt::memory_buffer out;
-     format_to(out, "The answer is {}.", 42);
+     auto out = fmt::memory_buffer();
+     format_to(std::back_inserter(out), "The answer is {}.", 42);
 
   This will append the following output to the ``out`` object:
 
@@ -659,34 +682,43 @@ class basic_memory_buffer final : public detail::buffer<T> {
   Allocator alloc_;
 
   // Deallocate memory allocated by the buffer.
-  void deallocate() {
+  FMT_CONSTEXPR20 void deallocate() {
     T* data = this->data();
     if (data != store_) alloc_.deallocate(data, this->capacity());
   }
 
  protected:
-  void grow(size_t size) final FMT_OVERRIDE;
+  FMT_CONSTEXPR20 void grow(size_t size) override;
 
  public:
   using value_type = T;
   using const_reference = const T&;
 
-  explicit basic_memory_buffer(const Allocator& alloc = Allocator())
+  FMT_CONSTEXPR20 explicit basic_memory_buffer(
+      const Allocator& alloc = Allocator())
       : alloc_(alloc) {
     this->set(store_, SIZE);
+    if (detail::is_constant_evaluated()) {
+      detail::fill_n(store_, SIZE, T{});
+    }
   }
-  ~basic_memory_buffer() { deallocate(); }
+  FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); }
 
  private:
   // Move data from other to this buffer.
-  void move(basic_memory_buffer& other) {
+  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);
-      std::uninitialized_copy(other.store_, other.store_ + size,
-                              detail::make_checked(store_, capacity));
+      if (detail::is_constant_evaluated()) {
+        detail::copy_str<T>(other.store_, other.store_ + size,
+                            detail::make_checked(store_, capacity));
+      } else {
+        std::uninitialized_copy(other.store_, other.store_ + size,
+                                detail::make_checked(store_, capacity));
+      }
     } else {
       this->set(data, capacity);
       // Set pointer to the inline array so that delete is not called
@@ -703,14 +735,18 @@ class basic_memory_buffer final : public detail::buffer<T> {
     of the other object to it.
     \endrst
    */
-  basic_memory_buffer(basic_memory_buffer&& other) FMT_NOEXCEPT { move(other); }
+  FMT_CONSTEXPR20 basic_memory_buffer(basic_memory_buffer&& other)
+      FMT_NOEXCEPT {
+    move(other);
+  }
 
   /**
     \rst
     Moves the content of the other ``basic_memory_buffer`` object to this one.
     \endrst
    */
-  basic_memory_buffer& operator=(basic_memory_buffer&& other) FMT_NOEXCEPT {
+  auto operator=(basic_memory_buffer&& other) FMT_NOEXCEPT
+      -> basic_memory_buffer& {
     FMT_ASSERT(this != &other, "");
     deallocate();
     move(other);
@@ -718,13 +754,13 @@ class basic_memory_buffer final : public detail::buffer<T> {
   }
 
   // Returns a copy of the allocator associated with this buffer.
-  Allocator get_allocator() const { return alloc_; }
+  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.
    */
-  void resize(size_t count) { this->try_resize(count); }
+  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); }
@@ -738,13 +774,18 @@ class basic_memory_buffer final : public detail::buffer<T> {
 };
 
 template <typename T, size_t SIZE, typename Allocator>
-void basic_memory_buffer<T, SIZE, Allocator>::grow(size_t size) {
+FMT_CONSTEXPR20 void basic_memory_buffer<T, SIZE, Allocator>::grow(
+    size_t size) {
 #ifdef FMT_FUZZ
   if (size > 5000) throw std::runtime_error("fuzz mode - won't grow that much");
 #endif
+  const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_);
   size_t old_capacity = this->capacity();
   size_t new_capacity = old_capacity + old_capacity / 2;
-  if (size > new_capacity) new_capacity = size;
+  if (size > new_capacity)
+    new_capacity = size;
+  else if (new_capacity > max_size)
+    new_capacity = size > max_size ? size : max_size;
   T* old_data = this->data();
   T* new_data =
       std::allocator_traits<Allocator>::allocate(alloc_, new_capacity);
@@ -759,12 +800,15 @@ void basic_memory_buffer<T, SIZE, Allocator>::grow(size_t size) {
 }
 
 using memory_buffer = basic_memory_buffer<char>;
-using wmemory_buffer = basic_memory_buffer<wchar_t>;
 
 template <typename T, size_t SIZE, typename Allocator>
 struct is_contiguous<basic_memory_buffer<T, SIZE, Allocator>> : std::true_type {
 };
 
+namespace detail {
+FMT_API void print(std::FILE*, string_view);
+}
+
 /** A formatting error such as invalid format string. */
 FMT_CLASS_API
 class FMT_API format_error : public std::runtime_error {
@@ -776,10 +820,62 @@ class FMT_API format_error : public std::runtime_error {
   format_error& operator=(const format_error&) = default;
   format_error(format_error&&) = default;
   format_error& operator=(format_error&&) = default;
-  ~format_error() FMT_NOEXCEPT FMT_OVERRIDE;
+  ~format_error() FMT_NOEXCEPT override FMT_MSC_DEFAULT;
 };
 
-namespace detail {
+/**
+  \rst
+  Constructs a `~fmt::format_arg_store` object that contains references
+  to arguments and can be implicitly converted to `~fmt::format_args`.
+  If ``fmt`` is a compile-time string then `make_args_checked` checks
+  its validity at compile time.
+  \endrst
+ */
+template <typename... Args, typename S, typename Char = char_t<S>>
+FMT_INLINE auto make_args_checked(const S& fmt,
+                                  const remove_reference_t<Args>&... args)
+    -> format_arg_store<buffer_context<Char>, remove_reference_t<Args>...> {
+  static_assert(
+      detail::count<(
+              std::is_base_of<detail::view, remove_reference_t<Args>>::value &&
+              std::is_reference<Args>::value)...>() == 0,
+      "passing views as lvalues is disallowed");
+  detail::check_format_string<Args...>(fmt);
+  return {args...};
+}
+
+// compile-time support
+namespace detail_exported {
+#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+template <typename Char, size_t N> struct fixed_string {
+  constexpr fixed_string(const Char (&str)[N]) {
+    detail::copy_str<Char, const Char*, Char*>(static_cast<const Char*>(str),
+                                               str + N, data);
+  }
+  Char data[N]{};
+};
+#endif
+
+// 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(detail::std_string_view<Char> s)
+    -> basic_string_view<Char> {
+  return {s.data(), s.size()};
+}
+}  // namespace detail_exported
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+template <typename T> struct is_integral : std::is_integral<T> {};
+template <> struct is_integral<int128_t> : std::true_type {};
+template <> struct is_integral<uint128_t> : std::true_type {};
 
 template <typename T>
 using is_signed =
@@ -789,16 +885,16 @@ using is_signed =
 // 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)>
-FMT_CONSTEXPR bool is_negative(T value) {
+FMT_CONSTEXPR auto is_negative(T value) -> bool {
   return value < 0;
 }
 template <typename T, FMT_ENABLE_IF(!is_signed<T>::value)>
-FMT_CONSTEXPR bool is_negative(T) {
+FMT_CONSTEXPR auto is_negative(T) -> bool {
   return false;
 }
 
 template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-FMT_CONSTEXPR bool is_supported_floating_point(T) {
+FMT_CONSTEXPR auto is_supported_floating_point(T) -> uint16_t {
   return (std::is_same<T, float>::value && FMT_USE_FLOAT) ||
          (std::is_same<T, double>::value && FMT_USE_DOUBLE) ||
          (std::is_same<T, long double>::value && FMT_USE_LONG_DOUBLE);
@@ -811,121 +907,33 @@ 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>;
 
-// 128-bit integer type used internally
-struct FMT_EXTERN_TEMPLATE_API uint128_wrapper {
-  uint128_wrapper() = default;
+#define FMT_POWERS_OF_10(factor)                                             \
+  factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000, \
+      (factor)*1000000, (factor)*10000000, (factor)*100000000,               \
+      (factor)*1000000000
 
-#if FMT_USE_INT128
-  uint128_t internal_;
-
-  uint128_wrapper(uint64_t high, uint64_t low) FMT_NOEXCEPT
-      : internal_{static_cast<uint128_t>(low) |
-                  (static_cast<uint128_t>(high) << 64)} {}
-
-  uint128_wrapper(uint128_t u) : internal_{u} {}
-
-  uint64_t high() const FMT_NOEXCEPT { return uint64_t(internal_ >> 64); }
-  uint64_t low() const FMT_NOEXCEPT { return uint64_t(internal_); }
-
-  uint128_wrapper& operator+=(uint64_t n) FMT_NOEXCEPT {
-    internal_ += n;
-    return *this;
-  }
-#else
-  uint64_t high_;
-  uint64_t low_;
-
-  uint128_wrapper(uint64_t high, uint64_t low) FMT_NOEXCEPT : high_{high},
-                                                              low_{low} {}
-
-  uint64_t high() const FMT_NOEXCEPT { return high_; }
-  uint64_t low() const FMT_NOEXCEPT { return low_; }
-
-  uint128_wrapper& operator+=(uint64_t n) FMT_NOEXCEPT {
-#  if defined(_MSC_VER) && defined(_M_X64)
-    unsigned char carry = _addcarry_u64(0, low_, n, &low_);
-    _addcarry_u64(carry, high_, 0, &high_);
-    return *this;
-#  else
-    uint64_t sum = low_ + n;
-    high_ += (sum < low_ ? 1 : 0);
-    low_ = sum;
-    return *this;
-#  endif
-  }
-#endif
-};
-
-// Table entry type for divisibility test used internally
-template <typename T> struct FMT_EXTERN_TEMPLATE_API divtest_table_entry {
-  T mod_inv;
-  T max_quotient;
-};
-
-// Static data is placed in this class template for the header-only config.
-template <typename T = void> struct FMT_EXTERN_TEMPLATE_API basic_data {
-  static const uint64_t powers_of_10_64[];
-  static const uint32_t zero_or_powers_of_10_32_new[];
-  static const uint64_t zero_or_powers_of_10_64_new[];
-  static const uint64_t grisu_pow10_significands[];
-  static const int16_t grisu_pow10_exponents[];
-  static const divtest_table_entry<uint32_t> divtest_table_for_pow5_32[];
-  static const divtest_table_entry<uint64_t> divtest_table_for_pow5_64[];
-  static const uint64_t dragonbox_pow10_significands_64[];
-  static const uint128_wrapper dragonbox_pow10_significands_128[];
-  // log10(2) = 0x0.4d104d427de7fbcc...
-  static const uint64_t log10_2_significand = 0x4d104d427de7fbcc;
-#if !FMT_USE_FULL_CACHE_DRAGONBOX
-  static const uint64_t powers_of_5_64[];
-  static const uint32_t dragonbox_pow10_recovery_errors[];
-#endif
-  // GCC generates slightly better code for pairs than chars.
-  using digit_pair = char[2];
-  static const digit_pair digits[];
-  static const char hex_digits[];
-  static const char foreground_color[];
-  static const char background_color[];
-  static const char reset_color[5];
-  static const wchar_t wreset_color[5];
-  static const char signs[];
-  static const char left_padding_shifts[5];
-  static const char right_padding_shifts[5];
-
-  // DEPRECATED! These are for ABI compatibility.
-  static const uint32_t zero_or_powers_of_10_32[];
-  static const uint64_t zero_or_powers_of_10_64[];
-};
-
-// Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)).
-// This is a function instead of an array to workaround a bug in GCC10 (#1810).
-FMT_INLINE uint16_t bsr2log10(int bsr) {
-  static constexpr uint16_t data[] = {
-      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};
-  return data[bsr];
+// Converts value in the range [0, 100) to a string.
+constexpr const char* digits2(size_t value) {
+  // GCC generates slightly better code when value is pointer-size.
+  return &"0001020304050607080910111213141516171819"
+         "2021222324252627282930313233343536373839"
+         "4041424344454647484950515253545556575859"
+         "6061626364656667686970717273747576777879"
+         "8081828384858687888990919293949596979899"[value * 2];
 }
 
-#ifndef FMT_EXPORTED
-FMT_EXTERN template struct basic_data<void>;
+// Sign is a template parameter to workaround a bug in gcc 4.8.
+template <typename Char, typename Sign> constexpr Char sign(Sign s) {
+#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 604
+  static_assert(std::is_same<Sign, sign_t>::value, "");
 #endif
-
-// This is a struct rather than an alias to avoid shadowing warnings in gcc.
-struct data : basic_data<> {};
-
-#ifdef FMT_BUILTIN_CLZLL
-// Returns the number of decimal digits in n. Leading zeros are not counted
-// except for n == 0 in which case count_digits returns 1.
-inline int count_digits(uint64_t n) {
-  // https://github.com/fmtlib/format-benchmark/blob/master/digits10
-  auto t = bsr2log10(FMT_BUILTIN_CLZLL(n | 1) ^ 63);
-  return t - (n < data::zero_or_powers_of_10_64_new[t]);
+  return static_cast<Char>("\0-+ "[s]);
 }
-#else
-// Fallback version of count_digits used when __builtin_clz is not available.
-inline int count_digits(uint64_t n) {
+
+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
@@ -939,103 +947,152 @@ inline int count_digits(uint64_t n) {
     count += 4;
   }
 }
-#endif
-
 #if FMT_USE_INT128
-inline int count_digits(uint128_t n) {
-  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;
-  }
+FMT_CONSTEXPR inline auto count_digits(uint128_t 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()) {
+    return do_count_digits(n);
+  }
+#endif
+  return count_digits_fallback(n);
+}
+
 // Counts the number of digits in n. BITS = log2(radix).
-template <unsigned BITS, typename UInt> inline int count_digits(UInt n) {
-  int num_digits = 0;
-  do {
-    ++num_digits;
-  } while ((n >>= BITS) != 0);
-  return num_digits;
+template <int BITS, typename UInt>
+FMT_CONSTEXPR auto count_digits(UInt n) -> int {
+#ifdef FMT_BUILTIN_CLZ
+  if (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);
 }
 
-template <> int count_digits<4>(detail::fallback_uintptr n);
-
-#if FMT_GCC_VERSION || FMT_CLANG_VERSION
-#  define FMT_ALWAYS_INLINE inline __attribute__((always_inline))
-#elif FMT_MSC_VER
-#  define FMT_ALWAYS_INLINE __forceinline
-#else
-#  define FMT_ALWAYS_INLINE inline
-#endif
-
-// To suppress unnecessary security cookie checks
-#if FMT_MSC_VER && !FMT_CLANG_VERSION
-#  define FMT_SAFEBUFFERS __declspec(safebuffers)
-#else
-#  define FMT_SAFEBUFFERS
-#endif
+template <> auto count_digits<4>(detail::fallback_uintptr n) -> int;
 
 #ifdef FMT_BUILTIN_CLZ
-// Optional version of count_digits for better performance on 32-bit platforms.
-inline int count_digits(uint32_t n) {
-  auto t = bsr2log10(FMT_BUILTIN_CLZ(n | 1) ^ 31);
-  return t - (n < data::zero_or_powers_of_10_32_new[t]);
+// 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
 
-template <typename Int> constexpr int digits10() FMT_NOEXCEPT {
+// 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()) {
+    return do_count_digits(n);
+  }
+#endif
+  return count_digits_fallback(n);
+}
+
+template <typename Int> constexpr auto digits10() FMT_NOEXCEPT -> int {
   return std::numeric_limits<Int>::digits10;
 }
-template <> constexpr int digits10<int128_t>() FMT_NOEXCEPT { return 38; }
-template <> constexpr int digits10<uint128_t>() FMT_NOEXCEPT { return 38; }
-
-template <typename Char> FMT_API std::string grouping_impl(locale_ref loc);
-template <typename Char> inline std::string grouping(locale_ref loc) {
-  return grouping_impl<char>(loc);
+template <> constexpr auto digits10<int128_t>() FMT_NOEXCEPT -> int {
+  return 38;
 }
-template <> inline std::string grouping<wchar_t>(locale_ref loc) {
-  return grouping_impl<wchar_t>(loc);
+template <> constexpr auto digits10<uint128_t>() FMT_NOEXCEPT -> int {
+  return 38;
 }
 
-template <typename Char> FMT_API Char thousands_sep_impl(locale_ref loc);
-template <typename Char> inline Char thousands_sep(locale_ref loc) {
-  return Char(thousands_sep_impl<char>(loc));
+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 wchar_t thousands_sep(locale_ref loc) {
+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 Char decimal_point_impl(locale_ref loc);
-template <typename Char> inline Char decimal_point(locale_ref 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 wchar_t decimal_point(locale_ref 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> bool equal2(const Char* lhs, const char* rhs) {
-  return lhs[0] == rhs[0] && lhs[1] == rhs[1];
+template <typename Char> auto equal2(const Char* lhs, const char* rhs) -> bool {
+  return lhs[0] == Char(rhs[0]) && lhs[1] == Char(rhs[1]);
 }
-inline bool equal2(const char* lhs, const char* rhs) {
+inline auto equal2(const char* lhs, const char* rhs) -> bool {
   return memcmp(lhs, rhs, 2) == 0;
 }
 
 // Copies two characters from src to dst.
-template <typename Char> void copy2(Char* dst, const char* src) {
+template <typename Char>
+FMT_CONSTEXPR20 FMT_INLINE void copy2(Char* dst, const char* src) {
+  if (!is_constant_evaluated() && sizeof(Char) == sizeof(char)) {
+    memcpy(dst, src, 2);
+    return;
+  }
   *dst++ = static_cast<Char>(*src++);
   *dst = static_cast<Char>(*src);
 }
-FMT_INLINE void copy2(char* dst, const char* src) { memcpy(dst, src, 2); }
 
 template <typename Iterator> struct format_decimal_result {
   Iterator begin;
@@ -1046,8 +1103,8 @@ template <typename Iterator> struct format_decimal_result {
 // buffer of specified size. The caller must ensure that the buffer is large
 // enough.
 template <typename Char, typename UInt>
-inline format_decimal_result<Char*> format_decimal(Char* out, UInt value,
-                                                   int size) {
+FMT_CONSTEXPR20 auto format_decimal(Char* out, UInt value, int size)
+    -> format_decimal_result<Char*> {
   FMT_ASSERT(size >= count_digits(value), "invalid digit count");
   out += size;
   Char* end = out;
@@ -1056,7 +1113,7 @@ inline format_decimal_result<Char*> format_decimal(Char* out, UInt value,
     // of for every digit. The idea comes from the talk by Alexandrescu
     // "Three Optimization Tips for C++". See speed-test for a comparison.
     out -= 2;
-    copy2(out, data::digits[value % 100]);
+    copy2(out, digits2(static_cast<size_t>(value % 100)));
     value /= 100;
   }
   if (value < 10) {
@@ -1064,27 +1121,27 @@ inline format_decimal_result<Char*> format_decimal(Char* out, UInt value,
     return {out, end};
   }
   out -= 2;
-  copy2(out, data::digits[value]);
+  copy2(out, digits2(static_cast<size_t>(value)));
   return {out, end};
 }
 
 template <typename Char, typename UInt, typename Iterator,
           FMT_ENABLE_IF(!std::is_pointer<remove_cvref_t<Iterator>>::value)>
-inline format_decimal_result<Iterator> format_decimal(Iterator out, UInt value,
-                                                      int size) {
+inline auto format_decimal(Iterator out, UInt value, int size)
+    -> format_decimal_result<Iterator> {
   // Buffer is large enough to hold all digits (digits10 + 1).
   Char buffer[digits10<UInt>() + 1];
   auto end = format_decimal(buffer, value, size).end;
-  return {out, detail::copy_str<Char>(buffer, end, out)};
+  return {out, detail::copy_str_noinline<Char>(buffer, end, out)};
 }
 
 template <unsigned BASE_BITS, typename Char, typename UInt>
-inline Char* format_uint(Char* buffer, UInt value, int num_digits,
-                         bool upper = false) {
+FMT_CONSTEXPR auto format_uint(Char* buffer, UInt value, int num_digits,
+                               bool upper = false) -> Char* {
   buffer += num_digits;
   Char* end = buffer;
   do {
-    const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits;
+    const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
     unsigned digit = (value & ((1 << BASE_BITS) - 1));
     *--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
                                                 : digits[digit]);
@@ -1093,8 +1150,8 @@ inline Char* format_uint(Char* buffer, UInt value, int num_digits,
 }
 
 template <unsigned BASE_BITS, typename Char>
-Char* format_uint(Char* buffer, detail::fallback_uintptr n, int num_digits,
-                  bool = false) {
+auto format_uint(Char* buffer, detail::fallback_uintptr n, int num_digits,
+                 bool = false) -> Char* {
   auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
   int start = (num_digits + char_digits - 1) / char_digits - 1;
   if (int start_digits = num_digits % char_digits) {
@@ -1107,7 +1164,7 @@ Char* format_uint(Char* buffer, detail::fallback_uintptr n, int num_digits,
     auto p = buffer;
     for (int i = 0; i < char_digits; ++i) {
       unsigned digit = (value & ((1 << BASE_BITS) - 1));
-      *--p = static_cast<Char>(data::hex_digits[digit]);
+      *--p = static_cast<Char>("0123456789abcdef"[digit]);
       value >>= BASE_BITS;
     }
   }
@@ -1115,7 +1172,8 @@ Char* format_uint(Char* buffer, detail::fallback_uintptr n, int num_digits,
 }
 
 template <unsigned BASE_BITS, typename Char, typename It, typename UInt>
-inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
+inline auto format_uint(It out, UInt value, int num_digits, bool upper = false)
+    -> It {
   if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
     format_uint<BASE_BITS>(ptr, value, num_digits, upper);
     return out;
@@ -1123,86 +1181,22 @@ inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
   // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
   char buffer[num_bits<UInt>() / BASE_BITS + 1];
   format_uint<BASE_BITS>(buffer, value, num_digits, upper);
-  return detail::copy_str<Char>(buffer, buffer + num_digits, out);
+  return detail::copy_str_noinline<Char>(buffer, buffer + num_digits, out);
 }
 
 // A converter from UTF-8 to UTF-16.
 class utf8_to_utf16 {
  private:
-  wmemory_buffer buffer_;
+  basic_memory_buffer<wchar_t> buffer_;
 
  public:
   FMT_API explicit utf8_to_utf16(string_view s);
-  operator wstring_view() const { return {&buffer_[0], size()}; }
-  size_t size() const { return buffer_.size() - 1; }
-  const wchar_t* c_str() const { return &buffer_[0]; }
-  std::wstring str() const { return {&buffer_[0], size()}; }
+  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()}; }
 };
 
-template <typename T = void> struct null {};
-
-// Workaround an array initialization issue in gcc 4.8.
-template <typename Char> struct fill_t {
- private:
-  enum { max_size = 4 };
-  Char data_[max_size] = {Char(' '), Char(0), Char(0), Char(0)};
-  unsigned char size_ = 1;
-
- public:
-  FMT_CONSTEXPR void operator=(basic_string_view<Char> s) {
-    auto size = s.size();
-    if (size > max_size) {
-      FMT_THROW(format_error("invalid fill"));
-      return;
-    }
-    for (size_t i = 0; i < size; ++i) data_[i] = s[i];
-    size_ = static_cast<unsigned char>(size);
-  }
-
-  size_t size() const { return size_; }
-  const Char* data() const { return data_; }
-
-  FMT_CONSTEXPR Char& operator[](size_t index) { return data_[index]; }
-  FMT_CONSTEXPR const Char& operator[](size_t index) const {
-    return data_[index];
-  }
-};
-}  // namespace detail
-
-// We cannot use enum classes as bit fields because of a gcc bug
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414.
-namespace align {
-enum type { none, left, right, center, numeric };
-}
-using align_t = align::type;
-
-namespace sign {
-enum type { none, minus, plus, space };
-}
-using sign_t = sign::type;
-
-// Format specifiers for built-in and string types.
-template <typename Char> struct basic_format_specs {
-  int width;
-  int precision;
-  char type;
-  align_t align : 4;
-  sign_t sign : 3;
-  bool alt : 1;  // Alternate form ('#').
-  detail::fill_t<Char> fill;
-
-  constexpr basic_format_specs()
-      : width(0),
-        precision(-1),
-        type(0),
-        align(align::none),
-        sign(sign::none),
-        alt(false) {}
-};
-
-using format_specs = basic_format_specs<char>;
-
-namespace detail {
 namespace dragonbox {
 
 // Type-specific information that Dragonbox uses.
@@ -1266,37 +1260,21 @@ template <typename T> struct decimal_fp {
   int exponent;
 };
 
-template <typename T> FMT_API decimal_fp<T> to_decimal(T x) FMT_NOEXCEPT;
+template <typename T>
+FMT_API auto to_decimal(T x) FMT_NOEXCEPT -> decimal_fp<T>;
 }  // namespace dragonbox
 
 template <typename T>
-constexpr typename dragonbox::float_info<T>::carrier_uint exponent_mask() {
+constexpr auto exponent_mask() ->
+    typename dragonbox::float_info<T>::carrier_uint {
   using uint = typename dragonbox::float_info<T>::carrier_uint;
   return ((uint(1) << dragonbox::float_info<T>::exponent_bits) - 1)
          << dragonbox::float_info<T>::significand_bits;
 }
 
-// A floating-point presentation format.
-enum class float_format : unsigned char {
-  general,  // General: exponent notation or fixed point based on magnitude.
-  exp,      // Exponent notation with the default precision of 6, e.g. 1.2e-3.
-  fixed,    // Fixed point with the default precision of 6, e.g. 0.0012.
-  hex
-};
-
-struct float_specs {
-  int precision;
-  float_format format : 8;
-  sign_t sign : 8;
-  bool upper : 1;
-  bool locale : 1;
-  bool binary32 : 1;
-  bool use_grisu : 1;
-  bool showpoint : 1;
-};
-
 // Writes the exponent exp in the form "[+-]d{2,3}" to buffer.
-template <typename Char, typename It> It write_exponent(int exp, It it) {
+template <typename Char, typename It>
+FMT_CONSTEXPR auto write_exponent(int exp, It it) -> It {
   FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range");
   if (exp < 0) {
     *it++ = static_cast<Char>('-');
@@ -1305,185 +1283,42 @@ template <typename Char, typename It> It write_exponent(int exp, It it) {
     *it++ = static_cast<Char>('+');
   }
   if (exp >= 100) {
-    const char* top = data::digits[exp / 100];
+    const char* top = digits2(to_unsigned(exp / 100));
     if (exp >= 1000) *it++ = static_cast<Char>(top[0]);
     *it++ = static_cast<Char>(top[1]);
     exp %= 100;
   }
-  const char* d = data::digits[exp];
+  const char* d = digits2(to_unsigned(exp));
   *it++ = static_cast<Char>(d[0]);
   *it++ = static_cast<Char>(d[1]);
   return it;
 }
 
 template <typename T>
-int format_float(T value, int precision, float_specs specs, buffer<char>& buf);
+FMT_HEADER_ONLY_CONSTEXPR20 auto format_float(T value, int precision,
+                                              float_specs specs,
+                                              buffer<char>& buf) -> int;
 
 // Formats a floating-point number with snprintf.
 template <typename T>
-int snprintf_float(T value, int precision, float_specs specs,
-                   buffer<char>& buf);
+auto snprintf_float(T value, int precision, float_specs specs,
+                    buffer<char>& buf) -> int;
 
-template <typename T> T promote_float(T value) { return value; }
-inline double promote_float(float value) { return static_cast<double>(value); }
-
-template <typename Handler>
-FMT_CONSTEXPR void handle_int_type_spec(char spec, Handler&& handler) {
-  switch (spec) {
-  case 0:
-  case 'd':
-    handler.on_dec();
-    break;
-  case 'x':
-  case 'X':
-    handler.on_hex();
-    break;
-  case 'b':
-  case 'B':
-    handler.on_bin();
-    break;
-  case 'o':
-    handler.on_oct();
-    break;
-#ifdef FMT_DEPRECATED_N_SPECIFIER
-  case 'n':
-#endif
-  case 'L':
-    handler.on_num();
-    break;
-  case 'c':
-    handler.on_chr();
-    break;
-  default:
-    handler.on_error();
-  }
+template <typename T> constexpr auto promote_float(T value) -> T {
+  return value;
 }
-
-template <typename ErrorHandler = error_handler, typename Char>
-FMT_CONSTEXPR float_specs parse_float_type_spec(
-    const basic_format_specs<Char>& specs, ErrorHandler&& eh = {}) {
-  auto result = float_specs();
-  result.showpoint = specs.alt;
-  switch (specs.type) {
-  case 0:
-    result.format = float_format::general;
-    result.showpoint |= specs.precision > 0;
-    break;
-  case 'G':
-    result.upper = true;
-    FMT_FALLTHROUGH;
-  case 'g':
-    result.format = float_format::general;
-    break;
-  case 'E':
-    result.upper = true;
-    FMT_FALLTHROUGH;
-  case 'e':
-    result.format = float_format::exp;
-    result.showpoint |= specs.precision != 0;
-    break;
-  case 'F':
-    result.upper = true;
-    FMT_FALLTHROUGH;
-  case 'f':
-    result.format = float_format::fixed;
-    result.showpoint |= specs.precision != 0;
-    break;
-  case 'A':
-    result.upper = true;
-    FMT_FALLTHROUGH;
-  case 'a':
-    result.format = float_format::hex;
-    break;
-#ifdef FMT_DEPRECATED_N_SPECIFIER
-  case 'n':
-#endif
-  case 'L':
-    result.locale = true;
-    break;
-  default:
-    eh.on_error("invalid type specifier");
-    break;
-  }
-  return result;
+constexpr auto promote_float(float value) -> double {
+  return static_cast<double>(value);
 }
 
-template <typename Char, typename Handler>
-FMT_CONSTEXPR void handle_char_specs(const basic_format_specs<Char>* specs,
-                                     Handler&& handler) {
-  if (!specs) return handler.on_char();
-  if (specs->type && specs->type != 'c') return handler.on_int();
-  if (specs->align == align::numeric || specs->sign != sign::none || specs->alt)
-    handler.on_error("invalid format specifier for char");
-  handler.on_char();
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler&& handler) {
-  if (spec == 0 || spec == 's')
-    handler.on_string();
-  else if (spec == 'p')
-    handler.on_pointer();
-  else
-    handler.on_error("invalid type specifier");
-}
-
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler&& eh) {
-  if (spec != 0 && spec != 's') eh.on_error("invalid type specifier");
-}
-
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler&& eh) {
-  if (spec != 0 && spec != 'p') eh.on_error("invalid type specifier");
-}
-
-template <typename ErrorHandler> class int_type_checker : private ErrorHandler {
- public:
-  FMT_CONSTEXPR explicit int_type_checker(ErrorHandler eh) : ErrorHandler(eh) {}
-
-  FMT_CONSTEXPR void on_dec() {}
-  FMT_CONSTEXPR void on_hex() {}
-  FMT_CONSTEXPR void on_bin() {}
-  FMT_CONSTEXPR void on_oct() {}
-  FMT_CONSTEXPR void on_num() {}
-  FMT_CONSTEXPR void on_chr() {}
-
-  FMT_CONSTEXPR void on_error() {
-    ErrorHandler::on_error("invalid type specifier");
-  }
-};
-
-template <typename ErrorHandler>
-class char_specs_checker : public ErrorHandler {
- private:
-  char type_;
-
- public:
-  FMT_CONSTEXPR char_specs_checker(char type, ErrorHandler eh)
-      : ErrorHandler(eh), type_(type) {}
-
-  FMT_CONSTEXPR void on_int() {
-    handle_int_type_spec(type_, int_type_checker<ErrorHandler>(*this));
-  }
-  FMT_CONSTEXPR void on_char() {}
-};
-
-template <typename ErrorHandler>
-class cstring_type_checker : public ErrorHandler {
- public:
-  FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh)
-      : ErrorHandler(eh) {}
-
-  FMT_CONSTEXPR void on_string() {}
-  FMT_CONSTEXPR void on_pointer() {}
-};
-
 template <typename OutputIt, typename Char>
-FMT_NOINLINE OutputIt fill(OutputIt it, size_t n, const fill_t<Char>& fill) {
+FMT_NOINLINE FMT_CONSTEXPR auto fill(OutputIt it, size_t n,
+                                     const fill_t<Char>& fill) -> OutputIt {
   auto fill_size = fill.size();
-  if (fill_size == 1) return std::fill_n(it, n, fill[0]);
-  for (size_t i = 0; i < n; ++i) it = std::copy_n(fill.data(), fill_size, it);
+  if (fill_size == 1) return detail::fill_n(it, n, fill[0]);
+  auto data = fill.data();
+  for (size_t i = 0; i < n; ++i)
+    it = copy_str<Char>(data, data + fill_size, it);
   return it;
 }
 
@@ -1492,39 +1327,73 @@ FMT_NOINLINE OutputIt fill(OutputIt it, size_t n, const fill_t<Char>& fill) {
 // width: output display width in (terminal) column positions.
 template <align::type align = align::left, typename OutputIt, typename Char,
           typename F>
-inline OutputIt write_padded(OutputIt out,
-                             const basic_format_specs<Char>& specs, size_t size,
-                             size_t width, F&& f) {
+FMT_CONSTEXPR auto write_padded(OutputIt out,
+                                const basic_format_specs<Char>& specs,
+                                size_t size, size_t width, F&& f) -> OutputIt {
   static_assert(align == align::left || align == align::right, "");
   unsigned spec_width = to_unsigned(specs.width);
   size_t padding = spec_width > width ? spec_width - width : 0;
-  auto* shifts = align == align::left ? data::left_padding_shifts
-                                      : data::right_padding_shifts;
+  // Shifts are encoded as string literals because static constexpr is not
+  // supported in constexpr functions.
+  auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
   size_t left_padding = padding >> shifts[specs.align];
+  size_t right_padding = padding - left_padding;
   auto it = reserve(out, size + padding * specs.fill.size());
-  it = fill(it, left_padding, specs.fill);
+  if (left_padding != 0) it = fill(it, left_padding, specs.fill);
   it = f(it);
-  it = fill(it, padding - left_padding, specs.fill);
+  if (right_padding != 0) it = fill(it, right_padding, specs.fill);
   return base_iterator(out, it);
 }
 
 template <align::type align = align::left, typename OutputIt, typename Char,
           typename F>
-inline OutputIt write_padded(OutputIt out,
-                             const basic_format_specs<Char>& specs, size_t size,
-                             F&& f) {
+constexpr auto write_padded(OutputIt out, const basic_format_specs<Char>& specs,
+                            size_t size, F&& f) -> OutputIt {
   return write_padded<align>(out, specs, size, size, f);
 }
 
+template <align::type align = align::left, typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write_bytes(OutputIt out, string_view bytes,
+                               const basic_format_specs<Char>& specs)
+    -> OutputIt {
+  return write_padded<align>(
+      out, specs, bytes.size(), [bytes](reserve_iterator<OutputIt> it) {
+        const char* data = bytes.data();
+        return copy_str<Char>(data, data + bytes.size(), it);
+      });
+}
+
+template <typename Char, typename OutputIt, typename UIntPtr>
+auto write_ptr(OutputIt out, UIntPtr value,
+               const basic_format_specs<Char>* 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_uint<4, Char>(it, value, num_digits);
+  };
+  return specs ? write_padded<align::right>(out, *specs, size, write)
+               : base_iterator(out, write(reserve(out, size)));
+}
+
 template <typename Char, typename OutputIt>
-OutputIt write_bytes(OutputIt out, string_view bytes,
-                     const basic_format_specs<Char>& specs) {
-  using iterator = remove_reference_t<decltype(reserve(out, 0))>;
-  return write_padded(out, specs, bytes.size(), [bytes](iterator it) {
-    const char* data = bytes.data();
-    return copy_str<Char>(data, data + bytes.size(), it);
+FMT_CONSTEXPR auto write_char(OutputIt out, Char value,
+                              const basic_format_specs<Char>& specs)
+    -> OutputIt {
+  return write_padded(out, specs, 1, [=](reserve_iterator<OutputIt> it) {
+    *it++ = value;
+    return it;
   });
 }
+template <typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write(OutputIt out, Char value,
+                         const basic_format_specs<Char>& specs,
+                         locale_ref loc = {}) -> OutputIt {
+  return check_char_specs(specs)
+             ? write_char(out, value, specs)
+             : write(out, static_cast<int>(value), specs, loc);
+}
 
 // Data for write_int that doesn't depend on output iterator type. It is used to
 // avoid template code bloat.
@@ -1532,9 +1401,9 @@ template <typename Char> struct write_int_data {
   size_t size;
   size_t padding;
 
-  write_int_data(int num_digits, string_view prefix,
-                 const basic_format_specs<Char>& specs)
-      : size(prefix.size() + to_unsigned(num_digits)), padding(0) {
+  FMT_CONSTEXPR write_int_data(int num_digits, unsigned prefix,
+                               const basic_format_specs<Char>& specs)
+      : size((prefix >> 24) + to_unsigned(num_digits)), padding(0) {
     if (specs.align == align::numeric) {
       auto width = to_unsigned(specs.width);
       if (width > size) {
@@ -1542,7 +1411,7 @@ template <typename Char> struct write_int_data {
         size = width;
       }
     } else if (specs.precision > num_digits) {
-      size = prefix.size() + to_unsigned(specs.precision);
+      size = (prefix >> 24) + to_unsigned(specs.precision);
       padding = to_unsigned(specs.precision - num_digits);
     }
   }
@@ -1550,183 +1419,280 @@ template <typename Char> struct write_int_data {
 
 // Writes an integer in the format
 //   <left-padding><prefix><numeric-padding><digits><right-padding>
-// where <digits> are written by f(it).
-template <typename OutputIt, typename Char, typename F>
-OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
-                   const basic_format_specs<Char>& specs, F f) {
+// where <digits> are written by write_digits(it).
+// prefix contains chars in three lower bytes and the size in the fourth byte.
+template <typename OutputIt, typename Char, typename W>
+FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, int num_digits,
+                                        unsigned prefix,
+                                        const basic_format_specs<Char>& specs,
+                                        W write_digits) -> OutputIt {
+  // 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));
+    if (prefix != 0) {
+      for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
+        *it++ = static_cast<Char>(p & 0xff);
+    }
+    return base_iterator(out, write_digits(it));
+  }
   auto data = write_int_data<Char>(num_digits, prefix, specs);
-  using iterator = remove_reference_t<decltype(reserve(out, 0))>;
-  return write_padded<align::right>(out, specs, data.size, [=](iterator it) {
-    if (prefix.size() != 0)
-      it = copy_str<Char>(prefix.begin(), prefix.end(), it);
-    it = std::fill_n(it, data.padding, static_cast<Char>('0'));
-    return f(it);
-  });
+  return write_padded<align::right>(
+      out, specs, data.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, data.padding, static_cast<Char>('0'));
+        return write_digits(it);
+      });
 }
 
-template <typename StrChar, typename Char, typename OutputIt>
-OutputIt write(OutputIt out, basic_string_view<StrChar> s,
-               const basic_format_specs<Char>& specs) {
+template <typename Char> class digit_grouping {
+ private:
+  thousands_sep_result<Char> sep_;
+
+  struct next_state {
+    std::string::const_iterator group;
+    int pos;
+  };
+  next_state initial_state() const { return {sep_.grouping.begin(), 0}; }
+
+  // Returns the next digit group separator position.
+  int next(next_state& state) const {
+    if (!sep_.thousands_sep) return max_value<int>();
+    if (state.group == sep_.grouping.end())
+      return state.pos += sep_.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)
+      sep_ = thousands_sep<Char>(loc);
+    else
+      sep_.thousands_sep = Char();
+  }
+  explicit digit_grouping(thousands_sep_result<Char> sep) : sep_(sep) {}
+
+  Char separator() const { return sep_.thousands_sep; }
+
+  int count_separators(int num_digits) const {
+    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>
+  Out apply(Out out, basic_string_view<C> digits) const {
+    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++ = separator();
+        --sep_index;
+      }
+      *out++ = static_cast<Char>(digits[to_unsigned(i)]);
+    }
+    return out;
+  }
+};
+
+template <typename OutputIt, typename UInt, typename Char>
+auto write_int_localized(OutputIt out, UInt value, unsigned prefix,
+                         const basic_format_specs<Char>& specs,
+                         const digit_grouping<Char>& grouping) -> OutputIt {
+  static_assert(std::is_same<uint64_or_128_t<UInt>, UInt>::value, "");
+  int num_digits = count_digits(value);
+  char digits[40];
+  format_decimal(digits, value, num_digits);
+  unsigned size = to_unsigned((prefix != 0 ? 1 : 0) + num_digits +
+                              grouping.count_separators(num_digits));
+  return write_padded<align::right>(
+      out, specs, size, size, [&](reserve_iterator<OutputIt> it) {
+        if (prefix != 0) *it++ = static_cast<Char>(prefix);
+        return grouping.apply(it, string_view(digits, to_unsigned(num_digits)));
+      });
+}
+
+template <typename OutputIt, typename UInt, typename Char>
+auto write_int_localized(OutputIt& out, UInt value, unsigned prefix,
+                         const basic_format_specs<Char>& specs, locale_ref loc)
+    -> bool {
+  auto grouping = digit_grouping<Char>(loc);
+  out = write_int_localized(out, value, prefix, specs, grouping);
+  return true;
+}
+
+FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) {
+  prefix |= prefix != 0 ? value << 8 : value;
+  prefix += (1u + (value > 0xff ? 1 : 0)) << 24;
+}
+
+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_t sign)
+    -> 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[sign];
+  }
+  return {abs_value, prefix};
+}
+
+template <typename Char, typename OutputIt, typename T>
+FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, write_int_arg<T> arg,
+                                        const basic_format_specs<Char>& specs,
+                                        locale_ref loc) -> OutputIt {
+  static_assert(std::is_same<T, uint32_or_64_or_128_t<T>>::value, "");
+  auto abs_value = arg.abs_value;
+  auto prefix = arg.prefix;
+  switch (specs.type) {
+  case presentation_type::none:
+  case presentation_type::dec: {
+    if (specs.localized &&
+        write_int_localized(out, static_cast<uint64_or_128_t<T>>(abs_value),
+                            prefix, specs, loc)) {
+      return out;
+    }
+    auto num_digits = count_digits(abs_value);
+    return write_int(
+        out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) {
+          return format_decimal<Char>(it, abs_value, num_digits).end;
+        });
+  }
+  case presentation_type::hex_lower:
+  case presentation_type::hex_upper: {
+    bool upper = specs.type == presentation_type::hex_upper;
+    if (specs.alt)
+      prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0');
+    int num_digits = count_digits<4>(abs_value);
+    return write_int(
+        out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) {
+          return format_uint<4, Char>(it, abs_value, num_digits, upper);
+        });
+  }
+  case presentation_type::bin_lower:
+  case presentation_type::bin_upper: {
+    bool upper = specs.type == presentation_type::bin_upper;
+    if (specs.alt)
+      prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0');
+    int num_digits = count_digits<1>(abs_value);
+    return write_int(out, num_digits, prefix, specs,
+                     [=](reserve_iterator<OutputIt> it) {
+                       return format_uint<1, Char>(it, abs_value, num_digits);
+                     });
+  }
+  case presentation_type::oct: {
+    int num_digits = count_digits<3>(abs_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 && abs_value != 0)
+      prefix_append(prefix, '0');
+    return write_int(out, num_digits, prefix, specs,
+                     [=](reserve_iterator<OutputIt> it) {
+                       return format_uint<3, Char>(it, abs_value, num_digits);
+                     });
+  }
+  case presentation_type::chr:
+    return write_char(out, static_cast<Char>(abs_value), specs);
+  default:
+    throw_format_error("invalid type specifier");
+  }
+  return out;
+}
+template <typename Char, typename OutputIt, typename T>
+FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline(
+    OutputIt out, write_int_arg<T> arg, const basic_format_specs<Char>& specs,
+    locale_ref loc) -> OutputIt {
+  return write_int(out, arg, specs, loc);
+}
+template <typename Char, typename OutputIt, typename T,
+          FMT_ENABLE_IF(is_integral<T>::value &&
+                        !std::is_same<T, bool>::value &&
+                        std::is_same<OutputIt, buffer_appender<Char>>::value)>
+FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value,
+                                    const basic_format_specs<Char>& specs,
+                                    locale_ref loc) -> OutputIt {
+  return write_int_noinline(out, make_write_int_arg(value, specs.sign), specs,
+                            loc);
+}
+// 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<OutputIt, buffer_appender<Char>>::value)>
+FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value,
+                                    const basic_format_specs<Char>& specs,
+                                    locale_ref loc) -> OutputIt {
+  return write_int(out, make_write_int_arg(value, specs.sign), specs, loc);
+}
+
+template <typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> s,
+                         const basic_format_specs<Char>& 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));
-  auto width = specs.width != 0
-                   ? count_code_points(basic_string_view<StrChar>(data, size))
-                   : 0;
-  using iterator = remove_reference_t<decltype(reserve(out, 0))>;
-  return write_padded(out, specs, size, width, [=](iterator it) {
-    return copy_str<Char>(data, data + size, it);
-  });
+  auto width =
+      specs.width != 0 ? compute_width(basic_string_view<Char>(data, size)) : 0;
+  return write_padded(out, specs, size, width,
+                      [=](reserve_iterator<OutputIt> it) {
+                        return copy_str<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 basic_format_specs<Char>& specs, locale_ref)
+    -> OutputIt {
+  check_string_type_spec(specs.type);
+  return write(out, s, specs);
+}
+template <typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write(OutputIt out, const Char* s,
+                         const basic_format_specs<Char>& specs, locale_ref)
+    -> OutputIt {
+  return check_cstring_type_spec(specs.type)
+             ? write(out, basic_string_view<Char>(s), specs, {})
+             : write_ptr<Char>(out, to_uintptr(s), &specs);
 }
 
-// The handle_int_type_spec handler that writes an integer.
-template <typename OutputIt, typename Char, typename UInt> struct int_writer {
-  OutputIt out;
-  locale_ref locale;
-  const basic_format_specs<Char>& specs;
-  UInt abs_value;
-  char prefix[4];
-  unsigned prefix_size;
-
-  using iterator =
-      remove_reference_t<decltype(reserve(std::declval<OutputIt&>(), 0))>;
-
-  string_view get_prefix() const { return string_view(prefix, prefix_size); }
-
-  template <typename Int>
-  int_writer(OutputIt output, locale_ref loc, Int value,
-             const basic_format_specs<Char>& s)
-      : out(output),
-        locale(loc),
-        specs(s),
-        abs_value(static_cast<UInt>(value)),
-        prefix_size(0) {
-    static_assert(std::is_same<uint32_or_64_or_128_t<Int>, UInt>::value, "");
-    if (is_negative(value)) {
-      prefix[0] = '-';
-      ++prefix_size;
-      abs_value = 0 - abs_value;
-    } else if (specs.sign != sign::none && specs.sign != sign::minus) {
-      prefix[0] = specs.sign == sign::plus ? '+' : ' ';
-      ++prefix_size;
-    }
-  }
-
-  void on_dec() {
-    auto num_digits = count_digits(abs_value);
-    out = write_int(
-        out, num_digits, get_prefix(), specs, [this, num_digits](iterator it) {
-          return format_decimal<Char>(it, abs_value, num_digits).end;
-        });
-  }
-
-  void on_hex() {
-    if (specs.alt) {
-      prefix[prefix_size++] = '0';
-      prefix[prefix_size++] = specs.type;
-    }
-    int num_digits = count_digits<4>(abs_value);
-    out = write_int(out, num_digits, get_prefix(), specs,
-                    [this, num_digits](iterator it) {
-                      return format_uint<4, Char>(it, abs_value, num_digits,
-                                                  specs.type != 'x');
-                    });
-  }
-
-  void on_bin() {
-    if (specs.alt) {
-      prefix[prefix_size++] = '0';
-      prefix[prefix_size++] = static_cast<char>(specs.type);
-    }
-    int num_digits = count_digits<1>(abs_value);
-    out = write_int(out, num_digits, get_prefix(), specs,
-                    [this, num_digits](iterator it) {
-                      return format_uint<1, Char>(it, abs_value, num_digits);
-                    });
-  }
-
-  void on_oct() {
-    int num_digits = count_digits<3>(abs_value);
-    if (specs.alt && specs.precision <= num_digits && abs_value != 0) {
-      // Octal prefix '0' is counted as a digit, so only add it if precision
-      // is not greater than the number of digits.
-      prefix[prefix_size++] = '0';
-    }
-    out = write_int(out, num_digits, get_prefix(), specs,
-                    [this, num_digits](iterator it) {
-                      return format_uint<3, Char>(it, abs_value, num_digits);
-                    });
-  }
-
-  enum { sep_size = 1 };
-
-  void on_num() {
-    std::string groups = grouping<Char>(locale);
-    if (groups.empty()) return on_dec();
-    auto sep = thousands_sep<Char>(locale);
-    if (!sep) return on_dec();
-    int num_digits = count_digits(abs_value);
-    int size = num_digits, n = num_digits;
-    std::string::const_iterator group = groups.cbegin();
-    while (group != groups.cend() && n > *group && *group > 0 &&
-           *group != max_value<char>()) {
-      size += sep_size;
-      n -= *group;
-      ++group;
-    }
-    if (group == groups.cend()) size += sep_size * ((n - 1) / groups.back());
-    char digits[40];
-    format_decimal(digits, abs_value, num_digits);
-    basic_memory_buffer<Char> buffer;
-    size += static_cast<int>(prefix_size);
-    const auto usize = to_unsigned(size);
-    buffer.resize(usize);
-    basic_string_view<Char> s(&sep, sep_size);
-    // Index of a decimal digit with the least significant digit having index 0.
-    int digit_index = 0;
-    group = groups.cbegin();
-    auto p = buffer.data() + size - 1;
-    for (int i = num_digits - 1; i > 0; --i) {
-      *p-- = static_cast<Char>(digits[i]);
-      if (*group <= 0 || ++digit_index % *group != 0 ||
-          *group == max_value<char>())
-        continue;
-      if (group + 1 != groups.cend()) {
-        digit_index = 0;
-        ++group;
-      }
-      std::uninitialized_copy(s.data(), s.data() + s.size(),
-                              make_checked(p, s.size()));
-      p -= s.size();
-    }
-    *p-- = static_cast<Char>(*digits);
-    if (prefix_size != 0) *p = static_cast<Char>('-');
-    auto data = buffer.data();
-    out = write_padded<align::right>(
-        out, specs, usize, usize,
-        [=](iterator it) { return copy_str<Char>(data, data + size, it); });
-  }
-
-  void on_chr() { *out++ = static_cast<Char>(abs_value); }
-
-  FMT_NORETURN void on_error() {
-    FMT_THROW(format_error("invalid type specifier"));
-  }
-};
-
 template <typename Char, typename OutputIt>
-OutputIt write_nonfinite(OutputIt out, bool isinf,
-                         const basic_format_specs<Char>& specs,
-                         const float_specs& fspecs) {
+FMT_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isinf,
+                                     basic_format_specs<Char> specs,
+                                     const float_specs& fspecs) -> OutputIt {
   auto str =
       isinf ? (fspecs.upper ? "INF" : "inf") : (fspecs.upper ? "NAN" : "nan");
   constexpr size_t str_size = 3;
   auto sign = fspecs.sign;
   auto size = str_size + (sign ? 1 : 0);
-  using iterator = remove_reference_t<decltype(reserve(out, 0))>;
-  return write_padded(out, specs, size, [=](iterator it) {
-    if (sign) *it++ = static_cast<Char>(data::signs[sign]);
+  // Replace '0'-padding with space for non-finite values.
+  const bool is_zero_fill =
+      specs.fill.size() == 1 && *specs.fill.data() == static_cast<Char>('0');
+  if (is_zero_fill) specs.fill[0] = static_cast<Char>(' ');
+  return write_padded(out, specs, size, [=](reserve_iterator<OutputIt> it) {
+    if (sign) *it++ = detail::sign<Char>(sign);
     return copy_str<Char>(str, str + str_size, it);
   });
 }
@@ -1738,74 +1704,118 @@ struct big_decimal_fp {
   int exponent;
 };
 
-inline int get_significand_size(const big_decimal_fp& fp) {
+constexpr auto get_significand_size(const big_decimal_fp& fp) -> int {
   return fp.significand_size;
 }
 template <typename T>
-inline int get_significand_size(const dragonbox::decimal_fp<T>& fp) {
+inline auto get_significand_size(const dragonbox::decimal_fp<T>& fp) -> int {
   return count_digits(fp.significand);
 }
 
 template <typename Char, typename OutputIt>
-inline OutputIt write_significand(OutputIt out, const char* significand,
-                                  int& significand_size) {
+constexpr auto write_significand(OutputIt out, const char* significand,
+                                 int significand_size) -> OutputIt {
   return copy_str<Char>(significand, significand + significand_size, out);
 }
 template <typename Char, typename OutputIt, typename UInt>
-inline OutputIt write_significand(OutputIt out, UInt significand,
-                                  int significand_size) {
+inline auto write_significand(OutputIt out, UInt significand,
+                              int significand_size) -> OutputIt {
   return format_decimal<Char>(out, significand, significand_size).end;
 }
+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.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 Char* write_significand(Char* out, UInt significand,
-                               int significand_size, int integral_size,
-                               Char decimal_point) {
+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).end;
-  auto end = format_decimal(out + 1, significand, significand_size).end;
-  if (integral_size == 1)
-    out[0] = out[1];
-  else
-    std::copy_n(out + 1, integral_size, out);
-  out[integral_size] = decimal_point;
+  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;
+    copy2(out, digits2(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 OutputIt write_significand(OutputIt out, UInt significand,
-                                  int significand_size, int integral_size,
-                                  Char decimal_point) {
+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_str<Char>(buffer, end, out);
+  return detail::copy_str_noinline<Char>(buffer, end, out);
 }
 
 template <typename OutputIt, typename Char>
-inline OutputIt write_significand(OutputIt out, const char* significand,
-                                  int significand_size, int integral_size,
-                                  Char decimal_point) {
-  out = detail::copy_str<Char>(significand, significand + integral_size, out);
+FMT_CONSTEXPR auto write_significand(OutputIt out, const char* significand,
+                                     int significand_size, int integral_size,
+                                     Char decimal_point) -> OutputIt {
+  out = detail::copy_str_noinline<Char>(significand,
+                                        significand + integral_size, out);
   if (!decimal_point) return out;
   *out++ = decimal_point;
-  return detail::copy_str<Char>(significand + integral_size,
-                                significand + significand_size, out);
+  return detail::copy_str_noinline<Char>(significand + integral_size,
+                                         significand + significand_size, out);
 }
 
-template <typename OutputIt, typename DecimalFP, typename Char>
-OutputIt write_float(OutputIt out, const DecimalFP& fp,
-                     const basic_format_specs<Char>& specs, float_specs fspecs,
-                     Char decimal_point) {
+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.separator()) {
+    return write_significand(out, significand, significand_size, integral_size,
+                             decimal_point);
+  }
+  auto buffer = basic_memory_buffer<Char>();
+  write_significand(buffer_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_str_noinline<Char>(buffer.data() + integral_size,
+                                         buffer.end(), out);
+}
+
+template <typename OutputIt, typename DecimalFP, typename Char,
+          typename Grouping = digit_grouping<Char>>
+FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& fp,
+                                    const basic_format_specs<Char>& specs,
+                                    float_specs fspecs, locale_ref loc)
+    -> OutputIt {
   auto significand = fp.significand;
   int significand_size = get_significand_size(fp);
-  static const Char zero = static_cast<Char>('0');
+  constexpr Char zero = static_cast<Char>('0');
   auto sign = fspecs.sign;
   size_t size = to_unsigned(significand_size) + (sign ? 1 : 0);
-  using iterator = remove_reference_t<decltype(reserve(out, 0))>;
+  using iterator = reserve_iterator<OutputIt>;
+
+  Char decimal_point =
+      fspecs.locale ? detail::decimal_point<Char>(loc) : static_cast<Char>('.');
 
   int output_exp = fp.exponent + significand_size - 1;
   auto use_exp_format = [=]() {
@@ -1820,7 +1830,8 @@ OutputIt write_float(OutputIt out, const DecimalFP& fp,
   if (use_exp_format()) {
     int num_zeros = 0;
     if (fspecs.showpoint) {
-      num_zeros = (std::max)(fspecs.precision - significand_size, 0);
+      num_zeros = fspecs.precision - significand_size;
+      if (num_zeros < 0) num_zeros = 0;
       size += to_unsigned(num_zeros);
     } else if (significand_size == 1) {
       decimal_point = Char();
@@ -1832,11 +1843,11 @@ OutputIt write_float(OutputIt out, const DecimalFP& fp,
     size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits);
     char exp_char = fspecs.upper ? 'E' : 'e';
     auto write = [=](iterator it) {
-      if (sign) *it++ = static_cast<Char>(data::signs[sign]);
+      if (sign) *it++ = detail::sign<Char>(sign);
       // 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 = std::fill_n(it, num_zeros, zero);
+      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);
     };
@@ -1855,25 +1866,29 @@ OutputIt write_float(OutputIt out, const DecimalFP& fp,
 #endif
     if (fspecs.showpoint) {
       if (num_zeros <= 0 && fspecs.format != float_format::fixed) num_zeros = 1;
-      if (num_zeros > 0) size += to_unsigned(num_zeros);
+      if (num_zeros > 0) size += to_unsigned(num_zeros) + 1;
     }
+    auto grouping = Grouping(loc, fspecs.locale);
+    size += to_unsigned(grouping.count_separators(significand_size));
     return write_padded<align::right>(out, specs, size, [&](iterator it) {
-      if (sign) *it++ = static_cast<Char>(data::signs[sign]);
-      it = write_significand<Char>(it, significand, significand_size);
-      it = std::fill_n(it, fp.exponent, zero);
+      if (sign) *it++ = detail::sign<Char>(sign);
+      it = write_significand<Char>(it, significand, significand_size,
+                                   fp.exponent, grouping);
       if (!fspecs.showpoint) return it;
       *it++ = decimal_point;
-      return num_zeros > 0 ? std::fill_n(it, num_zeros, zero) : it;
+      return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
     });
   } else if (exp > 0) {
     // 1234e-2 -> 12.34[0+]
     int num_zeros = fspecs.showpoint ? fspecs.precision - significand_size : 0;
     size += 1 + to_unsigned(num_zeros > 0 ? num_zeros : 0);
+    auto grouping = Grouping(loc, fspecs.locale);
+    size += to_unsigned(grouping.count_separators(significand_size));
     return write_padded<align::right>(out, specs, size, [&](iterator it) {
-      if (sign) *it++ = static_cast<Char>(data::signs[sign]);
+      if (sign) *it++ = detail::sign<Char>(sign);
       it = write_significand(it, significand, significand_size, exp,
-                             decimal_point);
-      return num_zeros > 0 ? std::fill_n(it, num_zeros, zero) : it;
+                             decimal_point, grouping);
+      return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
     });
   }
   // 1234e-6 -> 0.001234
@@ -1882,37 +1897,109 @@ OutputIt write_float(OutputIt out, const DecimalFP& fp,
       fspecs.precision < num_zeros) {
     num_zeros = fspecs.precision;
   }
-  size += 2 + to_unsigned(num_zeros);
+  bool pointy = num_zeros != 0 || significand_size != 0 || fspecs.showpoint;
+  size += 1 + (pointy ? 1 : 0) + to_unsigned(num_zeros);
   return write_padded<align::right>(out, specs, size, [&](iterator it) {
-    if (sign) *it++ = static_cast<Char>(data::signs[sign]);
+    if (sign) *it++ = detail::sign<Char>(sign);
     *it++ = zero;
-    if (num_zeros == 0 && significand_size == 0 && !fspecs.showpoint) return it;
+    if (!pointy) return it;
     *it++ = decimal_point;
-    it = std::fill_n(it, num_zeros, zero);
+    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 Char separator() const { return Char(); }
+
+  constexpr int count_separators(int) const { return 0; }
+
+  template <typename Out, typename C>
+  constexpr Out apply(Out out, basic_string_view<C>) const {
+    return out;
+  }
+};
+
+template <typename OutputIt, typename DecimalFP, typename Char>
+FMT_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& fp,
+                                 const basic_format_specs<Char>& specs,
+                                 float_specs fspecs, locale_ref loc)
+    -> OutputIt {
+  if (is_constant_evaluated()) {
+    return do_write_float<OutputIt, DecimalFP, Char,
+                          fallback_digit_grouping<Char>>(out, fp, specs, fspecs,
+                                                         loc);
+  } else {
+    return do_write_float(out, fp, specs, fspecs, loc);
+  }
+}
+
+template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+FMT_CONSTEXPR20 bool isinf(T value) {
+  if (is_constant_evaluated()) {
+#if defined(__cpp_if_constexpr)
+    if constexpr (std::numeric_limits<double>::is_iec559) {
+      auto bits = detail::bit_cast<uint64_t>(static_cast<double>(value));
+      constexpr auto significand_bits =
+          dragonbox::float_info<double>::significand_bits;
+      return (bits & exponent_mask<double>()) &&
+             !(bits & ((uint64_t(1) << significand_bits) - 1));
+    }
+#endif
+  }
+  return std::isinf(value);
+}
+
+template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+FMT_CONSTEXPR20 bool isfinite(T value) {
+  if (is_constant_evaluated()) {
+#if defined(__cpp_if_constexpr)
+    if constexpr (std::numeric_limits<double>::is_iec559) {
+      auto bits = detail::bit_cast<uint64_t>(static_cast<double>(value));
+      return (bits & exponent_mask<double>()) != exponent_mask<double>();
+    }
+#endif
+  }
+  return std::isfinite(value);
+}
+
+template <typename T, FMT_ENABLE_IF(std::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 & (uint64_t(1) << (num_bits<uint64_t>() - 1))) != 0;
+    }
+#endif
+  }
+  return std::signbit(value);
+}
+
 template <typename Char, typename OutputIt, typename T,
           FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-OutputIt write(OutputIt out, T value, basic_format_specs<Char> specs,
-               locale_ref loc = {}) {
+FMT_CONSTEXPR20 auto write(OutputIt out, T value,
+                           basic_format_specs<Char> specs, locale_ref loc = {})
+    -> OutputIt {
   if (const_check(!is_supported_floating_point(value))) return out;
   float_specs fspecs = parse_float_type_spec(specs);
   fspecs.sign = specs.sign;
-  if (std::signbit(value)) {  // value < 0 is false for NaN so use signbit.
+  if (detail::signbit(value)) {  // value < 0 is false for NaN so use signbit.
     fspecs.sign = sign::minus;
     value = -value;
   } else if (fspecs.sign == sign::minus) {
     fspecs.sign = sign::none;
   }
 
-  if (!std::isfinite(value))
-    return write_nonfinite(out, std::isinf(value), specs, fspecs);
+  if (!detail::isfinite(value))
+    return write_nonfinite(out, detail::isinf(value), specs, fspecs);
 
   if (specs.align == align::numeric && fspecs.sign) {
     auto it = reserve(out, 1);
-    *it++ = static_cast<Char>(data::signs[fspecs.sign]);
+    *it++ = detail::sign<Char>(fspecs.sign);
     out = base_iterator(out, it);
     fspecs.sign = sign::none;
     if (specs.width != 0) --specs.width;
@@ -1920,30 +2007,35 @@ OutputIt write(OutputIt out, T value, basic_format_specs<Char> specs,
 
   memory_buffer buffer;
   if (fspecs.format == float_format::hex) {
-    if (fspecs.sign) buffer.push_back(data::signs[fspecs.sign]);
+    if (fspecs.sign) buffer.push_back(detail::sign<char>(fspecs.sign));
     snprintf_float(promote_float(value), specs.precision, fspecs, buffer);
-    return write_bytes(out, {buffer.data(), buffer.size()}, specs);
+    return write_bytes<align::right>(out, {buffer.data(), buffer.size()},
+                                     specs);
   }
-  int precision = specs.precision >= 0 || !specs.type ? specs.precision : 6;
+  int precision = specs.precision >= 0 || specs.type == presentation_type::none
+                      ? specs.precision
+                      : 6;
   if (fspecs.format == float_format::exp) {
     if (precision == max_value<int>())
-      FMT_THROW(format_error("number is too big"));
+      throw_format_error("number is too big");
     else
       ++precision;
   }
   if (const_check(std::is_same<T, float>())) fspecs.binary32 = true;
-  fspecs.use_grisu = is_fast_float<T>();
+  if (!is_fast_float<T>()) fspecs.fallback = true;
   int exp = format_float(promote_float(value), precision, fspecs, buffer);
   fspecs.precision = precision;
-  Char point =
-      fspecs.locale ? decimal_point<Char>(loc) : static_cast<Char>('.');
   auto fp = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp};
-  return write_float(out, fp, specs, fspecs, point);
+  return write_float(out, fp, specs, fspecs, loc);
 }
 
 template <typename Char, typename OutputIt, typename T,
           FMT_ENABLE_IF(is_fast_float<T>::value)>
-OutputIt write(OutputIt out, T value) {
+FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt {
+  if (is_constant_evaluated()) {
+    return write(out, value, basic_format_specs<Char>());
+  }
+
   if (const_check(!is_supported_floating_point(value))) return out;
 
   using floaty = conditional_t<std::is_same<T, long double>::value, double, T>;
@@ -1951,90 +2043,53 @@ OutputIt write(OutputIt out, T value) {
   auto bits = bit_cast<uint>(value);
 
   auto fspecs = float_specs();
-  auto sign_bit = bits & (uint(1) << (num_bits<uint>() - 1));
-  if (sign_bit != 0) {
+  if (detail::signbit(value)) {
     fspecs.sign = sign::minus;
     value = -value;
   }
 
-  static const auto specs = basic_format_specs<Char>();
+  constexpr auto specs = basic_format_specs<Char>();
   uint mask = exponent_mask<floaty>();
   if ((bits & mask) == mask)
     return write_nonfinite(out, std::isinf(value), specs, fspecs);
 
   auto dec = dragonbox::to_decimal(static_cast<floaty>(value));
-  return write_float(out, dec, specs, fspecs, static_cast<Char>('.'));
+  return write_float(out, dec, specs, fspecs, {});
 }
 
 template <typename Char, typename OutputIt, typename T,
           FMT_ENABLE_IF(std::is_floating_point<T>::value &&
                         !is_fast_float<T>::value)>
-inline OutputIt write(OutputIt out, T value) {
+inline auto write(OutputIt out, T value) -> OutputIt {
   return write(out, value, basic_format_specs<Char>());
 }
 
 template <typename Char, typename OutputIt>
-OutputIt write_char(OutputIt out, Char value,
-                    const basic_format_specs<Char>& specs) {
-  using iterator = remove_reference_t<decltype(reserve(out, 0))>;
-  return write_padded(out, specs, 1, [=](iterator it) {
-    *it++ = value;
-    return it;
-  });
-}
-
-template <typename Char, typename OutputIt, typename UIntPtr>
-OutputIt write_ptr(OutputIt out, UIntPtr value,
-                   const basic_format_specs<Char>* specs) {
-  int num_digits = count_digits<4>(value);
-  auto size = to_unsigned(num_digits) + size_t(2);
-  using iterator = remove_reference_t<decltype(reserve(out, 0))>;
-  auto write = [=](iterator it) {
-    *it++ = static_cast<Char>('0');
-    *it++ = static_cast<Char>('x');
-    return format_uint<4, Char>(it, value, num_digits);
-  };
-  return specs ? write_padded<align::right>(out, *specs, size, write)
-               : base_iterator(out, write(reserve(out, size)));
-}
-
-template <typename T> struct is_integral : std::is_integral<T> {};
-template <> struct is_integral<int128_t> : std::true_type {};
-template <> struct is_integral<uint128_t> : std::true_type {};
-
-template <typename Char, typename OutputIt>
-OutputIt write(OutputIt out, monostate) {
+auto write(OutputIt out, monostate, basic_format_specs<Char> = {},
+           locale_ref = {}) -> OutputIt {
   FMT_ASSERT(false, "");
   return out;
 }
 
-template <typename Char, typename OutputIt,
-          FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
-OutputIt write(OutputIt out, string_view value) {
-  auto it = reserve(out, value.size());
-  it = copy_str<Char>(value.begin(), value.end(), it);
-  return base_iterator(out, it);
-}
-
 template <typename Char, typename OutputIt>
-OutputIt write(OutputIt out, basic_string_view<Char> value) {
+FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> value)
+    -> OutputIt {
   auto it = reserve(out, value.size());
-  it = std::copy(value.begin(), value.end(), it);
+  it = copy_str_noinline<Char>(value.begin(), value.end(), it);
   return base_iterator(out, it);
 }
 
-template <typename Char>
-buffer_appender<Char> write(buffer_appender<Char> out,
-                            basic_string_view<Char> value) {
-  get_container(out).append(value.begin(), value.end());
-  return out;
+template <typename Char, typename OutputIt, typename T,
+          FMT_ENABLE_IF(is_string<T>::value)>
+constexpr auto write(OutputIt out, const T& value) -> OutputIt {
+  return write<Char>(out, to_string_view(value));
 }
 
 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)>
-OutputIt write(OutputIt out, T 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.
@@ -2052,336 +2107,130 @@ OutputIt write(OutputIt out, T value) {
   return base_iterator(out, it);
 }
 
-template <typename Char, typename OutputIt>
-OutputIt write(OutputIt out, bool value) {
-  return write<Char>(out, string_view(value ? "true" : "false"));
+// 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, basic_format_context<OutputIt, Char>>::value !=
+            type::custom_type,
+    FMT_ENABLE_IF(check)>
+FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
+  return write<Char>(
+      out, static_cast<typename std::underlying_type<T>::type>(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 basic_format_specs<Char>& specs = {},
+                         locale_ref = {}) -> OutputIt {
+  return specs.type != presentation_type::none &&
+                 specs.type != presentation_type::string
+             ? write(out, value ? 1 : 0, specs, {})
+             : write_bytes(out, value ? "true" : "false", specs);
 }
 
 template <typename Char, typename OutputIt>
-OutputIt write(OutputIt out, Char value) {
+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>
-OutputIt write(OutputIt out, const Char* value) {
+FMT_CONSTEXPR_CHAR_TRAITS auto write(OutputIt out, const Char* value)
+    -> OutputIt {
   if (!value) {
-    FMT_THROW(format_error("string pointer is null"));
+    throw_format_error("string pointer is null");
   } else {
-    auto length = std::char_traits<Char>::length(value);
-    out = write(out, basic_string_view<Char>(value, length));
+    out = write(out, basic_string_view<Char>(value));
   }
   return out;
 }
 
-template <typename Char, typename OutputIt>
-OutputIt write(OutputIt out, const void* value) {
-  return write_ptr<Char>(out, to_uintptr(value), nullptr);
+template <typename Char, typename OutputIt, typename T,
+          FMT_ENABLE_IF(std::is_same<T, void>::value)>
+auto write(OutputIt out, const T* value,
+           const basic_format_specs<Char>& specs = {}, locale_ref = {})
+    -> OutputIt {
+  check_pointer_type_spec(specs.type, error_handler());
+  return write_ptr<Char>(out, to_uintptr(value), &specs);
 }
 
-template <typename Char, typename OutputIt, typename T>
-auto write(OutputIt out, const T& value) -> typename std::enable_if<
-    mapped_type_constant<T, basic_format_context<OutputIt, Char>>::value ==
-        type::custom_type,
-    OutputIt>::type {
-  using context_type = basic_format_context<OutputIt, Char>;
+// 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 && !is_string<T>::value &&
+        !std::is_same<T, Char>::value &&
+        !std::is_same<const T&,
+                      decltype(arg_mapper<Context>().map(value))>::value,
+    OutputIt> {
+  return write<Char>(out, arg_mapper<Context>().map(value));
+}
+
+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<mapped_type_constant<T, Context>::value == type::custom_type,
+                   OutputIt> {
   using formatter_type =
-      conditional_t<has_formatter<T, context_type>::value,
-                    typename context_type::template formatter_type<T>,
+      conditional_t<has_formatter<T, Context>::value,
+                    typename Context::template formatter_type<T>,
                     fallback_formatter<T, Char>>;
-  context_type ctx(out, {}, {});
+  auto ctx = Context(out, {}, {});
   return formatter_type().format(value, ctx);
 }
 
 // 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 OutputIt, typename Char> struct default_arg_formatter {
-  using context = basic_format_context<OutputIt, Char>;
+template <typename Char> struct default_arg_formatter {
+  using iterator = buffer_appender<Char>;
+  using context = buffer_context<Char>;
 
-  OutputIt out;
+  iterator out;
   basic_format_args<context> args;
   locale_ref loc;
 
-  template <typename T> OutputIt operator()(T value) {
+  template <typename T> auto operator()(T value) -> iterator {
     return write<Char>(out, value);
   }
-
-  OutputIt operator()(typename basic_format_arg<context>::handle handle) {
+  auto operator()(typename basic_format_arg<context>::handle h) -> iterator {
     basic_format_parse_context<Char> parse_ctx({});
-    basic_format_context<OutputIt, Char> format_ctx(out, args, loc);
-    handle.format(parse_ctx, format_ctx);
+    context format_ctx(out, args, loc);
+    h.format(parse_ctx, format_ctx);
     return format_ctx.out();
   }
 };
 
-template <typename OutputIt, typename Char,
-          typename ErrorHandler = error_handler>
-class arg_formatter_base {
- public:
-  using iterator = OutputIt;
-  using char_type = Char;
-  using format_specs = basic_format_specs<Char>;
+template <typename Char> struct arg_formatter {
+  using iterator = buffer_appender<Char>;
+  using context = buffer_context<Char>;
 
- private:
-  iterator out_;
-  locale_ref locale_;
-  format_specs* specs_;
+  iterator out;
+  const basic_format_specs<Char>& specs;
+  locale_ref locale;
 
-  // Attempts to reserve space for n extra characters in the output range.
-  // Returns a pointer to the reserved range or a reference to out_.
-  auto reserve(size_t n) -> decltype(detail::reserve(out_, n)) {
-    return detail::reserve(out_, n);
+  template <typename T>
+  FMT_CONSTEXPR FMT_INLINE auto operator()(T value) -> iterator {
+    return detail::write(out, value, specs, locale);
   }
-
-  using reserve_iterator = remove_reference_t<decltype(
-      detail::reserve(std::declval<iterator&>(), 0))>;
-
-  template <typename T> void write_int(T value, const format_specs& spec) {
-    using uint_type = uint32_or_64_or_128_t<T>;
-    int_writer<iterator, Char, uint_type> w(out_, locale_, value, spec);
-    handle_int_type_spec(spec.type, w);
-    out_ = w.out;
-  }
-
-  void write(char value) {
-    auto&& it = reserve(1);
-    *it++ = value;
-  }
-
-  template <typename Ch, FMT_ENABLE_IF(std::is_same<Ch, Char>::value)>
-  void write(Ch value) {
-    out_ = detail::write<Char>(out_, value);
-  }
-
-  void write(string_view value) {
-    auto&& it = reserve(value.size());
-    it = copy_str<Char>(value.begin(), value.end(), it);
-  }
-  void write(wstring_view value) {
-    static_assert(std::is_same<Char, wchar_t>::value, "");
-    auto&& it = reserve(value.size());
-    it = std::copy(value.begin(), value.end(), it);
-  }
-
-  template <typename Ch>
-  void write(const Ch* s, size_t size, const format_specs& specs) {
-    auto width = specs.width != 0
-                     ? count_code_points(basic_string_view<Ch>(s, size))
-                     : 0;
-    out_ = write_padded(out_, specs, size, width, [=](reserve_iterator it) {
-      return copy_str<Char>(s, s + size, it);
-    });
-  }
-
-  template <typename Ch>
-  void write(basic_string_view<Ch> s, const format_specs& specs = {}) {
-    out_ = detail::write(out_, s, specs);
-  }
-
-  void write_pointer(const void* p) {
-    out_ = write_ptr<char_type>(out_, to_uintptr(p), specs_);
-  }
-
-  struct char_spec_handler : ErrorHandler {
-    arg_formatter_base& formatter;
-    Char value;
-
-    char_spec_handler(arg_formatter_base& f, Char val)
-        : formatter(f), value(val) {}
-
-    void on_int() {
-      // char is only formatted as int if there are specs.
-      formatter.write_int(static_cast<int>(value), *formatter.specs_);
-    }
-    void on_char() {
-      if (formatter.specs_)
-        formatter.out_ = write_char(formatter.out_, value, *formatter.specs_);
-      else
-        formatter.write(value);
-    }
-  };
-
-  struct cstring_spec_handler : error_handler {
-    arg_formatter_base& formatter;
-    const Char* value;
-
-    cstring_spec_handler(arg_formatter_base& f, const Char* val)
-        : formatter(f), value(val) {}
-
-    void on_string() { formatter.write(value); }
-    void on_pointer() { formatter.write_pointer(value); }
-  };
-
- protected:
-  iterator out() { return out_; }
-  format_specs* specs() { return specs_; }
-
-  void write(bool value) {
-    if (specs_)
-      write(string_view(value ? "true" : "false"), *specs_);
-    else
-      out_ = detail::write<Char>(out_, value);
-  }
-
-  void write(const Char* value) {
-    if (!value) {
-      FMT_THROW(format_error("string pointer is null"));
-    } else {
-      auto length = std::char_traits<char_type>::length(value);
-      basic_string_view<char_type> sv(value, length);
-      specs_ ? write(sv, *specs_) : write(sv);
-    }
-  }
-
- public:
-  arg_formatter_base(OutputIt out, format_specs* s, locale_ref loc)
-      : out_(out), locale_(loc), specs_(s) {}
-
-  iterator operator()(monostate) {
-    FMT_ASSERT(false, "invalid argument type");
-    return out_;
-  }
-
-  template <typename T, FMT_ENABLE_IF(is_integral<T>::value)>
-  FMT_INLINE iterator operator()(T value) {
-    if (specs_)
-      write_int(value, *specs_);
-    else
-      out_ = detail::write<Char>(out_, value);
-    return out_;
-  }
-
-  iterator operator()(Char value) {
-    handle_char_specs(specs_,
-                      char_spec_handler(*this, static_cast<Char>(value)));
-    return out_;
-  }
-
-  iterator operator()(bool value) {
-    if (specs_ && specs_->type) return (*this)(value ? 1 : 0);
-    write(value != 0);
-    return out_;
-  }
-
-  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-  iterator operator()(T value) {
-    auto specs = specs_ ? *specs_ : format_specs();
-    if (const_check(is_supported_floating_point(value)))
-      out_ = detail::write(out_, value, specs, locale_);
-    else
-      FMT_ASSERT(false, "unsupported float argument type");
-    return out_;
-  }
-
-  iterator operator()(const Char* value) {
-    if (!specs_) return write(value), out_;
-    handle_cstring_type_spec(specs_->type, cstring_spec_handler(*this, value));
-    return out_;
-  }
-
-  iterator operator()(basic_string_view<Char> value) {
-    if (specs_) {
-      check_string_type_spec(specs_->type, error_handler());
-      write(value, *specs_);
-    } else {
-      write(value);
-    }
-    return out_;
-  }
-
-  iterator operator()(const void* value) {
-    if (specs_) check_pointer_type_spec(specs_->type, error_handler());
-    write_pointer(value);
-    return out_;
+  auto operator()(typename basic_format_arg<context>::handle) -> iterator {
+    // User-defined types are handled separately because they require access
+    // to the parse context.
+    return out;
   }
 };
 
-/** The default argument formatter. */
-template <typename OutputIt, typename Char>
-class arg_formatter : public arg_formatter_base<OutputIt, Char> {
- private:
-  using char_type = Char;
-  using base = arg_formatter_base<OutputIt, Char>;
-  using context_type = basic_format_context<OutputIt, Char>;
+template <typename Char> struct custom_formatter {
+  basic_format_parse_context<Char>& parse_ctx;
+  buffer_context<Char>& ctx;
 
-  context_type& ctx_;
-  basic_format_parse_context<char_type>* parse_ctx_;
-  const Char* ptr_;
-
- public:
-  using iterator = typename base::iterator;
-  using format_specs = typename base::format_specs;
-
-  /**
-    \rst
-    Constructs an argument formatter object.
-    *ctx* is a reference to the formatting context,
-    *specs* contains format specifier information for standard argument types.
-    \endrst
-   */
-  explicit arg_formatter(
-      context_type& ctx,
-      basic_format_parse_context<char_type>* parse_ctx = nullptr,
-      format_specs* specs = nullptr, const Char* ptr = nullptr)
-      : base(ctx.out(), specs, ctx.locale()),
-        ctx_(ctx),
-        parse_ctx_(parse_ctx),
-        ptr_(ptr) {}
-
-  using base::operator();
-
-  /** Formats an argument of a user-defined type. */
-  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
-    if (ptr_) advance_to(*parse_ctx_, ptr_);
-    handle.format(*parse_ctx_, ctx_);
-    return ctx_.out();
+  void operator()(
+      typename basic_format_arg<buffer_context<Char>>::handle h) const {
+    h.format(parse_ctx, ctx);
   }
-};
-
-template <typename Char> FMT_CONSTEXPR bool is_name_start(Char c) {
-  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
-}
-
-// 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, typename ErrorHandler>
-FMT_CONSTEXPR int parse_nonnegative_int(const Char*& begin, const Char* end,
-                                        ErrorHandler&& eh) {
-  FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
-  unsigned value = 0;
-  // Convert to unsigned to prevent a warning.
-  constexpr unsigned max_int = max_value<int>();
-  unsigned big = max_int / 10;
-  do {
-    // Check for overflow.
-    if (value > big) {
-      value = max_int + 1;
-      break;
-    }
-    value = value * 10 + unsigned(*begin - '0');
-    ++begin;
-  } while (begin != end && '0' <= *begin && *begin <= '9');
-  if (value > max_int) eh.on_error("number is too big");
-  return static_cast<int>(value);
-}
-
-template <typename Context> class custom_formatter {
- private:
-  using char_type = typename Context::char_type;
-
-  basic_format_parse_context<char_type>& parse_ctx_;
-  Context& ctx_;
-
- public:
-  explicit custom_formatter(basic_format_parse_context<char_type>& parse_ctx,
-                            Context& ctx)
-      : parse_ctx_(parse_ctx), ctx_(ctx) {}
-
-  void operator()(typename basic_format_arg<Context>::handle h) const {
-    h.format(parse_ctx_, ctx_);
-  }
-
   template <typename T> void operator()(T) const {}
 };
 
@@ -2396,13 +2245,13 @@ template <typename ErrorHandler> class width_checker {
   explicit FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {}
 
   template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T value) {
+  FMT_CONSTEXPR auto operator()(T value) -> unsigned long long {
     if (is_negative(value)) handler_.on_error("negative width");
     return static_cast<unsigned long long>(value);
   }
 
   template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T) {
+  FMT_CONSTEXPR auto operator()(T) -> unsigned long long {
     handler_.on_error("width is not integer");
     return 0;
   }
@@ -2416,13 +2265,13 @@ template <typename ErrorHandler> class precision_checker {
   explicit FMT_CONSTEXPR precision_checker(ErrorHandler& eh) : handler_(eh) {}
 
   template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T value) {
+  FMT_CONSTEXPR auto operator()(T value) -> unsigned long long {
     if (is_negative(value)) handler_.on_error("negative precision");
     return static_cast<unsigned long long>(value);
   }
 
   template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T) {
+  FMT_CONSTEXPR auto operator()(T) -> unsigned long long {
     handler_.on_error("precision is not integer");
     return 0;
   }
@@ -2431,148 +2280,50 @@ template <typename ErrorHandler> class precision_checker {
   ErrorHandler& handler_;
 };
 
-// A format specifier handler that sets fields in basic_format_specs.
-template <typename Char> class specs_setter {
- public:
-  explicit FMT_CONSTEXPR specs_setter(basic_format_specs<Char>& specs)
-      : specs_(specs) {}
-
-  FMT_CONSTEXPR specs_setter(const specs_setter& other)
-      : specs_(other.specs_) {}
-
-  FMT_CONSTEXPR void on_align(align_t align) { specs_.align = align; }
-  FMT_CONSTEXPR void on_fill(basic_string_view<Char> fill) {
-    specs_.fill = fill;
-  }
-  FMT_CONSTEXPR void on_plus() { specs_.sign = sign::plus; }
-  FMT_CONSTEXPR void on_minus() { specs_.sign = sign::minus; }
-  FMT_CONSTEXPR void on_space() { specs_.sign = sign::space; }
-  FMT_CONSTEXPR void on_hash() { specs_.alt = true; }
-
-  FMT_CONSTEXPR void on_zero() {
-    specs_.align = align::numeric;
-    specs_.fill[0] = Char('0');
-  }
-
-  FMT_CONSTEXPR void on_width(int width) { specs_.width = width; }
-  FMT_CONSTEXPR void on_precision(int precision) {
-    specs_.precision = precision;
-  }
-  FMT_CONSTEXPR void end_precision() {}
-
-  FMT_CONSTEXPR void on_type(Char type) {
-    specs_.type = static_cast<char>(type);
-  }
-
- protected:
-  basic_format_specs<Char>& specs_;
-};
-
-template <typename ErrorHandler> class numeric_specs_checker {
- public:
-  FMT_CONSTEXPR numeric_specs_checker(ErrorHandler& eh, detail::type arg_type)
-      : error_handler_(eh), arg_type_(arg_type) {}
-
-  FMT_CONSTEXPR void require_numeric_argument() {
-    if (!is_arithmetic_type(arg_type_))
-      error_handler_.on_error("format specifier requires numeric argument");
-  }
-
-  FMT_CONSTEXPR void check_sign() {
-    require_numeric_argument();
-    if (is_integral_type(arg_type_) && arg_type_ != type::int_type &&
-        arg_type_ != type::long_long_type && arg_type_ != type::char_type) {
-      error_handler_.on_error("format specifier requires signed argument");
-    }
-  }
-
-  FMT_CONSTEXPR void check_precision() {
-    if (is_integral_type(arg_type_) || arg_type_ == type::pointer_type)
-      error_handler_.on_error("precision not allowed for this argument type");
-  }
-
- private:
-  ErrorHandler& error_handler_;
-  detail::type arg_type_;
-};
-
-// A format specifier handler that checks if specifiers are consistent with the
-// argument type.
-template <typename Handler> class specs_checker : public Handler {
- private:
-  numeric_specs_checker<Handler> checker_;
-
-  // Suppress an MSVC warning about using this in initializer list.
-  FMT_CONSTEXPR Handler& error_handler() { return *this; }
-
- public:
-  FMT_CONSTEXPR specs_checker(const Handler& handler, detail::type arg_type)
-      : Handler(handler), checker_(error_handler(), arg_type) {}
-
-  FMT_CONSTEXPR specs_checker(const specs_checker& other)
-      : Handler(other), checker_(error_handler(), other.arg_type_) {}
-
-  FMT_CONSTEXPR void on_align(align_t align) {
-    if (align == align::numeric) checker_.require_numeric_argument();
-    Handler::on_align(align);
-  }
-
-  FMT_CONSTEXPR void on_plus() {
-    checker_.check_sign();
-    Handler::on_plus();
-  }
-
-  FMT_CONSTEXPR void on_minus() {
-    checker_.check_sign();
-    Handler::on_minus();
-  }
-
-  FMT_CONSTEXPR void on_space() {
-    checker_.check_sign();
-    Handler::on_space();
-  }
-
-  FMT_CONSTEXPR void on_hash() {
-    checker_.require_numeric_argument();
-    Handler::on_hash();
-  }
-
-  FMT_CONSTEXPR void on_zero() {
-    checker_.require_numeric_argument();
-    Handler::on_zero();
-  }
-
-  FMT_CONSTEXPR void end_precision() { checker_.check_precision(); }
-};
-
 template <template <typename> class Handler, typename FormatArg,
           typename ErrorHandler>
-FMT_CONSTEXPR int get_dynamic_spec(FormatArg arg, ErrorHandler eh) {
+FMT_CONSTEXPR auto get_dynamic_spec(FormatArg arg, ErrorHandler eh) -> int {
   unsigned long long value = visit_format_arg(Handler<ErrorHandler>(eh), arg);
   if (value > to_unsigned(max_value<int>())) eh.on_error("number is too big");
   return static_cast<int>(value);
 }
 
-struct auto_id {};
-
 template <typename Context, typename ID>
-FMT_CONSTEXPR typename Context::format_arg get_arg(Context& ctx, ID id) {
+FMT_CONSTEXPR auto get_arg(Context& ctx, ID id) ->
+    typename Context::format_arg {
   auto arg = ctx.arg(id);
   if (!arg) ctx.on_error("argument not found");
   return arg;
 }
 
 // The standard format specifier handler with checking.
-template <typename ParseContext, typename Context>
-class specs_handler : public specs_setter<typename Context::char_type> {
- public:
-  using char_type = typename Context::char_type;
+template <typename Char> class specs_handler : public specs_setter<Char> {
+ private:
+  basic_format_parse_context<Char>& parse_context_;
+  buffer_context<Char>& context_;
 
-  FMT_CONSTEXPR specs_handler(basic_format_specs<char_type>& specs,
-                              ParseContext& parse_ctx, Context& ctx)
-      : specs_setter<char_type>(specs),
-        parse_context_(parse_ctx),
-        context_(ctx) {}
+  // This is only needed for compatibility with gcc 4.4.
+  using format_arg = basic_format_arg<buffer_context<Char>>;
+
+  FMT_CONSTEXPR auto get_arg(auto_id) -> format_arg {
+    return detail::get_arg(context_, parse_context_.next_arg_id());
+  }
+
+  FMT_CONSTEXPR auto get_arg(int arg_id) -> format_arg {
+    parse_context_.check_arg_id(arg_id);
+    return detail::get_arg(context_, arg_id);
+  }
+
+  FMT_CONSTEXPR auto get_arg(basic_string_view<Char> arg_id) -> format_arg {
+    parse_context_.check_arg_id(arg_id);
+    return detail::get_arg(context_, arg_id);
+  }
+
+ public:
+  FMT_CONSTEXPR specs_handler(basic_format_specs<Char>& specs,
+                              basic_format_parse_context<Char>& parse_ctx,
+                              buffer_context<Char>& ctx)
+      : specs_setter<Char>(specs), parse_context_(parse_ctx), context_(ctx) {}
 
   template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
     this->specs_.width = get_dynamic_spec<width_checker>(
@@ -2585,653 +2336,12 @@ class specs_handler : public specs_setter<typename Context::char_type> {
   }
 
   void on_error(const char* message) { context_.on_error(message); }
-
- private:
-  // This is only needed for compatibility with gcc 4.4.
-  using format_arg = typename Context::format_arg;
-
-  FMT_CONSTEXPR format_arg get_arg(auto_id) {
-    return detail::get_arg(context_, parse_context_.next_arg_id());
-  }
-
-  FMT_CONSTEXPR format_arg get_arg(int arg_id) {
-    parse_context_.check_arg_id(arg_id);
-    return detail::get_arg(context_, arg_id);
-  }
-
-  FMT_CONSTEXPR format_arg get_arg(basic_string_view<char_type> arg_id) {
-    parse_context_.check_arg_id(arg_id);
-    return detail::get_arg(context_, arg_id);
-  }
-
-  ParseContext& parse_context_;
-  Context& context_;
 };
 
-enum class arg_id_kind { none, index, name };
-
-// An argument reference.
-template <typename Char> struct arg_ref {
-  FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {}
-
-  FMT_CONSTEXPR explicit arg_ref(int index)
-      : kind(arg_id_kind::index), val(index) {}
-  FMT_CONSTEXPR explicit arg_ref(basic_string_view<Char> name)
-      : kind(arg_id_kind::name), val(name) {}
-
-  FMT_CONSTEXPR arg_ref& operator=(int idx) {
-    kind = arg_id_kind::index;
-    val.index = idx;
-    return *this;
-  }
-
-  arg_id_kind kind;
-  union value {
-    FMT_CONSTEXPR value(int id = 0) : index{id} {}
-    FMT_CONSTEXPR value(basic_string_view<Char> n) : name(n) {}
-
-    int index;
-    basic_string_view<Char> name;
-  } val;
-};
-
-// Format specifiers with width and precision resolved at formatting rather
-// than parsing time to allow re-using the same parsed specifiers with
-// different sets of arguments (precompilation of format strings).
-template <typename Char>
-struct dynamic_format_specs : basic_format_specs<Char> {
-  arg_ref<Char> width_ref;
-  arg_ref<Char> precision_ref;
-};
-
-// Format spec handler that saves references to arguments representing dynamic
-// width and precision to be resolved at formatting time.
-template <typename ParseContext>
-class dynamic_specs_handler
-    : public specs_setter<typename ParseContext::char_type> {
- public:
-  using char_type = typename ParseContext::char_type;
-
-  FMT_CONSTEXPR dynamic_specs_handler(dynamic_format_specs<char_type>& specs,
-                                      ParseContext& ctx)
-      : specs_setter<char_type>(specs), specs_(specs), context_(ctx) {}
-
-  FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler& other)
-      : specs_setter<char_type>(other),
-        specs_(other.specs_),
-        context_(other.context_) {}
-
-  template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
-    specs_.width_ref = make_arg_ref(arg_id);
-  }
-
-  template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
-    specs_.precision_ref = make_arg_ref(arg_id);
-  }
-
-  FMT_CONSTEXPR void on_error(const char* message) {
-    context_.on_error(message);
-  }
-
- private:
-  using arg_ref_type = arg_ref<char_type>;
-
-  FMT_CONSTEXPR arg_ref_type make_arg_ref(int arg_id) {
-    context_.check_arg_id(arg_id);
-    return arg_ref_type(arg_id);
-  }
-
-  FMT_CONSTEXPR arg_ref_type make_arg_ref(auto_id) {
-    return arg_ref_type(context_.next_arg_id());
-  }
-
-  FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<char_type> arg_id) {
-    context_.check_arg_id(arg_id);
-    basic_string_view<char_type> format_str(
-        context_.begin(), to_unsigned(context_.end() - context_.begin()));
-    return arg_ref_type(arg_id);
-  }
-
-  dynamic_format_specs<char_type>& specs_;
-  ParseContext& context_;
-};
-
-template <typename Char, typename IDHandler>
-FMT_CONSTEXPR const Char* parse_arg_id(const Char* begin, const Char* end,
-                                       IDHandler&& handler) {
-  FMT_ASSERT(begin != end, "");
-  Char c = *begin;
-  if (c == '}' || c == ':') {
-    handler();
-    return begin;
-  }
-  if (c >= '0' && c <= '9') {
-    int index = 0;
-    if (c != '0')
-      index = parse_nonnegative_int(begin, end, handler);
-    else
-      ++begin;
-    if (begin == end || (*begin != '}' && *begin != ':'))
-      handler.on_error("invalid format string");
-    else
-      handler(index);
-    return begin;
-  }
-  if (!is_name_start(c)) {
-    handler.on_error("invalid format string");
-    return begin;
-  }
-  auto it = begin;
-  do {
-    ++it;
-  } while (it != end && (is_name_start(c = *it) || ('0' <= c && c <= '9')));
-  handler(basic_string_view<Char>(begin, to_unsigned(it - begin)));
-  return it;
-}
-
-// Adapts SpecHandler to IDHandler API for dynamic width.
-template <typename SpecHandler, typename Char> struct width_adapter {
-  explicit FMT_CONSTEXPR width_adapter(SpecHandler& h) : handler(h) {}
-
-  FMT_CONSTEXPR void operator()() { handler.on_dynamic_width(auto_id()); }
-  FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_width(id); }
-  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
-    handler.on_dynamic_width(id);
-  }
-
-  FMT_CONSTEXPR void on_error(const char* message) {
-    handler.on_error(message);
-  }
-
-  SpecHandler& handler;
-};
-
-// Adapts SpecHandler to IDHandler API for dynamic precision.
-template <typename SpecHandler, typename Char> struct precision_adapter {
-  explicit FMT_CONSTEXPR precision_adapter(SpecHandler& h) : handler(h) {}
-
-  FMT_CONSTEXPR void operator()() { handler.on_dynamic_precision(auto_id()); }
-  FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_precision(id); }
-  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
-    handler.on_dynamic_precision(id);
-  }
-
-  FMT_CONSTEXPR void on_error(const char* message) {
-    handler.on_error(message);
-  }
-
-  SpecHandler& handler;
-};
-
-template <typename Char>
-FMT_CONSTEXPR int code_point_length(const Char* begin) {
-  if (const_check(sizeof(Char) != 1)) return 1;
-  constexpr char lengths[] = {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, 0};
-  int len = lengths[static_cast<unsigned char>(*begin) >> 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.
-  return len + !len;
-}
-
-template <typename Char> constexpr bool is_ascii_letter(Char c) {
-  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
-}
-
-// Converts a character to ASCII. Returns a number > 127 on conversion failure.
-template <typename Char, FMT_ENABLE_IF(std::is_integral<Char>::value)>
-constexpr Char to_ascii(Char value) {
-  return value;
-}
-template <typename Char, FMT_ENABLE_IF(std::is_enum<Char>::value)>
-constexpr typename std::underlying_type<Char>::type to_ascii(Char value) {
-  return value;
-}
-
-// Parses fill and alignment.
-template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char* parse_align(const Char* begin, const Char* end,
-                                      Handler&& handler) {
-  FMT_ASSERT(begin != end, "");
-  auto align = align::none;
-  auto p = begin + code_point_length(begin);
-  if (p >= end) p = begin;
-  for (;;) {
-    switch (to_ascii(*p)) {
-    case '<':
-      align = align::left;
-      break;
-    case '>':
-      align = align::right;
-      break;
-#if FMT_DEPRECATED_NUMERIC_ALIGN
-    case '=':
-      align = align::numeric;
-      break;
-#endif
-    case '^':
-      align = align::center;
-      break;
-    }
-    if (align != align::none) {
-      if (p != begin) {
-        auto c = *begin;
-        if (c == '{')
-          return handler.on_error("invalid fill character '{'"), begin;
-        handler.on_fill(basic_string_view<Char>(begin, to_unsigned(p - begin)));
-        begin = p + 1;
-      } else
-        ++begin;
-      handler.on_align(align);
-      break;
-    } else if (p == begin) {
-      break;
-    }
-    p = begin;
-  }
-  return begin;
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char* parse_width(const Char* begin, const Char* end,
-                                      Handler&& handler) {
-  FMT_ASSERT(begin != end, "");
-  if ('0' <= *begin && *begin <= '9') {
-    handler.on_width(parse_nonnegative_int(begin, end, handler));
-  } else if (*begin == '{') {
-    ++begin;
-    if (begin != end)
-      begin = parse_arg_id(begin, end, width_adapter<Handler, Char>(handler));
-    if (begin == end || *begin != '}')
-      return handler.on_error("invalid format string"), begin;
-    ++begin;
-  }
-  return begin;
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char* parse_precision(const Char* begin, const Char* end,
-                                          Handler&& handler) {
-  ++begin;
-  auto c = begin != end ? *begin : Char();
-  if ('0' <= c && c <= '9') {
-    handler.on_precision(parse_nonnegative_int(begin, end, handler));
-  } else if (c == '{') {
-    ++begin;
-    if (begin != end) {
-      begin =
-          parse_arg_id(begin, end, precision_adapter<Handler, Char>(handler));
-    }
-    if (begin == end || *begin++ != '}')
-      return handler.on_error("invalid format string"), begin;
-  } else {
-    return handler.on_error("missing precision specifier"), begin;
-  }
-  handler.end_precision();
-  return begin;
-}
-
-// Parses standard format specifiers and sends notifications about parsed
-// components to handler.
-template <typename Char, typename SpecHandler>
-FMT_CONSTEXPR const Char* parse_format_specs(const Char* begin, const Char* end,
-                                             SpecHandler&& handler) {
-  if (begin == end) return begin;
-
-  begin = parse_align(begin, end, handler);
-  if (begin == end) return begin;
-
-  // Parse sign.
-  switch (to_ascii(*begin)) {
-  case '+':
-    handler.on_plus();
-    ++begin;
-    break;
-  case '-':
-    handler.on_minus();
-    ++begin;
-    break;
-  case ' ':
-    handler.on_space();
-    ++begin;
-    break;
-  }
-  if (begin == end) return begin;
-
-  if (*begin == '#') {
-    handler.on_hash();
-    if (++begin == end) return begin;
-  }
-
-  // Parse zero flag.
-  if (*begin == '0') {
-    handler.on_zero();
-    if (++begin == end) return begin;
-  }
-
-  begin = parse_width(begin, end, handler);
-  if (begin == end) return begin;
-
-  // Parse precision.
-  if (*begin == '.') {
-    begin = parse_precision(begin, end, handler);
-  }
-
-  // Parse type.
-  if (begin != end && *begin != '}') handler.on_type(*begin++);
-  return begin;
-}
-
-// Return the result via the out param to workaround gcc bug 77539.
-template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
-FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr& out) {
-  for (out = first; out != last; ++out) {
-    if (*out == value) return true;
-  }
-  return false;
-}
-
-template <>
-inline bool find<false, char>(const char* first, const char* last, char value,
-                              const char*& out) {
-  out = static_cast<const char*>(
-      std::memchr(first, value, detail::to_unsigned(last - first)));
-  return out != nullptr;
-}
-
-template <typename Handler, typename Char> struct id_adapter {
-  Handler& handler;
-  int arg_id;
-
-  FMT_CONSTEXPR void operator()() { arg_id = handler.on_arg_id(); }
-  FMT_CONSTEXPR void operator()(int id) { arg_id = handler.on_arg_id(id); }
-  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
-    arg_id = handler.on_arg_id(id);
-  }
-  FMT_CONSTEXPR void on_error(const char* message) {
-    handler.on_error(message);
-  }
-};
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char* parse_replacement_field(const Char* begin,
-                                                  const Char* end,
-                                                  Handler&& handler) {
-  ++begin;
-  if (begin == end) return handler.on_error("invalid format string"), end;
-  if (*begin == '}') {
-    handler.on_replacement_field(handler.on_arg_id(), begin);
-  } else if (*begin == '{') {
-    handler.on_text(begin, begin + 1);
-  } else {
-    auto adapter = id_adapter<Handler, Char>{handler, 0};
-    begin = parse_arg_id(begin, end, adapter);
-    Char c = begin != end ? *begin : Char();
-    if (c == '}') {
-      handler.on_replacement_field(adapter.arg_id, begin);
-    } else if (c == ':') {
-      begin = handler.on_format_specs(adapter.arg_id, begin + 1, end);
-      if (begin == end || *begin != '}')
-        return handler.on_error("unknown format specifier"), end;
-    } else {
-      return handler.on_error("missing '}' in format string"), end;
-    }
-  }
-  return begin + 1;
-}
-
-template <bool IS_CONSTEXPR, typename Char, typename Handler>
-FMT_CONSTEXPR_DECL FMT_INLINE void parse_format_string(
-    basic_string_view<Char> format_str, Handler&& handler) {
-  auto begin = format_str.data();
-  auto end = begin + format_str.size();
-  if (end - begin < 32) {
-    // Use a simple loop instead of memchr for small strings.
-    const Char* 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);
-    return;
-  }
-  struct writer {
-    FMT_CONSTEXPR void operator()(const Char* pbegin, const Char* pend) {
-      if (pbegin == pend) return;
-      for (;;) {
-        const Char* p = nullptr;
-        if (!find<IS_CONSTEXPR>(pbegin, pend, '}', p))
-          return handler_.on_text(pbegin, pend);
-        ++p;
-        if (p == pend || *p != '}')
-          return handler_.on_error("unmatched '}' in format string");
-        handler_.on_text(pbegin, p);
-        pbegin = p + 1;
-      }
-    }
-    Handler& handler_;
-  } write{handler};
-  while (begin != end) {
-    // Doing two passes with memchr (one for '{' and another for '}') is up to
-    // 2.5x faster than the naive one-pass implementation on big format strings.
-    const Char* p = begin;
-    if (*begin != '{' && !find<IS_CONSTEXPR>(begin + 1, end, '{', p))
-      return write(begin, end);
-    write(begin, p);
-    begin = parse_replacement_field(p, end, handler);
-  }
-}
-
-template <typename T, typename ParseContext>
-FMT_CONSTEXPR const typename ParseContext::char_type* parse_format_specs(
-    ParseContext& ctx) {
-  using char_type = typename ParseContext::char_type;
-  using context = buffer_context<char_type>;
-  using mapped_type =
-      conditional_t<detail::mapped_type_constant<T, context>::value !=
-                        type::custom_type,
-                    decltype(arg_mapper<context>().map(std::declval<T>())), T>;
-  auto f = conditional_t<has_formatter<mapped_type, context>::value,
-                         formatter<mapped_type, char_type>,
-                         detail::fallback_formatter<T, char_type>>();
-  return f.parse(ctx);
-}
-
-template <typename OutputIt, typename Char, typename Context>
-struct format_handler : detail::error_handler {
-  basic_format_parse_context<Char> parse_context;
-  Context context;
-
-  format_handler(OutputIt out, basic_string_view<Char> str,
-                 basic_format_args<Context> format_args, detail::locale_ref loc)
-      : parse_context(str), context(out, format_args, loc) {}
-
-  void on_text(const Char* begin, const Char* end) {
-    auto size = to_unsigned(end - begin);
-    auto out = context.out();
-    auto&& it = reserve(out, size);
-    it = std::copy_n(begin, size, it);
-    context.advance_to(out);
-  }
-
-  int on_arg_id() { return parse_context.next_arg_id(); }
-  int on_arg_id(int id) { return parse_context.check_arg_id(id), id; }
-  int on_arg_id(basic_string_view<Char> id) {
-    int arg_id = context.arg_id(id);
-    if (arg_id < 0) on_error("argument not found");
-    return arg_id;
-  }
-
-  FMT_INLINE void on_replacement_field(int id, const Char*) {
-    auto arg = get_arg(context, id);
-    context.advance_to(visit_format_arg(
-        default_arg_formatter<OutputIt, Char>{context.out(), context.args(),
-                                              context.locale()},
-        arg));
-  }
-
-  const Char* on_format_specs(int id, const Char* begin, const Char* end) {
-    auto arg = get_arg(context, id);
-    if (arg.type() == type::custom_type) {
-      advance_to(parse_context, begin);
-      visit_format_arg(custom_formatter<Context>(parse_context, context), arg);
-      return parse_context.begin();
-    }
-    auto specs = basic_format_specs<Char>();
-    if (begin + 1 < end && begin[1] == '}' && is_ascii_letter(*begin)) {
-      specs.type = static_cast<char>(*begin++);
-    } else {
-      using parse_context_t = basic_format_parse_context<Char>;
-      specs_checker<specs_handler<parse_context_t, Context>> handler(
-          specs_handler<parse_context_t, Context>(specs, parse_context,
-                                                  context),
-          arg.type());
-      begin = parse_format_specs(begin, end, handler);
-      if (begin == end || *begin != '}')
-        on_error("missing '}' in format string");
-    }
-    context.advance_to(visit_format_arg(
-        arg_formatter<OutputIt, Char>(context, &parse_context, &specs), arg));
-    return begin;
-  }
-};
-
-// A parse context with extra argument id checks. It is only used at compile
-// time because adding checks at runtime would introduce substantial overhead
-// and would be redundant since argument ids are checked when arguments are
-// retrieved anyway.
-template <typename Char, typename ErrorHandler = error_handler>
-class compile_parse_context
-    : public basic_format_parse_context<Char, ErrorHandler> {
- private:
-  int num_args_;
-  using base = basic_format_parse_context<Char, ErrorHandler>;
-
- public:
-  explicit FMT_CONSTEXPR compile_parse_context(
-      basic_string_view<Char> format_str, int num_args = max_value<int>(),
-      ErrorHandler eh = {})
-      : base(format_str, eh), num_args_(num_args) {}
-
-  FMT_CONSTEXPR int next_arg_id() {
-    int id = base::next_arg_id();
-    if (id >= num_args_) this->on_error("argument not found");
-    return id;
-  }
-
-  FMT_CONSTEXPR void check_arg_id(int id) {
-    base::check_arg_id(id);
-    if (id >= num_args_) this->on_error("argument not found");
-  }
-  using base::check_arg_id;
-};
-
-template <typename Char, typename ErrorHandler, typename... Args>
-class format_string_checker {
- public:
-  explicit FMT_CONSTEXPR format_string_checker(
-      basic_string_view<Char> format_str, ErrorHandler eh)
-      : context_(format_str, num_args, eh),
-        parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
-
-  FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
-
-  FMT_CONSTEXPR int on_arg_id() { return context_.next_arg_id(); }
-  FMT_CONSTEXPR int on_arg_id(int id) { return context_.check_arg_id(id), id; }
-  FMT_CONSTEXPR int on_arg_id(basic_string_view<Char>) {
-    on_error("compile-time checks don't support named arguments");
-    return 0;
-  }
-
-  FMT_CONSTEXPR void on_replacement_field(int, const Char*) {}
-
-  FMT_CONSTEXPR const Char* on_format_specs(int id, const Char* begin,
-                                            const Char*) {
-    advance_to(context_, begin);
-    return id < num_args ? parse_funcs_[id](context_) : begin;
-  }
-
-  FMT_CONSTEXPR void on_error(const char* message) {
-    context_.on_error(message);
-  }
-
- private:
-  using parse_context_type = compile_parse_context<Char, ErrorHandler>;
-  enum { num_args = sizeof...(Args) };
-
-  // Format specifier parsing function.
-  using parse_func = const Char* (*)(parse_context_type&);
-
-  parse_context_type context_;
-  parse_func parse_funcs_[num_args > 0 ? num_args : 1];
-};
-
-// Converts string literals to basic_string_view.
-template <typename Char, size_t N>
-FMT_CONSTEXPR basic_string_view<Char> compile_string_to_view(
-    const Char (&s)[N]) {
-  // Remove trailing null character if needed. Won't be present if this is used
-  // with 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)};
-}
-
-// Converts string_view to basic_string_view.
-template <typename Char>
-FMT_CONSTEXPR basic_string_view<Char> compile_string_to_view(
-    const std_string_view<Char>& s) {
-  return {s.data(), s.size()};
-}
-
-#define FMT_STRING_IMPL(s, base)                                  \
-  [] {                                                            \
-    /* Use a macro-like name to avoid shadowing warnings. */      \
-    struct FMT_COMPILE_STRING : base {                            \
-      using char_type = fmt::remove_cvref_t<decltype(s[0])>;      \
-      FMT_MAYBE_UNUSED FMT_CONSTEXPR                              \
-      operator fmt::basic_string_view<char_type>() const {        \
-        return fmt::detail::compile_string_to_view<char_type>(s); \
-      }                                                           \
-    };                                                            \
-    return FMT_COMPILE_STRING();                                  \
-  }()
-
-/**
-  \rst
-  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");
-  \endrst
- */
-#define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::compile_string)
-
-template <typename... Args, typename S,
-          enable_if_t<(is_compile_string<S>::value), int>>
-void check_format_string(S format_str) {
-  FMT_CONSTEXPR_DECL auto s = to_string_view(format_str);
-  using checker = format_string_checker<typename S::char_type, error_handler,
-                                        remove_cvref_t<Args>...>;
-  FMT_CONSTEXPR_DECL bool invalid_format =
-      (parse_format_string<true>(s, checker(s, {})), true);
-  (void)invalid_format;
-}
-
 template <template <typename> class Handler, typename Context>
-void handle_dynamic_spec(int& value, arg_ref<typename Context::char_type> ref,
-                         Context& ctx) {
+FMT_CONSTEXPR void handle_dynamic_spec(int& value,
+                                       arg_ref<typename Context::char_type> ref,
+                                       Context& ctx) {
   switch (ref.kind) {
   case arg_id_kind::none:
     break;
@@ -3246,89 +2356,146 @@ void handle_dynamic_spec(int& value, arg_ref<typename Context::char_type> ref,
   }
 }
 
-using format_func = void (*)(detail::buffer<char>&, int, string_view);
+#define FMT_STRING_IMPL(s, base, explicit)                                 \
+  [] {                                                                     \
+    /* Use the hidden visibility as a workaround for a GCC bug (#1973). */ \
+    /* Use a macro-like name to avoid shadowing warnings. */               \
+    struct FMT_GCC_VISIBILITY_HIDDEN FMT_COMPILE_STRING : base {           \
+      using char_type = fmt::remove_cvref_t<decltype(s[0])>;               \
+      FMT_MAYBE_UNUSED FMT_CONSTEXPR explicit                              \
+      operator fmt::basic_string_view<char_type>() const {                 \
+        return fmt::detail_exported::compile_string_to_view<char_type>(s); \
+      }                                                                    \
+    };                                                                     \
+    return FMT_COMPILE_STRING();                                           \
+  }()
+
+/**
+  \rst
+  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");
+  \endrst
+ */
+#define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::compile_string, )
+
+#if FMT_USE_USER_DEFINED_LITERALS
+template <typename Char> struct udl_formatter {
+  basic_string_view<Char> str;
+
+  template <typename... T>
+  auto operator()(T&&... args) const -> std::basic_string<Char> {
+    return vformat(str, fmt::make_args_checked<T...>(str, args...));
+  }
+};
+
+#  if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+template <typename T, typename Char, size_t N,
+          fmt::detail_exported::fixed_string<Char, N> Str>
+struct statically_named_arg : view {
+  static constexpr auto name = Str.data;
+
+  const T& value;
+  statically_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<statically_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_statically_named_arg<statically_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 statically_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
+#endif  // FMT_USE_USER_DEFINED_LITERALS
+
+template <typename Locale, typename Char>
+auto vformat(const Locale& loc, basic_string_view<Char> format_str,
+             basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
+  basic_memory_buffer<Char> buffer;
+  detail::vformat_to(buffer, format_str, args, detail::locale_ref(loc));
+  return {buffer.data(), buffer.size()};
+}
+
+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) FMT_NOEXCEPT;
 
 FMT_API void report_error(format_func func, int error_code,
-                          string_view message) FMT_NOEXCEPT;
-}  // namespace detail
+                          const char* message) FMT_NOEXCEPT;
+FMT_END_DETAIL_NAMESPACE
 
-template <typename OutputIt, typename Char>
-using arg_formatter FMT_DEPRECATED_ALIAS =
-    detail::arg_formatter<OutputIt, Char>;
+FMT_API auto vsystem_error(int error_code, string_view format_str,
+                           format_args args) -> std::system_error;
 
 /**
- An error returned by an operating system or a language runtime,
- for example a file opening error.
+ \rst
+ Constructs :class:`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";
+   std::FILE* file = std::fopen(filename, "r");
+   if (!file)
+     throw fmt::system_error(errno, "cannot open file '{}'", filename);
+ \endrst
 */
-FMT_CLASS_API
-class FMT_API system_error : public std::runtime_error {
- private:
-  void init(int err_code, string_view format_str, format_args args);
-
- protected:
-  int error_code_;
-
-  system_error() : std::runtime_error(""), error_code_(0) {}
-
- public:
-  /**
-   \rst
-   Constructs a :class:`fmt::system_error` object with a description
-   formatted with `fmt::format_system_error`. *message* and additional
-   arguments passed into the constructor are formatted similarly to
-   `fmt::format`.
-
-   **Example**::
-
-     // This throws a system_error with the description
-     //   cannot open file 'madeup': No such file or directory
-     // or similar (system message may vary).
-     const char *filename = "madeup";
-     std::FILE *file = std::fopen(filename, "r");
-     if (!file)
-       throw fmt::system_error(errno, "cannot open file '{}'", filename);
-   \endrst
-  */
-  template <typename... Args>
-  system_error(int error_code, string_view message, const Args&... args)
-      : std::runtime_error("") {
-    init(error_code, message, make_format_args(args...));
-  }
-  system_error(const system_error&) = default;
-  system_error& operator=(const system_error&) = default;
-  system_error(system_error&&) = default;
-  system_error& operator=(system_error&&) = default;
-  ~system_error() FMT_NOEXCEPT FMT_OVERRIDE;
-
-  int error_code() const { return error_code_; }
-};
+template <typename... T>
+auto system_error(int error_code, format_string<T...> fmt, T&&... args)
+    -> std::system_error {
+  return vsystem_error(error_code, fmt, fmt::make_format_args(args...));
+}
 
 /**
   \rst
-  Formats an error returned by an operating system or a language runtime,
-  for example a file opening error, and writes it to *out* in the following
-  form:
+  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:
 
   .. parsed-literal::
      *<message>*: *<system-message>*
 
-  where *<message>* is the passed message and *<system-message>* is
-  the system message corresponding to the error code.
+  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``.
-  If *error_code* is not a valid error code such as -1, the system message
-  may look like "Unknown error -1" and is platform-dependent.
   \endrst
  */
 FMT_API void format_system_error(detail::buffer<char>& out, int error_code,
-                                 string_view message) FMT_NOEXCEPT;
+                                 const char* message) FMT_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,
-                                 string_view message) FMT_NOEXCEPT;
+                                 const char* message) FMT_NOEXCEPT;
 
 /** Fast integer formatter. */
 class format_int {
@@ -3339,12 +2506,12 @@ class format_int {
   mutable char buffer_[buffer_size];
   char* str_;
 
-  template <typename UInt> char* format_unsigned(UInt value) {
+  template <typename UInt> auto format_unsigned(UInt value) -> char* {
     auto n = static_cast<detail::uint32_or_64_or_128_t<UInt>>(value);
     return detail::format_decimal(buffer_, n, buffer_size - 1).begin;
   }
 
-  template <typename Int> char* format_signed(Int value) {
+  template <typename Int> 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;
@@ -3363,7 +2530,7 @@ class format_int {
       : str_(format_unsigned(value)) {}
 
   /** Returns the number of characters written to the output buffer. */
-  size_t size() const {
+  auto size() const -> size_t {
     return detail::to_unsigned(buffer_ - str_ + buffer_size - 1);
   }
 
@@ -3371,13 +2538,13 @@ class format_int {
     Returns a pointer to the output buffer content. No terminating null
     character is appended.
    */
-  const char* data() const { return str_; }
+  auto data() const -> const char* { return str_; }
 
   /**
     Returns a pointer to the output buffer content with terminating null
     character appended.
    */
-  const char* c_str() const {
+  auto c_str() const -> const char* {
     buffer_[buffer_size - 1] = '\0';
     return str_;
   }
@@ -3387,104 +2554,37 @@ class format_int {
     Returns the content of the output buffer as an ``std::string``.
     \endrst
    */
-  std::string str() const { return std::string(str_, size()); }
+  auto str() const -> std::string { return std::string(str_, size()); }
 };
 
-// A formatter specialization for the core types corresponding to detail::type
-// constants.
 template <typename T, typename Char>
-struct formatter<T, Char,
-                 enable_if_t<detail::type_constant<T, Char>::value !=
-                             detail::type::custom_type>> {
-  FMT_CONSTEXPR formatter() = default;
-
-  // Parses format specifiers stopping either at the end of the range or at the
-  // terminating '}'.
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    using handler_type = detail::dynamic_specs_handler<ParseContext>;
-    auto type = detail::type_constant<T, Char>::value;
-    detail::specs_checker<handler_type> handler(handler_type(specs_, ctx),
-                                                type);
-    auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
-    auto eh = ctx.error_handler();
-    switch (type) {
-    case detail::type::none_type:
-      FMT_ASSERT(false, "invalid argument type");
-      break;
-    case detail::type::int_type:
-    case detail::type::uint_type:
-    case detail::type::long_long_type:
-    case detail::type::ulong_long_type:
-    case detail::type::int128_type:
-    case detail::type::uint128_type:
-    case detail::type::bool_type:
-      handle_int_type_spec(specs_.type,
-                           detail::int_type_checker<decltype(eh)>(eh));
-      break;
-    case detail::type::char_type:
-      handle_char_specs(
-          &specs_, detail::char_specs_checker<decltype(eh)>(specs_.type, eh));
-      break;
-    case detail::type::float_type:
-      if (detail::const_check(FMT_USE_FLOAT))
-        detail::parse_float_type_spec(specs_, eh);
-      else
-        FMT_ASSERT(false, "float support disabled");
-      break;
-    case detail::type::double_type:
-      if (detail::const_check(FMT_USE_DOUBLE))
-        detail::parse_float_type_spec(specs_, eh);
-      else
-        FMT_ASSERT(false, "double support disabled");
-      break;
-    case detail::type::long_double_type:
-      if (detail::const_check(FMT_USE_LONG_DOUBLE))
-        detail::parse_float_type_spec(specs_, eh);
-      else
-        FMT_ASSERT(false, "long double support disabled");
-      break;
-    case detail::type::cstring_type:
-      detail::handle_cstring_type_spec(
-          specs_.type, detail::cstring_type_checker<decltype(eh)>(eh));
-      break;
-    case detail::type::string_type:
-      detail::check_string_type_spec(specs_.type, eh);
-      break;
-    case detail::type::pointer_type:
-      detail::check_pointer_type_spec(specs_.type, eh);
-      break;
-    case detail::type::custom_type:
-      // Custom format specifiers should be checked in parse functions of
-      // formatter specializations.
-      break;
-    }
-    return it;
-  }
-
-  template <typename FormatContext>
-  auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
-    detail::handle_dynamic_spec<detail::width_checker>(specs_.width,
-                                                       specs_.width_ref, ctx);
+template <typename FormatContext>
+FMT_CONSTEXPR FMT_INLINE auto
+formatter<T, Char,
+          enable_if_t<detail::type_constant<T, Char>::value !=
+                      detail::type::custom_type>>::format(const T& val,
+                                                          FormatContext& ctx)
+    const -> decltype(ctx.out()) {
+  if (specs_.width_ref.kind != detail::arg_id_kind::none ||
+      specs_.precision_ref.kind != detail::arg_id_kind::none) {
+    auto specs = specs_;
+    detail::handle_dynamic_spec<detail::width_checker>(specs.width,
+                                                       specs.width_ref, ctx);
     detail::handle_dynamic_spec<detail::precision_checker>(
-        specs_.precision, specs_.precision_ref, ctx);
-    using af = detail::arg_formatter<typename FormatContext::iterator,
-                                     typename FormatContext::char_type>;
-    return visit_format_arg(af(ctx, nullptr, &specs_),
-                            detail::make_arg<FormatContext>(val));
+        specs.precision, specs.precision_ref, ctx);
+    return detail::write<Char>(ctx.out(), val, specs, ctx.locale());
   }
+  return detail::write<Char>(ctx.out(), val, specs_, ctx.locale());
+}
 
- private:
-  detail::dynamic_format_specs<Char> specs_;
-};
-
-#define FMT_FORMAT_AS(Type, Base)                                             \
-  template <typename Char>                                                    \
-  struct formatter<Type, Char> : formatter<Base, Char> {                      \
-    template <typename FormatContext>                                         \
-    auto format(Type const& val, FormatContext& ctx) -> decltype(ctx.out()) { \
-      return formatter<Base, Char>::format(val, ctx);                         \
-    }                                                                         \
+#define FMT_FORMAT_AS(Type, Base)                                        \
+  template <typename Char>                                               \
+  struct formatter<Type, Char> : formatter<Base, Char> {                 \
+    template <typename FormatContext>                                    \
+    auto format(Type const& val, FormatContext& ctx) const               \
+        -> decltype(ctx.out()) {                                         \
+      return formatter<Base, Char>::format(static_cast<Base>(val), ctx); \
+    }                                                                    \
   }
 
 FMT_FORMAT_AS(signed char, int);
@@ -3496,12 +2596,13 @@ FMT_FORMAT_AS(unsigned long, unsigned long long);
 FMT_FORMAT_AS(Char*, const Char*);
 FMT_FORMAT_AS(std::basic_string<Char>, basic_string_view<Char>);
 FMT_FORMAT_AS(std::nullptr_t, const void*);
+FMT_FORMAT_AS(detail::byte, unsigned char);
 FMT_FORMAT_AS(detail::std_string_view<Char>, basic_string_view<Char>);
 
 template <typename Char>
 struct formatter<void*, Char> : formatter<const void*, Char> {
   template <typename FormatContext>
-  auto format(void* val, FormatContext& ctx) -> decltype(ctx.out()) {
+  auto format(void* val, FormatContext& ctx) const -> decltype(ctx.out()) {
     return formatter<const void*, Char>::format(val, ctx);
   }
 };
@@ -3509,7 +2610,8 @@ struct formatter<void*, Char> : formatter<const void*, Char> {
 template <typename Char, size_t N>
 struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {
   template <typename FormatContext>
-  auto format(const Char* val, FormatContext& ctx) -> decltype(ctx.out()) {
+  FMT_CONSTEXPR auto format(const Char* val, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
     return formatter<basic_string_view<Char>, Char>::format(val, ctx);
   }
 };
@@ -3528,21 +2630,29 @@ struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {
 //   };
 template <typename Char = char> class dynamic_formatter {
  private:
+  detail::dynamic_format_specs<Char> specs_;
+  const Char* format_str_;
+
   struct null_handler : detail::error_handler {
     void on_align(align_t) {}
-    void on_plus() {}
-    void on_minus() {}
-    void on_space() {}
+    void on_sign(sign_t) {}
     void on_hash() {}
   };
 
+  template <typename Context> void handle_specs(Context& ctx) {
+    detail::handle_dynamic_spec<detail::width_checker>(specs_.width,
+                                                       specs_.width_ref, ctx);
+    detail::handle_dynamic_spec<detail::precision_checker>(
+        specs_.precision, specs_.precision_ref, ctx);
+  }
+
  public:
   template <typename ParseContext>
-  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
     format_str_ = ctx.begin();
     // Checks are deferred to formatting time when the argument type is known.
     detail::dynamic_specs_handler<ParseContext> handler(specs_, ctx);
-    return parse_format_specs(ctx.begin(), ctx.end(), handler);
+    return detail::parse_format_specs(ctx.begin(), ctx.end(), handler);
   }
 
   template <typename T, typename FormatContext>
@@ -3551,46 +2661,13 @@ template <typename Char = char> class dynamic_formatter {
     detail::specs_checker<null_handler> checker(
         null_handler(), detail::mapped_type_constant<T, FormatContext>::value);
     checker.on_align(specs_.align);
-    switch (specs_.sign) {
-    case sign::none:
-      break;
-    case sign::plus:
-      checker.on_plus();
-      break;
-    case sign::minus:
-      checker.on_minus();
-      break;
-    case sign::space:
-      checker.on_space();
-      break;
-    }
+    if (specs_.sign != sign::none) checker.on_sign(specs_.sign);
     if (specs_.alt) checker.on_hash();
     if (specs_.precision >= 0) checker.end_precision();
-    using af = detail::arg_formatter<typename FormatContext::iterator,
-                                     typename FormatContext::char_type>;
-    visit_format_arg(af(ctx, nullptr, &specs_),
-                     detail::make_arg<FormatContext>(val));
-    return ctx.out();
+    return detail::write<Char>(ctx.out(), val, specs_, ctx.locale());
   }
-
- private:
-  template <typename Context> void handle_specs(Context& ctx) {
-    detail::handle_dynamic_spec<detail::width_checker>(specs_.width,
-                                                       specs_.width_ref, ctx);
-    detail::handle_dynamic_spec<detail::precision_checker>(
-        specs_.precision, specs_.precision_ref, ctx);
-  }
-
-  detail::dynamic_format_specs<Char> specs_;
-  const Char* format_str_;
 };
 
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR void advance_to(
-    basic_format_parse_context<Char, ErrorHandler>& ctx, const Char* p) {
-  ctx.advance_to(ctx.begin() + (p - &*ctx.begin()));
-}
-
 /**
   \rst
   Converts ``p`` to ``const void*`` for pointer formatting.
@@ -3600,11 +2677,14 @@ FMT_CONSTEXPR void advance_to(
     auto s = fmt::format("{}", fmt::ptr(p));
   \endrst
  */
-template <typename T> inline const void* ptr(const T* p) { return p; }
-template <typename T> inline const void* ptr(const std::unique_ptr<T>& p) {
+template <typename T> auto ptr(T p) -> const void* {
+  static_assert(std::is_pointer<T>::value, "");
+  return detail::bit_cast<const void*>(p);
+}
+template <typename T> auto ptr(const std::unique_ptr<T>& p) -> const void* {
   return p.get();
 }
-template <typename T> inline const void* ptr(const std::shared_ptr<T>& p) {
+template <typename T> auto ptr(const std::shared_ptr<T>& p) -> const void* {
   return p.get();
 }
 
@@ -3642,31 +2722,114 @@ template <> struct formatter<bytes> {
   }
 };
 
-template <typename It, typename Sentinel, typename Char>
-struct arg_join : detail::view {
+// group_digits_view is not derived from view because it copies the argument.
+template <typename T> struct group_digits_view { T value; };
+
+/**
+  \rst
+  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"
+  \endrst
+ */
+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<char> specs_;
+
+ public:
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    using handler_type = detail::dynamic_specs_handler<ParseContext>;
+    detail::specs_checker<handler_type> handler(handler_type(specs_, ctx),
+                                                detail::type::int_type);
+    auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
+    detail::check_string_type_spec(specs_.type, ctx.error_handler());
+    return it;
+  }
+
+  template <typename FormatContext>
+  auto format(group_digits_view<T> t, FormatContext& ctx)
+      -> decltype(ctx.out()) {
+    detail::handle_dynamic_spec<detail::width_checker>(specs_.width,
+                                                       specs_.width_ref, ctx);
+    detail::handle_dynamic_spec<detail::precision_checker>(
+        specs_.precision, specs_.precision_ref, ctx);
+    return detail::write_int_localized(
+        ctx.out(), static_cast<detail::uint64_or_128_t<T>>(t.value), 0, specs_,
+        detail::digit_grouping<char>({"\3", ','}));
+  }
+};
+
+template <typename It, typename Sentinel, typename Char = char>
+struct join_view : detail::view {
   It begin;
   Sentinel end;
   basic_string_view<Char> sep;
 
-  arg_join(It b, Sentinel e, basic_string_view<Char> s)
+  join_view(It b, Sentinel e, basic_string_view<Char> s)
       : begin(b), end(e), sep(s) {}
 };
 
 template <typename It, typename Sentinel, typename Char>
-struct formatter<arg_join<It, Sentinel, Char>, Char>
-    : formatter<typename std::iterator_traits<It>::value_type, Char> {
+using arg_join FMT_DEPRECATED_ALIAS = join_view<It, Sentinel, Char>;
+
+template <typename It, typename Sentinel, typename Char>
+struct formatter<join_view<It, Sentinel, Char>, Char> {
+ private:
+  using value_type =
+#ifdef __cpp_lib_ranges
+      std::iter_value_t<It>;
+#else
+      typename std::iterator_traits<It>::value_type;
+#endif
+  using context = buffer_context<Char>;
+  using mapper = detail::arg_mapper<context>;
+
+  template <typename T, FMT_ENABLE_IF(has_formatter<T, context>::value)>
+  static auto map(const T& value) -> const T& {
+    return value;
+  }
+  template <typename T, FMT_ENABLE_IF(!has_formatter<T, context>::value)>
+  static auto map(const T& value) -> decltype(mapper().map(value)) {
+    return mapper().map(value);
+  }
+
+  using formatter_type =
+      conditional_t<is_formattable<value_type, Char>::value,
+                    formatter<remove_cvref_t<decltype(map(
+                                  std::declval<const value_type&>()))>,
+                              Char>,
+                    detail::fallback_formatter<value_type, Char>>;
+
+  formatter_type value_formatter_;
+
+ public:
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return value_formatter_.parse(ctx);
+  }
+
   template <typename FormatContext>
-  auto format(const arg_join<It, Sentinel, Char>& value, FormatContext& ctx)
+  auto format(const join_view<It, Sentinel, Char>& value, FormatContext& ctx)
       -> decltype(ctx.out()) {
-    using base = formatter<typename std::iterator_traits<It>::value_type, Char>;
     auto it = value.begin;
     auto out = ctx.out();
     if (it != value.end) {
-      out = base::format(*it++, ctx);
+      out = value_formatter_.format(map(*it), ctx);
+      ++it;
       while (it != value.end) {
-        out = std::copy(value.sep.begin(), value.sep.end(), out);
+        out = detail::copy_str<Char>(value.sep.begin(), value.sep.end(), out);
         ctx.advance_to(out);
-        out = base::format(*it++, ctx);
+        out = value_formatter_.format(map(*it), ctx);
+        ++it;
       }
     }
     return out;
@@ -3674,22 +2837,17 @@ struct formatter<arg_join<It, Sentinel, Char>, Char>
 };
 
 /**
-  Returns an object that formats the iterator range `[begin, end)` with elements
+  Returns a view that formats the iterator range `[begin, end)` with elements
   separated by `sep`.
  */
 template <typename It, typename Sentinel>
-arg_join<It, Sentinel, char> join(It begin, Sentinel end, string_view sep) {
-  return {begin, end, sep};
-}
-
-template <typename It, typename Sentinel>
-arg_join<It, Sentinel, wchar_t> join(It begin, Sentinel end, wstring_view sep) {
+auto join(It begin, Sentinel end, string_view sep) -> join_view<It, Sentinel> {
   return {begin, end, sep};
 }
 
 /**
   \rst
-  Returns an object that formats `range` with elements separated by `sep`.
+  Returns a view that formats `range` with elements separated by `sep`.
 
   **Example**::
 
@@ -3704,14 +2862,8 @@ arg_join<It, Sentinel, wchar_t> join(It begin, Sentinel end, wstring_view sep) {
   \endrst
  */
 template <typename Range>
-arg_join<detail::iterator_t<Range>, detail::sentinel_t<Range>, char> join(
-    Range&& range, string_view sep) {
-  return join(std::begin(range), std::end(range), sep);
-}
-
-template <typename Range>
-arg_join<detail::iterator_t<Range>, detail::sentinel_t<Range>, wchar_t> join(
-    Range&& range, wstring_view sep) {
+auto join(Range&& range, string_view sep)
+    -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>> {
   return join(std::begin(range), std::end(range), sep);
 }
 
@@ -3727,209 +2879,142 @@ arg_join<detail::iterator_t<Range>, detail::sentinel_t<Range>, wchar_t> join(
   \endrst
  */
 template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-inline std::string to_string(const T& value) {
-  std::string result;
+inline auto to_string(const T& value) -> std::string {
+  auto result = std::string();
   detail::write<char>(std::back_inserter(result), value);
   return result;
 }
 
 template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-inline std::string to_string(T value) {
-  // The buffer should be large enough to store the number including the sign or
-  // "false" for bool.
+FMT_NODISCARD inline 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 std::string(begin, detail::write<char>(begin, value));
 }
 
-/**
-  Converts *value* to ``std::wstring`` using the default format for type *T*.
- */
-template <typename T> inline std::wstring to_wstring(const T& value) {
-  return format(L"{}", value);
-}
-
 template <typename Char, size_t SIZE>
-std::basic_string<Char> to_string(const basic_memory_buffer<Char, SIZE>& buf) {
+FMT_NODISCARD auto to_string(const basic_memory_buffer<Char, SIZE>& buf)
+    -> std::basic_string<Char> {
   auto size = buf.size();
   detail::assume(size < std::basic_string<Char>().max_size());
   return std::basic_string<Char>(buf.data(), size);
 }
 
+FMT_BEGIN_DETAIL_NAMESPACE
+
 template <typename Char>
-void detail::vformat_to(
-    detail::buffer<Char>& buf, basic_string_view<Char> format_str,
-    basic_format_args<buffer_context<type_identity_t<Char>>> args,
-    detail::locale_ref loc) {
-  using iterator = typename buffer_context<Char>::iterator;
+void vformat_to(
+    buffer<Char>& buf, basic_string_view<Char> fmt,
+    basic_format_args<FMT_BUFFER_CONTEXT(type_identity_t<Char>)> args,
+    locale_ref loc) {
+  // workaround for msvc bug regarding name-lookup in module
+  // link names into function scope
+  using detail::arg_formatter;
+  using detail::buffer_appender;
+  using detail::custom_formatter;
+  using detail::default_arg_formatter;
+  using detail::get_arg;
+  using detail::locale_ref;
+  using detail::parse_format_specs;
+  using detail::specs_checker;
+  using detail::specs_handler;
+  using detail::to_unsigned;
+  using detail::type;
+  using detail::write;
   auto out = buffer_appender<Char>(buf);
-  if (format_str.size() == 2 && equal2(format_str.data(), "{}")) {
+  if (fmt.size() == 2 && equal2(fmt.data(), "{}")) {
     auto arg = args.get(0);
     if (!arg) error_handler().on_error("argument not found");
-    visit_format_arg(default_arg_formatter<iterator, Char>{out, args, loc},
-                     arg);
+    visit_format_arg(default_arg_formatter<Char>{out, args, loc}, arg);
     return;
   }
-  format_handler<iterator, Char, buffer_context<Char>> h(out, format_str, args,
-                                                         loc);
-  parse_format_string<false>(format_str, h);
+
+  struct format_handler : error_handler {
+    basic_format_parse_context<Char> parse_context;
+    buffer_context<Char> context;
+
+    format_handler(buffer_appender<Char> out, basic_string_view<Char> str,
+                   basic_format_args<buffer_context<Char>> args, locale_ref loc)
+        : parse_context(str), context(out, args, loc) {}
+
+    void on_text(const Char* begin, const Char* end) {
+      auto text = basic_string_view<Char>(begin, to_unsigned(end - begin));
+      context.advance_to(write<Char>(context.out(), text));
+    }
+
+    FMT_CONSTEXPR auto on_arg_id() -> int {
+      return parse_context.next_arg_id();
+    }
+    FMT_CONSTEXPR auto on_arg_id(int id) -> int {
+      return parse_context.check_arg_id(id), id;
+    }
+    FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int {
+      int arg_id = context.arg_id(id);
+      if (arg_id < 0) on_error("argument not found");
+      return arg_id;
+    }
+
+    FMT_INLINE void on_replacement_field(int id, const Char*) {
+      auto arg = get_arg(context, id);
+      context.advance_to(visit_format_arg(
+          default_arg_formatter<Char>{context.out(), context.args(),
+                                      context.locale()},
+          arg));
+    }
+
+    auto on_format_specs(int id, const Char* begin, const Char* end)
+        -> const Char* {
+      auto arg = get_arg(context, id);
+      if (arg.type() == type::custom_type) {
+        parse_context.advance_to(parse_context.begin() +
+                                 (begin - &*parse_context.begin()));
+        visit_format_arg(custom_formatter<Char>{parse_context, context}, arg);
+        return parse_context.begin();
+      }
+      auto specs = basic_format_specs<Char>();
+      specs_checker<specs_handler<Char>> handler(
+          specs_handler<Char>(specs, parse_context, context), arg.type());
+      begin = parse_format_specs(begin, end, handler);
+      if (begin == end || *begin != '}')
+        on_error("missing '}' in format string");
+      auto f = arg_formatter<Char>{context.out(), specs, context.locale()};
+      context.advance_to(visit_format_arg(f, arg));
+      return begin;
+    }
+  };
+  detail::parse_format_string<false>(fmt, format_handler(out, fmt, args, loc));
 }
 
 #ifndef FMT_HEADER_ONLY
-extern template void detail::vformat_to(detail::buffer<char>&, string_view,
-                                        basic_format_args<format_context>,
-                                        detail::locale_ref);
-namespace detail {
+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;
+extern template auto format_float<double>(double value, int precision,
+                                          float_specs specs, buffer<char>& buf)
+    -> int;
+extern template auto format_float<long double>(long double value, int precision,
+                                               float_specs specs,
+                                               buffer<char>& buf) -> int;
+void snprintf_float(float, int, float_specs, buffer<char>&) = delete;
+extern template auto snprintf_float<double>(double value, int precision,
+                                            float_specs specs,
+                                            buffer<char>& buf) -> int;
+extern template auto snprintf_float<long double>(long double value,
+                                                 int precision,
+                                                 float_specs specs,
+                                                 buffer<char>& buf) -> int;
+#endif  // FMT_HEADER_ONLY
 
-extern template FMT_API std::string grouping_impl<char>(locale_ref loc);
-extern template FMT_API std::string grouping_impl<wchar_t>(locale_ref loc);
-extern template FMT_API char thousands_sep_impl<char>(locale_ref loc);
-extern template FMT_API wchar_t thousands_sep_impl<wchar_t>(locale_ref loc);
-extern template FMT_API char decimal_point_impl(locale_ref loc);
-extern template FMT_API wchar_t decimal_point_impl(locale_ref loc);
-extern template int format_float<double>(double value, int precision,
-                                         float_specs specs, buffer<char>& buf);
-extern template int format_float<long double>(long double value, int precision,
-                                              float_specs specs,
-                                              buffer<char>& buf);
-int snprintf_float(float value, int precision, float_specs specs,
-                   buffer<char>& buf) = delete;
-extern template int snprintf_float<double>(double value, int precision,
-                                           float_specs specs,
-                                           buffer<char>& buf);
-extern template int snprintf_float<long double>(long double value,
-                                                int precision,
-                                                float_specs specs,
-                                                buffer<char>& buf);
-}  // namespace detail
-#endif
-
-template <typename S, typename Char = char_t<S>,
-          FMT_ENABLE_IF(detail::is_string<S>::value)>
-inline void vformat_to(
-    detail::buffer<Char>& buf, const S& format_str,
-    basic_format_args<FMT_BUFFER_CONTEXT(type_identity_t<Char>)> args) {
-  return detail::vformat_to(buf, to_string_view(format_str), args);
-}
-
-template <typename S, typename... Args, size_t SIZE = inline_buffer_size,
-          typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
-inline typename buffer_context<Char>::iterator format_to(
-    basic_memory_buffer<Char, SIZE>& buf, const S& format_str, Args&&... args) {
-  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
-  detail::vformat_to(buf, to_string_view(format_str), vargs);
-  return detail::buffer_appender<Char>(buf);
-}
-
-template <typename OutputIt, typename Char = char>
-using format_context_t = basic_format_context<OutputIt, Char>;
-
-template <typename OutputIt, typename Char = char>
-using format_args_t = basic_format_args<format_context_t<OutputIt, Char>>;
-
-template <typename OutputIt, typename Char = typename OutputIt::value_type>
-using format_to_n_context FMT_DEPRECATED_ALIAS = buffer_context<Char>;
-
-template <typename OutputIt, typename Char = typename OutputIt::value_type>
-using format_to_n_args FMT_DEPRECATED_ALIAS =
-    basic_format_args<buffer_context<Char>>;
-
-template <typename OutputIt, typename Char, typename... Args>
-FMT_DEPRECATED format_arg_store<buffer_context<Char>, Args...>
-make_format_to_n_args(const Args&... args) {
-  return format_arg_store<buffer_context<Char>, Args...>(args...);
-}
-
-template <typename Char, enable_if_t<(!std::is_same<Char, char>::value), int>>
-std::basic_string<Char> detail::vformat(
-    basic_string_view<Char> format_str,
-    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
-  basic_memory_buffer<Char> buffer;
-  detail::vformat_to(buffer, format_str, args);
-  return to_string(buffer);
-}
-
-template <typename Char, FMT_ENABLE_IF(std::is_same<Char, wchar_t>::value)>
-void vprint(std::FILE* f, basic_string_view<Char> format_str,
-            wformat_args args) {
-  wmemory_buffer buffer;
-  detail::vformat_to(buffer, format_str, args);
-  buffer.push_back(L'\0');
-  if (std::fputws(buffer.data(), f) == -1)
-    FMT_THROW(system_error(errno, "cannot write to file"));
-}
-
-template <typename Char, FMT_ENABLE_IF(std::is_same<Char, wchar_t>::value)>
-void vprint(basic_string_view<Char> format_str, wformat_args args) {
-  vprint(stdout, format_str, args);
-}
+FMT_END_DETAIL_NAMESPACE
 
 #if FMT_USE_USER_DEFINED_LITERALS
-namespace detail {
-
-#  if FMT_USE_UDL_TEMPLATE
-template <typename Char, Char... CHARS> class udl_formatter {
- public:
-  template <typename... Args>
-  std::basic_string<Char> operator()(Args&&... args) const {
-    static FMT_CONSTEXPR_DECL Char s[] = {CHARS..., '\0'};
-    return format(FMT_STRING(s), std::forward<Args>(args)...);
-  }
-};
-#  else
-template <typename Char> struct udl_formatter {
-  basic_string_view<Char> str;
-
-  template <typename... Args>
-  std::basic_string<Char> operator()(Args&&... args) const {
-    return format(str, std::forward<Args>(args)...);
-  }
-};
-#  endif  // FMT_USE_UDL_TEMPLATE
-
-template <typename Char> struct udl_arg {
-  const Char* str;
-
-  template <typename T> named_arg<Char, T> operator=(T&& value) const {
-    return {str, std::forward<T>(value)};
-  }
-};
-}  // namespace detail
-
 inline namespace literals {
-#  if FMT_USE_UDL_TEMPLATE
-#    pragma GCC diagnostic push
-#    pragma GCC diagnostic ignored "-Wpedantic"
-#    if FMT_CLANG_VERSION
-#      pragma GCC diagnostic ignored "-Wgnu-string-literal-operator-template"
-#    endif
-template <typename Char, Char... CHARS>
-FMT_CONSTEXPR detail::udl_formatter<Char, CHARS...> operator""_format() {
-  return {};
-}
-#    pragma GCC diagnostic pop
-#  else
-/**
-  \rst
-  User-defined literal equivalent of :func:`fmt::format`.
-
-  **Example**::
-
-    using namespace fmt::literals;
-    std::string message = "The answer is {}"_format(42);
-  \endrst
- */
-FMT_CONSTEXPR detail::udl_formatter<char> operator"" _format(const char* s,
-                                                             size_t n) {
-  return {{s, n}};
-}
-FMT_CONSTEXPR detail::udl_formatter<wchar_t> operator"" _format(
-    const wchar_t* s, size_t n) {
-  return {{s, n}};
-}
-#  endif  // FMT_USE_UDL_TEMPLATE
-
 /**
   \rst
   User-defined literal equivalent of :func:`fmt::arg`.
@@ -3940,16 +3025,75 @@ FMT_CONSTEXPR detail::udl_formatter<wchar_t> operator"" _format(
     fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
   \endrst
  */
-FMT_CONSTEXPR detail::udl_arg<char> operator"" _a(const char* s, size_t) {
+#  if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+template <detail_exported::fixed_string Str>
+constexpr auto operator""_a()
+    -> detail::udl_arg<remove_cvref_t<decltype(Str.data[0])>,
+                       sizeof(Str.data) / sizeof(decltype(Str.data[0])), Str> {
+  return {};
+}
+#  else
+constexpr auto operator"" _a(const char* s, size_t) -> detail::udl_arg<char> {
   return {s};
 }
-FMT_CONSTEXPR detail::udl_arg<wchar_t> operator"" _a(const wchar_t* s, size_t) {
-  return {s};
+#  endif
+
+// DEPRECATED!
+// User-defined literal equivalent of fmt::format.
+FMT_DEPRECATED constexpr auto operator"" _format(const char* s, size_t n)
+    -> detail::udl_formatter<char> {
+  return {{s, n}};
 }
 }  // namespace literals
 #endif  // FMT_USE_USER_DEFINED_LITERALS
+
+template <typename Locale, FMT_ENABLE_IF(detail::is_locale<Locale>::value)>
+inline auto vformat(const Locale& loc, string_view fmt, format_args args)
+    -> std::string {
+  return detail::vformat(loc, fmt, args);
+}
+
+template <typename Locale, typename... T,
+          FMT_ENABLE_IF(detail::is_locale<Locale>::value)>
+inline auto format(const Locale& loc, format_string<T...> fmt, T&&... args)
+    -> std::string {
+  return vformat(loc, string_view(fmt), fmt::make_format_args(args...));
+}
+
+template <typename... T, size_t SIZE, typename Allocator>
+FMT_DEPRECATED auto format_to(basic_memory_buffer<char, SIZE, Allocator>& buf,
+                              format_string<T...> fmt, T&&... args)
+    -> appender {
+  detail::vformat_to(buf, string_view(fmt), fmt::make_format_args(args...));
+  return appender(buf);
+}
+
+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 {
+  using detail::get_buffer;
+  auto&& buf = get_buffer<char>(out);
+  detail::vformat_to(buf, fmt, args, detail::locale_ref(loc));
+  return detail::get_iterator(buf);
+}
+
+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 vformat_to(out, loc, fmt, fmt::make_format_args(args...));
+}
+
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
+#ifdef FMT_DEPRECATED_INCLUDE_XCHAR
+#  include "xchar.h"
+#endif
+
 #ifdef FMT_HEADER_ONLY
 #  define FMT_FUNC inline
 #  include "format-inl.h"
diff --git a/deps/fmt/include/fmt/locale.h b/deps/fmt/include/fmt/locale.h
index 7301bf92..7571b526 100644
--- a/deps/fmt/include/fmt/locale.h
+++ b/deps/fmt/include/fmt/locale.h
@@ -1,64 +1,2 @@
-// Formatting library for C++ - std::locale support
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_LOCALE_H_
-#define FMT_LOCALE_H_
-
-#include <locale>
-
-#include "format.h"
-
-FMT_BEGIN_NAMESPACE
-
-namespace detail {
-template <typename Char>
-std::basic_string<Char> vformat(
-    const std::locale& loc, basic_string_view<Char> format_str,
-    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
-  basic_memory_buffer<Char> buffer;
-  detail::vformat_to(buffer, format_str, args, detail::locale_ref(loc));
-  return fmt::to_string(buffer);
-}
-}  // namespace detail
-
-template <typename S, typename Char = char_t<S>>
-inline std::basic_string<Char> vformat(
-    const std::locale& loc, const S& format_str,
-    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
-  return detail::vformat(loc, to_string_view(format_str), args);
-}
-
-template <typename S, typename... Args, typename Char = char_t<S>>
-inline std::basic_string<Char> format(const std::locale& loc,
-                                      const S& format_str, Args&&... args) {
-  return detail::vformat(loc, to_string_view(format_str),
-                         fmt::make_args_checked<Args...>(format_str, args...));
-}
-
-template <typename S, typename OutputIt, typename... Args,
-          typename Char = char_t<S>,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)>
-inline OutputIt vformat_to(
-    OutputIt out, const std::locale& loc, const S& format_str,
-    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
-  decltype(detail::get_buffer<Char>(out)) buf(detail::get_buffer_init(out));
-  vformat_to(buf, to_string_view(format_str), args, detail::locale_ref(loc));
-  return detail::get_iterator(buf);
-}
-
-template <typename OutputIt, typename S, typename... Args,
-          bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value>
-inline auto format_to(OutputIt out, const std::locale& loc,
-                      const S& format_str, Args&&... args) ->
-    typename std::enable_if<enable, OutputIt>::type {
-  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
-  return vformat_to(out, loc, to_string_view(format_str), vargs);
-}
-
-FMT_END_NAMESPACE
-
-#endif  // FMT_LOCALE_H_
+#include "xchar.h"
+#warning fmt/locale.h is deprecated, include fmt/format.h or fmt/xchar.h instead
diff --git a/deps/fmt/include/fmt/os.h b/deps/fmt/include/fmt/os.h
index d44ea0c9..b64f8bbf 100644
--- a/deps/fmt/include/fmt/os.h
+++ b/deps/fmt/include/fmt/os.h
@@ -8,16 +8,12 @@
 #ifndef FMT_OS_H_
 #define FMT_OS_H_
 
-#if defined(__MINGW32__) || defined(__CYGWIN__)
-// Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/.
-#  undef __STRICT_ANSI__
-#endif
-
 #include <cerrno>
-#include <clocale>  // for locale_t
+#include <clocale>  // locale_t
 #include <cstddef>
 #include <cstdio>
-#include <cstdlib>  // for strtod_l
+#include <cstdlib>       // strtod_l
+#include <system_error>  // std::system_error
 
 #if defined __APPLE__ || defined(__FreeBSD__)
 #  include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
@@ -25,17 +21,20 @@
 
 #include "format.h"
 
+#ifndef FMT_USE_FCNTL
 // UWP doesn't provide _pipe.
-#if FMT_HAS_INCLUDE("winapifamily.h")
-#  include <winapifamily.h>
-#endif
-#if (FMT_HAS_INCLUDE(<fcntl.h>) || defined(__APPLE__) || \
-     defined(__linux__)) &&                              \
-    (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
-#  include <fcntl.h>  // for O_RDONLY
-#  define FMT_USE_FCNTL 1
-#else
-#  define FMT_USE_FCNTL 0
+#  if FMT_HAS_INCLUDE("winapifamily.h")
+#    include <winapifamily.h>
+#  endif
+#  if (FMT_HAS_INCLUDE(<fcntl.h>) || defined(__APPLE__) || \
+       defined(__linux__)) &&                              \
+      (!defined(WINAPI_FAMILY) ||                          \
+       (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
+#    include <fcntl.h>  // for O_RDONLY
+#    define FMT_USE_FCNTL 1
+#  else
+#    define FMT_USE_FCNTL 0
+#  endif
 #endif
 
 #ifndef FMT_POSIX
@@ -74,6 +73,7 @@
 #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
 
 FMT_BEGIN_NAMESPACE
+FMT_MODULE_EXPORT_BEGIN
 
 /**
   \rst
@@ -122,19 +122,28 @@ template <typename Char> class basic_cstring_view {
 using cstring_view = basic_cstring_view<char>;
 using wcstring_view = basic_cstring_view<wchar_t>;
 
-// An error code.
-class error_code {
- private:
-  int value_;
+template <typename Char> struct formatter<std::error_code, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
 
- public:
-  explicit error_code(int value = 0) FMT_NOEXCEPT : value_(value) {}
-
-  int get() const FMT_NOEXCEPT { return value_; }
+  template <typename FormatContext>
+  FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    out = detail::write_bytes(out, ec.category().name(),
+                              basic_format_specs<Char>());
+    out = detail::write<Char>(out, Char(':'));
+    out = detail::write<Char>(out, ec.value());
+    return out;
+  }
 };
 
 #ifdef _WIN32
-namespace detail {
+FMT_API const std::error_category& system_category() FMT_NOEXCEPT;
+
+FMT_BEGIN_DETAIL_NAMESPACE
 // A converter from UTF-16 to UTF-8.
 // It is only provided for Windows since other systems support UTF-8 natively.
 class utf16_to_utf8 {
@@ -143,7 +152,7 @@ class utf16_to_utf8 {
 
  public:
   utf16_to_utf8() {}
-  FMT_API explicit utf16_to_utf8(wstring_view s);
+  FMT_API explicit utf16_to_utf8(basic_string_view<wchar_t> s);
   operator string_view() const { return string_view(&buffer_[0], size()); }
   size_t size() const { return buffer_.size() - 1; }
   const char* c_str() const { return &buffer_[0]; }
@@ -152,59 +161,68 @@ class utf16_to_utf8 {
   // Performs conversion returning a system error code instead of
   // throwing exception on conversion error. This method may still throw
   // in case of memory allocation error.
-  FMT_API int convert(wstring_view s);
+  FMT_API int convert(basic_string_view<wchar_t> s);
 };
 
 FMT_API void format_windows_error(buffer<char>& out, int error_code,
-                                  string_view message) FMT_NOEXCEPT;
-}  // namespace detail
+                                  const char* message) FMT_NOEXCEPT;
+FMT_END_DETAIL_NAMESPACE
 
-/** A Windows error. */
-class windows_error : public system_error {
- private:
-  FMT_API void init(int error_code, string_view format_str, format_args args);
+FMT_API std::system_error vwindows_error(int error_code, string_view format_str,
+                                         format_args args);
 
- public:
-  /**
-   \rst
-   Constructs a :class:`fmt::windows_error` object with the description
-   of the form
+/**
+ \rst
+ Constructs a :class:`std::system_error` object with the description
+ of the form
 
-   .. parsed-literal::
-     *<message>*: *<system-message>*
+ .. parsed-literal::
+   *<message>*: *<system-message>*
 
-   where *<message>* is the formatted message and *<system-message>* is the
-   system message corresponding to the error code.
-   *error_code* is a Windows error code as given by ``GetLastError``.
-   If *error_code* is not a valid error code such as -1, the system message
-   will look like "error -1".
+ where *<message>* is the formatted message and *<system-message>* is the
+ system message corresponding to the error code.
+ *error_code* is a Windows error code as given by ``GetLastError``.
+ If *error_code* is not a valid error code such as -1, the system message
+ will look like "error -1".
 
-   **Example**::
+ **Example**::
 
-     // This throws a windows_error with the description
-     //   cannot open file 'madeup': The system cannot find the file specified.
-     // or similar (system message may vary).
-     const char *filename = "madeup";
-     LPOFSTRUCT of = LPOFSTRUCT();
-     HFILE file = OpenFile(filename, &of, OF_READ);
-     if (file == HFILE_ERROR) {
-       throw fmt::windows_error(GetLastError(),
-                                "cannot open file '{}'", filename);
-     }
-   \endrst
-  */
-  template <typename... Args>
-  windows_error(int error_code, string_view message, const Args&... args) {
-    init(error_code, message, make_format_args(args...));
-  }
-};
+   // This throws a system_error with the description
+   //   cannot open file 'madeup': The system cannot find the file specified.
+   // or similar (system message may vary).
+   const char *filename = "madeup";
+   LPOFSTRUCT of = LPOFSTRUCT();
+   HFILE file = OpenFile(filename, &of, OF_READ);
+   if (file == HFILE_ERROR) {
+     throw fmt::windows_error(GetLastError(),
+                              "cannot open file '{}'", filename);
+   }
+ \endrst
+*/
+template <typename... Args>
+std::system_error windows_error(int error_code, string_view message,
+                                const Args&... args) {
+  return vwindows_error(error_code, message, fmt::make_format_args(args...));
+}
 
 // Reports a Windows error without throwing an exception.
 // Can be used to report errors from destructors.
 FMT_API void report_windows_error(int error_code,
-                                  string_view message) FMT_NOEXCEPT;
+                                  const char* message) FMT_NOEXCEPT;
+#else
+inline const std::error_category& system_category() FMT_NOEXCEPT {
+  return std::system_category();
+}
 #endif  // _WIN32
 
+// std::system is not available on some platforms such as iOS (#2248).
+#ifdef __OSX__
+template <typename S, typename... Args, typename Char = char_t<S>>
+void say(const S& format_str, Args&&... args) {
+  std::system(format("say \"{}\"", format(format_str, args...)).c_str());
+}
+#endif
+
 // A buffered file.
 class buffered_file {
  private:
@@ -255,7 +273,7 @@ class buffered_file {
 
   template <typename... Args>
   inline void print(string_view format_str, const Args&... args) {
-    vprint(format_str, make_format_args(args...));
+    vprint(format_str, fmt::make_format_args(args...));
   }
 };
 
@@ -280,7 +298,8 @@ class file {
     WRONLY = FMT_POSIX(O_WRONLY),  // Open for writing only.
     RDWR = FMT_POSIX(O_RDWR),      // Open for reading and writing.
     CREATE = FMT_POSIX(O_CREAT),   // Create if the file doesn't exist.
-    APPEND = FMT_POSIX(O_APPEND)   // Open in append mode.
+    APPEND = FMT_POSIX(O_APPEND),  // Open in append mode.
+    TRUNC = FMT_POSIX(O_TRUNC)     // Truncate the content of the file.
   };
 
   // Constructs a file object which doesn't represent any file.
@@ -295,7 +314,8 @@ class file {
 
   file(file&& other) FMT_NOEXCEPT : fd_(other.fd_) { other.fd_ = -1; }
 
-  file& operator=(file&& other) FMT_NOEXCEPT {
+  // Move assignment is not noexcept because close may throw.
+  file& operator=(file&& other) {
     close();
     fd_ = other.fd_;
     other.fd_ = -1;
@@ -331,7 +351,7 @@ class file {
 
   // Makes fd be the copy of this file descriptor, closing fd first if
   // necessary.
-  FMT_API void dup2(int fd, error_code& ec) FMT_NOEXCEPT;
+  FMT_API void dup2(int fd, std::error_code& ec) FMT_NOEXCEPT;
 
   // Creates a pipe setting up read_end and write_end file objects for reading
   // and writing respectively.
@@ -345,9 +365,10 @@ class file {
 // Returns the memory page size.
 long getpagesize();
 
-namespace detail {
+FMT_BEGIN_DETAIL_NAMESPACE
 
 struct buffer_size {
+  buffer_size() = default;
   size_t value = 0;
   buffer_size operator=(size_t val) const {
     auto bs = buffer_size();
@@ -357,14 +378,14 @@ struct buffer_size {
 };
 
 struct ostream_params {
-  int oflag = file::WRONLY | file::CREATE;
+  int oflag = file::WRONLY | file::CREATE | file::TRUNC;
   size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768;
 
   ostream_params() {}
 
   template <typename... T>
-  ostream_params(T... params, int oflag) : ostream_params(params...) {
-    this->oflag = oflag;
+  ostream_params(T... params, int new_oflag) : ostream_params(params...) {
+    oflag = new_oflag;
   }
 
   template <typename... T>
@@ -372,23 +393,27 @@ struct ostream_params {
       : ostream_params(params...) {
     this->buffer_size = bs.value;
   }
+
+// Intel has a bug that results in failure to deduce a constructor
+// for empty parameter packs.
+#  if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 2000
+  ostream_params(int new_oflag) : oflag(new_oflag) {}
+  ostream_params(detail::buffer_size bs) : buffer_size(bs.value) {}
+#  endif
 };
-}  // namespace detail
 
-static constexpr detail::buffer_size buffer_size;
+FMT_END_DETAIL_NAMESPACE
 
-// A fast output stream which is not thread-safe.
-class ostream final : private detail::buffer<char> {
+// Added {} below to work around default constructor error known to
+// occur in Xcode versions 7.2.1 and 8.2.1.
+constexpr detail::buffer_size buffer_size{};
+
+/** A fast output stream which is not thread-safe. */
+class FMT_API ostream final : private detail::buffer<char> {
  private:
   file file_;
 
-  void flush() {
-    if (size() == 0) return;
-    file_.write(data(), size());
-    clear();
-  }
-
-  FMT_API void grow(size_t) override final;
+  void grow(size_t) override;
 
   ostream(cstring_view path, const detail::ostream_params& params)
       : file_(path, params.oflag) {
@@ -399,6 +424,7 @@ class ostream final : private detail::buffer<char> {
   ostream(ostream&& other)
       : detail::buffer<char>(other.data(), other.size(), other.capacity()),
         file_(std::move(other.file_)) {
+    other.clear();
     other.set(nullptr, 0);
   }
   ~ostream() {
@@ -406,6 +432,12 @@ class ostream final : private detail::buffer<char> {
     delete[] data();
   }
 
+  void flush() {
+    if (size() == 0) return;
+    file_.write(data(), size());
+    clear();
+  }
+
   template <typename... T>
   friend ostream output_file(cstring_view path, T... params);
 
@@ -414,16 +446,30 @@ class ostream final : private detail::buffer<char> {
     file_.close();
   }
 
-  template <typename S, typename... Args>
-  void print(const S& format_str, const Args&... args) {
-    format_to(detail::buffer_appender<char>(*this), format_str, args...);
+  /**
+    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) {
+    vformat_to(detail::buffer_appender<char>(*this), fmt,
+               fmt::make_format_args(args...));
   }
 };
 
 /**
-  Opens a file for writing. Supported parameters passed in `params`:
-  * ``<integer>``: Output flags (``file::WRONLY | file::CREATE`` by default)
+  \rst
+  Opens a file for writing. Supported parameters passed in *params*:
+
+  * ``<integer>``: Flags passed to `open
+    <https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html>`_
+    (``file::WRONLY | file::CREATE`` by default)
   * ``buffer_size=<integer>``: Output buffer size
+
+  **Example**::
+
+    auto out = fmt::output_file("guide.txt");
+    out.print("Don't {}", "Panic");
+  \endrst
  */
 template <typename... T>
 inline ostream output_file(cstring_view path, T... params) {
@@ -466,7 +512,7 @@ class locale {
 
   // Converts string to floating-point number and advances str past the end
   // of the parsed input.
-  double strtod(const char*& str) const {
+  FMT_DEPRECATED double strtod(const char*& str) const {
     char* end = nullptr;
     double result = strtod_l(str, &end, locale_);
     str = end;
@@ -475,6 +521,7 @@ class locale {
 };
 using Locale FMT_DEPRECATED_ALIAS = locale;
 #endif  // FMT_LOCALE
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
 #endif  // FMT_OS_H_
diff --git a/deps/fmt/include/fmt/ostream.h b/deps/fmt/include/fmt/ostream.h
index 29c58ec1..3d716ece 100644
--- a/deps/fmt/include/fmt/ostream.h
+++ b/deps/fmt/include/fmt/ostream.h
@@ -14,81 +14,44 @@
 
 FMT_BEGIN_NAMESPACE
 
-template <typename Char> class basic_printf_parse_context;
 template <typename OutputIt, typename Char> class basic_printf_context;
 
 namespace detail {
 
-template <class Char> class formatbuf : public std::basic_streambuf<Char> {
- private:
-  using int_type = typename std::basic_streambuf<Char>::int_type;
-  using traits_type = typename std::basic_streambuf<Char>::traits_type;
-
-  buffer<Char>& buffer_;
-
- public:
-  formatbuf(buffer<Char>& buf) : buffer_(buf) {}
-
- protected:
-  // The put-area is actually 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. The obvious
-  // 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.
-
-  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
-    if (!traits_type::eq_int_type(ch, traits_type::eof()))
-      buffer_.push_back(static_cast<Char>(ch));
-    return ch;
-  }
-
-  std::streamsize xsputn(const Char* s, std::streamsize count) FMT_OVERRIDE {
-    buffer_.append(s, s + count);
-    return count;
-  }
-};
-
-struct converter {
-  template <typename T, FMT_ENABLE_IF(is_integral<T>::value)> converter(T);
-};
-
-template <typename Char> struct test_stream : std::basic_ostream<Char> {
- private:
-  void_t<> operator<<(converter);
-};
-
-// Hide insertion operators for built-in types.
-template <typename Char, typename Traits>
-void_t<> operator<<(std::basic_ostream<Char, Traits>&, Char);
-template <typename Char, typename Traits>
-void_t<> operator<<(std::basic_ostream<Char, Traits>&, char);
-template <typename Traits>
-void_t<> operator<<(std::basic_ostream<char, Traits>&, char);
-template <typename Traits>
-void_t<> operator<<(std::basic_ostream<char, Traits>&, signed char);
-template <typename Traits>
-void_t<> operator<<(std::basic_ostream<char, Traits>&, unsigned char);
-
-// Checks if T has a user-defined operator<< (e.g. not a member of
-// std::ostream).
-template <typename T, typename Char> class is_streamable {
+// Checks if T has a user-defined operator<<.
+template <typename T, typename Char, typename Enable = void>
+class is_streamable {
  private:
   template <typename U>
-  static bool_constant<!std::is_same<decltype(std::declval<test_stream<Char>&>()
-                                              << std::declval<U>()),
-                                     void_t<>>::value>
-  test(int);
+  static auto test(int)
+      -> bool_constant<sizeof(std::declval<std::basic_ostream<Char>&>()
+                              << std::declval<U>()) != 0>;
 
-  template <typename> static std::false_type test(...);
+  template <typename> static auto test(...) -> std::false_type;
 
   using result = decltype(test<T>(0));
 
  public:
+  is_streamable() = default;
+
   static const bool value = result::value;
 };
 
+// Formatting of built-in types and arrays is intentionally disabled because
+// it's handled by standard (non-ostream) formatters.
+template <typename T, typename Char>
+struct is_streamable<
+    T, Char,
+    enable_if_t<
+        std::is_arithmetic<T>::value || std::is_array<T>::value ||
+        std::is_pointer<T>::value || std::is_same<T, char8_type>::value ||
+        std::is_same<T, std::basic_string<Char>>::value ||
+        std::is_same<T, std_string_view<Char>>::value ||
+        (std::is_convertible<T, int>::value && !std::is_enum<T>::value)>>
+    : std::false_type {};
+
 // Write the content of buf to os.
+// It is a separate function rather than a part of vprint to simplify testing.
 template <typename Char>
 void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
   const Char* buf_data = buf.data();
@@ -106,8 +69,8 @@ void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
 template <typename Char, typename T>
 void format_value(buffer<Char>& buf, const T& value,
                   locale_ref loc = locale_ref()) {
-  formatbuf<Char> format_buf(buf);
-  std::basic_ostream<Char> output(&format_buf);
+  auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
+  auto&& output = std::basic_ostream<Char>(&format_buf);
 #if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
   if (loc) output.imbue(loc.get<std::locale>());
 #endif
@@ -120,39 +83,33 @@ void format_value(buffer<Char>& buf, const T& value,
 template <typename T, typename Char>
 struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
     : private formatter<basic_string_view<Char>, Char> {
-  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
-      -> decltype(ctx.begin()) {
-    return formatter<basic_string_view<Char>, Char>::parse(ctx);
-  }
-  template <typename ParseCtx,
-            FMT_ENABLE_IF(std::is_same<
-                          ParseCtx, basic_printf_parse_context<Char>>::value)>
-  auto parse(ParseCtx& ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
-  }
+  using formatter<basic_string_view<Char>, Char>::parse;
 
   template <typename OutputIt>
   auto format(const T& value, basic_format_context<OutputIt, Char>& ctx)
       -> OutputIt {
-    basic_memory_buffer<Char> buffer;
+    auto buffer = basic_memory_buffer<Char>();
     format_value(buffer, value, ctx.locale());
-    basic_string_view<Char> str(buffer.data(), buffer.size());
-    return formatter<basic_string_view<Char>, Char>::format(str, ctx);
+    return formatter<basic_string_view<Char>, Char>::format(
+        {buffer.data(), buffer.size()}, ctx);
   }
+
+  // DEPRECATED!
   template <typename OutputIt>
   auto format(const T& value, basic_printf_context<OutputIt, Char>& ctx)
       -> OutputIt {
-    basic_memory_buffer<Char> buffer;
+    auto buffer = basic_memory_buffer<Char>();
     format_value(buffer, value, ctx.locale());
     return std::copy(buffer.begin(), buffer.end(), ctx.out());
   }
 };
 }  // namespace detail
 
+FMT_MODULE_EXPORT
 template <typename Char>
 void vprint(std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
             basic_format_args<buffer_context<type_identity_t<Char>>> args) {
-  basic_memory_buffer<Char> buffer;
+  auto buffer = basic_memory_buffer<Char>();
   detail::vformat_to(buffer, format_str, args);
   detail::write_buffer(os, buffer);
 }
@@ -166,6 +123,7 @@ void vprint(std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
     fmt::print(cerr, "Don't {}!", "panic");
   \endrst
  */
+FMT_MODULE_EXPORT
 template <typename S, typename... Args,
           typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
 void print(std::basic_ostream<Char>& os, const S& format_str, Args&&... args) {
diff --git a/deps/fmt/include/fmt/posix.h b/deps/fmt/include/fmt/posix.h
deleted file mode 100644
index da19e9d5..00000000
--- a/deps/fmt/include/fmt/posix.h
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "os.h"
-#warning "fmt/posix.h is deprecated; use fmt/os.h instead"
diff --git a/deps/fmt/include/fmt/printf.h b/deps/fmt/include/fmt/printf.h
index 8c28ac23..19d550f6 100644
--- a/deps/fmt/include/fmt/printf.h
+++ b/deps/fmt/include/fmt/printf.h
@@ -10,11 +10,54 @@
 
 #include <algorithm>  // std::max
 #include <limits>     // std::numeric_limits
+#include <ostream>
 
-#include "ostream.h"
+#include "format.h"
 
 FMT_BEGIN_NAMESPACE
-namespace detail {
+FMT_MODULE_EXPORT_BEGIN
+
+template <typename T> struct printf_formatter { printf_formatter() = delete; };
+
+template <typename Char>
+class basic_printf_parse_context : public basic_format_parse_context<Char> {
+  using basic_format_parse_context<Char>::basic_format_parse_context;
+};
+
+template <typename OutputIt, typename Char> class basic_printf_context {
+ private:
+  OutputIt out_;
+  basic_format_args<basic_printf_context> args_;
+
+ public:
+  using char_type = Char;
+  using format_arg = basic_format_arg<basic_printf_context>;
+  using parse_context_type = basic_printf_parse_context<Char>;
+  template <typename T> using formatter_type = printf_formatter<T>;
+
+  /**
+    \rst
+    Constructs a ``printf_context`` object. References to the arguments are
+    stored in the context object so make sure they have appropriate lifetimes.
+    \endrst
+   */
+  basic_printf_context(OutputIt out,
+                       basic_format_args<basic_printf_context> args)
+      : out_(out), args_(args) {}
+
+  OutputIt out() { return out_; }
+  void advance_to(OutputIt it) { out_ = it; }
+
+  detail::locale_ref locale() { return {}; }
+
+  format_arg arg(int id) const { return args_.get(id); }
+
+  FMT_CONSTEXPR void on_error(const char* message) {
+    detail::error_handler().on_error(message);
+  }
+};
+
+FMT_BEGIN_DETAIL_NAMESPACE
 
 // Checks if a value fits in int - used to avoid warnings about comparing
 // signed and unsigned integers.
@@ -178,81 +221,38 @@ template <typename Char> class printf_width_handler {
   }
 };
 
-template <typename Char, typename Context>
-void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
-             basic_format_args<Context> args) {
-  Context(buffer_appender<Char>(buf), format, args).format();
-}
-}  // namespace detail
-
-// For printing into memory_buffer.
-template <typename Char, typename Context>
-FMT_DEPRECATED void printf(detail::buffer<Char>& buf,
-                           basic_string_view<Char> format,
-                           basic_format_args<Context> args) {
-  return detail::vprintf(buf, format, args);
-}
-using detail::vprintf;
-
-template <typename Char>
-class basic_printf_parse_context : public basic_format_parse_context<Char> {
-  using basic_format_parse_context<Char>::basic_format_parse_context;
-};
-template <typename OutputIt, typename Char> class basic_printf_context;
-
-/**
-  \rst
-  The ``printf`` argument formatter.
-  \endrst
- */
+// The ``printf`` argument formatter.
 template <typename OutputIt, typename Char>
-class printf_arg_formatter : public detail::arg_formatter_base<OutputIt, Char> {
- public:
-  using iterator = OutputIt;
-
+class printf_arg_formatter : public arg_formatter<Char> {
  private:
-  using char_type = Char;
-  using base = detail::arg_formatter_base<OutputIt, Char>;
+  using base = arg_formatter<Char>;
   using context_type = basic_printf_context<OutputIt, Char>;
+  using format_specs = basic_format_specs<Char>;
 
   context_type& context_;
 
-  void write_null_pointer(char) {
-    this->specs()->type = 0;
-    this->write("(nil)");
-  }
-
-  void write_null_pointer(wchar_t) {
-    this->specs()->type = 0;
-    this->write(L"(nil)");
+  OutputIt write_null_pointer(bool is_string = false) {
+    auto s = this->specs;
+    s.type = presentation_type::none;
+    return write_bytes(this->out, is_string ? "(null)" : "(nil)", s);
   }
 
  public:
-  using format_specs = typename base::format_specs;
+  printf_arg_formatter(OutputIt iter, format_specs& s, context_type& ctx)
+      : base{iter, s, locale_ref()}, context_(ctx) {}
 
-  /**
-    \rst
-    Constructs an argument formatter object.
-    *buffer* is a reference to the output buffer and *specs* contains format
-    specifier information for standard argument types.
-    \endrst
-   */
-  printf_arg_formatter(iterator iter, format_specs& specs, context_type& ctx)
-      : base(iter, &specs, detail::locale_ref()), context_(ctx) {}
+  OutputIt operator()(monostate value) { return base::operator()(value); }
 
-  template <typename T, FMT_ENABLE_IF(fmt::detail::is_integral<T>::value)>
-  iterator operator()(T value) {
-    // MSVC2013 fails to compile separate overloads for bool and char_type so
-    // use std::is_same instead.
-    if (std::is_same<T, bool>::value) {
-      format_specs& fmt_specs = *this->specs();
-      if (fmt_specs.type != 's') return base::operator()(value ? 1 : 0);
-      fmt_specs.type = 0;
-      this->write(value != 0);
-    } else if (std::is_same<T, char_type>::value) {
-      format_specs& fmt_specs = *this->specs();
-      if (fmt_specs.type && fmt_specs.type != 'c')
+  template <typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)>
+  OutputIt operator()(T value) {
+    // MSVC2013 fails to compile separate overloads for bool and Char so use
+    // std::is_same instead.
+    if (std::is_same<T, Char>::value) {
+      format_specs fmt_specs = this->specs;
+      if (fmt_specs.type != presentation_type::none &&
+          fmt_specs.type != presentation_type::chr) {
         return (*this)(static_cast<int>(value));
+      }
       fmt_specs.sign = sign::none;
       fmt_specs.alt = false;
       fmt_specs.fill[0] = ' ';  // Ignore '0' flag for char types.
@@ -260,138 +260,49 @@ class printf_arg_formatter : public detail::arg_formatter_base<OutputIt, Char> {
       // ignored for non-numeric types
       if (fmt_specs.align == align::none || fmt_specs.align == align::numeric)
         fmt_specs.align = align::right;
-      return base::operator()(value);
-    } else {
-      return base::operator()(value);
+      return write<Char>(this->out, static_cast<Char>(value), fmt_specs);
     }
-    return this->out();
+    return base::operator()(value);
   }
 
   template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-  iterator operator()(T value) {
+  OutputIt operator()(T value) {
     return base::operator()(value);
   }
 
   /** Formats a null-terminated C string. */
-  iterator operator()(const char* value) {
-    if (value)
-      base::operator()(value);
-    else if (this->specs()->type == 'p')
-      write_null_pointer(char_type());
-    else
-      this->write("(null)");
-    return this->out();
+  OutputIt operator()(const char* value) {
+    if (value) return base::operator()(value);
+    return write_null_pointer(this->specs.type != presentation_type::pointer);
   }
 
   /** Formats a null-terminated wide C string. */
-  iterator operator()(const wchar_t* value) {
-    if (value)
-      base::operator()(value);
-    else if (this->specs()->type == 'p')
-      write_null_pointer(char_type());
-    else
-      this->write(L"(null)");
-    return this->out();
+  OutputIt operator()(const wchar_t* value) {
+    if (value) return base::operator()(value);
+    return write_null_pointer(this->specs.type != presentation_type::pointer);
   }
 
-  iterator operator()(basic_string_view<char_type> value) {
+  OutputIt operator()(basic_string_view<Char> value) {
     return base::operator()(value);
   }
 
-  iterator operator()(monostate value) { return base::operator()(value); }
-
   /** Formats a pointer. */
-  iterator operator()(const void* value) {
-    if (value) return base::operator()(value);
-    this->specs()->type = 0;
-    write_null_pointer(char_type());
-    return this->out();
+  OutputIt operator()(const void* value) {
+    return value ? base::operator()(value) : write_null_pointer();
   }
 
   /** Formats an argument of a custom (user-defined) type. */
-  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
-    handle.format(context_.parse_context(), context_);
-    return this->out();
+  OutputIt operator()(typename basic_format_arg<context_type>::handle handle) {
+    auto parse_ctx =
+        basic_printf_parse_context<Char>(basic_string_view<Char>());
+    handle.format(parse_ctx, context_);
+    return this->out;
   }
 };
 
-template <typename T> struct printf_formatter {
-  printf_formatter() = delete;
-
-  template <typename ParseContext>
-  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext>
-  auto format(const T& value, FormatContext& ctx) -> decltype(ctx.out()) {
-    detail::format_value(detail::get_container(ctx.out()), value);
-    return ctx.out();
-  }
-};
-
-/**
- This template formats data and writes the output through an output iterator.
- */
-template <typename OutputIt, typename Char> class basic_printf_context {
- public:
-  /** The character type for the output. */
-  using char_type = Char;
-  using iterator = OutputIt;
-  using format_arg = basic_format_arg<basic_printf_context>;
-  using parse_context_type = basic_printf_parse_context<Char>;
-  template <typename T> using formatter_type = printf_formatter<T>;
-
- private:
-  using format_specs = basic_format_specs<char_type>;
-
-  OutputIt out_;
-  basic_format_args<basic_printf_context> args_;
-  parse_context_type parse_ctx_;
-
-  static void parse_flags(format_specs& specs, const Char*& it,
-                          const Char* end);
-
-  // Returns the argument with specified index or, if arg_index is -1, the next
-  // argument.
-  format_arg get_arg(int arg_index = -1);
-
-  // Parses argument index, flags and width and returns the argument index.
-  int parse_header(const Char*& it, const Char* end, format_specs& specs);
-
- public:
-  /**
-   \rst
-   Constructs a ``printf_context`` object. References to the arguments are
-   stored in the context object so make sure they have appropriate lifetimes.
-   \endrst
-   */
-  basic_printf_context(OutputIt out, basic_string_view<char_type> format_str,
-                       basic_format_args<basic_printf_context> args)
-      : out_(out), args_(args), parse_ctx_(format_str) {}
-
-  OutputIt out() { return out_; }
-  void advance_to(OutputIt it) { out_ = it; }
-
-  detail::locale_ref locale() { return {}; }
-
-  format_arg arg(int id) const { return args_.get(id); }
-
-  parse_context_type& parse_context() { return parse_ctx_; }
-
-  FMT_CONSTEXPR void on_error(const char* message) {
-    parse_ctx_.on_error(message);
-  }
-
-  /** Formats stored arguments and writes the output to the range. */
-  template <typename ArgFormatter = printf_arg_formatter<OutputIt, Char>>
-  OutputIt format();
-};
-
-template <typename OutputIt, typename Char>
-void basic_printf_context<OutputIt, Char>::parse_flags(format_specs& specs,
-                                                       const Char*& it,
-                                                       const Char* end) {
+template <typename Char>
+void parse_flags(basic_format_specs<Char>& specs, const Char*& it,
+                 const Char* end) {
   for (; it != end; ++it) {
     switch (*it) {
     case '-':
@@ -417,35 +328,24 @@ void basic_printf_context<OutputIt, Char>::parse_flags(format_specs& specs,
   }
 }
 
-template <typename OutputIt, typename Char>
-typename basic_printf_context<OutputIt, Char>::format_arg
-basic_printf_context<OutputIt, Char>::get_arg(int arg_index) {
-  if (arg_index < 0)
-    arg_index = parse_ctx_.next_arg_id();
-  else
-    parse_ctx_.check_arg_id(--arg_index);
-  return detail::get_arg(*this, arg_index);
-}
-
-template <typename OutputIt, typename Char>
-int basic_printf_context<OutputIt, Char>::parse_header(const Char*& it,
-                                                       const Char* end,
-                                                       format_specs& specs) {
+template <typename Char, typename GetArg>
+int parse_header(const Char*& it, const Char* end,
+                 basic_format_specs<Char>& specs, GetArg get_arg) {
   int arg_index = -1;
-  char_type c = *it;
+  Char c = *it;
   if (c >= '0' && c <= '9') {
     // Parse an argument index (if followed by '$') or a width possibly
     // preceded with '0' flag(s).
-    detail::error_handler eh;
-    int value = parse_nonnegative_int(it, end, eh);
+    int value = parse_nonnegative_int(it, end, -1);
     if (it != end && *it == '$') {  // value is an argument index
       ++it;
-      arg_index = value;
+      arg_index = value != -1 ? value : max_value<int>();
     } else {
       if (c == '0') specs.fill[0] = '0';
       if (value != 0) {
         // Nonzero value means that we parsed width and don't need to
         // parse it or flags again, so return now.
+        if (value == -1) FMT_THROW(format_error("number is too big"));
         specs.width = value;
         return arg_index;
       }
@@ -455,58 +355,76 @@ int basic_printf_context<OutputIt, Char>::parse_header(const Char*& it,
   // Parse width.
   if (it != end) {
     if (*it >= '0' && *it <= '9') {
-      detail::error_handler eh;
-      specs.width = parse_nonnegative_int(it, end, eh);
+      specs.width = parse_nonnegative_int(it, end, -1);
+      if (specs.width == -1) FMT_THROW(format_error("number is too big"));
     } else if (*it == '*') {
       ++it;
       specs.width = static_cast<int>(visit_format_arg(
-          detail::printf_width_handler<char_type>(specs), get_arg()));
+          detail::printf_width_handler<Char>(specs), get_arg(-1)));
     }
   }
   return arg_index;
 }
 
-template <typename OutputIt, typename Char>
-template <typename ArgFormatter>
-OutputIt basic_printf_context<OutputIt, Char>::format() {
-  auto out = this->out();
-  const Char* start = parse_ctx_.begin();
-  const Char* end = parse_ctx_.end();
+template <typename Char, typename Context>
+void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
+             basic_format_args<Context> args) {
+  using OutputIt = buffer_appender<Char>;
+  auto out = OutputIt(buf);
+  auto context = basic_printf_context<OutputIt, Char>(out, args);
+  auto parse_ctx = basic_printf_parse_context<Char>(format);
+
+  // Returns the argument with specified index or, if arg_index is -1, the next
+  // argument.
+  auto get_arg = [&](int arg_index) {
+    if (arg_index < 0)
+      arg_index = parse_ctx.next_arg_id();
+    else
+      parse_ctx.check_arg_id(--arg_index);
+    return detail::get_arg(context, arg_index);
+  };
+
+  const Char* start = parse_ctx.begin();
+  const Char* end = parse_ctx.end();
   auto it = start;
   while (it != end) {
-    char_type c = *it++;
-    if (c != '%') continue;
+    if (!detail::find<false, Char>(it, end, '%', it)) {
+      it = end;  // detail::find leaves it == nullptr if it doesn't find '%'
+      break;
+    }
+    Char c = *it++;
     if (it != end && *it == c) {
-      out = std::copy(start, it, out);
+      out = detail::write(
+          out, basic_string_view<Char>(start, detail::to_unsigned(it - start)));
       start = ++it;
       continue;
     }
-    out = std::copy(start, it - 1, out);
+    out = detail::write(out, basic_string_view<Char>(
+                                 start, detail::to_unsigned(it - 1 - start)));
 
-    format_specs specs;
+    basic_format_specs<Char> specs;
     specs.align = align::right;
 
     // Parse argument index, flags and width.
-    int arg_index = parse_header(it, end, specs);
-    if (arg_index == 0) on_error("argument not found");
+    int arg_index = parse_header(it, end, specs, get_arg);
+    if (arg_index == 0) parse_ctx.on_error("argument not found");
 
     // Parse precision.
     if (it != end && *it == '.') {
       ++it;
       c = it != end ? *it : 0;
       if ('0' <= c && c <= '9') {
-        detail::error_handler eh;
-        specs.precision = parse_nonnegative_int(it, end, eh);
+        specs.precision = parse_nonnegative_int(it, end, 0);
       } else if (c == '*') {
         ++it;
         specs.precision = static_cast<int>(
-            visit_format_arg(detail::printf_precision_handler(), get_arg()));
+            visit_format_arg(detail::printf_precision_handler(), get_arg(-1)));
       } else {
         specs.precision = 0;
       }
     }
 
-    format_arg arg = get_arg(arg_index);
+    auto arg = get_arg(arg_index);
     // For d, i, o, u, x, and X conversion specifiers, if a precision is
     // specified, the '0' flag is ignored
     if (specs.precision >= 0 && arg.is_integral())
@@ -516,9 +434,10 @@ OutputIt basic_printf_context<OutputIt, Char>::format() {
       auto str = visit_format_arg(detail::get_cstring<Char>(), arg);
       auto str_end = str + specs.precision;
       auto nul = std::find(str, str_end, Char());
-      arg = detail::make_arg<basic_printf_context>(basic_string_view<Char>(
-          str,
-          detail::to_unsigned(nul != str_end ? nul - str : specs.precision)));
+      arg = detail::make_arg<basic_printf_context<OutputIt, Char>>(
+          basic_string_view<Char>(
+              str, detail::to_unsigned(nul != str_end ? nul - str
+                                                      : specs.precision)));
     }
     if (specs.alt && visit_format_arg(detail::is_zero_int(), arg))
       specs.alt = false;
@@ -532,7 +451,7 @@ OutputIt basic_printf_context<OutputIt, Char>::format() {
 
     // Parse length and convert the argument to the required type.
     c = it != end ? *it++ : 0;
-    char_type t = it != end ? *it : 0;
+    Char t = it != end ? *it : 0;
     using detail::convert_arg;
     switch (c) {
     case 'h':
@@ -573,28 +492,34 @@ OutputIt basic_printf_context<OutputIt, Char>::format() {
 
     // Parse type.
     if (it == end) FMT_THROW(format_error("invalid format string"));
-    specs.type = static_cast<char>(*it++);
+    char type = static_cast<char>(*it++);
     if (arg.is_integral()) {
       // Normalize type.
-      switch (specs.type) {
+      switch (type) {
       case 'i':
       case 'u':
-        specs.type = 'd';
+        type = 'd';
         break;
       case 'c':
-        visit_format_arg(detail::char_converter<basic_printf_context>(arg),
-                         arg);
+        visit_format_arg(
+            detail::char_converter<basic_printf_context<OutputIt, Char>>(arg),
+            arg);
         break;
       }
     }
+    specs.type = parse_presentation_type(type);
+    if (specs.type == presentation_type::none)
+      parse_ctx.on_error("invalid type specifier");
 
     start = it;
 
     // Format argument.
-    out = visit_format_arg(ArgFormatter(out, specs, *this), arg);
+    out = visit_format_arg(
+        detail::printf_arg_formatter<OutputIt, Char>(out, specs, context), arg);
   }
-  return std::copy(start, it, out);
+  detail::write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
 }
+FMT_END_DETAIL_NAMESPACE
 
 template <typename Char>
 using basic_printf_context_t =
@@ -612,9 +537,9 @@ using wprintf_args = basic_format_args<wprintf_context>;
   arguments and can be implicitly converted to `~fmt::printf_args`.
   \endrst
  */
-template <typename... Args>
-inline format_arg_store<printf_context, Args...> make_printf_args(
-    const Args&... args) {
+template <typename... T>
+inline auto make_printf_args(const T&... args)
+    -> format_arg_store<printf_context, T...> {
   return {args...};
 }
 
@@ -624,18 +549,19 @@ inline format_arg_store<printf_context, Args...> make_printf_args(
   arguments and can be implicitly converted to `~fmt::wprintf_args`.
   \endrst
  */
-template <typename... Args>
-inline format_arg_store<wprintf_context, Args...> make_wprintf_args(
-    const Args&... args) {
+template <typename... T>
+inline auto make_wprintf_args(const T&... args)
+    -> format_arg_store<wprintf_context, T...> {
   return {args...};
 }
 
 template <typename S, typename Char = char_t<S>>
-inline std::basic_string<Char> vsprintf(
-    const S& format,
-    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) {
+inline auto vsprintf(
+    const S& fmt,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
   basic_memory_buffer<Char> buffer;
-  vprintf(buffer, to_string_view(format), args);
+  vprintf(buffer, to_string_view(fmt), args);
   return to_string(buffer);
 }
 
@@ -648,19 +574,20 @@ inline std::basic_string<Char> vsprintf(
     std::string message = fmt::sprintf("The answer is %d", 42);
   \endrst
 */
-template <typename S, typename... Args,
+template <typename S, typename... T,
           typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
-inline std::basic_string<Char> sprintf(const S& format, const Args&... args) {
+inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> {
   using context = basic_printf_context_t<Char>;
-  return vsprintf(to_string_view(format), make_format_args<context>(args...));
+  return vsprintf(to_string_view(fmt), fmt::make_format_args<context>(args...));
 }
 
 template <typename S, typename Char = char_t<S>>
-inline int vfprintf(
-    std::FILE* f, const S& format,
-    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) {
+inline auto vfprintf(
+    std::FILE* f, const S& fmt,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+    -> int {
   basic_memory_buffer<Char> buffer;
-  vprintf(buffer, to_string_view(format), args);
+  vprintf(buffer, to_string_view(fmt), args);
   size_t size = buffer.size();
   return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
              ? -1
@@ -676,19 +603,19 @@ inline int vfprintf(
     fmt::fprintf(stderr, "Don't %s!", "panic");
   \endrst
  */
-template <typename S, typename... Args,
-          typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
-inline int fprintf(std::FILE* f, const S& format, const Args&... args) {
+template <typename S, typename... T, typename Char = char_t<S>>
+inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int {
   using context = basic_printf_context_t<Char>;
-  return vfprintf(f, to_string_view(format),
-                  make_format_args<context>(args...));
+  return vfprintf(f, to_string_view(fmt),
+                  fmt::make_format_args<context>(args...));
 }
 
 template <typename S, typename Char = char_t<S>>
-inline int vprintf(
-    const S& format,
-    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) {
-  return vfprintf(stdout, to_string_view(format), args);
+inline auto vprintf(
+    const S& fmt,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+    -> int {
+  return vfprintf(stdout, to_string_view(fmt), args);
 }
 
 /**
@@ -700,52 +627,31 @@ inline int vprintf(
     fmt::printf("Elapsed time: %.2f seconds", 1.23);
   \endrst
  */
-template <typename S, typename... Args,
-          FMT_ENABLE_IF(detail::is_string<S>::value)>
-inline int printf(const S& format_str, const Args&... args) {
-  using context = basic_printf_context_t<char_t<S>>;
-  return vprintf(to_string_view(format_str),
-                 make_format_args<context>(args...));
+template <typename S, typename... T, FMT_ENABLE_IF(detail::is_string<S>::value)>
+inline auto printf(const S& fmt, const T&... args) -> int {
+  return vprintf(
+      to_string_view(fmt),
+      fmt::make_format_args<basic_printf_context_t<char_t<S>>>(args...));
 }
 
 template <typename S, typename Char = char_t<S>>
-inline int vfprintf(
-    std::basic_ostream<Char>& os, const S& format,
-    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) {
+FMT_DEPRECATED auto vfprintf(
+    std::basic_ostream<Char>& os, const S& fmt,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+    -> int {
   basic_memory_buffer<Char> buffer;
-  vprintf(buffer, to_string_view(format), args);
-  detail::write_buffer(os, buffer);
+  vprintf(buffer, to_string_view(fmt), args);
+  os.write(buffer.data(), static_cast<std::streamsize>(buffer.size()));
   return static_cast<int>(buffer.size());
 }
-
-/** Formats arguments and writes the output to the range. */
-template <typename ArgFormatter, typename Char,
-          typename Context =
-              basic_printf_context<typename ArgFormatter::iterator, Char>>
-typename ArgFormatter::iterator vprintf(
-    detail::buffer<Char>& out, basic_string_view<Char> format_str,
-    basic_format_args<type_identity_t<Context>> args) {
-  typename ArgFormatter::iterator iter(out);
-  Context(iter, format_str, args).template format<ArgFormatter>();
-  return iter;
+template <typename S, typename... T, typename Char = char_t<S>>
+FMT_DEPRECATED auto fprintf(std::basic_ostream<Char>& os, const S& fmt,
+                            const T&... args) -> int {
+  return vfprintf(os, to_string_view(fmt),
+                  fmt::make_format_args<basic_printf_context_t<Char>>(args...));
 }
 
-/**
-  \rst
-  Prints formatted data to the stream *os*.
-
-  **Example**::
-
-    fmt::fprintf(cerr, "Don't %s!", "panic");
-  \endrst
- */
-template <typename S, typename... Args, typename Char = char_t<S>>
-inline int fprintf(std::basic_ostream<Char>& os, const S& format_str,
-                   const Args&... args) {
-  using context = basic_printf_context_t<Char>;
-  return vfprintf(os, to_string_view(format_str),
-                  make_format_args<context>(args...));
-}
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
 #endif  // FMT_PRINTF_H_
diff --git a/deps/fmt/include/fmt/ranges.h b/deps/fmt/include/fmt/ranges.h
index 632f0494..eb9fb8a9 100644
--- a/deps/fmt/include/fmt/ranges.h
+++ b/deps/fmt/include/fmt/ranges.h
@@ -13,47 +13,13 @@
 #define FMT_RANGES_H_
 
 #include <initializer_list>
+#include <tuple>
 #include <type_traits>
 
 #include "format.h"
 
-// output only up to N items from the range.
-#ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT
-#  define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
-#endif
-
 FMT_BEGIN_NAMESPACE
 
-template <typename Char> struct formatting_base {
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
-  }
-};
-
-template <typename Char, typename Enable = void>
-struct formatting_range : formatting_base<Char> {
-  static FMT_CONSTEXPR_DECL const size_t range_length_limit =
-      FMT_RANGE_OUTPUT_LENGTH_LIMIT;  // output only up to N items from the
-                                      // range.
-  Char prefix;
-  Char delimiter;
-  Char postfix;
-  formatting_range() : prefix('{'), delimiter(','), postfix('}') {}
-  static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
-  static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
-};
-
-template <typename Char, typename Enable = void>
-struct formatting_tuple : formatting_base<Char> {
-  Char prefix;
-  Char delimiter;
-  Char postfix;
-  formatting_tuple() : prefix('('), delimiter(','), postfix(')') {}
-  static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
-  static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
-};
-
 namespace detail {
 
 template <typename RangeT, typename OutputIterator>
@@ -75,8 +41,14 @@ OutputIterator copy(char ch, OutputIterator out) {
   return out;
 }
 
-/// Return true value if T has std::string interface, like std::string_view.
-template <typename T> class is_like_std_string {
+template <typename OutputIterator>
+OutputIterator copy(wchar_t ch, OutputIterator out) {
+  *out++ = ch;
+  return out;
+}
+
+// Returns true if T has a std::string-like interface, like std::string_view.
+template <typename T> class is_std_string_like {
   template <typename U>
   static auto check(U* p)
       -> decltype((void)p->find('a'), p->length(), (void)p->data(), int());
@@ -84,26 +56,118 @@ template <typename T> class is_like_std_string {
 
  public:
   static FMT_CONSTEXPR_DECL const bool value =
-      is_string<T>::value || !std::is_void<decltype(check<T>(nullptr))>::value;
+      is_string<T>::value ||
+      std::is_convertible<T, std_string_view<char>>::value ||
+      !std::is_void<decltype(check<T>(nullptr))>::value;
 };
 
 template <typename Char>
-struct is_like_std_string<fmt::basic_string_view<Char>> : std::true_type {};
+struct is_std_string_like<fmt::basic_string_view<Char>> : std::true_type {};
+
+template <typename T> class is_map {
+  template <typename U> static auto check(U*) -> typename U::mapped_type;
+  template <typename> static void check(...);
+
+ public:
+#ifdef FMT_FORMAT_MAP_AS_LIST
+  static FMT_CONSTEXPR_DECL const bool value = false;
+#else
+  static FMT_CONSTEXPR_DECL const bool value =
+      !std::is_void<decltype(check<T>(nullptr))>::value;
+#endif
+};
+
+template <typename T> class is_set {
+  template <typename U> static auto check(U*) -> typename U::key_type;
+  template <typename> static void check(...);
+
+ public:
+#ifdef FMT_FORMAT_SET_AS_LIST
+  static FMT_CONSTEXPR_DECL const bool value = false;
+#else
+  static FMT_CONSTEXPR_DECL const bool value =
+      !std::is_void<decltype(check<T>(nullptr))>::value && !is_map<T>::value;
+#endif
+};
 
 template <typename... Ts> struct conditional_helper {};
 
 template <typename T, typename _ = void> struct is_range_ : std::false_type {};
 
 #if !FMT_MSC_VER || FMT_MSC_VER > 1800
+
+#  define FMT_DECLTYPE_RETURN(val)  \
+    ->decltype(val) { return val; } \
+    static_assert(                  \
+        true, "")  // This makes it so that a semicolon is required after the
+                   // macro, which helps clang-format handle the formatting.
+
+// C array overload
+template <typename T, std::size_t N>
+auto range_begin(const T (&arr)[N]) -> const T* {
+  return arr;
+}
+template <typename T, std::size_t N>
+auto range_end(const T (&arr)[N]) -> const T* {
+  return arr + N;
+}
+
+template <typename T, typename Enable = void>
+struct has_member_fn_begin_end_t : std::false_type {};
+
 template <typename T>
-struct is_range_<
-    T, conditional_t<false,
-                     conditional_helper<decltype(std::declval<T>().begin()),
-                                        decltype(std::declval<T>().end())>,
-                     void>> : std::true_type {};
+struct has_member_fn_begin_end_t<T, void_t<decltype(std::declval<T>().begin()),
+                                           decltype(std::declval<T>().end())>>
+    : std::true_type {};
+
+// Member function overload
+template <typename T>
+auto range_begin(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).begin());
+template <typename T>
+auto range_end(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).end());
+
+// ADL overload. Only participates in overload resolution if member functions
+// are not found.
+template <typename T>
+auto range_begin(T&& rng)
+    -> enable_if_t<!has_member_fn_begin_end_t<T&&>::value,
+                   decltype(begin(static_cast<T&&>(rng)))> {
+  return begin(static_cast<T&&>(rng));
+}
+template <typename T>
+auto range_end(T&& rng) -> enable_if_t<!has_member_fn_begin_end_t<T&&>::value,
+                                       decltype(end(static_cast<T&&>(rng)))> {
+  return end(static_cast<T&&>(rng));
+}
+
+template <typename T, typename Enable = void>
+struct has_const_begin_end : std::false_type {};
+template <typename T, typename Enable = void>
+struct has_mutable_begin_end : std::false_type {};
+
+template <typename T>
+struct has_const_begin_end<
+    T,
+    void_t<
+        decltype(detail::range_begin(std::declval<const remove_cvref_t<T>&>())),
+        decltype(detail::range_end(std::declval<const remove_cvref_t<T>&>()))>>
+    : std::true_type {};
+
+template <typename T>
+struct has_mutable_begin_end<
+    T, void_t<decltype(detail::range_begin(std::declval<T>())),
+              decltype(detail::range_end(std::declval<T>())),
+              enable_if_t<std::is_copy_constructible<T>::value>>>
+    : std::true_type {};
+
+template <typename T>
+struct is_range_<T, void>
+    : std::integral_constant<bool, (has_const_begin_end<T>::value ||
+                                    has_mutable_begin_end<T>::value)> {};
+#  undef FMT_DECLTYPE_RETURN
 #endif
 
-/// tuple_size and tuple_element check.
+// tuple_size and tuple_element check.
 template <typename T> class is_tuple_like_ {
   template <typename U>
   static auto check(U* p) -> decltype(std::tuple_size<U>::value, int());
@@ -158,33 +222,321 @@ template <class Tuple, class F> void for_each(Tuple&& tup, F&& f) {
 }
 
 template <typename Range>
-using value_type = remove_cvref_t<decltype(*std::declval<Range>().begin())>;
+using value_type =
+    remove_cvref_t<decltype(*detail::range_begin(std::declval<Range>()))>;
 
-template <typename Arg, FMT_ENABLE_IF(!is_like_std_string<
-                                      typename std::decay<Arg>::type>::value)>
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&) {
-  return add_space ? " {}" : "{}";
+template <typename OutputIt> OutputIt write_delimiter(OutputIt out) {
+  *out++ = ',';
+  *out++ = ' ';
+  return out;
 }
 
-template <typename Arg, FMT_ENABLE_IF(is_like_std_string<
-                                      typename std::decay<Arg>::type>::value)>
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&) {
-  return add_space ? " \"{}\"" : "\"{}\"";
+struct singleton {
+  unsigned char upper;
+  unsigned char lower_count;
+};
+
+inline auto is_printable(uint16_t x, const singleton* singletons,
+                         size_t singletons_size,
+                         const unsigned char* singleton_lowers,
+                         const unsigned char* normal, size_t normal_size)
+    -> bool {
+  auto upper = x >> 8;
+  auto lower_start = 0;
+  for (size_t i = 0; i < singletons_size; ++i) {
+    auto s = singletons[i];
+    auto lower_end = lower_start + s.lower_count;
+    if (upper < s.upper) break;
+    if (upper == s.upper) {
+      for (auto j = lower_start; j < lower_end; ++j) {
+        if (singleton_lowers[j] == (x & 0xff)) return false;
+      }
+    }
+    lower_start = lower_end;
+  }
+
+  auto xsigned = static_cast<int>(x);
+  auto current = true;
+  for (size_t i = 0; i < normal_size; ++i) {
+    auto v = static_cast<int>(normal[i]);
+    auto len = (v & 0x80) != 0 ? (v & 0x7f) << 8 | normal[++i] : v;
+    xsigned -= len;
+    if (xsigned < 0) break;
+    current = !current;
+  }
+  return current;
 }
 
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char*) {
-  return add_space ? " \"{}\"" : "\"{}\"";
-}
-FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t*) {
-  return add_space ? L" \"{}\"" : L"\"{}\"";
+// Returns true iff the code point cp is printable.
+// This code is generated by support/printable.py.
+inline auto is_printable(uint32_t cp) -> bool {
+  static constexpr singleton singletons0[] = {
+      {0x00, 1},  {0x03, 5},  {0x05, 6},  {0x06, 3},  {0x07, 6},  {0x08, 8},
+      {0x09, 17}, {0x0a, 28}, {0x0b, 25}, {0x0c, 20}, {0x0d, 16}, {0x0e, 13},
+      {0x0f, 4},  {0x10, 3},  {0x12, 18}, {0x13, 9},  {0x16, 1},  {0x17, 5},
+      {0x18, 2},  {0x19, 3},  {0x1a, 7},  {0x1c, 2},  {0x1d, 1},  {0x1f, 22},
+      {0x20, 3},  {0x2b, 3},  {0x2c, 2},  {0x2d, 11}, {0x2e, 1},  {0x30, 3},
+      {0x31, 2},  {0x32, 1},  {0xa7, 2},  {0xa9, 2},  {0xaa, 4},  {0xab, 8},
+      {0xfa, 2},  {0xfb, 5},  {0xfd, 4},  {0xfe, 3},  {0xff, 9},
+  };
+  static constexpr unsigned char singletons0_lower[] = {
+      0xad, 0x78, 0x79, 0x8b, 0x8d, 0xa2, 0x30, 0x57, 0x58, 0x8b, 0x8c, 0x90,
+      0x1c, 0x1d, 0xdd, 0x0e, 0x0f, 0x4b, 0x4c, 0xfb, 0xfc, 0x2e, 0x2f, 0x3f,
+      0x5c, 0x5d, 0x5f, 0xb5, 0xe2, 0x84, 0x8d, 0x8e, 0x91, 0x92, 0xa9, 0xb1,
+      0xba, 0xbb, 0xc5, 0xc6, 0xc9, 0xca, 0xde, 0xe4, 0xe5, 0xff, 0x00, 0x04,
+      0x11, 0x12, 0x29, 0x31, 0x34, 0x37, 0x3a, 0x3b, 0x3d, 0x49, 0x4a, 0x5d,
+      0x84, 0x8e, 0x92, 0xa9, 0xb1, 0xb4, 0xba, 0xbb, 0xc6, 0xca, 0xce, 0xcf,
+      0xe4, 0xe5, 0x00, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a,
+      0x3b, 0x45, 0x46, 0x49, 0x4a, 0x5e, 0x64, 0x65, 0x84, 0x91, 0x9b, 0x9d,
+      0xc9, 0xce, 0xcf, 0x0d, 0x11, 0x29, 0x45, 0x49, 0x57, 0x64, 0x65, 0x8d,
+      0x91, 0xa9, 0xb4, 0xba, 0xbb, 0xc5, 0xc9, 0xdf, 0xe4, 0xe5, 0xf0, 0x0d,
+      0x11, 0x45, 0x49, 0x64, 0x65, 0x80, 0x84, 0xb2, 0xbc, 0xbe, 0xbf, 0xd5,
+      0xd7, 0xf0, 0xf1, 0x83, 0x85, 0x8b, 0xa4, 0xa6, 0xbe, 0xbf, 0xc5, 0xc7,
+      0xce, 0xcf, 0xda, 0xdb, 0x48, 0x98, 0xbd, 0xcd, 0xc6, 0xce, 0xcf, 0x49,
+      0x4e, 0x4f, 0x57, 0x59, 0x5e, 0x5f, 0x89, 0x8e, 0x8f, 0xb1, 0xb6, 0xb7,
+      0xbf, 0xc1, 0xc6, 0xc7, 0xd7, 0x11, 0x16, 0x17, 0x5b, 0x5c, 0xf6, 0xf7,
+      0xfe, 0xff, 0x80, 0x0d, 0x6d, 0x71, 0xde, 0xdf, 0x0e, 0x0f, 0x1f, 0x6e,
+      0x6f, 0x1c, 0x1d, 0x5f, 0x7d, 0x7e, 0xae, 0xaf, 0xbb, 0xbc, 0xfa, 0x16,
+      0x17, 0x1e, 0x1f, 0x46, 0x47, 0x4e, 0x4f, 0x58, 0x5a, 0x5c, 0x5e, 0x7e,
+      0x7f, 0xb5, 0xc5, 0xd4, 0xd5, 0xdc, 0xf0, 0xf1, 0xf5, 0x72, 0x73, 0x8f,
+      0x74, 0x75, 0x96, 0x2f, 0x5f, 0x26, 0x2e, 0x2f, 0xa7, 0xaf, 0xb7, 0xbf,
+      0xc7, 0xcf, 0xd7, 0xdf, 0x9a, 0x40, 0x97, 0x98, 0x30, 0x8f, 0x1f, 0xc0,
+      0xc1, 0xce, 0xff, 0x4e, 0x4f, 0x5a, 0x5b, 0x07, 0x08, 0x0f, 0x10, 0x27,
+      0x2f, 0xee, 0xef, 0x6e, 0x6f, 0x37, 0x3d, 0x3f, 0x42, 0x45, 0x90, 0x91,
+      0xfe, 0xff, 0x53, 0x67, 0x75, 0xc8, 0xc9, 0xd0, 0xd1, 0xd8, 0xd9, 0xe7,
+      0xfe, 0xff,
+  };
+  static constexpr singleton singletons1[] = {
+      {0x00, 6},  {0x01, 1}, {0x03, 1},  {0x04, 2}, {0x08, 8},  {0x09, 2},
+      {0x0a, 5},  {0x0b, 2}, {0x0e, 4},  {0x10, 1}, {0x11, 2},  {0x12, 5},
+      {0x13, 17}, {0x14, 1}, {0x15, 2},  {0x17, 2}, {0x19, 13}, {0x1c, 5},
+      {0x1d, 8},  {0x24, 1}, {0x6a, 3},  {0x6b, 2}, {0xbc, 2},  {0xd1, 2},
+      {0xd4, 12}, {0xd5, 9}, {0xd6, 2},  {0xd7, 2}, {0xda, 1},  {0xe0, 5},
+      {0xe1, 2},  {0xe8, 2}, {0xee, 32}, {0xf0, 4}, {0xf8, 2},  {0xf9, 2},
+      {0xfa, 2},  {0xfb, 1},
+  };
+  static constexpr unsigned char singletons1_lower[] = {
+      0x0c, 0x27, 0x3b, 0x3e, 0x4e, 0x4f, 0x8f, 0x9e, 0x9e, 0x9f, 0x06, 0x07,
+      0x09, 0x36, 0x3d, 0x3e, 0x56, 0xf3, 0xd0, 0xd1, 0x04, 0x14, 0x18, 0x36,
+      0x37, 0x56, 0x57, 0x7f, 0xaa, 0xae, 0xaf, 0xbd, 0x35, 0xe0, 0x12, 0x87,
+      0x89, 0x8e, 0x9e, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a,
+      0x45, 0x46, 0x49, 0x4a, 0x4e, 0x4f, 0x64, 0x65, 0x5c, 0xb6, 0xb7, 0x1b,
+      0x1c, 0x07, 0x08, 0x0a, 0x0b, 0x14, 0x17, 0x36, 0x39, 0x3a, 0xa8, 0xa9,
+      0xd8, 0xd9, 0x09, 0x37, 0x90, 0x91, 0xa8, 0x07, 0x0a, 0x3b, 0x3e, 0x66,
+      0x69, 0x8f, 0x92, 0x6f, 0x5f, 0xee, 0xef, 0x5a, 0x62, 0x9a, 0x9b, 0x27,
+      0x28, 0x55, 0x9d, 0xa0, 0xa1, 0xa3, 0xa4, 0xa7, 0xa8, 0xad, 0xba, 0xbc,
+      0xc4, 0x06, 0x0b, 0x0c, 0x15, 0x1d, 0x3a, 0x3f, 0x45, 0x51, 0xa6, 0xa7,
+      0xcc, 0xcd, 0xa0, 0x07, 0x19, 0x1a, 0x22, 0x25, 0x3e, 0x3f, 0xc5, 0xc6,
+      0x04, 0x20, 0x23, 0x25, 0x26, 0x28, 0x33, 0x38, 0x3a, 0x48, 0x4a, 0x4c,
+      0x50, 0x53, 0x55, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x63, 0x65, 0x66,
+      0x6b, 0x73, 0x78, 0x7d, 0x7f, 0x8a, 0xa4, 0xaa, 0xaf, 0xb0, 0xc0, 0xd0,
+      0xae, 0xaf, 0x79, 0xcc, 0x6e, 0x6f, 0x93,
+  };
+  static constexpr unsigned char normal0[] = {
+      0x00, 0x20, 0x5f, 0x22, 0x82, 0xdf, 0x04, 0x82, 0x44, 0x08, 0x1b, 0x04,
+      0x06, 0x11, 0x81, 0xac, 0x0e, 0x80, 0xab, 0x35, 0x28, 0x0b, 0x80, 0xe0,
+      0x03, 0x19, 0x08, 0x01, 0x04, 0x2f, 0x04, 0x34, 0x04, 0x07, 0x03, 0x01,
+      0x07, 0x06, 0x07, 0x11, 0x0a, 0x50, 0x0f, 0x12, 0x07, 0x55, 0x07, 0x03,
+      0x04, 0x1c, 0x0a, 0x09, 0x03, 0x08, 0x03, 0x07, 0x03, 0x02, 0x03, 0x03,
+      0x03, 0x0c, 0x04, 0x05, 0x03, 0x0b, 0x06, 0x01, 0x0e, 0x15, 0x05, 0x3a,
+      0x03, 0x11, 0x07, 0x06, 0x05, 0x10, 0x07, 0x57, 0x07, 0x02, 0x07, 0x15,
+      0x0d, 0x50, 0x04, 0x43, 0x03, 0x2d, 0x03, 0x01, 0x04, 0x11, 0x06, 0x0f,
+      0x0c, 0x3a, 0x04, 0x1d, 0x25, 0x5f, 0x20, 0x6d, 0x04, 0x6a, 0x25, 0x80,
+      0xc8, 0x05, 0x82, 0xb0, 0x03, 0x1a, 0x06, 0x82, 0xfd, 0x03, 0x59, 0x07,
+      0x15, 0x0b, 0x17, 0x09, 0x14, 0x0c, 0x14, 0x0c, 0x6a, 0x06, 0x0a, 0x06,
+      0x1a, 0x06, 0x59, 0x07, 0x2b, 0x05, 0x46, 0x0a, 0x2c, 0x04, 0x0c, 0x04,
+      0x01, 0x03, 0x31, 0x0b, 0x2c, 0x04, 0x1a, 0x06, 0x0b, 0x03, 0x80, 0xac,
+      0x06, 0x0a, 0x06, 0x21, 0x3f, 0x4c, 0x04, 0x2d, 0x03, 0x74, 0x08, 0x3c,
+      0x03, 0x0f, 0x03, 0x3c, 0x07, 0x38, 0x08, 0x2b, 0x05, 0x82, 0xff, 0x11,
+      0x18, 0x08, 0x2f, 0x11, 0x2d, 0x03, 0x20, 0x10, 0x21, 0x0f, 0x80, 0x8c,
+      0x04, 0x82, 0x97, 0x19, 0x0b, 0x15, 0x88, 0x94, 0x05, 0x2f, 0x05, 0x3b,
+      0x07, 0x02, 0x0e, 0x18, 0x09, 0x80, 0xb3, 0x2d, 0x74, 0x0c, 0x80, 0xd6,
+      0x1a, 0x0c, 0x05, 0x80, 0xff, 0x05, 0x80, 0xdf, 0x0c, 0xee, 0x0d, 0x03,
+      0x84, 0x8d, 0x03, 0x37, 0x09, 0x81, 0x5c, 0x14, 0x80, 0xb8, 0x08, 0x80,
+      0xcb, 0x2a, 0x38, 0x03, 0x0a, 0x06, 0x38, 0x08, 0x46, 0x08, 0x0c, 0x06,
+      0x74, 0x0b, 0x1e, 0x03, 0x5a, 0x04, 0x59, 0x09, 0x80, 0x83, 0x18, 0x1c,
+      0x0a, 0x16, 0x09, 0x4c, 0x04, 0x80, 0x8a, 0x06, 0xab, 0xa4, 0x0c, 0x17,
+      0x04, 0x31, 0xa1, 0x04, 0x81, 0xda, 0x26, 0x07, 0x0c, 0x05, 0x05, 0x80,
+      0xa5, 0x11, 0x81, 0x6d, 0x10, 0x78, 0x28, 0x2a, 0x06, 0x4c, 0x04, 0x80,
+      0x8d, 0x04, 0x80, 0xbe, 0x03, 0x1b, 0x03, 0x0f, 0x0d,
+  };
+  static constexpr unsigned char normal1[] = {
+      0x5e, 0x22, 0x7b, 0x05, 0x03, 0x04, 0x2d, 0x03, 0x66, 0x03, 0x01, 0x2f,
+      0x2e, 0x80, 0x82, 0x1d, 0x03, 0x31, 0x0f, 0x1c, 0x04, 0x24, 0x09, 0x1e,
+      0x05, 0x2b, 0x05, 0x44, 0x04, 0x0e, 0x2a, 0x80, 0xaa, 0x06, 0x24, 0x04,
+      0x24, 0x04, 0x28, 0x08, 0x34, 0x0b, 0x01, 0x80, 0x90, 0x81, 0x37, 0x09,
+      0x16, 0x0a, 0x08, 0x80, 0x98, 0x39, 0x03, 0x63, 0x08, 0x09, 0x30, 0x16,
+      0x05, 0x21, 0x03, 0x1b, 0x05, 0x01, 0x40, 0x38, 0x04, 0x4b, 0x05, 0x2f,
+      0x04, 0x0a, 0x07, 0x09, 0x07, 0x40, 0x20, 0x27, 0x04, 0x0c, 0x09, 0x36,
+      0x03, 0x3a, 0x05, 0x1a, 0x07, 0x04, 0x0c, 0x07, 0x50, 0x49, 0x37, 0x33,
+      0x0d, 0x33, 0x07, 0x2e, 0x08, 0x0a, 0x81, 0x26, 0x52, 0x4e, 0x28, 0x08,
+      0x2a, 0x56, 0x1c, 0x14, 0x17, 0x09, 0x4e, 0x04, 0x1e, 0x0f, 0x43, 0x0e,
+      0x19, 0x07, 0x0a, 0x06, 0x48, 0x08, 0x27, 0x09, 0x75, 0x0b, 0x3f, 0x41,
+      0x2a, 0x06, 0x3b, 0x05, 0x0a, 0x06, 0x51, 0x06, 0x01, 0x05, 0x10, 0x03,
+      0x05, 0x80, 0x8b, 0x62, 0x1e, 0x48, 0x08, 0x0a, 0x80, 0xa6, 0x5e, 0x22,
+      0x45, 0x0b, 0x0a, 0x06, 0x0d, 0x13, 0x39, 0x07, 0x0a, 0x36, 0x2c, 0x04,
+      0x10, 0x80, 0xc0, 0x3c, 0x64, 0x53, 0x0c, 0x48, 0x09, 0x0a, 0x46, 0x45,
+      0x1b, 0x48, 0x08, 0x53, 0x1d, 0x39, 0x81, 0x07, 0x46, 0x0a, 0x1d, 0x03,
+      0x47, 0x49, 0x37, 0x03, 0x0e, 0x08, 0x0a, 0x06, 0x39, 0x07, 0x0a, 0x81,
+      0x36, 0x19, 0x80, 0xb7, 0x01, 0x0f, 0x32, 0x0d, 0x83, 0x9b, 0x66, 0x75,
+      0x0b, 0x80, 0xc4, 0x8a, 0xbc, 0x84, 0x2f, 0x8f, 0xd1, 0x82, 0x47, 0xa1,
+      0xb9, 0x82, 0x39, 0x07, 0x2a, 0x04, 0x02, 0x60, 0x26, 0x0a, 0x46, 0x0a,
+      0x28, 0x05, 0x13, 0x82, 0xb0, 0x5b, 0x65, 0x4b, 0x04, 0x39, 0x07, 0x11,
+      0x40, 0x05, 0x0b, 0x02, 0x0e, 0x97, 0xf8, 0x08, 0x84, 0xd6, 0x2a, 0x09,
+      0xa2, 0xf7, 0x81, 0x1f, 0x31, 0x03, 0x11, 0x04, 0x08, 0x81, 0x8c, 0x89,
+      0x04, 0x6b, 0x05, 0x0d, 0x03, 0x09, 0x07, 0x10, 0x93, 0x60, 0x80, 0xf6,
+      0x0a, 0x73, 0x08, 0x6e, 0x17, 0x46, 0x80, 0x9a, 0x14, 0x0c, 0x57, 0x09,
+      0x19, 0x80, 0x87, 0x81, 0x47, 0x03, 0x85, 0x42, 0x0f, 0x15, 0x85, 0x50,
+      0x2b, 0x80, 0xd5, 0x2d, 0x03, 0x1a, 0x04, 0x02, 0x81, 0x70, 0x3a, 0x05,
+      0x01, 0x85, 0x00, 0x80, 0xd7, 0x29, 0x4c, 0x04, 0x0a, 0x04, 0x02, 0x83,
+      0x11, 0x44, 0x4c, 0x3d, 0x80, 0xc2, 0x3c, 0x06, 0x01, 0x04, 0x55, 0x05,
+      0x1b, 0x34, 0x02, 0x81, 0x0e, 0x2c, 0x04, 0x64, 0x0c, 0x56, 0x0a, 0x80,
+      0xae, 0x38, 0x1d, 0x0d, 0x2c, 0x04, 0x09, 0x07, 0x02, 0x0e, 0x06, 0x80,
+      0x9a, 0x83, 0xd8, 0x08, 0x0d, 0x03, 0x0d, 0x03, 0x74, 0x0c, 0x59, 0x07,
+      0x0c, 0x14, 0x0c, 0x04, 0x38, 0x08, 0x0a, 0x06, 0x28, 0x08, 0x22, 0x4e,
+      0x81, 0x54, 0x0c, 0x15, 0x03, 0x03, 0x05, 0x07, 0x09, 0x19, 0x07, 0x07,
+      0x09, 0x03, 0x0d, 0x07, 0x29, 0x80, 0xcb, 0x25, 0x0a, 0x84, 0x06,
+  };
+  auto lower = static_cast<uint16_t>(cp);
+  if (cp < 0x10000) {
+    return is_printable(lower, singletons0,
+                        sizeof(singletons0) / sizeof(*singletons0),
+                        singletons0_lower, normal0, sizeof(normal0));
+  }
+  if (cp < 0x20000) {
+    return is_printable(lower, singletons1,
+                        sizeof(singletons1) / sizeof(*singletons1),
+                        singletons1_lower, normal1, sizeof(normal1));
+  }
+  if (0x2a6de <= cp && cp < 0x2a700) return false;
+  if (0x2b735 <= cp && cp < 0x2b740) return false;
+  if (0x2b81e <= cp && cp < 0x2b820) return false;
+  if (0x2cea2 <= cp && cp < 0x2ceb0) return false;
+  if (0x2ebe1 <= cp && cp < 0x2f800) return false;
+  if (0x2fa1e <= cp && cp < 0x30000) return false;
+  if (0x3134b <= cp && cp < 0xe0100) return false;
+  if (0xe01f0 <= cp && cp < 0x110000) return false;
+  return cp < 0x110000;
 }
 
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char) {
-  return add_space ? " '{}'" : "'{}'";
+inline auto needs_escape(uint32_t cp) -> bool {
+  return cp < 0x20 || cp == 0x7f || cp == '"' || cp == '\\' ||
+         !is_printable(cp);
 }
-FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t) {
-  return add_space ? L" '{}'" : L"'{}'";
+
+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) {
+    auto cp = static_cast<typename std::make_unsigned<Char>::type>(*begin);
+    if (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 (!is_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 <typename Char, typename OutputIt>
+auto write_range_entry(OutputIt out, basic_string_view<Char> str) -> OutputIt {
+  *out++ = '"';
+  auto begin = str.begin(), end = str.end();
+  do {
+    auto escape = find_escape(begin, end);
+    out = copy_str<Char>(begin, escape.begin, out);
+    begin = escape.end;
+    if (!begin) break;
+    auto c = static_cast<Char>(escape.cp);
+    switch (escape.cp) {
+    case '\n':
+      *out++ = '\\';
+      c = 'n';
+      break;
+    case '\r':
+      *out++ = '\\';
+      c = 'r';
+      break;
+    case '\t':
+      *out++ = '\\';
+      c = 't';
+      break;
+    case '"':
+      FMT_FALLTHROUGH;
+    case '\\':
+      *out++ = '\\';
+      break;
+    default:
+      if (is_utf8()) {
+        if (escape.cp < 0x100) {
+          out = format_to(out, "\\x{:02x}", escape.cp);
+          continue;
+        }
+        if (escape.cp < 0x10000) {
+          out = format_to(out, "\\u{:04x}", escape.cp);
+          continue;
+        }
+        if (escape.cp < 0x110000) {
+          out = format_to(out, "\\U{:08x}", escape.cp);
+          continue;
+        }
+      }
+      for (Char escape_char : basic_string_view<Char>(
+               escape.begin, to_unsigned(escape.end - escape.begin))) {
+        out = format_to(
+            out, "\\x{:02x}",
+            static_cast<typename std::make_unsigned<Char>::type>(escape_char));
+      }
+      continue;
+    }
+    *out++ = c;
+  } while (begin != end);
+  *out++ = '"';
+  return out;
+}
+
+template <typename Char, typename OutputIt, typename T,
+          FMT_ENABLE_IF(std::is_convertible<T, std_string_view<char>>::value)>
+inline auto write_range_entry(OutputIt out, const T& str) -> OutputIt {
+  auto sv = std_string_view<Char>(str);
+  return write_range_entry<Char>(out, basic_string_view<Char>(sv));
+}
+
+template <typename Char, typename OutputIt, typename Arg,
+          FMT_ENABLE_IF(std::is_same<Arg, Char>::value)>
+OutputIt write_range_entry(OutputIt out, const Arg v) {
+  *out++ = '\'';
+  *out++ = v;
+  *out++ = '\'';
+  return out;
+}
+
+template <
+    typename Char, typename OutputIt, typename Arg,
+    FMT_ENABLE_IF(!is_std_string_like<typename std::decay<Arg>::type>::value &&
+                  !std::is_same<Arg, Char>::value)>
+OutputIt write_range_entry(OutputIt out, const Arg& v) {
+  return write<Char>(out, v);
+}
+
 }  // namespace detail
 
 template <typename T> struct is_tuple_like {
@@ -195,55 +547,37 @@ template <typename T> struct is_tuple_like {
 template <typename TupleT, typename Char>
 struct formatter<TupleT, Char, enable_if_t<fmt::is_tuple_like<TupleT>::value>> {
  private:
-  // C++11 generic lambda for format()
+  // C++11 generic lambda for format().
   template <typename FormatContext> struct format_each {
     template <typename T> void operator()(const T& v) {
-      if (i > 0) {
-        if (formatting.add_prepostfix_space) {
-          *out++ = ' ';
-        }
-        out = detail::copy(formatting.delimiter, out);
-      }
-      out = format_to(out,
-                      detail::format_str_quoted(
-                          (formatting.add_delimiter_spaces && i > 0), v),
-                      v);
+      if (i > 0) out = detail::write_delimiter(out);
+      out = detail::write_range_entry<Char>(out, v);
       ++i;
     }
-
-    formatting_tuple<Char>& formatting;
-    size_t& i;
-    typename std::add_lvalue_reference<decltype(
-        std::declval<FormatContext>().out())>::type out;
+    int i;
+    typename FormatContext::iterator& out;
   };
 
  public:
-  formatting_tuple<Char> formatting;
-
   template <typename ParseContext>
   FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return formatting.parse(ctx);
+    return ctx.begin();
   }
 
   template <typename FormatContext = format_context>
   auto format(const TupleT& values, FormatContext& ctx) -> decltype(ctx.out()) {
     auto out = ctx.out();
-    size_t i = 0;
-    detail::copy(formatting.prefix, out);
-
-    detail::for_each(values, format_each<FormatContext>{formatting, i, out});
-    if (formatting.add_prepostfix_space) {
-      *out++ = ' ';
-    }
-    detail::copy(formatting.postfix, out);
-
-    return ctx.out();
+    *out++ = '(';
+    detail::for_each(values, format_each<FormatContext>{0, out});
+    *out++ = ')';
+    return out;
   }
 };
 
 template <typename T, typename Char> struct is_range {
   static FMT_CONSTEXPR_DECL const bool value =
-      detail::is_range_<T>::value && !detail::is_like_std_string<T>::value &&
+      detail::is_range_<T>::value && !detail::is_std_string_like<T>::value &&
+      !detail::is_map<T>::value &&
       !std::is_convertible<T, std::basic_string<Char>>::value &&
       !std::is_constructible<detail::std_string_view<Char>, T>::value;
 };
@@ -251,100 +585,167 @@ template <typename T, typename Char> struct is_range {
 template <typename T, typename Char>
 struct formatter<
     T, Char,
-    enable_if_t<fmt::is_range<T, Char>::value
-// Workaround a bug in MSVC 2017 and earlier.
-#if !FMT_MSC_VER || FMT_MSC_VER >= 1927
-                &&
-                (has_formatter<detail::value_type<T>, format_context>::value ||
-                 detail::has_fallback_formatter<detail::value_type<T>,
-                                                format_context>::value)
+    enable_if_t<
+        fmt::is_range<T, Char>::value
+// Workaround a bug in MSVC 2019 and earlier.
+#if !FMT_MSC_VER
+        && (is_formattable<detail::value_type<T>, Char>::value ||
+            detail::has_fallback_formatter<detail::value_type<T>, Char>::value)
 #endif
-                >> {
-  formatting_range<Char> formatting;
-
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return formatting.parse(ctx);
-  }
-
-  template <typename FormatContext>
-  typename FormatContext::iterator format(const T& values, FormatContext& ctx) {
-    auto out = detail::copy(formatting.prefix, ctx.out());
-    size_t i = 0;
-    auto it = values.begin();
-    auto end = values.end();
-    for (; it != end; ++it) {
-      if (i > 0) {
-        if (formatting.add_prepostfix_space) *out++ = ' ';
-        out = detail::copy(formatting.delimiter, out);
-      }
-      out = format_to(out,
-                      detail::format_str_quoted(
-                          (formatting.add_delimiter_spaces && i > 0), *it),
-                      *it);
-      if (++i > formatting.range_length_limit) {
-        out = format_to(out, " ... <other elements>");
-        break;
-      }
-    }
-    if (formatting.add_prepostfix_space) *out++ = ' ';
-    return detail::copy(formatting.postfix, out);
-  }
-};
-
-template <typename Char, typename... T> struct tuple_arg_join : detail::view {
-  const std::tuple<T...>& tuple;
-  basic_string_view<Char> sep;
-
-  tuple_arg_join(const std::tuple<T...>& t, basic_string_view<Char> s)
-      : tuple{t}, sep{s} {}
-};
-
-template <typename Char, typename... T>
-struct formatter<tuple_arg_join<Char, T...>, Char> {
+        >> {
   template <typename ParseContext>
   FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
     return ctx.begin();
   }
 
+  template <
+      typename FormatContext, typename U,
+      FMT_ENABLE_IF(
+          std::is_same<U, conditional_t<detail::has_const_begin_end<T>::value,
+                                        const T, T>>::value)>
+  auto format(U& range, FormatContext& ctx) -> decltype(ctx.out()) {
+#ifdef FMT_DEPRECATED_BRACED_RANGES
+    Char prefix = '{';
+    Char postfix = '}';
+#else
+    Char prefix = detail::is_set<T>::value ? '{' : '[';
+    Char postfix = detail::is_set<T>::value ? '}' : ']';
+#endif
+    auto out = ctx.out();
+    *out++ = prefix;
+    int i = 0;
+    auto it = std::begin(range);
+    auto end = std::end(range);
+    for (; it != end; ++it) {
+      if (i > 0) out = detail::write_delimiter(out);
+      out = detail::write_range_entry<Char>(out, *it);
+      ++i;
+    }
+    *out++ = postfix;
+    return out;
+  }
+};
+
+template <typename T, typename Char>
+struct formatter<
+    T, Char,
+    enable_if_t<
+        detail::is_map<T>::value
+// Workaround a bug in MSVC 2019 and earlier.
+#if !FMT_MSC_VER
+        && (is_formattable<detail::value_type<T>, Char>::value ||
+            detail::has_fallback_formatter<detail::value_type<T>, Char>::value)
+#endif
+        >> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <
+      typename FormatContext, typename U,
+      FMT_ENABLE_IF(
+          std::is_same<U, conditional_t<detail::has_const_begin_end<T>::value,
+                                        const T, T>>::value)>
+  auto format(U& map, FormatContext& ctx) -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    *out++ = '{';
+    int i = 0;
+    for (const auto& item : map) {
+      if (i > 0) out = detail::write_delimiter(out);
+      out = detail::write_range_entry<Char>(out, item.first);
+      *out++ = ':';
+      *out++ = ' ';
+      out = detail::write_range_entry<Char>(out, item.second);
+      ++i;
+    }
+    *out++ = '}';
+    return out;
+  }
+};
+
+template <typename Char, typename... T> struct tuple_join_view : detail::view {
+  const std::tuple<T...>& tuple;
+  basic_string_view<Char> sep;
+
+  tuple_join_view(const std::tuple<T...>& t, basic_string_view<Char> s)
+      : tuple(t), sep{s} {}
+};
+
+template <typename Char, typename... T>
+using tuple_arg_join = tuple_join_view<Char, T...>;
+
+// Define FMT_TUPLE_JOIN_SPECIFIERS to enable experimental format specifiers
+// support in tuple_join. It is disabled by default because of issues with
+// the dynamic width and precision.
+#ifndef FMT_TUPLE_JOIN_SPECIFIERS
+#  define FMT_TUPLE_JOIN_SPECIFIERS 0
+#endif
+
+template <typename Char, typename... T>
+struct formatter<tuple_join_view<Char, T...>, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return do_parse(ctx, std::integral_constant<size_t, sizeof...(T)>());
+  }
+
   template <typename FormatContext>
-  typename FormatContext::iterator format(
-      const tuple_arg_join<Char, T...>& value, FormatContext& ctx) {
-    return format(value, ctx, detail::make_index_sequence<sizeof...(T)>{});
+  auto format(const tuple_join_view<Char, T...>& value,
+              FormatContext& ctx) const -> typename FormatContext::iterator {
+    return do_format(value, ctx,
+                     std::integral_constant<size_t, sizeof...(T)>());
   }
 
  private:
-  template <typename FormatContext, size_t... N>
-  typename FormatContext::iterator format(
-      const tuple_arg_join<Char, T...>& value, FormatContext& ctx,
-      detail::index_sequence<N...>) {
-    return format_args(value, ctx, std::get<N>(value.tuple)...);
+  std::tuple<formatter<typename std::decay<T>::type, Char>...> formatters_;
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto do_parse(ParseContext& ctx,
+                              std::integral_constant<size_t, 0>)
+      -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename ParseContext, size_t N>
+  FMT_CONSTEXPR auto do_parse(ParseContext& ctx,
+                              std::integral_constant<size_t, N>)
+      -> decltype(ctx.begin()) {
+    auto end = ctx.begin();
+#if FMT_TUPLE_JOIN_SPECIFIERS
+    end = std::get<sizeof...(T) - N>(formatters_).parse(ctx);
+    if (N > 1) {
+      auto end1 = do_parse(ctx, std::integral_constant<size_t, N - 1>());
+      if (end != end1)
+        FMT_THROW(format_error("incompatible format specs for tuple elements"));
+    }
+#endif
+    return end;
   }
 
   template <typename FormatContext>
-  typename FormatContext::iterator format_args(
-      const tuple_arg_join<Char, T...>&, FormatContext& ctx) {
-    // NOTE: for compilers that support C++17, this empty function instantiation
-    // can be replaced with a constexpr branch in the variadic overload.
+  auto do_format(const tuple_join_view<Char, T...>&, FormatContext& ctx,
+                 std::integral_constant<size_t, 0>) const ->
+      typename FormatContext::iterator {
     return ctx.out();
   }
 
-  template <typename FormatContext, typename Arg, typename... Args>
-  typename FormatContext::iterator format_args(
-      const tuple_arg_join<Char, T...>& value, FormatContext& ctx,
-      const Arg& arg, const Args&... args) {
-    using base = formatter<typename std::decay<Arg>::type, Char>;
-    auto out = ctx.out();
-    out = base{}.format(arg, ctx);
-    if (sizeof...(Args) > 0) {
+  template <typename FormatContext, size_t N>
+  auto do_format(const tuple_join_view<Char, T...>& value, FormatContext& ctx,
+                 std::integral_constant<size_t, N>) const ->
+      typename FormatContext::iterator {
+    auto out = std::get<sizeof...(T) - N>(formatters_)
+                   .format(std::get<sizeof...(T) - N>(value.tuple), ctx);
+    if (N > 1) {
       out = std::copy(value.sep.begin(), value.sep.end(), out);
       ctx.advance_to(out);
-      return format_args(value, ctx, args...);
+      return do_format(value, ctx, std::integral_constant<size_t, N - 1>());
     }
     return out;
   }
 };
 
+FMT_MODULE_EXPORT_BEGIN
+
 /**
   \rst
   Returns an object that formats `tuple` with elements separated by `sep`.
@@ -357,14 +758,15 @@ struct formatter<tuple_arg_join<Char, T...>, Char> {
   \endrst
  */
 template <typename... T>
-FMT_CONSTEXPR tuple_arg_join<char, T...> join(const std::tuple<T...>& tuple,
-                                              string_view sep) {
+FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple, string_view sep)
+    -> tuple_join_view<char, T...> {
   return {tuple, sep};
 }
 
 template <typename... T>
-FMT_CONSTEXPR tuple_arg_join<wchar_t, T...> join(const std::tuple<T...>& tuple,
-                                                 wstring_view sep) {
+FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple,
+                        basic_string_view<wchar_t> sep)
+    -> tuple_join_view<wchar_t, T...> {
   return {tuple, sep};
 }
 
@@ -380,17 +782,12 @@ FMT_CONSTEXPR tuple_arg_join<wchar_t, T...> join(const std::tuple<T...>& tuple,
   \endrst
  */
 template <typename T>
-arg_join<const T*, const T*, char> join(std::initializer_list<T> list,
-                                        string_view sep) {
-  return join(std::begin(list), std::end(list), sep);
-}
-
-template <typename T>
-arg_join<const T*, const T*, wchar_t> join(std::initializer_list<T> list,
-                                           wstring_view sep) {
+auto join(std::initializer_list<T> list, string_view sep)
+    -> join_view<const T*, const T*> {
   return join(std::begin(list), std::end(list), sep);
 }
 
+FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
 #endif  // FMT_RANGES_H_
diff --git a/deps/fmt/include/fmt/xchar.h b/deps/fmt/include/fmt/xchar.h
new file mode 100644
index 00000000..55825077
--- /dev/null
+++ b/deps/fmt/include/fmt/xchar.h
@@ -0,0 +1,236 @@
+// Formatting library for C++ - optional wchar_t and exotic character support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_XCHAR_H_
+#define FMT_XCHAR_H_
+
+#include <cwchar>
+#include <tuple>
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+template <typename T>
+using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;
+}
+
+FMT_MODULE_EXPORT_BEGIN
+
+using wstring_view = basic_string_view<wchar_t>;
+using wformat_parse_context = basic_format_parse_context<wchar_t>;
+using wformat_context = buffer_context<wchar_t>;
+using wformat_args = basic_format_args<wformat_context>;
+using wmemory_buffer = basic_memory_buffer<wchar_t>;
+
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+// Workaround broken conversion on older gcc.
+template <typename... Args> using wformat_string = wstring_view;
+#else
+template <typename... Args>
+using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
+#endif
+
+template <> struct is_char<wchar_t> : std::true_type {};
+template <> struct is_char<detail::char8_type> : std::true_type {};
+template <> struct is_char<char16_t> : std::true_type {};
+template <> struct is_char<char32_t> : std::true_type {};
+
+template <typename... Args>
+constexpr format_arg_store<wformat_context, Args...> make_wformat_args(
+    const Args&... args) {
+  return {args...};
+}
+
+inline namespace literals {
+constexpr auto operator"" _format(const wchar_t* s, size_t n)
+    -> detail::udl_formatter<wchar_t> {
+  return {{s, n}};
+}
+
+#if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+constexpr detail::udl_arg<wchar_t> operator"" _a(const wchar_t* s, size_t) {
+  return {s};
+}
+#endif
+}  // namespace literals
+
+template <typename It, typename Sentinel>
+auto join(It begin, Sentinel end, wstring_view sep)
+    -> join_view<It, Sentinel, wchar_t> {
+  return {begin, end, sep};
+}
+
+template <typename Range>
+auto join(Range&& range, wstring_view sep)
+    -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>,
+                 wchar_t> {
+  return join(std::begin(range), std::end(range), sep);
+}
+
+template <typename T>
+auto join(std::initializer_list<T> list, wstring_view sep)
+    -> join_view<const T*, const T*, wchar_t> {
+  return join(std::begin(list), std::end(list), sep);
+}
+
+template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
+auto vformat(basic_string_view<Char> format_str,
+             basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
+  basic_memory_buffer<Char> buffer;
+  detail::vformat_to(buffer, format_str, args);
+  return to_string(buffer);
+}
+
+// Pass char_t as a default template parameter instead of using
+// std::basic_string<char_t<S>> to reduce the symbol size.
+template <typename S, typename... Args, typename Char = char_t<S>,
+          FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
+auto format(const S& format_str, Args&&... args) -> std::basic_string<Char> {
+  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
+  return vformat(to_string_view(format_str), vargs);
+}
+
+template <typename Locale, typename S, typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto vformat(
+    const Locale& loc, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
+  return detail::vformat(loc, to_string_view(format_str), args);
+}
+
+template <typename Locale, typename S, typename... Args,
+          typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto format(const Locale& loc, const S& format_str, Args&&... args)
+    -> std::basic_string<Char> {
+  return detail::vformat(loc, to_string_view(format_str),
+                         fmt::make_args_checked<Args...>(format_str, args...));
+}
+
+template <typename OutputIt, typename S, typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_exotic_char<Char>::value)>
+auto vformat_to(OutputIt out, const S& format_str,
+                basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> OutputIt {
+  auto&& buf = detail::get_buffer<Char>(out);
+  detail::vformat_to(buf, to_string_view(format_str), args);
+  return detail::get_iterator(buf);
+}
+
+template <typename OutputIt, typename S, typename... Args,
+          typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto format_to(OutputIt out, const S& fmt, Args&&... args) -> OutputIt {
+  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
+  return vformat_to(out, to_string_view(fmt), vargs);
+}
+
+template <typename S, typename... Args, typename Char, size_t SIZE,
+          typename Allocator, FMT_ENABLE_IF(detail::is_string<S>::value)>
+FMT_DEPRECATED auto format_to(basic_memory_buffer<Char, SIZE, Allocator>& buf,
+                              const S& format_str, Args&&... args) ->
+    typename buffer_context<Char>::iterator {
+  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
+  detail::vformat_to(buf, to_string_view(format_str), vargs, {});
+  return detail::buffer_appender<Char>(buf);
+}
+
+template <typename Locale, typename S, typename OutputIt, typename... Args,
+          typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_locale<Locale>::value&&
+                                detail::is_exotic_char<Char>::value)>
+inline auto vformat_to(
+    OutputIt out, const Locale& loc, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) -> OutputIt {
+  auto&& buf = detail::get_buffer<Char>(out);
+  vformat_to(buf, to_string_view(format_str), args, detail::locale_ref(loc));
+  return detail::get_iterator(buf);
+}
+
+template <
+    typename OutputIt, typename Locale, typename S, typename... Args,
+    typename Char = char_t<S>,
+    bool enable = detail::is_output_iterator<OutputIt, Char>::value&&
+        detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value>
+inline auto format_to(OutputIt out, const Locale& loc, const S& format_str,
+                      Args&&... args) ->
+    typename std::enable_if<enable, OutputIt>::type {
+  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
+  return vformat_to(out, loc, to_string_view(format_str), vargs);
+}
+
+template <typename OutputIt, typename Char, typename... Args,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto vformat_to_n(
+    OutputIt out, size_t n, basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> format_to_n_result<OutputIt> {
+  detail::iterator_buffer<OutputIt, Char, detail::fixed_buffer_traits> buf(out,
+                                                                           n);
+  detail::vformat_to(buf, format_str, args);
+  return {buf.out(), buf.count()};
+}
+
+template <typename OutputIt, typename S, typename... Args,
+          typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto format_to_n(OutputIt out, size_t n, const S& fmt,
+                        const Args&... args) -> format_to_n_result<OutputIt> {
+  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
+  return vformat_to_n(out, n, to_string_view(fmt), vargs);
+}
+
+template <typename S, typename... Args, typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
+inline auto formatted_size(const S& fmt, Args&&... args) -> size_t {
+  detail::counting_buffer<Char> buf;
+  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
+  detail::vformat_to(buf, to_string_view(fmt), vargs);
+  return buf.count();
+}
+
+inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) {
+  wmemory_buffer buffer;
+  detail::vformat_to(buffer, fmt, args);
+  buffer.push_back(L'\0');
+  if (std::fputws(buffer.data(), f) == -1)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+}
+
+inline void vprint(wstring_view fmt, wformat_args args) {
+  vprint(stdout, fmt, args);
+}
+
+template <typename... T>
+void print(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
+  return vprint(f, wstring_view(fmt), fmt::make_wformat_args(args...));
+}
+
+template <typename... T> void print(wformat_string<T...> fmt, T&&... args) {
+  return vprint(wstring_view(fmt), fmt::make_wformat_args(args...));
+}
+
+/**
+  Converts *value* to ``std::wstring`` using the default format for type *T*.
+ */
+template <typename T> inline auto to_wstring(const T& value) -> std::wstring {
+  return format(FMT_STRING(L"{}"), value);
+}
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif  // FMT_XCHAR_H_
diff --git a/deps/fmt/lib/cmake/fmt/fmt-config-version.cmake b/deps/fmt/lib/cmake/fmt/fmt-config-version.cmake
index 7adab269..fe4abdc7 100644
--- a/deps/fmt/lib/cmake/fmt/fmt-config-version.cmake
+++ b/deps/fmt/lib/cmake/fmt/fmt-config-version.cmake
@@ -7,14 +7,25 @@
 # PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version.
 # The variable CVF_VERSION must be set before calling configure_file().
 
-set(PACKAGE_VERSION "7.1.3")
+set(PACKAGE_VERSION "8.1.1")
 
-if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
-  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+if (PACKAGE_FIND_VERSION_RANGE)
+  # Package version must be in the requested version range
+  if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN)
+      OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX)
+        OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX)))
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+  else()
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  endif()
 else()
-  set(PACKAGE_VERSION_COMPATIBLE TRUE)
-  if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
-    set(PACKAGE_VERSION_EXACT TRUE)
+  if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+  else()
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+      set(PACKAGE_VERSION_EXACT TRUE)
+    endif()
   endif()
 endif()
 
diff --git a/deps/fmt/lib/cmake/fmt/fmt-targets.cmake b/deps/fmt/lib/cmake/fmt/fmt-targets.cmake
index 3ec1c599..cca3e1c1 100644
--- a/deps/fmt/lib/cmake/fmt/fmt-targets.cmake
+++ b/deps/fmt/lib/cmake/fmt/fmt-targets.cmake
@@ -4,7 +4,7 @@ if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.5)
    message(FATAL_ERROR "CMake >= 2.6.0 required")
 endif()
 cmake_policy(PUSH)
-cmake_policy(VERSION 2.6...3.17)
+cmake_policy(VERSION 2.6...3.19)
 #----------------------------------------------------------------
 # Generated CMake target import file.
 #----------------------------------------------------------------
diff --git a/deps/fmt/lib/libfmt.a b/deps/fmt/lib/libfmt.a
index e90cecdf57710d7ef5828ea30e9b5dbf3752669d..e3e3abb743825a5e5da58e10fb1020e28eb263b9 100644
GIT binary patch
literal 350288
zcmeFa31C#!^*=r@43J>t1&JCIYy65zT-r<$mVsD#Faz(w44{BoTRO%pI0__9W>}OZ
zVG_u5d`fMtbg}yT^=H4fUt7^u1Qf_5ny^#|iwL5!DKd^i03``v=KneOzBfxq0=RYg
ze*-i3y}RFY&pr3tbIv`pv2FEQlgX4Im`ptpcEcyrl<?OydPZC_LZtpxHYNNyk>ak&
z%`45n|A)P<wfrC}Gd=oe89Zpv5KCre&fxU)L75gL@MJ^{&dI@>C3Emlmi^vdF4y-b
z{m5yvk7kwgue*DgOxI+ZOiS<J?-Zuvk-{J9;ZOAN$2mN{{~#W|uZK?$=I_&n@X#`p
zho|)L4J&_tY#0yk8qUKiJ*?BiFZ8fHm#3e;m4~;ZBh;V&(Zj^s`1^f&_<|mu)Wg?D
z@bpCz59N_O>^+KyJM{23HvWFEorl*0Fx1Ycdian&?$7nG6ca<~EA_BV4@V{NcvTPU
z_3%?Y?2Fl@awGNdAwB$?9=@lCJ<L2`mL9tG@L4^q@6OYY=;3(G9o2hS4{rh{(fcet
z4CrB459@(Rl)fm5hq=9Y*zF=7X6fP2^zbD;Jf?>?11qWg9zFcU#r%C-Zyqkw!;kdv
z8j;8UNDrUT!_9hFn8MQs_u=8&did8%`1_Ch^6<Y>dAROU9$tGH4+DBQ^>Y6Hr5@U_
zim0D2=;3iawD;rjf7Zi`ui)<`dbnK=bFSp^PwL@zJ?zt;$1l;tFZJ+|t9bmEdU*Hu
z`1{}V@B=-Zb~TT0(!;sw{Jm8V=U$_y>*28f((BQ~(bw|#7YFe0xE^L+$KRjUL*aV<
ze!m`W(Zj(v@c3dqd|nUt>){mxdHN(hd{hrt=;23tn3%!yU9X3C>fvHNOt_J!kI}<N
z^{`P72j0ZfpVq@GZ|3hm*TbuB(cks3+xPi<t{y(EhpYAQj2`~*2Rz?GJq+mKemxX)
zIw$GjPxbIwJv^X?*IIZzg?d<}htKKZn|k<>9wub*{5CyYtcMMHn3T=a_l-4~?q85#
zS~`x0zaGQGOJyGZQV(C%!_W25qVV*IdT7?m{YbB8tsb7%>rdC;t$O(1dRU@|#d<x9
z_3-z4xJeI#de}{`ufHA+)x*hpSfz(6^l+0NUaj|U7us{V?irt5G{ciMYp5lwsJL`S
zp2t;KT3TE>%3_~5F2D11Tc&+h7paymQ?uHqmd!2m6wcr+D`V|;`}j$oY?sSo$%;*}
zyT?z;bXlzT<(0YfU3zcJJf-fL)0F(Nwi1?_?U`Fr=yDen&h)rFbCt<1dk)2*PP?sS
z!lc2jxL#+^>Y#xkya8UbYnHokwvta>Lfd+h-gaK;v@(U_vohoQlwUm4Q#i-Nl7{A$
zloZY^C@i(34!b?Bb$ui=3TG6T&UM}AEh;K3Rq`D(24!X%5U}P=pI)4w=P5=4iswu#
zEuL+kaqe2&oz>#LkXjya%*f8_peqktNF}p7>&ooTYB8oZ1}p4$5S#}W6ngU9(+3-%
zvfJJ5vD8{xSW;Z-amCMTyIfg0?wMttJfKLPr_jKpqUptXp129po3rS%Taf3;Q)byM
znfDjYaTU0yxjkj)lifPKu*l;o$tx%TqPoiNcNd*kxvb1m_q6-JLcu|0?rAg6r)PuD
zdkjNMN(+nJa|%1Dl`wRAp$mCNS%CCx=?><RnBqIeO^#c15vax#%esJKvvl<E6w{KJ
z1;ntp42-~Xk6Wm*Yj{#lyTtQe#heydu&fK*9(VD~yy?o_Wu@6=o`NCnGFMsNj6$~5
zE$wIzHOPq%`Z;J;-gIvv>s*v1jGr`;(T@BFT|me}psm|eSjtxW_(|C=WzuMLnN|rS
zVfq`5*OD0pUWYhn$tz>^6=As$C3mB`SgK)6f~6#{w5-rI+g;$fU&&{%v}Bi+6y}$?
z^6xLqe-H$TwWr73pEt8$IuR+>EmS<&HA$lX6DDVVo%*vZ1#@TS%>Y^FZ5!=S+gSko
zj1o5xjQ7=`uKB!UY`b#l1$ejc&3a~YO|o^`v#k7L?@W)rjunSH2Xh0!4lV-4y)O?l
z;&spTlz2)}nY)w089OGU97+LYbh%kA78b<^L!>K;p@3XR^AKNE;n%84r+^GF_KBn8
zR|wiCnrU~p+X@YY$eLXW9AxCGut0GT)g6>K9TbJ*prsuK=ihM;A22U=-&{{&nc@KE
zTkQFh1_65~TU?WdxMDZY*fojX+%b+N4vpJE85Sr2JD@*hI#q-xEEfEy{1TSN5X8)w
zF=296hj{lDhcSo`V`lNpBKJ(dLD2`1NrSkr^Nyk~)Gy#q+|0-HeF)V+d4{?az~r0k
zJDUOC^SJ(Y26Q5lT|j-373m%IeB{^dIk6I%t|<BI6nV1#xyX|pM^lCt&*YqGdyd#x
zGTHh@Qc#*Vt#~FQBUwcy_WRuJ7ycdYj+TD5*Hbjq<tcU{v<wF0-Pyc#LOR-&=Rh_%
z)pm=mqxN$c8{h(G=`CTbw0#uS(QcEuuj8V{F1}(o35=g!R!7c#?rE-q!hH9Pyy-4L
zg;VXb+XTvCFQFxZRo?}6vbA&eN;|8+U#+`VK8N=e&#`1iJ58j$>wa7RHTzxkPwscw
z%o3c=JVmZ=V28|USJ~IvBXc;`7S1Uto{5v9g4vBFOu)rVmm9lSM_4q7?^Ny?CDUET
zkszm}cy?i_tGEc9nQL%Phg*C{<p!Y~N*Mj<n7{6*;80$WSbcYqJ0EOWCuIwYb+!qI
zRUC`K<LMjr*Ju3Lc1(<)-IC21NLOA#UI`djW2>eO+tx7*zh<|-9e&a7nq+7EVh00a
zX-J+l=E4Rvh{G8NsC;)B&JJIZ$&P{bkVswM0K6}td*3?DI~>?ognL#thdX%T>3R8u
zGqA{AMef4sv;b(Y$g&th1|~m>9CkW9RE(8|xbjJGqMs{bCL_~b@bzcmo9%2D?1Pl;
z0ux~jBXT@~NF#0-ECDMQ2hI)&U?+>Wt6^}Wllhg;?t{UT#t!UTKf9yBbDiC7ouAzY
z;ea9&8yz{j^S86u6uTuyA4=o|J8>M2W|OASe@<NECx<0a@?9NI&NoAEx;)hX(}_j|
zb2~!M!P5$Htd9{V=n@RRMd?xvj!c8&4xQK`nH=Z*rMYZ6<4+5iaS|7RO}&7=#ZbO~
zZvTel7njU+;n3ikS?r!U-8~a0U`Pwj;*KmXj1k;=Cqjfyt6`Eff^UZsuQ(|QtsOv-
z+5x?lIs|8j?R3^#EUG~r*P^dLe(K9FE+{-pWCN*ARQi7&XR0Bbzl>qe7-q#BeHm17
z#_H@OG?Y-tO{jzuQO7clb2st;L(tBe82n8%G51?&qTLL34JzP=4yy|RRJ$g+0u&n1
zA@wyH=n72d(ZEpSFj|6T2`Mqo9wdXE48dBvb9zTqr=!xd&%ZR^Q4D^GWWx$E64dks
z%Vuqp^QRYhib`CA?kk+;o(Vw|FucP)choA_u<yRrE|&gx-x(01Zx!mE`-{D0beeRP
z6_!Nsj5V4WpH^B}=AG^#1?$<uq7ElCzBof+AmKMuHPoVp9#5Bh$7`<*S=~@hm}wD3
zcewcN4a!a0baMFG%8nKw{(y;}x)M*FH#nm8cGi*Nf0d5R{Z2Y!jY5Pex7-gw0TDkn
z#f;`*YA`_$bTtbkV5jsBHdt^i9jjo@qy4$xV*6RTDvoQ8m=yzQK>z^^q8*QkZm{S$
zWkXl+AVtcA4%M*6p$$TXG8~fgNWbZ#)@gs?r0=XG>^mK-aHFPg<;dODdE}dIxC?S0
ze|#S0nl!32?P6D5`npG9(yGOF@>@R&qrr0>g-3OM6wbj>cnrFXKV6N@-xvbNs<Ash
z3J-Ekf?i;9XMoNra!;S$j!GDdbOxsYgDHy(I~6U04)AsmlTq6z4sp54Mk|gu*q)o!
zH}r1tgepofJ3cm?O9e;bj*hy@NMwi7Y9fkV=}nk2_AHp6cN+x`cP3_#Z;aRk83J~w
zvt`(MZl<(jxD|dk%@ln%&A8h&bKcN?;Hws#`Be)Rf7OC>zG}g_=Po!Hx<hbkmMj>v
zK+)l1IuCnCN>n3fc7c1=jADpnSpl#BlR7*)>)8jF{mh$JS{QGQsB?;Xmg$o^X-_xS
zvk&I>easYz8J!I2Xm2#^lV(TqgY})&dHx|J!@5v;RP3hEj&Nbem<-iabgQu6L8s;p
zk6y7lP-vy~lPBpw#{-&idQl={9Sc=DsRRniuU1J;ejX%auDtyG!m=_LLl)RAOwPxm
z3kWlycIpT-bgmADJnhNmj2Ln@5xgQOb!P-EZsE@2`$ZSfj!lY!{Og#C4%QnzpH1qU
zZ+(a^w(n|d{N`J=a?nAa$oBV6EE@7>*||8HWzrXK7h;LQXED>nnRFnQh+D=neStLU
zJ8#o{p)JDxs@;*H%TbQgZNQCFatvFR4N3&iwzKJ+?Bdqn?F*hQY8(XmIDKx19NOSc
z&B7wA+GM3;^K`}>#Ux(1CG~mL(4`gidDYOB1@(DV(53ZsyBZ=}m$5l@oeqsA5w<88
z+m(kPq|5Z#ditcU<|vx@Rp;m&HJryBouh_x&(S$5IFC7s)X)ybIIA!icb0C<QD^DK
z9Cem%%+Z})%~3S*tIp9mYB-NMI!6uXo}+VAaPB#Z+=S7m$nw>-)j8}C6g~Q#HxuwL
zZfR~G-(Fp983b{WK0Ic$%dCqh-NAOxvmlxS%K<Ls`<Js9w2vPLL*s0hJ=2vx-L6~9
z|62|q>)(9<U$6hMCl5nwR#fs`ns9zosPr#1lCOzV|3V}AR*>sEw6pz|k?Wr^l5YpO
z{uv|b3b_Vh?~A>1WPiXu$dh;9^g`nQ&e~|s%01VfmHAL%X|b!gluJ9xxV7>5mbTtk
zR+=@vc$y`%!xBTWhr0?PV?iGaaDx(JH-#%Ivg!7f7gvIq{Zv;X0J{bDICQ6qsz4`E
zM;WACOft>T7Ds1Do$L%sL&<ET!>(B4HUIp6uj9T<d;b4wPQX`^1g)KTy#vk3EPm05
z>;0e&9Y2`yU8Ue{Xcq475cDx*`uyZ=XqZXf7%mQi;d@6D`W0&Jz`FgLsToREW^fN{
z?BZF4xOB~o1<Ee4@}drfk9NxicRP#Z)i4VO6>!}*m#=GD)`RR1xM72iL|muyxH=^h
zQP6f?)7<l`DWZIDFREdSE~*>H4YO>QZXz-0n=_H1`(}*!hCrF=dfiOFZ-w%Z^qr)%
zHyHFTh-^$ZNgf$vZugyzf~*hz{YR1YU5-Mxb@?~PsBdi)-zi3YYoqv1F-kXD`Zvd@
zZ*3IcDMo#3qqs1P!p@Ng7aVX_0eg_b(i!fVaQ{Jje?&NHfwrS0Z(3m)jL+iL!tt(X
zzEdYPaZYfQv3Jl-q;JhZPQ3cM{iyG7Lk0XDHlNKsy%ZMU^49diLHW~*%i7ONd=}&S
zw64j`Z>I;><$96%ZdX{pJN=ak+uHj)im%(&&gl^uE)`}McuV57)+{;)(OI3x;{qF(
z6KBTUScpYqUP*}?ZjbK3S)rW`1Wzq3%qy@@oE7Ivh^2G{WS+oSL>wPFC^WdJpcrnB
z+TW08<<2oBaY}n$pzCQkyFh!;vs&5%d`K~Hp)hYotP3SWeQAlGE3z0XoLQ_B03#Et
zH780LI@OyQI-Q8_(rCJCRgY0DqRNRc7SV6SMt4lnOs3BKP-a^@_CsmO$;!%xkIMA)
zdwX$d{`d3qzh4Z`iu`ZOsn6PanoI&*A)4S;(F7NVrV;RaXiCQie{k7nT1knW{FOgR
zrA(%KsSN&%cht!oY+l4-$sZXx&eC5HxLlL%cTbMK8&7GsN9&_1_x)Nhb)!z1P31-&
z3SF*g`T4kBonKhOj#2IFGwMm#`!#2ZV1ir7PXAo4>C8jVbPJqn;;(&uBT%0HCi1}a
z?2iO=Df-tt`pBLl^$q0-?dw~5C$9)D64_tVJs79{OhIhj^d6}%hu+Ta-}8EXDLmPf
z_~ZET#@5Zt>l9Sa-@bn<_4)?u9Z5rdv48Dh>4Izsp0^@d+Sf<pqrZiE2PeAX;TI{W
zKb&2kO`0r4bCo>E>l>kWtFf5FuO%Ruu8n4kJh|A7{>Urf8DHP>>Aa#uJxj{Zczr2#
z0$Uf+lKhGKH=`sk-{bPmob8@j;Bq-^v3XYN^*yVPH%+fE4fSo}8RJ0cauwe1Dk_D?
zDWm@Q^>O!n-oJr5!mO;|{VUnP`-gRQe{A~$@WPr-?!}@r^!GW)e>a|~ajL2j?|o49
zzIO%F^Ak-bTCWJ$AKWaO=<^qRKEMa=6fgL1imZO5sEz6|Sv@8DX(5|r|4>;Q^jjd9
zrRFe2urKlIa(brx(w&nOwQU`BpC!p^ovb!E)RX*8gZo?5qQNUE0(CEoRn&Up(V;f$
zHDX4nzDW~h^|W5LJJl+y-DKYzi9eoNx0KSS2C1eZ@oGK4beD9eG)0;`N%nm@R8hA`
z>KEvbrKaknxU5D!*1TJEY?d3wP)#Ovvv0E?u4%)F=vD5P+$INt>9VkX)u#ZfoDq;$
zQUbx-VQm!`y+gUwDbLH=t%CppS)IRJZm_R3vuJybtZ^8r_Vv-nMp?UxGB~ut<)KT9
zzAs)~i8qr;yc*>jWa}=^C|MgLh%3bM*7=_P<*g5UKbF-G9O?l!>d?E<BFHROW}s)~
zL+6WC>C{DELxQZfgkF*T_UC2QzTBbCUm0y1Jz^tsX!hl+sS~T-!WUp{w`|}rjf@XN
zqF!C#kmfHBT@uqjKAzznkLOfJ<MB+uSiED6ajdbahh^<z-V^6?jOgqkz=3Ss5PWY8
z{ju~DX{z*7$u+eO<9KGWz;Q2>jJKZ~Z{kIOHy?E;;Y60ozT)u-*i`XpI?w>Hmi@eY
z{v=s-?vfj-8ovyOslyKKI>IW4`dkfS9NL<F6sT*~BS5xY2tKDN)7DUWxKZ}=B>yW^
zgY1VRT%`IhT8&Kl+NrAXTrB&u*AW?D-O?-9i#n`fPj@~dV|AM3;r3nL6uIIJ>Mp^B
zL4{?)GV83ovFxIADPBE-t-to`D`q{ad-+0SE6~UvU4Ipy%IJbq-Rx8w6!k4x-LAg!
zcZ^g~&qRm`0BUdKBT%cB5*Qk)2wn^nn!etvR#Jk-ASkO<1U((>Iy_lAEtyXoYO7Oi
zGO*j>{|n3Pf11sK@ATzmmuu!LtE-lw3WxT}uc@Z0J>Kt!hB>r{QxxCFO%63|zzR)0
zj|_@$i-1|ABC`7Qvs6-TcBn^W^<9=zsyBZRlN#4oKbvBs%hm>CmNbpEtbXigkdXaP
z(wJE_Ct0TiPcr6~n&m)=oz_P0r4Dr;W|qJjgYi74T4&UdrPmM|K(zP#I;Ioi*y*?F
z^gKdOD?S~FhCxi@XYVV|Sag;cv@lsTON#Hy%gg$X(rmYwr0O0{tw?ZIedZky%2c$e
zDYEZild)4M>KlqW8c~}BMg5*rotfxRKX#~Xzyb!5QT67V&v#zV0&^3<Orz}p%wHX%
zY(0U%wh$Ew93Hxo_-t?9N_ZkS$*TzEO{TC(uG->tuB44bkHcc1I4j>~SUy@G6n7ot
z?wcE^pf_zLI&7ksu*rLor3O#PCq7xD280@Mh2!ED-v;b<8+^z52Z9M1>wPteQ|n@9
zobTU}`SyJ}P*Iy{zV+=gGV-1v@ab5&D`j;|B2v@XI#lPcm(>%p@07W82sX)@@!Ei4
zitmjt9omfb4)rwlJBRgPS(-yVitWu<J%plFHQtXxd9r^>jUv3GWbE}!!Cu+eVBe16
zm>TSj6ku-IrpPxDs*>tck2=&tk*Yu~uawn*BV)fTY{G-AO=*-fwgOSGdC%LX_<=22
ziJ(|#rIn>9{vKGzVT5|De|(~%&Pr)8S5SMPYy)E^Ka>yxsWMiRqV`by3linw^H&-x
zyMqPPG5uupk#Q&Kin>!G0H5J2SesvC1F+Rvhk7g$!yhoREY3*rcfd~|mdRieWR&G8
zzBke%L?4^qYZLUXkT$<M?1wZ4Bd^|PR?yf00B3Z<p&kePSVHIpW7jNV{Fba9M<+S6
zpzjS4mWKE-Il{p4@yG55)c~xbey*t4?R0LEZ2-WT1aFEYzG@zD>%;Sbvz2qP2RhWk
zWx%6n8|=^1jDWKNKj2*H08ijho$H-iPAUpsEk6Ehny;#DVx>r>wE0UN>cNo6_^UdH
zwMnczK^e4B;IS?u9&0G^SO<Y`;Fbuh*f@dCs2&hK=}<Y60dGQU;?@VN>@M`2@n7Td
z5UHd-T8Xa?EZHtaeJ?l<+dNPe{rO7?dt5_7=w^cj#AXwVzk2JOd@-zT@;IgP+yM_`
zK%Q-iHg5oSqT_PLskIMdM0$&C{k#IMf;FKYLJpP^y2Rn1Pa}*OQViIK+Z)BIr@#|}
z(p96j7-W~LHq1#@H~J2U-hRQk$WpaIeC%fkCI7?}f^#9Bo&HS4KO)gr8}^;*J^PPf
zG#{YK@>72$3&+C;+P8EI5;0txdh)FH82b>zRSkEdXJ6vX%fNFI3!>v9MdHz#B5`3A
zjl02Kjxi99ECr4%1CBfk908yH3Z;S&U=EtYjlt7xc#Gm51Hu!$sV=$}!Bv+3zG&Cl
zgH9hxeEzI+=8rIxZ0HHm{GAQmvcX<?Qv9WUJi!RTnlL!jSIxnTsi>i9E`_Fss)rG#
z12iDszi{BlqFuU#0@2o3U$qcvg6!L1#xi4Y)8U2V0^o%@H!@5LzDfJCe~eB&XEW;A
z6B&ql>aqR_pq{f+Y}GkJ@K?xQB#ATY#gvOPWWgk6X!oKeo7&Xe_$Mr$g<_S8m0Be3
z>3+o+!G!q0;j1m%>^P$Rx^@*11t+hq;`h5>hq6Utard`JQ@GH+6rDdkj>a(P3<ct-
z<9yVz`U(v@^s^#`xB53!tGDV<o8;z3V|#5{C|9i)tH$fiKZu%@z>(V&ZG5*PwD?<;
zqZad{Ep}H~i<dsaTWqwc9HrDJsYzM$E_G-O^sxZ@<r(4<a|RTtwgHLqT8zkq%wc&o
z9@6o_G7jq}u;Bg3>%`D2uSBN|GTeSS96=$6(1c`}nD|p2uLyoxWi6@prS<k@Km<Fe
zV}t#-)M~x`8G$babdI0LgP)wHi8&DnU0!jJWF?q{xrta=-AnBH&H=)>R1O?Wr=iN)
zlQffTsJrdD1R(fF)PWK3a*46!)G5mV-ph69)A+7A7GF=Kk~~y`ZRH>!&ybFNA!33N
zf#=VF5G)?F{TbvR2GBi#&u{SAg7=LGzr?2m2>1*>mtwX5AAH`z=L39F(f0(T8}wI~
zSKwqK154D_wdf%>B>j+R-BsHC$I?%y)~zGpv37BSVxd11sJI>@U6qQY=%jHmf}aUD
zBC%>+^pVRu;@T&Ei=8hsJK(Or`uWn}u5lP(hadmbbjs96_-=&7z#xZqb|{P^l)Jq5
z0O_cY5&ohRxGc8`*oC#_XwCqSG0U>QBM6BX@yU(?D%1^(N~hg2crC_{C@Q$lt>8-J
zn1jhs&Y7_JHTc;gaY2LHR&gjCUTCWLn8=W)U*PEF6%7vnD`@?JRWem<MuI7H@wx}~
z$XhXBo4cW}t*=Q6v|MJ_<S_k`k;#@(vx?Bd1{o0-W;y(+8*T1g6Mk_8a-Qxh38!DW
z%{FkiQ{Aa-KVs8z2TQ&N!KSv@)ZN?n*|eJnE6oRFckR_xq1$m7xbDGSzZ16GtS7|9
zKS#Afjb<*FwjQx%oX{q9KUphqnzi*4oBQ}%|3I_qv5Ng?K;WgokxL|@zM?f70zPrc
zQ`BAcutR*Yarp?_z+K{s8b$m=t@uRE$vOcWMrJ^)r2hNDH;9ivfXu#dPw~+;cu?{&
z5VjH7#20T4*oIFJn8n4!dk04%S@iA4W7Qt9>i<yjLxNbjjMWnsAAOuX^c1ye^iUIi
zt$<2d0YL+D6*Yp;5+(pj?wXgTe-sY1^c7lGU5$LP0L<A4yo3a<ALDX1zBF)PK;Dis
z{Yg1+B+Vh5l(!#ITYdZ6EPH&d3F4D=!glres<-~}kAKMGiyKkyS}iq6OMSxnuIO8e
zs$aTcU;wa}eDwlA=?lLvRxL-g<U7<BoQbaLumlJ(TlGN_l1ti@@Q9Q3g7*i$aCqL0
z3_4T>@LJg4nZMt`8Q)R<oR7s9kB=Je`4~WY92wMYiumHTmjLtK;))Hj_=k<94+jT>
z=GZMKf&IZY)^Lp=zP{CWswX@7i6d(*+k7nv^HOc@V;MhryjH4c`$NgCy~M?bD6_iR
zS{wWWJy}1Hd^=6S*H{(x;o!@7pblN3<Zsmle3-M`ownigcA`5Ep;gI8O*NvaRdmP{
zM{Yz@tqJo|Z0@F*re^h&)Ozd2&~54#-^V?Ct=$$_+`E3h;PkN7m~vCaY3k1GbYE+a
zd6&6sta-Kf-}?WkgClpbv#2<#MN&UdPgysLzpIhln`tI0T640qv&ARs((7!Z{g}97
zQ_@xmb0Dl&0{haj)jN`EVpvVJf!b~9wqUS(ce{4QC1)@YUrUd9m%BGm+ZC<6@!gC?
z5J$DL#)CU4SNKcu@c}gMj8;i}{Y{&7z4&-4-a~4Xf#>I!$a!R<yb>6SKhXrXVL^ja
z{ZhH+O(k$NN2>Uke*MeSPpW8mi|uWn@w0^ts47WshD2%IW+UDYNZH-ZoItc)CTXMF
zRQrzC2!2?+I;m3B8b#e|b8qL=;Z$F{aEhn{=+-;(_M_vq{<i@6Oim%>P(QGNoNdRc
z7JSPAM%o}iZ&I4~$-=v`Zz}|9pE`w4<<+@+CumR2yu>Gi08+-CSR_gA`ZVlsLcqGE
z>;@SNM$1{T^=L+`CS^U}O{}~Rjks%e0jUCqFT)8kcnF-TxOg9$28&-c8H}go`-lWC
zV&xe25^fV8y_G-p61CoVl702zRfq8qdd3)bMLl2LZI{{9=H|V2_aR#1Qs4}Rsh@2z
zOtleYZm^tD`_e_Wf%~zpA=j4!p+T~6THYQ4Vf5{5!%D$|kRY>A1n_KxQ1pl6l-#_Z
z53!r9nFr%j?y%N~zRNM9mwK`KjzWek$Xky}zVP3~syrmfzK?O7ZVQrLRM9362umm5
z6ueesXq%Uf?_T1gd6*|W-MR2uNB)c*O5h{2Lt}E-aemuX;4ojT9XH%|Rie0fC^9<K
zO^CtXSwjF9-X#j#2nvhUUMnuT3^{_;z`4NT1b0ow{{v)KGzJc*0?xiuy~HICfw6Up
zFa86?mF5o}!p6AbAkYDWK;Os#ey8~OXq4d{Eg;b6+jq!;eP*3bgUAm^bPO*@ME9m5
zIhcmrL~Tw6d$V%&f-JsX?`ug}m4X=-N3Qp^CeFJ@UVTmP;D3$lIjsSM*(tB=m-oh1
zCvHUT*4i?=9QY)W6DQKAs5^o1SW3R%5aR4)>-!X~@6wNgOAzI-Hpsqrz%jK2e}@hL
zhbpH53YgU-dG(}we*5eXR@#t?$vc3GFLKwKuI_b8%kAObOI2BFDo&%WY;nm?P}tXs
zEoA~qyBml=-O9*_?}vyWT3=a3DSO|Z6TH6SG*2pHNx<sgutG#V^g{HLg1%O>SovpG
z=&D1TE;0%&V@ch`%2lioBWb+4=UGY*v2rb?Y<X_9_E(*j`CdRwAlMTK479_Nk{E=7
ze?&CHovY8DnEsfUpU}j-h2=;aPzN({M^`g(Yh)&(1Z=53A7#Dc<|3%cE!&R-FGqK1
z20p@E%d5ZKoLAXr_CNkdCnJGRuILo{A7CaK^l5{MgZ`fp!Jxl|QsSV$h9v>|-3c`s
zVxa#yO9AxLC}nRf^n0+D0R0<Sp&002#!>+NA(Rpa{p%0|=mYjoL}7m;BC)Gpi+~7H
z@G3lP4ax4~<-b~Hl7$Z#j}|nuSj?NdDK7p~bP=l**++~Nk-eTtPJ?eF8WVbY;U#|O
z4qHa6BEJ5HH6Us=h?j|Jc$Jp}eRdy<EBRYW0MqI|{_J8LOwm3t+7zth(X0cp389&R
z!)9boxd9cUb*xrX=pMwen&V<^flznkB!WxTl4K#2i8xkgT<jHr!#(5&j~9fJ@PLXQ
zJXSz;lW-Z_4e-DQ9+?!UQC%7F$2M)r0Dwu!uaVs~&6m78js&NH;B9iC<yv9AmRw`g
zk`<{U@E$0eoDUj)z^t}7ILkZMpL5Ar|Kv*&Z5iva+R&0s>#w-C&@LAU_LbbN?CEG<
zp&_GHUZzV8!6-LiHvs#qpegkoON~@<n)(1PLe9YHwoz_A1p3HH%T8JROB+6oIF~UB
zPovmo(u>HVvjv}>k~TuLSJg<O0%>=k)hy?4&^aT2&SSoPO;SdUU8u34z3oSQhq}oE
zHio8n={M*dmtPK<S{I|wmeu%orvH-tgXOA|o}TR764F(0pmSU=4P`XVyskgFlQhwg
z^+ISmf7jWi^b--%j6)FR<IjF<b||BM5S}<tTw&k!yx>WNqIVx8=AOPXQq{fTiRqzU
z^47y7ME}fEBm13)6?J@ym}1{0iG6xV)uSPBZ$ih?*-;k9s+0Czf+tD#&p)g;$j_u)
zGHi5$#}Pa*-m0*tH=VAu`AvMlNs&k6KxZV${zS}E`1Uj=XXe?(wRJjRcpE$xeP@+L
z$=g}{nRTaF`8cSW0_Ivh$)v^$Qy{8p3|+<b{fd8KibL3|s0&k^!Us;u??Qg3y2F|A
z`B*LI2B*I`O|gDama6!<yvpI9(nzIPLdKU)>qk!Ypi><AzO!nN=kHEPv7DOOs`ySP
zmR>bZGk;GZCWBNiV>R>D4luFSdeH|N7M=MWP&KG~9NH)d%D|Z&=;;|~IT;-eWEA2G
z^N?z@1r$n<t;fAhvd}CG$K;F?im#=oxad|epO%_viKXI-)SlI;5K~X?DO67u*h2yy
z5-6q{9=g$k84qT9=#Gc(^w0wjJ?Nn)9(saHO_Z&5-j{;3W-*rZvYy}xK4ZQ90EBFx
ztc~8smw9*D7Z4<MqvSgPtBRI;%gmOV&>TfewaUKQ64|%^jNH82Qlqa2NlY>Kz?Y*(
zirB}NuvF~hNO%_SwjSv$Hj`qPQ!G{@Vn?vpi4@yNvHMu;y)3qbVw=Q1$qBOWa5=hR
z_CD*Z+U6N73k`~vjP?VVTVQTYiV`@`-Lj3~nPN+65>t{>P__@1?So#XE7on^j}+?(
znp?5*FvJeh$+|R;M3XCy{D^d>zI`nU_zu*IiQ6M*)EW4bI#^LtGciGcSd;gtVtqrb
z{3B`zUI)<G)IGj~S1S;^fs<zQ9qdh1FrJ9U%wL?m0jqwX%#O3^+L&-v_%)*4qOz+T
z?98aW>eL;I`p$8&53~-NeRIA2t?OiQ^`V@yi_2TPc@q)0rQW{zTHpK~ra4JP4W{qk
z2uLI#jZ`4e?;~%f_=`Zz{_f=)q)-x7`pZChps+fzeuMzwd~u4R*##;N`CZMN`(<tF
zTcPWseP#9yihp*R>}v}{=?oM#)`-(TJJBf|ar&pFIWs<Gh)y~-?1{%gR+cXp*t)H%
znNy?IE7s3vyX9`)8pR5+@SCC6pt*Z1bd`=TUDmJoU1^RC9C#qoBx{#;mDj;0$a-RS
za-{P0p|zlHE7dxT)sq8Ah*i%3qKfc7gwSaY>)|qyj{v%PCYYu;hdA=EQ!P#jzKH#W
zpdnT+qTNpTKzbdaDHb3jOryjVw(Hx>jnG<#b9<Fy$2`#d?l>*?dTcylrvTLomzw(O
zNF1I9a~z{hqR}J_r#KnsV?}kP1YtF1a%#!ndnv(klEJ$iYpr~qC0r<Lv%=nEpeem+
zR+WYtpjBAOXp$QmfP7&&qgnQayOs5`ghxN(=q<<s)T(tr>zZ!fX~9Qn)GCf4Agc$l
zKKEE4&@4x!NnD$v<*w6GAA%4>Tsue5Qt#qV36UqP@*1<2dsjun@*fZ?*O|Q=9P0M=
z&3JBv6vMZ_TP#5<S}Lwh&7=l$AM!Oca;kRB`-!BUk(%F=%3E*2iT`8RQ+UQI+5!RV
z6}qeMK~nnTu;&ZKSD!$A<^T-ccpmVxTRsd~EPEV&Zw=IGLOq}6CIjTC%b4aSOmmYH
z>IW&~JsU0eINfb@j@z$Kxuf-oWf@tbduF8Ung7BCEYNzB<2=?V__7fRXD`wMwn)>X
z{q1u7=<9ROj2HIg4v1Z)x>z0ybY1%e`bKCqTcG_7`q#z!*VkvHe!fbhmDjdkpbeol
z?HB0p302Q;f&MkJKw%u&@dEwd^%)@p|L*HkjyZ)y@xA@}yc=r~)J0xL#0|o3lYC8c
zk$BezsOlh;m_cVE?1S0jqL1-tuli7|Zl*ZZ`#jf#kri!`EG~d#dtz9=hD5|U75hoH
z=g?9Uv<edLVLz>|+CU0WhiKdO8p-uU`z}RXeIN%X5p{QI2GiQ1@kEol+oA4^c6TYx
zq=S6{n2_y+R?c%wo%(l(XD(X386-Soqny7@c5fT$OmVKodsr4oK$ouliiB_#^(1T-
z<>Tt{z^QJ&LoGJ#r->-w&<#kr3`$)0lSv6mb3r3is}M|ncAFx+Eo@q~iK^etPPp=R
z@NxE<*I?oZuJ^FA{cy$!n~HNzt#2bteYWXmAi0~FdPwc_!GK8y`I(TYdUwcHi00<Q
zs$xpH_j)ZgyK38l%M|s4*U-qq3@9WHI@A;5qkqRSQWAEEkA0s3c<OqaIu!<tu+D_M
zA6-}m(W&G+lfZf<iOx3=_pD938~iQQBd?=0*$3jJ?rTe$eUl?U=Ve9MX;bU$mTgk_
z5FXZ%L<j<@y$~K<tL0vaZ6^2@dTH4c+<?G_!=HOE*Oi2>d+>BYkficFcDwVw6qLH&
zeVWe0!KYY4-MSxL{_0k}!du*@=};Y7hysD5I8X0=^PYLVQ04~rX*!pOig-=F53U@A
z*ev&HI^BmR^4JGAx*kOAVE1VfB7}zVSatZJDTuYYPn-6C(LFSPRh@*YedEj|0YlZM
zjlUTl#TMERGg|CwEr6~)oGDf3!V;-Ytjx#U`7sX=wb|81D54&J8{B|X_-w3}`WK7^
zdS8f2NldJ{G9CUI%N*By0zje`hc;1=s{2EOf2x<wKebU@{1~kRE2hbV8D2|PqqKWQ
z&Z7!Wf&!2t^$C&<vpPva?6dC(Q{C5mGOD_NADmRg#n+)C#aAm(r>r{`)(5jtAy(Le
z@llIt+1lW}&88mgaw{KIr>JAV87)j)n~Cliwpw5qf;T|yfwCzwv&rhps-WI1WP%$A
zet}-u$e`sEw)nfFB!rt?fD~kvmNMp4Qg<*NHP_Y#*RXQi<n0IKe8|LaC8)~&oMwpG
z35E>7IF@adty@de!0F2w@6dl=I6?HC#Pq<p$diJj1{kxQ1Rft*91+BWR{<=?#d~U4
zt7MTF_%t0Y>uTbljpl>s5-tuvC`avbS^zmp3pDCXQH-9{lE6PA?smWi8shH2Ct&uQ
z<cvny+E{uiu`1|c#@6LHuC(?QmyD+wv226AWP#|T3kC!s4Pkkm1@qXCPP92V<wY@Y
zDb9K2xqYk)u7b^KA24ROhhc$MZngk}0{FDTZfWbnccpTxRar}YMGGds6YG5HdhxMS
zs9LHQEDo!8rC9Y5-f-Z0Rsxbp^)^As4DO~3i~vM1kJNb?$Hc`aQITxL13!csu)YF1
zp@a#Vxt!&r!6}e7FZNOHjN`1?MI@9|GIlxu_C+t^S*;mS-e95CLwXYJc0tlg+rVyO
zWLE2fei)fGQ*FkmtQZlDlj_0bo=RBwe*CD!$8L%nP6OV+iKBE<rli&eFUETm2Go<_
zDKt*-jzA_zlTL-y+7OOWwI_ic%PrFDh{a%mB`;8kjCcL^9X6q{J5hXShEUh@*tHI3
zm0ltH<}Wqj*yfvGogn_ACVf4GGUa~n-$Nq_rJ%2dEDPHe^wnx@;FHT`4T6YrQ$;N)
ztbxPj*!@Pft|d)1EMXw}{bhhKTVPd56=%YjzE$)kiH?6j7va#HJDh3@N7cwEXga-<
zgTF#asalYj@p*KNp`NczMZYsP2~&62)a_j^b$;rh@ll<gG0{C(zNXGQ6#Qfg9S**S
zN?>6^`i1g&Y2i$74xMd4g9I|g{*;=q?1?!>+5ClQnwa{S6<=rcWG6rKMb2NLH(7^m
z8GC{X026-?MH`d>Ib+1Y<9zR;EFFI;9KN?T9A1RaGJIabX9GS5@M*!PH_`{-L;MQ~
z``X_UXi<-G(_5YPK!n*Xb&DK0l`i||q{zZMvUN^c=`2~ri(gKJ{hh}x3$4Dk0&x+E
z)4>)bT`!oHqMUmh-vmFo&i3HO0=3zeu?2RMxpRutxoud*Z53@Ib~<(E?Cri&N#c?K
zN|)DWR^JY*w~O%%vX>+eceaR?G~vNId^t4pjf$`42wE#0>(DNK1_F17T1)#iD4{#d
z+dGQ(-YHOz*)q1Gy=0|G9gFsAjrQ8mUN~uXD%NJ^i0X&Jp({~^+KjkapQ^23Llo4C
za^qP!ZT=AlUHPeHxES9vZx&`ceQKS0oCdJ?HcX;Qd`u#%Aob27^>!Gb$BxCbnN@@R
z)quZ(CZk4vs=bBisBb-#Fl)e$u(A-%LCC_Z8J-i6eY*gf37Ct3Y@LuMF7g91imG7e
znv3}edltyT7KlnPA^ou)Fd=h*Ny_TFF9t$c^~FGr&(sX`3S`(3_#{Dou(p6v?EqP}
z%0=oJK&+un=2HZ1=4{kRlSH?QXp-)VH%-JO{Wnb#C1a8XVv?{5FiUqq{N4)Hhw_@y
zyhClE`HHlE@a*=-cGmvvRNgjC8RYViuAjoB!CdfHXaXId$O>xn_hHH$x<w!f?xO%6
zZg24pazG8uCQh$HT%3WaLp2j(tBEV**~BI;x<SSB{}rF!jqQ`neZixzl%U{lsA>Ug
z1aO!zb)?gjRqZfhaM2=>8dIy9=&hlOcG+~KH`tfr+k}{M$W_>*s*!aVN-U*7t(rqY
zLsd0`bYy6#N;8^hsLC`RRV|%2GlBxOY9Iv-RYMW*LhJFws&A-T3XLCoRJC$EqNQgk
zP^+pbXsB9-fEOBwHYum1zAgFQ6u^c*4<WZr4Jz9|R=r>aVZypxtR4k~lN;(Vq;M2e
zjDFhG*Pl*CG>jI~K}4ar4|_wn$s(+z24qNnOD}_AFo6gcBlN|_fCKvK5J$J*UJF6g
z029yZ_v$xt{A`>JWEP0U!A47JhW>cw;8;TeGbsy$aIp-Q4ag!s3B8U+(8FyWe4{*O
zjO8{eC;QdP|Dloj8DJu<5O|DMIQ-U75N(Ar#I!=-Zm2RqiRww%uCX!z=z2EjAnXQV
zyleq;UA>7|GRubyexudbpCiP9yiXt)dXFgDPX>ge(CZ(8-k~_?`JK!C77jx!i|68D
zNchEa+isfChzjW4rXDdWAl!+JmN3W|?S;dX0a3w#B0waL4KH60h(K8edAi2vpR%%Q
z+uWhSFHkeiaxBWeoa`UjxcH#jkCDoV)wL+1jRZ||F3%9u?Y@vucB8}3R-zL)Qkj!P
zebs0ILLUMPx0?`Q*@hEeJ|1Yj`{&olOt#xp2K<5s2NFLc66a5t<CEae0l}Yd{>lXL
z(F9Dh%|D|NLPPC2hV`)jM)jfZ8T9!TnyS%iZUrqDhczTt!r%`y24@N`nKWmjzi3rS
ztTy*UZz(@|>)C>y5^<rPdV9iH*%A(opiK;VVfIG!*Pr`yzwPI+&&XW|b;Ck6_vbRL
zOwC;G&~nGv)OkNQ^QBswAX|5O8zImYJbnE+Kc`ceQ_G!gLlMehuL_HmKO)S;*+{m&
zLi9}Z-HLBaE?>?c6DU}h^j=cd;1!gGFJrRh#@IO~`WcP_HcS1l5Gl0zUrEDg>@Z6l
zr6u1C_TPs4t&e8o$Y>WnwOh}KkFUZc*sVwG>S4R+sJB}i#K(S(D2LJLlQeO5H6%4}
z2a|2tW&`Q69$j!HG3+LAs+dCSnRzLamONbY_gB^3A+u$VWrMmw7Is_q*sRS9E|RR_
zc|Ft<Nd679GD+`}A#TPdanTRa4yczPF8RNBg6y3XY=HymXvb!4Shx&~B1lXy8Hvpw
z=)+~>bntOHtk2QH5`Fh4vgHu7vT)xbLaQ9seTp~=q6$XngJY1{Kyik_>JKqOS<`66
z%D7+K-00f}Ds6ur7b|f6WHwYRcO`=6V!cocAh9s3Z<5tl8hHVr(FmwRt9H?=#u`yX
zJNTZep;WQ@<UUFe?HfTX??;TK#sRV)>Kk)jA3Rd+UqKoyx@>j!yh>_~|4Bkon%R+B
z{~Ix{M0Wj*?AnATr~x06)ZI4ip0K1X02$hoahhHE73E#l?eoXW{#OXAfk`w-8$|VL
zV{;?y1tj5vqNO-LsV#nUh1L8ke&WMaSl?ZE*rsl>)Yz>jJQ<<>(JiTHsid|=l6sTA
z?it)Ws}X7-BU0_Z1L_iB{41XaZs3K0VDqO-!Wl@JRH&;RZ}>HioLU+(+R2&|5)KkY
zVcxevl+h?YO6nV%wQ)gT=`}o=f~EL2^zC%*12_m`D>|Ab>oHV$Ou|X*v0P+Ai)^TB
z)d+&VzluOE`@ut0$vlD(8gCO3;0TUOJDGU0sh>1&!(82sXSJmnW(ZaH;t^s$yZVmZ
z@>%ToVR|Jo=-P&_p|T6o^;hfZd6%L^s>3GW2Jw^B1)JZz2rFR06<BU8nd;@q)FGQc
zXAuN>FqxEvMvxfmmIV{+)>8z9c~{^huePYoxCiEcn)>Tc{e^mhpx*#pdD7cT#+#*?
zkPHa3$HVFv{J}@*=&)pM79YPGzzk(^dPsE{`O6wPKtuh-ry{e4*$j@Psjz&eG{0}}
z2W8Cs^$x%NSrEzRC1I0O4Z!jOBy-A2hjyO;Y$9B*Hecqq{|+blNAJZJV8>#8{4P91
zsi{~=mNc;x^-`kyq47~*vi&(iUoCssdklRAjeR(VzRFtvG3rl1dIKSFLY%yAW#sh|
zoxCDPnc5!&Ih2k==&%^VTJ~R<8X~It0_%vdVo}pFW2@26Rx;bdNC>H~9kwy_X2Td0
z#YcUA_}2PA6rE!Ik0Eia|FoO|a3Th5s4AliIyC{!5-a}%Nw<?OLGEKi`3+tH2S$?o
ziEK1I*l3iPS!g#u-_U%Z3&4@eH1vS_N~&bhXX5=Kih)H6nOYb|8_?imKaBJ;xCe*s
z;r8cYc@E_|A=+cbcmNTk$?{K$Y<6qX@NU;`9x_rhXF;ZEvmO>7wIQn{?8F`?K7Io|
zTcK=d#AerEx4tPp)&o&!iqi~xqr=ZOJW1WIZ+IJQ>QU=E3%<wpJGSa2YumiOl4c$b
z8AzkQzfax8w!9j(MizF_mKUZi@5|UNZ?_Da(u_KB(H|iU<y+og@Wi&f-Ev^RvE}`W
zZFx1pG9;2Y`EP)DG4rD9f4`ym!1}mVUmw+=EeyX(@PPF}0mCn%mB6oZ1Ui1vBjJ|<
zOEdpp^a-%}pCizZ(Q?fI{fz*<v?9}HZ4n=(5lF(@cI%f55~UTE;3M>I-2wPw2Hvw<
z_ll3rW~+<M0JsinQBt=_&D$jGCjh4!2KcXFoW@$@MCmW*iC{N|`ID>F%>exd%Sl`v
z5H?#j*sLEfNG5KhCrrR3f3gZLBnf~&QCdkr2mc5j19zOLW}9{I!argLYh?c@CYzS6
zWw`OCn_D5&WBuc>x0j``8*j<jUvLhf)#j}F&;z;VhY69bbq!mKx;qcQeW}VeXYlSG
zDax-9$1eIB`G{lAJqEu*=}~@#4n0AVhH`!-_#QoOsNCT7ssZ1A!86m>lH@G{S;inn
zLb2p*tT!hPll|V6zP5yUH^N4p(NhwR`o|`g=URq&FReFQK*;fC79csTfu=@Si0x%$
zV)@WvaA88nZLw+`=y<)!0&Zxz&m;tM@rpT(GR<=Sl*VdvA3cAtKaqX)IqELK<*InN
z(1F;v!OY+?5K{~!<A;y=>)Dx)@pV{-giv&}tV{%~?P{xpdmzLrV_mW(%J_0@z?PGt
zpOLvevnIz|lw^TF@%MjO^3QwO3^@i=L)&qSMi#c>;>KP{O@0~L!F1eKONViYB5Za5
zMZ_1kkkO>D5m|tHlV8UE@`;|O4GJunKqM%z8~Se;<_(bixi7;c8zoLSgiVs#pWd+b
z9!Yn?+7R0g>cuTN&p26ons%GerAzf)#jfToqI?kFcy5uS9DmtfjGJvtu=7hX2C9Ps
z*+T1(PRk;4oTTMy94BK|Z1nI<8Db94v}U6cj}FeO!5<tazO=H&+s~%12m9;k<F~Jr
zGzBQ|<SvY&Iyu3PJI6Swkwg|JGJWd1veF>z0Ryoz0}JSBHrf6)OgN%(QAyNahWa$y
z*Zgb=frTDHND!OM2I*fzKtS?R3SyHP@ce5Sg6J}$XmZ6HBwvbZk#Ide)GL%2>Jc)>
zU-t*g*JUpwE;hRCY$R8geU9Ynvg^9-WJF%Z{0U?-e*$6HtjKInBC(5n&57Md_6Ezc
zaP6My%1h_d*|M6H6b*JF8z!i_Kg<#rk@55UyRd#R-ND{iWAE=m&IJXr`o22v6q|Y)
z9uo}HCvXpBy+w97EDl$4q3;`w*9GnMeS4WX6iih>w?Wj5Tk64|qN#`vhAurba4lds
zNDh$nPLpW#{i*9uhzsmo(j%$wurBF}zc!@rp1Pw*oN33`*VCuq>S$D-vW4qY-h;Cl
zPM{bAfDF+5K&QKi9#|BaASl<o;Vo1AKV|BVt1;L_eZS`Vk3n4j@t&do7!CbLXz1>#
zyQtgTAXkA09inyM`1!~}H*`4*BVmB{(-fP3KFpz7AePM}EN6~@qU2DQm&0GzKhr*0
z{pZ^!N9?w{HcvL-W!xv72oa80`D4tvqQaIFUdF%>xj?38r-iQM=PRdB=Y%2P1Z{ei
z3D&4$<t@k!Uk)&Plmn*|6fNgU#d?x_kwCV^7+e>a+}UZsDrd$ng=Dm&>PY&u!s)*&
zah#U(8}Q|crPsl5unHIk%Yef&86?v&1lG#k6wSOy0q^R2h7!p+O07d1i!&{Z_4bi@
z@}Ah~hrCKuVSw0R#y*Bm9VAV=ydgQ`UB%Z5^W-0b)r&PxE?VkOUZN&1_B)oCRmWm8
z!bF6L2$K;eBTPY<f-n_fD#A2`X$box><^{_R<^a?RlyHI#vST@oE{b5epu#8P|!3$
zR0iY323RAXk$fMLHF6rWMt*plmiil<=}K^&3)YT%(Iw-2Mdrj+P;aI<s>mdG(NY*0
zFM5{6rnA^gid{~zH7s@ni=9ZZjTF0&#oo(eODMJpM#YQJQ5+&0%-&~+X|cl^8jyv}
zgs&F-pt*`TAwV9yOm|D1M4s%Ehmw8rP*gRHsv3rBV4r-(`;pVSUQz!cRtB*}k$KL6
zo@2FK4K<;vqcBx}EM}s_s!0G)a29QLo!J^Q{*CBAtzOtHoQ8IHU*wuKL+LcQ$cvwE
zW51X*5!Vs4(N{wruGG_giSEMVB$V;(+m}%<R+39WC*0z&bD<e8(yDZ%N*Tw9t`iED
z^<pwl#<T;;VEo=f4j%%bSUcf7V1orFT0;k6qJ|FI7VW}PxK`MGLM$HeIKHMoo`ToU
zi^OeB2;V}u9${;dI81CyrtcH@K7OD`Y&(ST6NE=khzqIcLKKCn6S%a|`xi7j?6NK0
z6l<d=3$!lU7?a2Le@asK+SCow_M_^t?FWTAwf|F?M!JTL65hSo;XK#V`6b>b5DlKi
zf>e`FAP9`h`7H|Ep5bIP0)O3~4*&|@t{DD&m<0r1|C0K~D9t<o@|^{r6WMQI9$Hxj
z#kU~M<h>kTh!}GQ${tR!fNMo8-G0O#Dm5&oIiWvTR+-E0LLRv0F(`SE5_qMUA$m$9
z&aY2gjTCFJdvq-%rcR@tI^5Gt2wlm>Lt~{Q9MtVwThJ)h;v2K7(JtHL>{VwxAL)4E
zc~2pKNyKz>DS;Go8jY;a*z>5cHzKa-UyeJU?WHx_nY1R=kk$wvs1S=YruYO22izb=
z#zcv}N%R(R;50tbn6Th5Bt&t*z<0wRWE#6ha>juRAU6Mt1l>`Z=T?U6lK=PgjzelU
zYrXeDyEXv=QyGFUoHI9OY?MS9ws5EB|CB7|)T!$g|GWW-*wPbips#lI6i%gfp;i(g
z1&_f&l6!9U=lso@v&3tG0M6RD@Kc;D*TdY)ZrwWnrr<j42WY}tzwqkd-|&o^7?f}c
zyIZK|6c_)RazW6Z0r|!&=p_0uO3N9p_-zBgh&7eLqQVRdVCXP#XjQ%I>45Hqm~JX~
za-Ic-B29|w8GxMz{che)oShYRDZ(y!83_n+>#e8g8-;chP~gb?jr2R#ol%pQ&~Xq6
z;e|&aV_9&eB)kubMRE#kGJ6<qDC!=`kNWNY7X}a<?HTXeRsP84hCEL0iT8eK!+G*C
zLViYOXk1SJor#kFS5)4X@rmMh0K|l0iNuqJCKN5@8%7(wGJM5(Znd1TOWp3z`88~+
zReT59Zqr5zlK&^G&2q*E{{9uPod-tKCDcI6Z6q0l$4tfA>aAn=cB$mgK^0BvPJjQG
zWTFo*fjmIiGWQ0x(Vto&H`D{84EuT*A_(v^0YlEV+h7wm=ct;BwbBA;uA(()6DPDr
zkq`U=UGDFv_$R{$3~<ReZ_yb@o7Z~|vpY9i>?&{=^W(6#lz|ZFQwSOEo^Xn!?lID!
z;%afK^9H0y*r5&hf~@?204w<)W8lJ#Z@9I20Xv3)xeRR?3o6Qugt{ZU#90Q<SbV)k
z$5-H^sQm~P<GjkzQ`E-NYY%Y=iH2?ZUK71l2wR0Euw7gOh+w!|VaOsr5pY;*#U<pE
zr4kp-pF-$_&r?{ZIdCyhOMV>rm%#e243Yyvw}4r;ZV?w1(|HaE9bpud7De5tz%Y(%
z6PcL|;XIHJ<=26*e-1?&ir0URD-F0D(MFdeHpEOxitQ2FpC7^2{22D=$M9l%q!IkX
zBm2M(JccjZW8jqnP2h$Syts!5gI~zJr`CiLEE^=a;qauB@ga<Rq4~?$jM7hih|*7e
zj?%B<%l7Jr*yw5XiIrPP=#jC-k+DAb-*}|`$e>4T|25nXgl~i42`JMRW$RHz*rHgQ
z%PxlBJur5&E(`t|c%@hyW+meUK&;-9YKj2e0r$WF%vPV%KOUPk?*5XVW4xBCp*;W&
z!o_;UcdEa*=prfwlN18mSS|S%vUPpg6@VFIKxCno=au0&W63_uniID(*_A07j2Y~d
zIAf-^(alL;E3su8LJu13SR8!Ket^TDBK9#?10>ZcfRI0(qA~%T>U4_Bq_`0jH<98-
zP~1d{yO-ihDDGa01HTvGY}oU3Yx0MX_*Y}`f(1+VBMBzIhj1$_W^&p6FkA~uN$!J6
zE^oplUk;o|Csix>uUgMF7`hLXs~jWuGycG;{*WOX@xRusxc{Y&PIRgZ(r{ZP-2wg9
zCAg)?Suoo5*_Io9tz)o{c0j+sc;}>eqcg*uP@L-<<Mv|*o{ysyGXFNXe+fSc+MtRr
z4UccS4Gk{FMO`6te#5{ozTZ`RN*!d!lG!QZT{U8#D$*mv1SJIll3<fzcr9hpHJmX>
z-7aer05hQY{Pmt|p!s5jR8~k);pPke9;vWpL$DlZC2OywF>GT>YKTgxax84-(h7dU
zaWKh!m08m^-~<o`GTuzcsJ1F_LaBffVp1NFt((h`+Ax42m6rSixgx;21md&g3>tH)
z>pQ~8)4qcSMxG2UG%ymEttzR9;K$7`1F2q45&KlKUW$DlePtl}2XuRx(DLO>N*PKq
zNRjmvLe7^bQVJ={DCK@Vg;4b65=xoFQXH=UCF?nsK7n1sGZa|LT9AdKphYhu6^MGU
zyJZ968=CD+_}LryDK-H=MTX<nO<uT73^=U;Qm=V#0eUV1npQEm3P;9i$*)pAoWF(<
zzSi>d8n|CL(ga~`D!T$gQv#P^!~n4%&4L2Df@J8p>&IvV24ij#5etiL*}B`1&*{>e
z328R95O)DUGT=2&9J!k=u)!A?c%9|qV}$r*wMklN(nrE1OKEr$b%mL^D7?`@vwt#l
zJp_A5?_aHmFPumx=1n29CeR$ZDm&Z`;qCuJO%6?h4(DlxR<Lw@fFDoW;MXMnI5h%_
zoaEPR{>iVINBigf!3^gatxjR@Xn+4d$nb}Q*LR)p9fC);r~BS$ldUb@P2>+HqlI>N
zv65_KLunCy#sb7#&r@zkir?(>=e`ChZ;Qg~2@Xdr8;i~Ag%v${7lA_;D6dyyXyB+O
zCMx-xbr&zxjtWx|O+u~qXQg$>40*g={XCST%Xb_q4j=m^HTMx&e4&{^M1rZ2q)iYY
zHCNQrc5AbwZV@a0ilVq|c+-@XHtTV?QRUE4Yn!*(gyYWq2JAfEOGun=weRq}5X#c)
zAL&o^!732Ybk_Li`Ojb|r}UwqY2<$v`Nc}YRR^d(R@<2<bpd}u<-z0m%yxeUgw>xo
zh4%@Zl7H?QRGWb6T5&q1C=|uki~iPoHwI}1$?z>%#a&^E;~UtH2Yx4<Fz<31TpUOU
z*qznH?riY{vB=f+Y8^oMJR}TdeW7*+1AVsaaO5t6vaH^nvh`WwYTA>hH4J4mzAj?r
zxJ2h-<+y0paMcQ==d`Vp!n!2YunCR@kG@|s`4~to<Y<62xf6W}%{`I`C!%8Iuc@2r
zc6b%_Ug;l~f<3sJWG^sFS0|+mAD24s;oxuaj&lcA(!K^e+cL^qhj}k&x#xHzIp@z(
zorgmr{PXQYXN;AM<?C^aYZHBNTbk)Zxu4*IKkJCUFI?%!!Xzw8B7wr}p5zT+@+MmG
zo{{8K{Z^LG_eKi8`LEsj$7W*-(QZ8y^ZY5y^I6AWp8Qfw{G-ORK~HIau|0CNq>XCK
zh282Vj7%y&o#_P`YY^aY4nPX3Y`85-b0aQJD?*D5J`YKZzqG3x$7sn<Nbm|Zn!HN*
z0=V1I<hj8nu1J%#ap1gag!0y2rSCYj5wMk|n?(T`45F{K*Ze-AEHZD6M9jO^d!>zT
z03@rDxOS)y7gDw43377)?U#FcNUMOP3#s-3nyO)*?lebt%l=-zxhbZFH#A5@A))M3
zQWsorQ^&#;GKTd`?iFPN0EJ=3$npF|40LM0&>@9kyF9o%QMV3HSCsw(`D7zs6o&|2
z5YLQ&^90&|Ge7||;C3~`-h>aZ;SK5nTr_SV-;A5maS0sZ7NNnu3xj}szKH_(THx19
zz<G>_mFVdHc)#WPNxnfcrh&5mdu(Zw16a~8kUs|I@_BwEc=TNj_I+ecO_wd^4Jv<F
znD70;Bi+<M`To7-fpz7r{br}<Iz0Wwwfz1;CH4Y3Zj#gyKHGyScy?$xeZ>{o{7x=B
zUqJtEGOfdnnR48HlEt-V!S^w)LN`F?i92gh(?hEsg*Dq>X`%eoGtk%iLr<2kHP=%D
zdV`~%_Yjylv5G`l!58p_`)xt8JuQ;prv<jmO2%%l7@COJ1pU=BYD9S();HyXG}J6E
z`3s&HkNp&l6831Y3KC$Qvzal)r@ED028+P)r~-D`yv8+XIaETbM&E%mbVnQhAYcnu
z?YQkCc;g<9t6PrSlIbado-U@RZuG=Over{Le}M133EaSK*h4RZ%%uJPNcB}SAtMM=
zo43hcJpoG*I(G5Z2}!>FO$Zy4HWo?hUHGj6xI#W5R{jOOf25nZcD=7PU99{&-h8dM
zV4UpXCb9DW;vqK^PL(LUR;+viA!rh)^4>U_g!&#a<$mAWuY*JfPjq<u!B+`Zv9IN#
zGAEJtq6#_51crc2FHd-`d!$?Ld~bJ5M(BztUU+`MB+-5+<fR`}ONr9SF^NaLS8(wg
zTyit<8<txtE=CwcYXclS8_zppo(~$&`hMwaSmz55nSCv-%jK{VzPOA=m!G-{D&DE#
z1IrU(tyZ@jo-}IeAYq{AUhEsQgy-Ju8=g1t+>?F7`39av_MODOF|&xlT;dyEJMi6y
zeW$Q*xbLWeZyD25SoTlj^9TL&CxkEJ^GZydk#?csYv)l%0C^hlc?+NC@Y#;fZhZFQ
z(^Y#PAw3k6=UB|MQLY(rvHJz59x2!X9}zW)?Hd(<x&jGobE8w=B3!gZ6fMPS(#$L1
zc>q3#B-$MaP5QxWHwqF~z$e3d@VA1k0S*|*X#{S^VOwtLHSb!n>i4J>5t_Li`#~aY
zEt*-9Z$)<&ic6?T$=4e8JS_VYY-(a?8u<Ws(Z1!dHhX@C`@e@D>6tssV+Kmz1T%;f
zzm$R-^aYR&t3OK_E~U;dB;yEd8=wOwRl+vg?7b`met!xq1-b1o?c1nqK>2O+y;oD!
z5DIg=jcmbxIvT~)%R$}^ti3Ddd8(0zo&R+BIlwb2xItGr8tp^T3s3vfBYm{7jpeP_
zi62Lw=!is{?k=Z*n-~ocSS$rNlL5|cTJl)7)$S!=UapM<FdGP%dmS3PlLA718pH~s
z3ImuevA|66)e<mA8o=CxM8Hz4+=d4*a;j{WAZYfr^cEMBUW%y&%1=EkRx$R7exe5E
zJeA9k1OwM7oU<WA=5Q9Pe}P08d#bk+tVL}pt9d-&J&?mY6IB4-cM-gCX5nxnnaEzx
zD1tZ6MGcTAoz^=tyVt5V2?xMG1WMuaeiydR$P_qYKs_Mlxf(u}jp;~;d44_Sx%M+X
zPxQPU;fH4TBVI_XqKj438J!>MhyHWUqBNCp4ZRJnLG)RXhADun41QjPEs4hp?g&z4
z<(cKU(%5=M=_Q)9F82xvBDC^Wm-x#XTOv-vH3BR$ww4Dl`@Kpx;2lRla`8pW!QYFl
z*MX?mQn69Zg>pzrN7__q=Feiw;`h&g3V${vhCjo~L+@`-@jV0{?Z$?YI*&FsbwP$c
zD8dGts-&?W`gt3U+>9w3Z%hsLhAWNu*x^Cm9LK-@tIZev+z8EACgyACf69EZ)r<Mc
zWb<`hC^}!ik9mIZ6JuFLeoBI!7ihjNfd5QpEAPDdPX_?bc#(e!|M_=d^11m>%EkH5
z6?poO<3CA+&G=8wh=TtlMwIx^KTrt%lTObau$b-(<v;H{Z~k*=JO1;LF^QVo1eZXi
zW)R)88Bsr^V+Ii#5%WAQ=J_7uIhG*($H^B)e;kFx;+W@04@Ki|kBPt8csBOGIQsmb
zEMIsx1|m<!Jm2?`4yg|03x|!gC=L<4{(mH2puPVB<O^C1eJ4N9-;I3XOQP72FHm@H
z`u+vwX7Yt*JpBjIce1z?*LL%@q<d0)EjM}k_*!o9USG5_#T4pQv@+8aG8e5(H|YY3
z$HiA`lGZ~$F(!#^#3Z1gEdhdoYrWu>CnS|e;-BO3ncn|G;W0_ii{6Xi*VVV)%!*6(
zV=l_n^Lplg6C1{?^WHE9p1on@_AKiiFR{oKJx9QqUVSi13U7>gw#GaUGoJbRkN-Xh
z9VPwKn0}6oK}l8I097%J18~ITmpmaGjVOYHz@`aWYBG!sfnJH?B0C}+*2c0Fh?5d2
z7G8oDWpeBz|DfR@wkRCWwm^xtPuA|*M|UyF_b`s#5-#WY_Cd;giu{9~49zk84#pVQ
zGky(rbmkl~rprlz2G{~Et_8p9m14_DXOWpuds)&cHj~AUV6hV^b_B&vWU=?M*b<7p
zmtsp~-w{Fs<{z{M{z0|=G}CYndWf`Za3Mo#VAejGx{UN|m!WXqCg|7tLU0EAyGHU4
z+A3CV#}K8Hfi#cBp>D>_U6>yB&yj^DWB*b7skyRBzE2xqUDgJDu=SX?ckp*8CJQYN
z0Y4UY+NQpfu@@&$xp}99ZUB7T(*xrvetr{I^sP=|*g&cR7|eJ-gTscNr9ajEKf=Fj
zc6DkdJhf)SziTG>cg==>*G%&7nhpQ1ndIL!8~$B0$-iqh{JUn7f7fjIcg-aKuG#SK
znh8(Xso5A;B1WI+fbY{k!Llo&wRT!R_oToU$T07sS!KGBv#fvh^AO{&Cj!0x*B*f|
z@juTVA!4r#5uCX8GI0gD!Rsb5!MXy$I+wFE`MLxFJLrlYHS*fjm4O47h$}`5bgSsL
z!2aZ<tx(mBh5!u)thWUY^hnx>_wn6uP1JYrwxsQls1mx3d?b0*_K@z~%CceP@cyeI
zz6k8^p}t#jz|;b(;*%ApOwe(R5Pw-8IE35u6{k(6J|^)OwSfbPaG*jCyWzxK3Iuz=
zAg|n(v>yK&lbU=@H^w$`7}tTSK0t%M(-20zjR%MSh6>ypG?`}Skoi=K%uG8y1JcSa
z(G9HVs)CWg49v(X4hCYu3KX|#IDX)kS>Ur?QpKCpLzbB=(O?xpH}Q`}EVcBCB5BOb
zi`m%O)SDMo91M4Zo4-vaT(OX~(I^=xyF&3NlbIf@a>6jvgjJYACUcam;CI5%i<faz
zh;JLQUfSc$Nwh)lzK=RD)T$)zJWanh1@aDA<!ELR84g{>(&fmVwgG|@sRQleiW|rx
zFmmaQuEOnZe-$nSw=ug6f)itM9J_ykO-&~v6LkQi!b7?GIUK>+L<c+o?t_1xsCyoV
zKR4hMK4!lRrv$?3+&9m92lR>7F>udQjoE^+4kmLn-1F2xtShW1?;by)ZB8KDRe0*j
z#|yA<Gv<Kr4^YO-?hV|bQSdrA$cHnzjArrGoQI0k5>hy}!EF}#Pm<Js%*OBKK(cxh
z>L?FnR?E<McSobR63TvJS*+ZTm*6c(t~xm<52pOkThwpn4f`pdcIgzFe6=acueWQz
z7409)I1Tqr_Y|pfI%<FR1m1S&ZVXh%=B|Fc6jx+!iR+5b3;8$tfR-_wSuf#In|A3M
z2yo$x2_AuDa_Ww&Zu}P`$rveaklx!lHl{}=x88IMDVPip`<`YNfK<1*nA{e!`lrU$
zA6KF0MRrm)_De&)!|au?2f+_kvsn2kcy&cR4s0P$?a(crpTBpEJNJM6y~9rTfBn6G
zv;N*4><U#ZMLr9Ejo<T)p>Om%x6SW4K-*v)w2L{Rk8?nVjWZW^GK{8-A3mT(@$Ch%
zpkF_OJ?I#6MCK4$xi2!(Y?1XoncTzZRjkyAz6b%RhsA30{D_<iqj;5gfvw<s?;u!b
zI0uW;AL<4D?n(2<hJP@e1nBzttLC2;sS+qqpiSWv5O<npH<BwbaS0if8b0LWN#HRe
zfs~A%%=wv4cxrf8NN@)?X}8C91p|!srf6wr{lN*(e0K*O!r|mp((H-6GoiaKm?rYB
z`3f0LJcg^sRNt)Sn1w&@B$7zJ&Hx1%Ty#znC!R$T1(3u5NFtvD-#liB$Ep?=zkwH2
zKQ6ZVc#623QN*Y|iQOleLOZnYQ<+~Yiy_LY9Yz7$=0It_Ba{R;R`AN9^xGk^J0$S;
z(Tm~PE}Y}$FBKPYONA-Rq_t+63^n9bKaPSQdgzt;gh<w1D-oC+{aVWITuGjkV`Ik3
z70h=oTLimIr9WKFex8P`0owFmFvZUsnO8kSzk6fd&2Hm6`n5tl3vyoid!&6C>V@yN
zkQv{&A%`F6^-ozwM)WY=0kS*uPdWr#EMh3HFyDKm&4i^X@ZAM`$K{U&)J*|DbbNAd
z&-!ivHw*{_{D{Vv1^Rf!MN@!<(mL9^qa(yGvzE23E}*f|UARMff8__)qudeLZ-be9
zX$RX2e^#W9YjawU>iypjr^n=TS=~|kTCf{O@VVr(Uf+Yy;jH!+_;UI__@-xLx`-)R
zRysvmOI>8YhK}<WT(zC6e|_TmcO=@s(?<V7Fr<SD`haD_+9ZOLwO;PGwKUNT55r@^
zA$0iSw{Y$Sa!VvB0fq7|1BO3~Sy;-&*0IhM8@&p2rE-ih9j_b`t@!$rss7PmitJ0_
z_FcQ!9c^PY+Cc1obHt9(=tS(_jr%yj?{|RW@%YV=8RzC+%rF#w838$Q(PE4(29eK@
zy-z#*-FFuL?kkJp?>_SJ7>mCKK6HS;`x*Z3I2(Uq_P9*R2b(m(a1~kVk%6i*M^(=>
z{PH}Xbl4^AGKq_>CA@r{CLQZ79v_YM6Niu2K&KAgOvlGhjrC;U<2%5|-GtCu&OjKc
z>j=i$f@*zf>15s(vJ-sHqrI25o~u0_zfQ%?KdoVoW1~5axmi67$7ue&O9{s~e&K##
zEXiy1%4}lK#<ElGu`I5Y)xffDv8{xjZ--&g^M+18VeS{%us}Jn<vxHLMPG{IlId`C
zrof*q`!RYt1JO-0t^31>9-E)~JS@Ay2e1o`O8OIdKNPF(2Tw{o^ah+!wqjeu6yW`!
z<iAMrmzm*ySn1ZkF$tEu&mxI=EBhp!j(UNkLv5OQm~Wq0<ZCgDRsZNg$r~LRwQ#9q
zvj%M9n1DkZ^GR@MBJhM7tgM-vfx9N<U-p2Dv%vm~D>h_~gu%&1oQ&xQvTa*!NyjT{
z(LDSP!-G2S(r(|0eZIPDjPBeiByAKcNdm1qPP41~l%z)dI%D8ynwENXq&xJ}j&#E#
z;~mRME4-zTX%@$94X(o&&;hdqa|85gTvFwRxdZVlU5LWn#K69bFV4IhU82J}>r!KU
zm-LgIuc<$Hjn^<PQ%0TS?<@HqHpA8-sZp#<05r)eBd{;suI^Wo0{HFqz>zfk-jZ)W
z00ncqs#jT-o%lU4OW0bAp0$Z%YJ<<AXOW}g>i_xkpZ^RSW%$zm<Qf>6+r?KWCE5Ms
z%=XG{bFY`ITNhpf-`k%4=pzKr<dY8H{~vqr0v}a%?)~o}2_z8QK|wB}MunEtOB1dM
zpfWIl8J!@l#oBXPF9l-xE0>eZ7_3BslR$RHq0}QDPpg%BX|=6Kda8&QY{Df0R0yD4
zs{~MF97RM+05y5P&)R#>>`B5!PkYXL-hcD?OlHs8d#~%W)_T_Ox#^yDo{UfC*YO)%
zb0gk-7(x`%GqBj%D`nyZM)lSXtG7~n6B|h{c85+-s|Xt@!-wWA{Z&V;jxc`FebQgy
z6ucIP4&q~W9Inh5NIDscr5vp$6D!iUeOo{Bg;sY{!8Lo(@4&X~LPes+v`Y~(xNh`w
zs!(XW>yOM>%AVylHYx>s+saP8!dV#`G~x=I@w<5IXyH<H-QN((Ln~Y5rN)qk2Qu6e
z@winB{)@TAVpT5Z=R2Sc(=q#XCQB*asX0S)xWhnTuca@CN_xdUSH*_h>a5LCxyA7o
zvU|PsK=fuxTa1ALEi<FOV;4|&Fr5&#pf8-C>+k$o(suc#ZR2jI##Tx7x?9!Lt3=U|
z{8(0Znp}WL5=<@tvlLM}{YWx~24QeFy+LgwX*=ah_tfLW1s1Fo{jq(F6)0;~bq}uV
zKEP4}w`ZX*u%~;obZ_)`3}1phC_ZKV^#wEOH@mhfyisGjHoRK!j=pFSW9DkkdB<y<
zh*okfu8U4cT8jY1hogtN#unsK@PVbMQSn{-sOn=#xqbgam9Li_h~5K*n2imb&s*K!
zeqFWrefiQo1hmK`pSnjAt&#Qqr0v&ff7#w>4w)tq#T`jRAr`1fMDdu^JWdp%pGSSW
zD0%=wv<M<y2;#lyMDji*Jv@-qmmSc9Oog0S(o?X2re_2@6}~)C$N(|a)GObVS|%3y
zQD|6KEo7vbErQc0`3+ZacrxMrJ7k47hHQI?ObF*4nGca(_iy0KKtNEzQ}k~Vesp^L
zMql_O`Is1vsd4OJhsK<;zw`ySodNx!F`2VXUvv|tcyLgS{=G25c}G1)a49;CPl28+
zV_nK&Z6CKYu^dUiY{dsRb}bT&Zgn?U>%cj5Sn_fdOX0U{<hJ)<u|lNFt0qxMRIoO;
z@mF`wTl%6qxpuYqp!Qi(KJK~1Izb<|i$0W|t07dID$}eOh9E}yGTa-l@Kod8`D@jI
znV?01Xc?vs=2ita%=y)pUI}^qdf9up3A9l$eZfE5$kpTP6gOleW3>B(T25oL?Jkv?
zn_bHCFI~zyNH^3F#_qq=r-2?Oxh4*t7}cn}O~4VF{u4cGVi8V9`0x>VTl_gv8;l|B
z{f4oBh!D%>&~Cv<b}=c{Rw3IQJ5GH4eT-(v-c$v;+`)W!Us5Bz?rl)>0Slgo;Ag+u
zeDGfytX7!nf0CCqC*<UrSi=%idnhg%to=k7F!mGu-kZ)~J|yyz_0Y~wJO^QlhLGTr
zwt3*kAbEv}VfZL;sWj29@q&rGrl8Gx>pLb8CWbP2^s2)@8~af?Uq$oysR#(s?|`+o
z=vQKJE;VCtn!B}a4Z7&Bt*!DIh!S=9sQGE-w|sW-b*j(Hypx2d3Vu)|XIOlZ5kK<_
z2RR9ffU;<^M|`;Bp*A3O&8VS=eW7=Vnw@zC+ssnsc776k@4Ym_8+SV|nJ7HT;cuSc
zDGl&HsdH@nrmesGvK|(GgJP=bY+htgIb>`DFz{N0!a3{??PzsZl=smBw<3oq63MMA
z_)oq_xy!dXiZh%XHdGf*{s<O<(zT4YzPt;8o+?h1>kAhNy&}1At@adrI``bDKnRP+
z>92aavz|Ar)bbg?HoO~L7vm@xyBUA3Md8Uf;3>k@PHNXY;^J+W%o_sVwAO!p`H093
zl7AUsKY4#DdH0K5Y~z9CALz=a)1dB@cUAc}NdDp?!nF=25x>#?oLc<)9Ba=c0t*lc
z-JG+#nX?ZCdMj~}aEOJ*n~IPM4Wj0*@#WyUgjksgSyq7vx%yZ_E+Tb^3xQpU+i_8s
zhxnr6_AWA+#Z5pFl`9TG1G=cMi-czKLng^4;{tjcTtGeJoNnM5ivE<f&=@4;%H+6<
zw_!pSeXmj7No*yJX5NwVW!{M8XTGNJV0GcTqlJy;lxR{<98FQb?#{C6B0&JgWl8)=
zy+=w-;kxQ^ePXHg<N7ejYsM%8H>4MmN3c7u2D5FaC2+)v3_pm$uGUM|P2RATwf&&b
zPuux3$W*i!r~LZz@1|l)?+SX@0D~7sn_)T@qpE$D536b6fpLTfF2xe_Hg{}xMX`-L
z+buC_6RmuX2RW*s^T<V!3&v(1E?@}6)yPqv=Kg41?3>OG9s`%dhApZE_z(f4V~N6y
zY6fq6*~w!);b+^#!wtM)#=`yTvXK=hiG}+NL+Ol#`v|{T?ZnfR9Se7lQi|x0{Q*HX
z&Z<uB$_m0f+a&RCH)3gni*MX|;9#nVCC%wzisv&s(~np}b#_(zJE0%p@7#$Cm6E~*
z`Vs!lsa&MWMH(0ANBBE;<^uf)f9Eb-IO5-a$ntB+Lu#$~w>yvxG<hT5CeBt^D5Kv}
z566APjDLGv^jo$_{M-KMfUKU4iU=O3-jUd|6||EBdRFSWqMmYYmS~tPMm^=6rTq4s
zo2^oFB^3hopHr(+$EegvlG-S#O)B*kl{#Be51TqFA5>6{MEu+BiTJlHkgLr2w-~jH
z{rF(fZyC(HdGfA=7Dm72i0HShHsjwO!)Jya|Mo-T-x9!;qnmiy8hRF9tkC^|HG9p(
zn|)zo;u@owL$&C;)QP^!8+zq(a!@-Lo=8;u+ggdkE5ScjMf<7!4ZJBS!lu3cCC{Jv
zANENX(wtnYU~K$+^pcgpYb;sEUggD`xqKNb8~MVPMIV&b|7A9T9#uO?XsD9A(&^Yf
z>s2~T0Di(SiMXo|^j5@a-Awuyj6Q;mAmL(oM~Jrz5;I2R3o9kB@y39KOw}F)KN3Ug
zg2oT@<-6#QzB2f%cghHLsJ=YcT-^1AtEHOEGq>xr;J2c6{IdJ&2gvNd1ExB(AEu?j
z*IDn+Y2_)sQgnpe1+VLog<KRx=3rK|vWc?wP#ILN;KYrX<y$S6FV<Rd)T5fu9jT~a
z-ox_EYNe{YhssNMEMtdWHG-_F*3Y{t>XPojLMhQ5Ri7|2rVTnz^pEb5Y8VY%XGKNr
zNnPuU)=4!{Ou}}Z<2=g-U3b(srD0U&!r;_)@qw+{afSwKbXkvGDT;BPnp@ax3h4>)
zofYg;+8am4BrrA~i)Ms*2bjVap3L$X#7*viPEs&0*N)eh56HEjIpenpDg_fPexR&s
z`6JIO3W__iP`wH-V8&yYC~EW92njmS>~@Yl)qq%o5K%PebRfD%?LG{CCH-dYZ(<Mo
z4}B>X!T(47w^;Vhc;snrtFY1}#+BM77wT0@p$5yNr(X3MKg90L9loc(cgiMr%?;T^
z?ghze_7%(nY?J#Eqh6vQ5=%<2e2Iigf?A#5hXqeg$nvFow#xn($s8e|mD0yC>O%*B
zv-%IN?rYT79a3mk=vbC<7`z2wf*P3k8!;e_9iVThQL!)>xD&sHiY7539pEhq{7cS9
zCi60^?Ry=ZkEG^-?%O%i{D6i~eYbq+p6y;2J58M<K&sIYdSB{4lKK;P)2hF294mVd
zRuE6E=IL5c1?O3}DTwl{>@j^Tb6+(J+5hbQMP#G-ryQTfs&|yfRlSPdwZ`X8#%CiO
z8)LIgxtYKB&+;Jb8w1AJ5R>RXNDw9^l6kI-gRv^Hp)4l$_<mQ#Yq`~ZH-8{E@$Y3c
zmPVs8p3d`T`|+6FwqMV1JPO;s*THzO8_7{<nc4l%Qe%6)YF}TM(O4Fx@4;S9)A#ww
zeP2NnlluSE^W*Q=|6Nr7OKeOv0O<_CL2Cd`F(3XL`u{Dn|KDuW|845qg#kFo0K9eD
z0Z1Z#lmD>k-<F@s2|C<au(ox;KRfgn#&;xjDB`@xxegZs;5)Em>jF%#W@Ha)T5%u}
zceJ=sD-xB&B0<_~<UkT0J)p>S0*{|rawNe-|3dngAFe$<<DM)W@e~zo*DG(9M~yd&
za=tLn7&H6$3jSK!6RTj#5U1sn8|AH{FgJ3(#0hSZu^+DVZHZ3$9O~-nMUm73c=Ys=
z^Eq^1=qsqzLn8EypD`Nr(9`_pY^=^0VzLb1LURs?L)+TK>=gcZd1i__hl!(>dO2^b
z7UyO;4d!`6Y{8vx$azDa=j4!LpEpwM^G1q&-bk^}8!7gABgH;%q&UtS4Z%M~|B^Uw
z9JS6H;Lis*Z;a=>u{xnozso#t9E+bfQaNwba^Bd_d1H6dd84<S7J6sF@n<dO43V`|
z&Jew`RcfxJE|b(+l{!YHPLk9{No`W8x2V+Fl6sgkLzXur=M7Vz9t?r-llTpm@)_F`
z@$-iASCJ)dY_l>)@-B{Tdt~MVdvM-3A?J-x&GW{=_UDa*rv6p`E}S<QxIGMj%|B<3
z@EMuxHT9e~4$FCCtzP*XId2T4>paGu(EAtSHpY*`e7xv$-Z+b7q{+2{Ph)!547U#F
zDjUNO-9J*kAQYl+>f|_5@v>m!5w`xb>=~z>FMsiE{ZN5st>%1rm-*5t^96R@gi6?~
z-0-=gbXtJC+J;>Fb1*m)?GUyGg!BHK{c^r93Qyy;oAEX48891WyjCu<<S-Aa>o=yc
zN|!$syC}Y%%d>tLQfu5qyWT>QouXIHV*<KgMfjo><s4!T;tX^iUO}4^UZqtDl9;mx
z_XI`85sXH*GtUFh5qkGBs-2E=C|us1NH598*VwoGuD!m3^?FEPTAZ_;gQl5;<qbWi
zrXlD2^+ia|Bc*hSdDOoMztXC|Iq&x)Y#PMH{M#e*Z<mPkauAHRaNbw*&tWqn_`u+5
z>_nD(2D_>~d7Sq>gFA7-jPwjn;ezwNXK*SPocBG0)41Tg?-|^g3(otV!CkoEykDOV
zImYMT39)B6szUe@uHBq}6PbVLy??-YpLoSceND%4xA5fpXoQA|3$2Nf0XYO}qbnMi
ziu;&~yPV!5i66n#%as5A%%yJTgwAyjzs@!3%T#);O6Qt%u1RlH=}jt~Ytp$U{V@MC
zGgUH|$`@RedATYz_z;VuKRj(&U?kckSbOx5N$H2VN-0|56K8UGKdqq7f(Kx{l9lPA
zE}dk40zuU>KUd5AJc6#(Q+nk(H9uGNA=rpA7h>W6lywF?pl2U&hQ2bEIo9}r2jqeW
z2&%yR{8Z-WJ9^~;nV*?V#6s0?Owdncjtb(lKKdCq#ru~vLAmBQ9a;nT&}M=PKj%ng
zg0{um=6|@3Hu=D1jLFM<xY;x!;sGywf$^gi#*QTQaG&uPf69P5iMEa3x>xE8x8)YW
zt}7S$0!a_jmmf3A|A4<ifaJaI(9Tx(^H;c=5ngoCXb{DK8mt3*m_z}<3AF^GxKUkh
z#T%{PsLJLC2!*iG0hH=2r~Br?(rbBgG;ga-)EiC*J#GC?AGfjAdd=Egcj3!T<*cF#
zs`8|}2%RHEc&cY?5057_PS0$2MXM{&uduQ;SP(k#<y>*T_oBchZvDEA1sm=e;Bkp7
z9o2>`EjUg>jp3j<IKIAcJ1&Gj;&*H$_7K&h1R8MFxpPnsA;O@vIZL%xuWI2|k+HGJ
zcq=-9RRgzuIR`wt_md*mC(3_q&Sp0M>(;4v2>trNs@i>N6&nf-)eXiYQ>DVjli~}}
zQ~k^x>eutaSk+er_@7(7B*+&LRrxRE>&B%mHCiN+eM~%#A7qizA6W%4r-Y7AeUTb)
zYAD*^bBVT#%NN?I;bjhh{3w1%0LYmXFL(wdGc+Ps*?P#AbCigkN@mH*%rRo0)!D18
zzGvE-!(!k)AD;e81Zk!NBl}r#w5FQncr?0=$LN7YN2!{}m;rq(QLgUVkqJGB+uypT
zZgs~lqz~N})w}CH?jhDQ@m%XY7K2@}Qu+g`dsTAPmsbf*i4Q`M5^yc#)ZWPRx02@D
ze6T2zImkD^PJZRpBGtq3tiNDmV35tv>&q{QT-%BxGkxJ*<i<30xpsL9_RT#%I-TE(
z$Lg;>oF@5W-llHok?)W$3i|~cgLN^421n=hg3>w#^aikUAupvmiY_Vrv}g~LS+(u(
z#K=%IrGQ2g?aEd8I@;wWK?}^0HpxA+O^1R(Z)8axzZ30|U$lp;kN68V1ajj0nZCTA
z-JV|xHLy0j_7JOSZr`YwP?+s8%iW-El$WWtYzVH6?H8#05X<&DvW-n4K-3tDVP56)
zh3TV9?!Sh#rC_T=esd1)y6L~N2HB%r+oi02v6t-rMSk-=7oE3N-6?-e6}DC6H&PDm
zlDZIE2%a)h_y;eM0Qt@33NB?@aQO<Cv*pr=$hfnVRd_9rg+^gD4{T?9U(7cWxIz>$
z3(<ouTxw4jMf{B?A%0omwtg&>FX9^H=`7`#3z@_ZKI>d~;5LhLTI8WU3Z1tfT76WF
z73xA!A)xR|=`=N0qB}@v-essZqBo^i{ssDwiq%6Y(eB)p9{pH|(jA%Tf?$+xl78K0
zpKGfDMvV8y$;-lB^NxCzH2M?$g|W%Amo>MR>B}&yx!YI4!rQHx+7MEUqZaHDyT!a=
zB?P{s^x>8H6?(Vl5C|6G63{8!haHQ{lzV%_OD55rnoNAipfh9&Wkh6RRNY8Af#hGQ
zDcnv7TaW%K-aI1_HGE;^<rUQy3FK$@2K^^<<)4N3^yeH3oTWO_JTi0ds2X{C@p1Zy
zUX&3xd+~k};`D9T59uYrY_F$Er6MO1Md-kj_DvOD>}}hoD)t(bEZITHLQ*y*ZzQIz
zS`M})&7X5kde#?C7e-mu1KiZ_pW81g9=k=}spxr|O4TDC5*1Bv3$BUnqk%HKb98sX
zw(_nXA_P(%%4Kkdon_2p{oV85m)%3wx`RFQwp153Dv({GCZypi50#HqK2)!g<^uF=
z&jm=_oC}KT)xN-7kW!#|riF}*niEW#LV|M<DdBIw_*bP6BT$qL=dW2ujT3yyYEc2P
z=R;teb1pF07FF6K9k|3f%8vWVlkQ}AF=r3(lB41>F#&WLg-wt$=ZGQBL&TYwd2xtv
zhbN@^rd*d^SaV%wAwJbBn`j(T-M2u4dI%wS@Jkyyo}%A(0Tk&mR&S1p)_kN_?UTY|
zp&rcn2+iE-Crop=j|bkqX==_ok=&0(PkdYpV(1p+nZ_~V<IUS9i+f<8aqPu6UVr^{
zbS~GSx_?O|H6xN*k<&1yViU^XcOxX=`Avn@*Q%>fD<*i)t6HU9OQD?4jpI)9yPZ>w
z6FIx|7kc7&(YRg}IKNdirHxHxZz)BQdwCm05jQzT$$|DMr0cEFv8g5HXd`^~1Zl>R
z_<X}TsKdOE{2Oxi(4x`kBK%YUkd`Y|_Up>Fk$qXA=%8GK(?;y+@unsYgRA;MoGOTf
zaa`H7-NSEWC6Vq1MbS5+LqD!1b{?f-6N^RN%j)j!_FZGFn2!MN#4YOFoY|^&&ztV9
zxw+Sw8LX($o!5tT+ayA#9KI<y#(|3>)VdC+<pv}ycgn&-{|EjpsgSpAAjVFOy{0my
z%NYM8JZX}+loR<s6d0bU>|Lu`=UgT>uOy^E^CGSqr$j!sp(w!drS4G6)bb(Gl`=l3
zdG>O5^E>jmexI0lpyA`6eoV*@#(iLs@kNpA3-m{YO`JQ-8%aC&apdDQm!-xFJxv_O
z%Up%Ge>{~J-+oM9oST|#w%V={g*mVf*Q!O?Q$3o4!cl+Z%3t&Dgqi_mXIkh0*Myot
z*=b5j6f+cY<qk&BX-$@Zu<Y>=pYPb8Fcw{~Hf4pNJCtUZrv{rbdkjv~9iv^0Iq(85
z_Hx768;|c3_NEduf>qC4ra&@C9dvX|=d8e82s04LoeIII>E=*%;KlrKAA*65DGJ{?
zCf3iSC+N|s4<Y1;B*c;FJMB~<UN@0``lFqLg7)XbeD)l~jM6c%>d+g#g9y`IF^8x*
z$`><YPW;=ifRB~?{>bHWgd&pjQ*um=RLNnOO=+2YHB{B|^_gtoQwWoliakYby%6WU
z&#70tKe$w0txF8gV)T`!Z!y=)4+h@8YO2v}>N?$J>pIPEQ47pA)-Mdz?lKjfqVveF
zZ5d}%u0PU!uvvz6p8sn3>kD_2u~o)iE~%_>L@e4C8jXl$wmqtrtg)6&8~ouC=?42W
z%ivw_k31<!vGdLGg9B1sV>~ZCC{iIA!pps3)uSToB^JH(TIpM)nVG3L^zr+#S75?a
z9^r`Op@1`U9TTA08i?>p^@uedC|HeFi&AWu-2#2VKv{UD6<KXsLG>N0D=RC}cH_i=
z?r-o~0R!i+5n6F<_G-No14>yc?Ut>DjMaLk!awb8w^nX4s|As*K55l0Ou(8`31aC8
z-;g??eX0mp&1Y{I$Gk-lFj@_IWj|=52y2Y5Ou&WWPI;eD)RYadRcnhl{z#~g!W^)V
z<DK;T@+g@2otqB|_ZK<;6|{Ez#%4v&iT!`i)SP$NEr*sC8~?&?S=R#IK+KP0u6f%<
z^-i|`SFP<IjO7s9|M2+sKc@OF*iXb|&7Nxf;frWSw*NP%6Jkz3<w<`a)SF&w&Yyz=
zZ$B*i{}J~8>x+%=r~<9+zk&Vv7>1|6;O*30@{8U`{Z%6uNrqE6eiebU^iP*loF``=
zKBx8j-r<(fXf?6>P82eH#;)Y?;KVe2kGbK*2D)#5ZEDU&8jP`(+qee)W0kbnW4t3x
zep7<I3?jHq2ON(ZdlsZnh1LHAqqB;@u&)(Xk2NntpVR7}s8;v7fhr`IFR^kQ9k34j
z|2;XIsKHO;HE_@WT$T{GvAS%t>V$8qPH<B|bf?*Pf21dC)vC2>t-4T^b>#<~pBYhS
zaqRC*gz1gW_3Be)>w9y%<!T$NhQ4rbVmX2D*W`Rj4D~wLqD~wfq8IZIc94--P%M|V
zQ9+2kLUR2PK(00`)Qbwin*D$Zq5k2l5aXY;ex8_W941f$T-BI%6_WK+Ux@9ny}rH8
zrCT<|T}mHlid1L;|L9Uxqn)ZoY?DpDh%;(qTcW?=HCmyTMSa1A_M-B#`H;OdLQB@t
zXyHcY8YWu60{q*2*z>Y#`KEk<VBedfmPmUgI@JP^Z!RKv^oCW99J?Ar+g3x2flSVk
z9NVmGz05;Qn{`cPeyZZnXnnHn*V}14aHh9dkfcM3V@pSJo~%IaP)d+MMM?XAyNBB{
z6<HPeEQFn*A>Kv9=u`!@eK*@?NQ%=%S_%Ebk7N#Ta4qc_68Pif+Q-mh8b1i0Iu}TH
zN+(VngE&oX1h6deiT?9LLe{oD2qFasKd@`6u_=DuFx`2~Kd$(J%_cu^w(QlDTIKX`
z*w`Q&^&xDaBfTysQx*Z+>R{u^M8i9Rh++jt&z6l%@k?s>*}N;E^EUjv*T&P|F!6Le
zJS#li8$MUrU$*r|AVJF1MtaSto=xu1UudU-KLObPU;^xi#7a`ss%(J$DFN6qgADC%
zb-w_<j&ghl_&WIr{DQ!11<Hs2ReT-qL<+c7Ehq99y09zYIaCSZcKEtczQ$8szTHFI
z$_bI4qumuPE(`)Ij|Ru0Wd7yc9)(pO;hIh;<+`=*f>rliieWk-Dn{dc9IT!8m{|Kq
zg0+VW*O+iSL0<Acij4vW(K$B=+`gwU2Sj)VaJza%gbRAr$FdR{yQ96?yaa2153D`v
zcg4s@!R?-$%_wnG@_O}JJH(yn;DP`FxeFdttw45<@r=NV^;L8E58_^~9w@3nbsN(^
zceslH?mwqNrvTg$Dvd$d;0^5taa}EdJ2CVu%yB|8V#nHN<LwPL-VUH>tBw$4#RAc7
zhukLKej-(72@j$dY(DG2+vAT$xAGW0pfB1&55=j(979DclficPh#`oDw7=)RXsx^M
z5J>xhB&6M3GUG`5?VKQ!k@i-->UpWtNs)F?_KS;=N5=8>%gDotulMJ7NBDXw=?YS_
z@b!-bUvF{X>nouGP4M-P^hJjhN4(o(92D<;SP(cGBd{2}E%=+F?246M62M<)EDHpk
z5Ibf@dX;$dW6$asW*3Zopj!Xp_<9*SWj3~ce(YQJdZFY6X2BM|uB*0K__|m$CF9;q
zJ~4o@aPO)?RFPjorQ8reTqu=wMria5p>GkUE7<RtMS_LNBxs}FYm-s$53G&vl&H7;
zkd5-`mA43`nW%U4I<8MCHps@GpN+463V-2{8ASK<JC3iK@&Y}wkwn#jTLoWrH}CSq
z;q>77P{16$u;49$TAz_lFEl<7>aP@=QNdef2Cv{+a|^7B<(#9dMNDA#^XXt!YgiPr
z%9seU+9gS_@Hd&{Rp$|8Fe=dyL@XdO;1%vj5n_RlY_R~bGL2fVtI-q-VEBSufH6Ma
zPA*V{rzcY^fV56Ft3bCn(}fD5DHjM#{x69EykVPKWv4(C@CPLdSR<l<H64foip+TO
za8|Tv-jt%8W)%$3G?1~aw&Lh;W->b50obhOqYd4(lLxGA4LoAsJac(K!M4EVP6iwO
zr?@=e4n?mCdB6{y^lHlkCfM|<<N=rhnrJ_UcRdT8a6fW_@@0C}%`9J0`S<rj&K>5l
zp0@l9F^D?A&>O!#hK{!|;<-)8Dy*5%Q=KlAr<X|4GPpjDmV%*AYW2Nn`%wxV15Nir
z@R(OwX!^hs?93FJUctO&w-?^1ldl>7A=~l&(8+sy!&G0++Hst5?oi0Fg{u3EF9lZL
zq(X{b>U~L$)$%7%#+vt`r;-v$Jv)B5wy||GEvz1=z;zfe4w{XW$?^K5h#ar!FL~W6
zpJ1O}5GpT_drlq2UmGvpYo4;ntW5b+(icj^3RqKj_4TdM7gUyt>0Ks{O!Rweq+yY?
zY6?m81&*A+^BwKA%EQSJ{-oqg=kVY3r7*!h<1MqiGOr0)#jZn|sDSrXoG>LwTl508
zZJ>k3;cvnJCqK~bm&S=_CL4IiZxhP5FwZNvd*nXruIaZ4g()ZS4nR3?Ho*J&NjMLO
z5K}oZo@&8DCh(peUwfRudt-0{jQ5}<L`lvU*Y$6Mzb}sGT7aj%GsEBi#(1wc0r*N}
z?Cg#J-#K3w@V#0AzI_$F{k`#CFT3H%@!lsOOcU=FB$6Kvy!Rnez<ULPWaC^aUkwWO
zO~!kdiD9dLujtYP#y$zD`(CoAyB{dov~TsPDQV58Pnb_a-@amTrW9&uX=~rAFBIJc
zq4DpxMn%q%fPSswzQGzoal_jdxA<$8$Fgmg_kpxTDy}SR^#!7l!!&u#u%`)iR<@T*
zq=y_(@Qpyhk`%i*v7;;o4^~}gJTE<Lqo#rf%WtoV2MZ{o@L)4X6A!lUD?C``5spZj
z15YvWV0nqnQ$1phR}vnaXo`sDXo}XRDQAiY3oRwhUe?S18Xnwn)z1iTQT~bMe<*bV
z@C6cf8=Kh^9Egt+Ys?c=_$uM`8&r=oxUBbf%wARg$!J{dXP1ya=6^*~L`J`?C^D3Q
zyY-;L`w|N|$6&Bi(H=_dYL`E}Q0nz*f*zgw87_ICe@_ta_6adD8ria;ZT!j`n$LJ6
zc~ARPnj7ifmnu+x`~9qi@|k{u*_uM?_WPL}x$OOH2`y87A&I^zI8G^AhVv|?+!Tk$
z`>E!?W^L-{KeB*F<L(ntFS5@|@%j0_V}CdMBej$YjWt2!)vP(HJJ{dB%`f#T3^~5P
z?`^-o|5TyJYJWF@WOIN2H?uFgQ=f#<y>ot={o`$R*xx()$E;5K{wcEi=ew=Z6q-)A
zSpLMU1<K6>Z23#7oaKu4bqDtT_Il_&`FhyNEKk-$LH1Bwg1CfI^r|gP|L8GU1JL(W
z+x|Eh0cgB0WyiPu=q3oiT`hCWT7F#Frk05g`kM7^qBLv$ephCk)c1%9go{Im==Y_H
zc76Y3)^|F!u<8r!{0y(D{<4<g7V{yG{g7-O&Sls}n3u>pXv5B?eTFyuyd=h9XLA*e
zpKRMK2kll;8+~@xCfi&|mxq!!1qIh6GESDNS?F_{Rn$6!JA&<=(V}S2CtKcadb`Z-
zz@qDa27f*u%K9J1pC{&e!+pF{fVmVeUh74&RB{uOQoEPB#m^*34pmt%@u_B>KjQqq
zSYHUg;_%0zBuqE}xA^g%7C#OwjhXQ-#an*}T|GG8rVraEs*U?4o9mqvmTu#ZZ~ljK
zWU(<eA^+SxBWq{v?v<5L_U@Il`R~{N{LCD_lea)1P{kP-N<0JFXz~e45Mu$rYeZ5~
z7t7XPsCt_BalEdf#0u7Og*dIBUAH$?e__3#p~{h;X9K@7UfcbQD*52f+MRpvzA!qK
z@y1s>|IHgan|7;Pdd)SY?Mz!*&j0nhqi^rjL;0k<y~FaL7rforF;Ii|4E$IbU=rVx
zy^G1Od1@|0^x=>$b54*`huP-VEVH2a6V?gDQ+=7sY(ZEtt*Cxvh!oc5U~6fi<er%I
z!hQK8&os)H@yrUo;1$;KC5&#x=P7#CNG_UJt4dzdrjj+O={zl&@{CqpCAoxGJ|UUl
z2G3(0@MgTTdo%%&l}O*5?3OM-I3llkjjF}!E28FoM2(g|q7v1Lv%y{=qEn>bb{6Zi
zR9lMmd5Rs^mp2r9^^xb|AVQ2NrE#s^i#B-01T2>i3I`j4UFxe|rj%@2!5GoON9Rcw
z^oq$B9uZ0TP^AppYo>g%Gwq|hWytnK-`;^`+z}+YFQ$^67bSDM%FkO>HhZw6D$B0p
z2|pwKA>iEw6`#9;dG7iAY@HVzK+cgXcT$XMqTa1yr7X=_V5fU!XI_+tae2Ge1z~CF
z%CBJC4)quxTYai@CA>yNI@9b~L-nXp^)M;m#oi3o*ymMWN7N>vdKV{vW;kUL0GdRQ
zOc`+2LK6Ohk1eBk$Mh0i32RlCdFkMdRi$F7?QG?xr>q<~TQ$nBL=^T86d;s-nZ6uV
z+|Y@$^o0-5D-ycLsH=;13GH<m8|x1AtZT{`C{m-0!?^XU;0eO<J_vHyx{qn((wJO?
zm0y=4t|EW5+D_6DZ-nNhYWk8@892u5>1qUZJ^dq{k{`K{L6KY;#%g;Qix)r0=pH%A
zXA$WJpI`HNn9mwMf9CT(pM8Ad`<dl`w9jen&BQC@KkPIAVV~*m{SW(0r@Xq>wExOt
zQu)Ie`9wru;t3b0+vZ-vMquvcMg7*6Mz3&4qn9VFy+8<I;gu+re3Z(+u~LbPvB1RE
z!xTvOA%FM_kzbv{;7e{>OE!9=roop;pyKK1rzq!4VO0XsCCkJ>L}Y06ODUe};P&vu
zOgGWF+;N+)k(SL@LK=-QdZ0U!n#uNW8-0yO?5vEwe5TRYQ4vF5NkD*ViBf{4C9W7v
zDRhGX`F>M=uU8%5F6V5(^Jpe3y;Bx_YP&CK7JW8HYHdubpyrk2UtM2#UvBl}2$Ch_
z0<~u>bQa<J*A+Tr<YhCTD1WK`c35sHBQF=q3mpiZ%{EwiJ;v(jF8BbEIln_sVDq2`
zrX5)zjFv-Ek$6~++j*JN=eV7hnQ_7%s=OMorWkRsNNeS$X%N+{SG`1$?B4%ETEZww
zekmg_M9&HTa&h_d#bo4^KcCHSQ~qq0Yuk5;quF-yXQzFaQ~un{mJJoaPxvFSr!XfD
z`>uQ{qy*4rM^{*4H)Y=?_oO)-Mn&eUSB(>bi!3SNN1{pcOYFQv0B!l>v+TRdMmgor
zaUqYAKbz%R^5=7s<j-bl-bh5A5xXlCwUjxJ^g-N|#4;=q)2qS?T&Go|Qn{GBS@Mu+
zWF<ydOL@1E@2B`inp(IF;}?k6GCDc<^^LBiGUlRia-%D00OmqJVzl6(y!?tv_+b_Z
zxn^Y;!<TLAV_B_Tgg!!C{@g4GLc(S(`aZwg$)C57n2<k<F_)B!F;@^L*hrt<mh@Rt
zJ;nzjd@iFFmhib&37@fTQ?h5Vnligt$)4x%iq(M?d`pL7&8Cd)xRmbBl_$*ZmXTO$
zN}atqwmI7wNS#kV%d7f{)cIVfPo&PxtUv48NS*OvU`w5A!(Ekfi%6Z@TceqZ1!9bb
zIUQ2xT9G=pSObaF`9|8K1#bKbQfGN1+4#&Gwz@@WOxOl!N|2A>S$!jWR^1$aUbYI;
z3{BP^o1#SgJXLJ@&Nde}r0KQxy`yS`Ot*;@R$>RT=VBXgu|>=s$)6v#Z?=~|7ga!@
zLI5^_iZL3(XY?cD^5zmnp9y*MkDc^s%bSaA`n2TD@1MlFOtuxhY6h!SRQ_4w=6q`4
z3XHMlkJVh$l!5b)-51&3aJk(V@te*q+LnePzwCft7qbgfqWtx2E{f1J^G)I0kC|a%
zO>s|Oqzp@6=qt$DvrAQ)z#WB^?*`mS9?&q*XyZK1haXbQbDGPaQofFMH7bKo6QUy*
zH!6}yIB#;-+=PVF;f(F%nJE$HJ=tP8+un=DV&r)f!6{6SZI(UJV@Ww9&uml8*oFk&
zn$(|@{t?fMkeywK@9Dyy#rL`p-_s@WJ-ZO!)0HY0#P@XJ&*FPsi0|o=_?}&e@9A>*
zuROIsnL2Fn@MlqnKZ^|xe=@b=zfxkDu9}VCN1RyfjQfkg<3ws_aYxZPOFTv_#u-JY
zrQ(dDbGAy&mDFXDTB}mWsMJZ4+9;__D)knXI$Kf?n?5HFR#1(E|H_7h|H{KSq%i$g
z;zLvXRp5dqD>I9Cd&s+3DoT9TEhq6O^B$gp-cuodn($YFugXX!TrKX7R<ope1f%Ua
z+-LO6g;BEo$*f88Cu91r#GedmMQF3vDSt9?izC}Z1->XMIV2?XP5yrJ_{{&+^7wq1
z1-Ib0ZA12m0hWKt7945_2BuejEWAw|wG=o~x;KGMDNri%{0?sT4P{XT4k>_=pq9dx
zJOnde<odw<sw9XfW`#g1M^hi-<R;TsaI|zFyQ^fx;x1oeofwg#{Nd*%E5E74@5|X(
zRB*ubI`s~YRrE@691r6q_$AJ#GUCpsE>+H_M5hMlQ+@reb>f{UR4Y%5r)12IcKaja
zSju-YuZa4Ko2KQdy{l946SoSSa<llm!3Q2OOSX!?sghfqzNQqtqK@9BI#WE=cER6N
zXO~>yZ>qC+pkjUScNYJ)tPl9Ol?(h$br%1&tPl9Ol?(h$bxy1gc6(hrfexkRMXtAt
z3f|HyC76fR3(<A#xp5!3AF9S+fY{XJjZA7XrI@TCXrkhvI<zkl<2i^A+zc2_){ysE
zL-t4nV@;<2F!}EvCR2FGVituVOI2#NO3jtjWs+K}Qpc#&Ns`(qsZA>N7L__%QV+8T
z3^4;dH>3t16|Y3Yysl6DuJx=a5~~{b<F*4_^m9++|5g!+UimIfRxWU_CK@tJ$Y*E;
z;m_yTHIdQZf_PA(X9?L#dkEf|#>qI7la@HZT@^g!E7+!2oy+^tNBQS)fO}AR$F7f_
z5Xv$sSM<MsCcZ+VJ~^xzp9|qG<~M{Z?xiiF#fh`MzTgW+=7+lJ+T%6u#*LFXVn2}A
z#EqIz_h^3@SKd%~Z`<zHqGk1>+{+<WnS-VSfAnL>n&e5%B<5#LV!qHO=10}|$J%>R
zyFm7c|GWIB9aeRH=M4O(-DUYNgI3%5PxJKBgxY##L2V8PYQ3^mYObU%gECDAYQ4s&
z)Jc-sD5*{S_Vl_%rOuYr!_aG1+<}@+uMP)lsHR!;+N$XFl>XB!dVLR?XhW}u#f926
zk^X}cF4RnV9VYaeYj1eaYrS6iB=1MBQ1lvipmxY|pw^pY2zB1KqD}N?f>ks11ugSu
z(d-fDyn5x!Jd|`0_=`<~c4}+`_)%5sJvVwIkI1qc%SmL)f^15Ko|o0AJ~bU7rdpUJ
z^T0Q}5xg}QsKvSTO?&Y+lv%lYO76#A#+XB8Vu`ZDO83Y<@g#2{90lZ299x}Iydm3G
zJMl)R7*p0ExK=xfnIDJQ9c0^HxRJ!)VqYWD@Iv@-W0SGuIo=?gnCJy0B<D(tN7;7v
zmL=H~>HsdORlt<f(cx`2M!R^!?99Z*STv=Xum?lIU8J%qG=LJgsm>{^{3zg)7KO)T
znVMOIYGzC9*l=G2jov9$s?x4C^y5;MBe6=&Gm13`9@Iy}D<6{1aE?P*ZP`A!suVTS
zB8&>FMxAn;?1mLI=#?RwtsaierCCL;12iYDc!|<At(jtzoH~)7x+#e+7qQmFMAHN$
zK#mD4JAX~G@`7?4=ol-9JS_Ra)o0i!n+7dO81prWUN{eZrYwIggSrC5mNNJ?;yTa{
zNv^^;oHAB9Cpgor?sTt+d7Q);mjLIS<wVr1jO#97voe(%zIqO(iQQN^<i`4lKfL97
zQXyhshrwM^#zdh=9l+>{TX5?}te)EB`ln<mZ=(@r5x)od!-Lp4ec`zS*gD1ID5|t_
zEe=QdwztZg)K<C8^mcev5s$D}Hap_7n?6V74RtT4l~Cp=9Ki_e5wD}q7D+IS4mL~E
z-(hNevwV!fL7%z(W_b~eoz2hvZ}d0%zjnWzOzgmeEJkXx99vY-!kFR#3zNvUo27j|
z^tanDS$oued1=S{WlxgTi8IMXhvlCkX+E3&L`^pxoK|GtWJeK)`Zx_mk>+smVnkB}
z4OxTK<2cb(>dHPQF6?F4eLbt<+1<vLAPzq}2~7EsX&e)6XB^`<W;}(E7`DQ4-@CM}
z`(ByZvf?Wz1}9Z+mp%T}Ph#u!ls_jblA?s41oXtm!-r>bN}t%L<VHsr>cF+)7!(N=
z%rj@OEB!YK6YQ|KFJ6o(z4$NBysA1Kok!e%^I+(6u(7SB?}{(t@Z_bz??uO|ei(Wg
zOwBU(_f(b7PUSCPml@8lle@Y%U<Z9k0D;iw^yO=1`@PDGbzI%w%1^KSR83n}eN%r<
z@ja(*xTCqJ=_1FI$sIG!*)h1(b#}~<AE}OEKR8u?#IAz#xBEa-uk19wLi^k7WM`W$
zah)DF)i#!3*4pk*(DNK&8Y8oyq`&HwB@i|7Z`?J7+UUCjlSY>Ze<Duq#mD3<ZbiJD
z87E?*eZwH3=4x>>6*_j7{<HCNGqXy~2;8r3JtQ<xnJc-4(Q2z}N{ybyv#7}OZZ?D7
ziQ~1Zo6i`Z9sNGSGB5$b#2XaoEE$a+89dJ}{0I+Ng`2)6W4+*r<azSJWYNlMt*_v1
zy>c@TyD{;iY9j-j%FFdC35E@SAb57X^1q=BRe3`)Z&&$JQsb2uYnkx#>U9KYiof^(
zOu%Fk3U&lCL1ruR%Zbu1r^3jU<8QP$oq|R^l9R|OEgW!ViFe9gr1`@HGYorN*lXOA
zjeEFI3kow{GlOq%-#caK3tm@C>jBB+UA2R&zKmzmNLq)Pq?nnU@5}^18eJr-qi}vj
zw>Pn?c96W@Om;XwR!{$D$H~8pCwq-mN!iao>7CoS!-=BuUHySNuY`ls7#Kj7!o~H4
z4{5~>g~VrUDEwtMH&`4Re;{AI*2tIcX{;}Nl*M&@su&F-^}`}4NYHOYdxE%|x@Y3$
zNE#?AZm0GqU^^}#REaD4I*%8-^_gq*tnSk$qqvk)R6*p~=EkQ{?V6`o)ysW-ciM~J
z6ESjA-N6g<wuslne_v%Pn&oWPuSmOt7twf23-AycZ-p#xy+*1Q3>&3dFz$%R&Wzwg
zvFXJ=v#?`4D}~7>)ZC~P;b{8ddEP2a%9mKBp2I^pzrETQ@efETrlb#43A56=CQ3?c
zgzzYEvwZ2}i2gf`q6iBZ38Ddy?7n>;?WQEZF<?Nk;lUfgtNbztLsav!`G_RL3Ziaz
z>r*5biMPm7ss@**M*W(|&}^<_8Gct2-zs*HExuQy5ep;@H7+Js$WXs1L;bRpRA2aK
zR9`2{K(?X1Sb;BmXMVB%F+AA3!o>}ROL?4<2`FYvMrc`7E7tcy2<H3mw>FCPVv%uA
zwg|k%WG%F2j^j9p|AM+$@A>;h{gV;AE1kU4wtP1ptdCJc8B%(U3@cQx?JUeQWpGw6
z#Ga%J%onFSU!+2eQg3SzrGqZo>&U20F3}$f;YY4)z1}W6a^-g%*FzXv)xA6;<7{7V
zhsxCT;z0;UujX?DpBa2A`TUB{3O?EJP1o^xg^&1wEaUTYKELO4fX|1Yx3;G6oCsL+
z_;~sJn9p23@A5f^_bT|L^Xw=-lljcz^E*B^zLmruP4a@JRsM{@F{8Z8*~i#QtWTi$
zS5c@HX2EO%TCU$Es2%Z0B7p(8s%;6}UU5}<u-F&A0N<N9&dm0^4%wT8*BF;wWW2{%
zvTuA&=mKseWk*i9Obh<0C`@>~8+cWoNbC!k!zH_4qc>;TgXY{FJqdY$8E?VXPg;j5
zBWRyv!-ebfhi@AM5zP6PtlU3aga&9NQ=A`aIFxsX-em{;DQTQ&bBRFWMJqXWvAf_i
zebLmU)HF|cYC5i;nNQbp!yguRZ~k;VbI=Dyc}1~NRK0sf#qO1(Ar(}C^x#F_NU6Al
zBd*u&>HeI9Ue`EIPpz$+{o&iwRlIDa4dGl^m(~|PC9{o{tfBDt+0?PV@L6WtIEpD+
z3Y08@Xs=~%Zm69V9~83T`Em0~5rjPf!%&I~BJVdInZ&)hc(5*al?VF@!(h}^?A=pQ
z_veb^eaq5E`}L}6tnx+T?Efe50fgncQHqF^|DF>hzVz|iNIYS%r`8GrAhKpj$9eTv
zGkb*gyKq+_V_2}-r;mHvIY47H{nc)v<2MC*hmKzr7!W!>I&g)*fYFWx4<PrCO)VC`
z_&#G#QO?J~i%5=*C#92}qQ^eur_1^o*faWWy|R^E(idt?)fb93k+|9I1|Mnb9^pyk
zS$~)oqlZz9ckQQ%>P@5krm~k_c^_|E%tm(LlF+fs10zDmE)Cx4W|hVlXE!}0VTp@Z
zWNV@0UG5wl^CfP~R5x<fjlQwm#Er@7MwZ+t>&u9z>kCUrda*03iAR5YuO6DhPZaz&
zdh{0#yE8VL6=S7S-F=+hUvY4k1i$U(tU<^cs-f`;(bA8)=Wnc_r;}f)w_nLc**X5o
z8<MKOQ2&%3>>6r199oxJY!p6SU-)|otZJ5J@;gg}dYEyxZ6S^U9wOF*UOAH-V2x_D
z(N_r7+RvFwfc=ml>E=WJ;3cNg0fz=v>1(+KXeiki&-Z3%csN^Ya;iP0ZcyFm^1#LV
ztENV@ctjg0nemXSf~ksE?Iu(J%<W$25qj0&2e)xazCy$P@a$}NXpPLQ?)pLj8vNlg
z`LG?`$myCXnM+~pTlXrzFXC-Yf1&Vcv9|~{^#{wjt_Z#mg?e;~JuGz@=mkoQO%Xe)
zHb%S291x!|;zT$3-E-vKo@)N7H%v7Y)8Q9!WEF$`vvzO2?N=p6tJ>XJZQfD4Vi;v8
zSfi*MH;)!Rh12opxDu9&8JIS260MK)DwQu7Dq+Hs`KhHQKZWg=$xlT+ybYB%w{6~K
zqzlJ{aR{-e!;_zKwq2K-a5x>_JR-B*dTIAFvb14z;Cy>C57ZPs74aUfINqrwow2R*
zk>OJx2a8ziObTM@GP}-ZJ)^(mEwjP>d05sq>j8RHy%U>Drj@mU^wB*qK$l9`BWCu0
z?1%2=Jtm`aIn0lWQQ~Xf^OE{8iG43`JwLsDH?NQsI>_cij6#@`S%fMbR8*_y_y=Uc
zs-$8@5j1OHv&Qw1ow<sFle6APFKAxDA%7%n%KWwti<4<)&oyy+V-;;q5S+!K#eT)k
zw(r^mpO9u>TOD@gW~juzUf{U?x#N1N<N9^`x&?lq3%tNcKI8b@!RKH3yvT<`N^4&}
z!}(m#C%{K|g!O!q_yh5YOce0O8a?7}9E~5u$+cyDDvsysRgbHlC~p+GWL|CbcZ^=d
z{pjd^B|R#R-yFzP`$|7Ov{^<qj80$VMwf~A5VInXuP;xD%z5;WE_@vID>*yjWfST*
zM!&yd^vw|WnDpbadRMLwZcS|*-L>QmezDgPYLzntY-6~SH|!nc)nD3sl^zl#!CSR{
z&OKo2h+Jw9vpx_Y>1gmCGwwKL`_M{kZuGeh`&_kNqBlB4zTl%q-MC1qp)X$_!4#yH
zIFrqKCEG57Ha+qK)xL_)yO!)ArjeMEQ<3A|ON&T9-c^r?7pJI-MrM}YWR)Jc8O6nQ
z{!6F9bL4}Fq{n*O{FlFAe_$j@S(y2@21elD;#h)hTJ0}r!dtvoAKS=!64)wSQP>K>
z3kSA3R<AU9@0tSH?DE=_Ax59^O3l4Ec%Db%VD~pz0n$Tt^nK<Jyv=n~wE~ym%-ner
zjCo{@UU7V6APrCZ!7CVJ`n78aG042j8{B<(2x&r5t>K1mDO{JVha|=rt?|MmSI+TS
z6;XJrO+OO<4JZmNPT)5(i_aZgYLBTI5g89X=?jJR#6U)k&yFG&8YJ`DjE}J@l6wCb
zefiNy>UcFgdjkC=#`8pTXpVO+c{?#Q_)pvE&w+f7cbz*xugZh^#Cuz&bVXKZm2|~5
z-ucI+5A=oSa5r=eftu{ozVKOwEBZFo8B@`6w_YVG28<G$*B-s{ulzu1b%nd8%jl7T
zRA83t1!W?*rywmK%cJ2NvVixDe?bINB0=ir6e_F&CGR*^p->id%=F4XlIjg#lO;fl
zJ}A|t=M>h)MzFHsd<_D#;gN>eRcy+UP~z#d@b_F<;O_QI(8y2pL4~y}VvTAM({oY>
zsO3Vnhsp==r*?IDaJaNZVpk`|VN@Y8{7g^BH#+0UF}lAUZ<AK!%3c!^*S9&+eRjH&
z-SZ^)aW(#q;uv;sWCF59*o>{x;l?&>N#W7Q)Z|C5Ypgg9HT+6?Qq5K&1!ik#bth+Z
zAB8t=jASl{9$F)r*FoI=g3pB>Mn%34J*;+BoKW;Ij;XpDQQsceLT?V?Oipy2dx>5(
zN9f_OH<DTrr-#(B-YZRV5QU7;ameAjiX1u{-c*6JWEdA5qGC~5YFMx!4xt>W8-?qY
z%1bcBQIpaEZ3yCaGTJywem0Jkpp7O{+tJ1-p$(;5YVLZ-5M$$nHvTj5bbH#+EB}?-
zC#Mg0s`TFEic#gkNz!@rm(}93t}nK@dG+zSk_#MTC?qr3RL!zU25NcKK^0|=>)lX;
zqDA$O2PfGHT=#cex7gP*zH0qY@yQX!;f?>8qkN<A;Fy}LBNJFU%K9)A>_bn`LLd6n
zqH4T4+K29rOptA;C%117oHeGR;m@+k=&1kjAef}T;FG{`eYq<#`_VtK|FrZgIVUok
zXIf+fs+SFD^_X;`FV(p!cL%qq4d``#K}`63{KTJA=MDGshLPGv$|=%h6FTl<Z@8Pm
zoclB?mLEk%ov(Q_QGAL7cfOJO+Ww^LBdI1mr%qsf^Rqn;6nehSq-S$|yH?S&THN6M
zj(08Z5zCbrQL@^pgt-?5`ytRUSGv4Vy{vQ-lNWt*)+=A3yK1`0!k-}_YO4OgZ-02O
ztY)FRvNZi?atLj3XUPU2bZf6>-&U(x4L93TY+#O})`ybTvWp51m){akZ%>(laUFM=
zTD2SlKC19waDcf+O=68wc7T;*6ARKdh%|}BKD2Mf^?8Jz!bREQ?fCdvWmkD4qJ!J(
zpJ<79N@k7MwYha~SgWeN>*CnRuomkn+#SC%W5E1#(zQ7#uxVal2P%SRsp1O?6UEQ7
zi-(}kw$s7vpQZO+;3J`EU+1&d`rgU+=|1-UX~&NoWI|@LKaa<rsjwEtrwPWVnL7E5
z*9il_Ad%YK$T4RW$36}ca2<j4gUaGY_Az$yMz4!qycYh%WJmhP`$zbZt89KmuUyLW
zr{qaCnLNn~)$Q;ke~ztkhkI9TnKNBDg@!R%WI%~39N?Tm7?sZZ=Sb!fm1r(<v$N2F
zsM|-#0QRgwsXg=@B7zqjDIZE=ns7T|Lbn^<Ebg7ly{h$re()bouTIW_B3Ev?+8Pj(
zzx;~p$CK3TjMk6UOyd9k^@An)qzj1IUgN)Y{a8tNIoFS8_?@(V01uyh{Rnfj-THA?
ze4R+}Lb86`8c*+F{qUT8{cuBBab~ll1!UY+i5a})$~Ftg@9mp5zy7ygKQ3~t8CTn-
zvwj>MW7Xtuyne7e$9n?|6vMaaSe1RL>k9{VlNIDOxACUs)FYBMiX<?Urxb<)lr%2m
zX@T6?Cj@8VkP%w%^6D!&T`2gE%r5I;smM$mH9G1Gy-g73ZtietYUBo2#s<BzZ)Xv`
zykGZmAL8eI+w#ajg!nG35d;y;*_OAvV6#49vsa(+PIN`Og1p9M;0)+4;>HqkuCu<R
zwyvpr_gvO>Y|{6p3-0P!=gHVRzYb#Rgj*)E7lp365Bgy7VjPD(adM=ZcQat<Y9vtT
z|Avl(0MwOzsOmT_6^1=yqh5I~Z9~$DyZk<07qL&8^kR4DSgKxC3ZjH>1Ft@QGmZj@
z%?U5LtKbuT!Y9$ev<r03S=Cg#s>pIqQdQy{67@|AidS{9=pUFBtd|NZ9fVlk7TTWb
zCcK|r)j6(=O?st7`0`Y5VWrIWX6*74hd}D(+T*D74rxunMk@V@uP)lhpF=OdQ*d0L
za6H<TO2-Sf>6`M=DCU3-da3ju81`#3e8vu6^9~uv%Jp}B!&6W{?;=53F;RPWMJ^rx
zl6Zaqi}Gabo4<<R$eG`ChtG+OcV%$C5ran=7S(Bc@JGK_FAg22NB5>mSEGGh&$yqE
zLDwe`L-JU3JXLdt@pJsHH+0a2Em)JHKE}e<z{*S)iNe;8@Xjbo7JB7mMn{1~V80B!
zDW||;S@deT5t&h80-VazDNm^V$^@6hfXl!y!$FnCD@O|}F#J0tL>VqOai?e#zi4eB
z!#)39wrwpKFclPt!its!E*E7#FeakQF_H5g!JY0RfqBE}qMImDK#J--OpL*beXfcP
zxz$<T%~81nc-;xpXyU`qr3`sr;$4VDQwb^4-SfW?ReZOx=Fa<)lp=^nF78Q0Nz2qG
ziLH_vcDHJ%S3SmS<OhS3+SgYwo?5E&hcTWvZlIRvK6j^<LR)xpxMDOFj-=(wm+q-I
z1FD}Rye_AvIDY_6suV=}6H(n%5P=sCQ3qpt>Hg?TjGJ@1jX7m|^aVH3m3HlwE=*&)
zHoaP~LtoUWDCht)#Z{lP1Gq3+ON!hX$LN|XimO5H)JKQNG>xQQ>P?$R?l|MQ6omyw
z{}lbtQD;-xd(o9iZ<^f_IKP6`?d(yKXZQZ{rF#GkPuTOtW3-0eM`5OaL3JNnVTS(D
z>5sDg(c8%}c}x~DCc?pjK*`A9jy`9Xuiys8<`6CN88;-x=4}#W6kLs}@|C<PZH0ci
znDm1H#v&j{W>e|A(NQez&hF<Rbt-z&7nGbq|1()c$NiKVOUMNi1&wwo>GFTb<W6ih
zV5EB0E2ODOcOY4!8<nOdca(5q2&FHtkU?}EqEGSq_yy#OL#1c)$@*p6>m#aLiAKwD
z6nx*|UrjKSHvW`+rax5~Bg>!apUBwssT6&I%S3*OX0@M>`htHxgZ^W+)EAYKshZAx
zT!&qsMvM8Gw?z!}fiN+Cp1c?w`XS|S`4d*V<IF?p5qFIkPqm<sWBh2TFQ-`+JBiwR
zj_O0_Di=!;3yDZMbZ$B(V;K{{MdctUP(6(#cUM$Q(v43&IWc|FjZ{Hmb{~mOlFDFV
zE|n>#GU#Ja8DsKN=s8;=)gMO}VW*=?;$(d5q3X#`AQ^U63D572g*TSM?>1HPV$7qk
zw5S+efUZ|~U5D9_6oFSrlRKvGE;2#ija|r43xuP*&WU9zm3n+QJC8V<HQmY50j7Rg
z^ioR5!*RPb3&UsQN2*!Uo>jC5U)`#UYck;hq&Xg=aOu}-Pvu(rk1i$~>K1)gdULlp
z=!c6L#~Hl4G^-|)!<y1SqA07+{Kg}q0%bY6uv7%&`&N7vmovHQxA(d5O~IaCxfiQ2
zXM_l1m=TW*YcnJKVI}^h&0ldo_%D6(CsHfv<As7JS<_-Um++z;&Ie%%*`M@#zjp@n
zAu+cE-?8%(T}R<N;1S#A@t1ac!UmHLtTsApykMf#J(3m~+A&qAY4L8LmzolUh*hF;
zd*4r9t%8<5o>TEeJqdT-ZHRqlz=|1eA&?R06dbn78$WApmCxfxTU!tP)%=X(TRz*V
z=cztdHH(ghg@1kDtq`z59eCSo5>P?A<U+k_nUF{LrYuD(yVZ{y`nb_e^G@01t{IPx
zcUcx;aC`;x*lg5&V;-B$JQx9beFHC4*5a8upPr)wv*k<otoFJ#f*lcypbkRahJNUF
zbGyrz?f($0D(RsUY-C5+e|C|Hb9mMMa~+#gSr$6*%9Gjr&xKfw)%v|6y-m{Yf}d#<
z*ku*^C1LaZ1bs-Dv84B)k2ddZkd_3x^Y6;(j1;Z<j(q8!JzhexhwA=}6`hT@HNsS4
z6qr(tH>!{A_P}<ZD0|n$^iEjhk?cVau-rsGK_VPsUE==pEO|$}=sbz>TI?LJm(`E)
zjMtrv*G2;1Fjm`q1!auYpXDB1$N-8cL9bL2CK!WACU%T6E~^rqZmh1@?;_F_!?PK~
zCK(-3{b(#b5EYfMcz?DZ4_S+n`t=OQqp<CJ9gGKSRt{X)Vzc{yMvZO$siXR`A~%*D
zp!Zq5PSg7~?ySb>tIe0cU;lS8`yZF^)&Q{fH^Se`0NC{WKhpoTaq>^<|917|<kwjC
z-d898cKXSt{*_~0H6e#$Acrr298Rz|`ivt!l)}R0S^jXak0(4Mo7Ly6v*OAdUSnlG
z6xO<z6W~uXnj1_2Vlj-2`xRCa(7M*HN^yFJrr+DAE7ROqna%SnU^Tf`&ODHG6&aY6
zs^Cb8xgzwkVv0OgutR`u&EL045B(uS(^kAs{z<8ilj@!SdDb^&uW#~(q_l@gdr4B1
zDCU4A#K-V+5as*Bk4U|-rpx6ETYInR5$nZA7vK=FV5cBs6u1}Jjn8;fzqeGq^Q1hC
zKFgQU@njC9FjmkHtL7#M@<j(A$VUnUiP|8@8-+&HkI<I`f8K7lb>zkB0>zdi&gQc|
zi@#?5iNjZ`)k1KQI%J$jlpd+KFYIAGOJxZTvQ(SGojl?1rn(~~t_*A#e*%NmA?Dzs
z>%9eaU=Hg{%wfGZXJ^4NeZnyXl(;LtNYx*xrE%BLxb@X)h>DCxt9cy&CvBUDBOITx
z#iuYH_shC;q=DF+=HWB|ZuN<}(dOoa5DTEkSFl<Quea|paXw}=m+V9>&K=Hm6J9mq
zc4Z)gRBnD$1PBvA0iqxdW2!ZZdet=$1Rdko$8QsC$(OUm2l&&XPiTpL1S6TZdj*Gg
zszEOwK`<0QFN?jl{zUVYqAjOzm4d@o=OPNHe>ar84PjpsM_5WyL0EDGVL_edm_OsN
zfGi)i0a-q<L6*1N;j=A}Wg!*BJ7s&2<w+ThjzE@S3S{Xd{&q}|<uElFn;gnVq)J<3
zbRy>t?C@n;_~Gh}cd&f+8(XZcadmXF%$JA?O;1@i$ihP=$0P>>=@}26&5b7f=Zt~O
z?U#=#Pf8#zbu!1yfM7O4L$t8y?_?%aeI&rfd%OnxXwcO@6;oH>muuN0g$MT;*Rn?v
z9a!L(=SWC`Ut~z2cL)9=Bc(ra0@6?5FrjzIW;?>Y(rwYfl*@j3E&NL<c+6$sF$e1o
zg2#Mm;xTLW1!dI7tcck1V7=Ms3v&{~KGq@}`)2F~T41F)8e;Nn*IEe8I2tlhHDnwO
zA@;l=G*^-!GX{j_zHdn<r#&cNZ4nwAo>$N-v@e0rh<9lHi5BL981h&+jcOrm$+prr
zqm$A*;MY#oUXy1t14^H!z3zft`XV<=1Vjn&=W%U!=KxV|j((f8f}Q%JKgI94Hs$Q}
z85^QckYXY?SJSTwxtU)tl%ibTF<k5~9^-S1!RaFtUVoz1T)IHm3XTgG#hNM_CN!{Q
zYjm_COTmI9N3$EBJ72N{)VVT8it9c>z5sRHE6jzY*||bWd7=G+@AR#vz)vagbNW*l
z#afIMkI9x!iELq5Jhqf<j&7h0$;5gePuPeLBW)o**E7}<&B|w7pBU?_qysF($4Rdy
z-eb|LwUj8}kbN{xux~}@GoepSuK`+aljLc}kGbp1A^5Xnu+KG#o4F}?A7T8=duS*n
zN)_-27WF7=qGQ`v;7=E-$J~%bx~-mERJu_CCBK5))jTtSlArT4Z#~hs)R-B{4I3M&
z&><?xx2P}W5KwsyQ}M`{A(ESkok%P^^O)_+VVRR<>}ViMEn!>j^(ThC^;T=~^2fDp
z%&>S@ke5|w;FCW5BFd7$(m5^QH1Mc)SxEK|C=|h2Q}*rlH8rbKqjo(rLZC0_Ghe9I
zMt0~RLKoW#hpPqILB&cftx2^*;e0VmyQ-a7OGkey3w`8y)l&*pdC}aG99w?zVl{sh
z!)MPQ=t&sWjwaBSc)2Dl5$#VAf~i=IRH~4cGI{cFoC0PsUDOG3WR3=4)*iezI(8F5
zj<&^%w$-0js~zZ(_zuK$h{~o13Sco!EwP@7AFZ)2)(^InYzW02?&OAhiCp8#s0-wJ
zj6<Nw?nvfP&a<eM6pIRZl}OP!oOp9KAdpz6PgsXcVpmj_;N&^|6wmpl5QOZqLB9EG
zrN;%0vDi?YdJ6-n-z$Nc+^<L^B{bQs_1Pb}z2&8;+yItjCRjY9_x5$XO&kag+ub)`
zBG?5Xj*V;a8S;h2C<1)Nl<ms4l9yw}asDDP^E%p}Zj_oir|`-5Cu6H8Xa7CdyN-B`
z&9RA!pE{Da{#Eusc)5BsW=qmji8oc)8e_NWez~e+s+$NJg@krjP7A%Z??*+eYIa3q
zGJkjHZSm&NmE#%{^M!6+BE#n0`hiIZTP!A*bQ!Hc4>d`hWMOUpz-Gc&>s5b}stKSd
z>R4(t1~3|H+KtAOedO_bMK902(j1Nb@&5Birkrj(+!s5?<IBW&?6=1w`tRgz@)sSB
zhl!7^)$c8$CTBPv7QNW{CGd~4+vdS}yJMb%W#kyM1Q#}{r!Rd(IyQMsGh|G$F^GxW
z_Qs18XeNW|8Q>UI=|5{a+G{5LE+Cq4g4Wp}ekTd?5Ask4?hVz$pfjs4bl_+v8yJwl
ze6nhq&sd%r7I(tIw|pK2PkZfC^Yd4J%V#T3pX&2{@HQK7Xsb_iqaV+segI;$%YeTt
z9GezrRbowb<t!}6J)`L1(sTWh@?X1^dsaf6qSL!LDo#Q;zqwbkGBT%OJ+>$D4{gqu
z$4YN#bGAHIiVCWAuEZ*ShgNb`;!N3Mtq(Y*Pi=E>JgyFo+e?1My)R>3`QH)~=k<gg
z0V3`{h{MKGAEC0W(`w0gP5Sgl?zZWj<C1-5HP;_7YgvE3!=Tvf&x>ll6ntWzRyj!n
zq0-=z<(LZ62kiaEo@AQRrDMWH4-08cXpQwI%a#k`lr^Enx{dU`&^YK0?SL=CAq4Aq
zd39iVp~Qc-0=G!lM&=H1`8G#!qLK-K<jPym&Vst~AbULZ<z3(gDo&J_0UtNGT&q0=
zvAKO?m)Q5m>91n$ZZxYK<(V9Bc|Ev3_I}=aw`-jpX0w*fTuwjj9G;q|9|@$pJAmpV
z^r29Gi#F@wkitKDxN3JWD^`fEQic6HFai+@B!!O^Q#30`UMY-TGEnINgXDZf2XH|0
zDvJiwDidBRfKqOQaPk%u=1mT9Hv>T$AXwZlUJ(vN@S=gcjB6vQUBwOCcImN(z&FhC
z7hUNaq`&lqUx)xj`s`EbvwqPJ`7Qow16_d>8&s+u*-oPBv<8Wfs@k1I-}ZbGyfgol
z_;jPJ(l$Q*IX{Xp^&?>rm?su?E$*5dhARBgRd3>+rb?Rw_dLK$m0OT@Ja9g9Ez*51
zUqv7vUe__Ns~+;8-aDMN^9U~~fHl?@JqxPOg-e2g-vR?KN*48O+921&R0d37HkEFT
zenbh*48~C7li}C0rhXl~G_CD>9pI&va9)8cm$6+w-Cs5J=kleR`Y}WHta(<UweWMB
zQKz7NnHklf);nq6W~+S-98en70ma*Q7w0RQSi%lmzRV^iwlBwWrxd{1F(9b?BuqQ*
z`#Bk3o&VuOGNQ&QAnr%x0ei^TsUMj1#)ll2G7gwq-FL#=!ajM$xA8V>Xr=tP`h*N7
z$ch}_(dc35QKL|<$^l#$%k9x7UQfsm+T*QL+K$5+;@!f0B#nCq<ELbF^Xp|B^G13O
z^3Gp%9hYvgB9pUVg2WaZ$1C=_D%R&#v(N0LJ;%-VtZMZY924MQ^Y&$v-6Ui8CVQ~t
zc=F+cXFA5&O2(z*5iCxUPn>$bE+v=v;Jv1PoP6-qedpi_-L)CK3X;_LspG6YejGnU
z<46r)x?=#hMc?4@#V4PCx3nFHGaSERZQncD_$l8e3|?pz^G%LYGT&spx;V$ns((iV
z#-Z}7PPX{?D1Bd4-rsVo305;UU2SunODAHh&`?=Br$5`(<P6SkokIJtWgHgjDfWni
zMHeiV*}Ox==Fu)k#t(#>0UOP3k37ifB1av%l`WmFS8bww<XDtpth3efDxa0{+7Q||
zyBHv<>eu|LT(4IPuj>vMaS(pj8;Xi@)?Rja5=F@EH})&MaIM-gp+{3JZu>uG!=$(E
zEs<cWY>CM_Otw7OQ?1lU0{vCZ4|H64(_u=wWBY@r^q*_<l#wf^pqFUwSvEgl?^m{c
z_>BsK*`()GiKV=9_N9*WmS-S@^WtWWLy7YL);^jQMuQRa%{9!?c2TX0^?TN1j`r<S
z1h&$zSg#LC^PCNb^u4;f2S%r}NSKkW^zU~+Uy{`WmzWReHDX4I`-lel9U9FKYrKLp
z?7&u2+r*4&7uf0ov)A<;RrOYMtIampBNNv_yX<cs+G+$9{tBV3^zYYxs{d16+Xz?K
zB1>c=HMCe{nvMX!YIv)gsEQ1q3^3N75y{aGZiQZ}tY8B4o<VS{zK|J!;#u-#2Dj2x
z%CJ;3<rBuMcMrMwb>muzIjtkEReuRp^=&(@)x}VK3fZgfNJO>T-9c2VRL$zqM6@ug
zFaNKJY$Y?&F{4$ZzGh^r4&;%4gZXZ)6dliZuYOOR7@!V5#f-=M3&zHSdd)`4S*(Ar
z@$MYQq%YRLpEg0=Fdw?sdPuJ+RP=g9uNO(tLo$)<nLo>(`NgN3`EXyd-WFTyT`OkJ
zgUt5)H_Uypzx)bw|L-#C#hUMLGwBD&gpTy;tLC+eXxC4r4AadN0Q@U@b!TJz`m=t`
z>1MrTf0|kU|BH#9V5pP#cXcLxJ&X-VK_fmY;8i}T;;ireAXK0Qz60K~)Z2h(75*>;
zd&+CzI0y(Qgg&$ptS!l(7#V#9woqRxA8Wy7a{j<XvQ&5y0lq9HbJ_RtUh`fon72Mw
zF1Ah+BSWtM3J3tcVD=rE*4R+ERSIb+ltVBu5he;K3z~|GU`opp^;fWP!lx@1RmAwL
z^XKfvrwSK<1C3}F;xGrp#kpI=tXzBmf=n!xf~hvAyBRA?2N1$FDe5qfba9LzQCi|W
zVB44V`A7V_ME9_NaIpU0=r5Fb5~&3Ub!K<qUpuw8ILGdtmF!--ceYB+O?I!{dyGn*
zl<Z!+_bn=Qc6;~QOT`^L&J-Q)wNcl#-D^vKW_eEOUpvWPsJp1(L;Qt)s62p4Jc<5Y
z63(@4yghS-)4le`5&@v{H?VTb_lL)byVpk9;#1^mDxQRzD`0E=WG06vuVaGrN$?!%
zU}T;x9I1qy08diu3)+~*Vg1$N*qvj(6HRfWUea3O+j@}wKqk2IgM<-|%ZHhzc{Un*
z$<X<A2hPSs>PGYkc82y|UAH$g;}d>+J9*@gb#>jo&KVo{Jt@UwYzrN@Is*}yI#!LX
z$(+CSkd-xZ&atD0-s{FV*<E*_vvFkpKJA#G`twg{JKzf*z$&T>v2$BAt%s)n>#Dka
z>F&B%CwFN7VRv1$v%Btt&f_Be!=8+-o{Ud3wr0E*`t)1Qa$<Swi3;C$ee>pwPhMrO
z)QG~%ex~314A*#Kl7w4S!oyrge!l%L;Df}Yzc-?OR%|Ao?}<rw%3<>Uy7|Yi&gI=D
ztBUoRb;bJZTG@KL8yv8T^_F#f(nNkrTCXMQJAYJTv3@6?S!oYg3A}bEpWDe|`woEC
z98dO!-~c>rbZ?P@kpGpOJAbdnnLh6*RXy&~#^?_S7U=ThFd(dZU3tn<7%wN8T5nD3
z-7R0cIEUf-Wsd8D^{#G9Q(gCW%3hZ0`uCJ>Po=uvN*T3+l+;X8r1k2r^_RU|T_<0<
z$>pkWm2jetr?<M!4c>q%+H0=Knzpo4|Ia&VuXGaEKIGr(>h}Hd_jl4Bas5UT_}y>X
zS-<L}m0qc7%UowY+)4Y`mG+BH+Gnnb>iJ)u?>guFv&&r*FTdC2y8Ap$d(f4(+!e2c
zsy{lpL(iM0T_^Q#b)7f)a=bU*>$*nMUUv;#)JglqbuI}DJB={QJNuHXKe)6ZmuuQB
zo$q&P#s8$rX?3Mv+;@^T%FH86+mog7(JOmshqBDHAHUhDF>T>M?O6H?uJAyuzUw)m
zf!gz#LrD6?S-m3zwbq_XQ;dPyqvvIi^yv9%tpl_t&i{#~-FHDI2@hTHDGd&1pC#89
zr&SHqHec-Ky77|q`2)2bmxx80s{bkKcbztBka{Ll1J>x7K3MCo#_S?jpW`X|OI=;d
zQqzsD+J9uEFYKx<&$y2QRj;devb3#`#nu%4Sc<kU#cWd#tqFo^O6&QXUfO4AuZyOK
zdiJdBjK^JCPWN(cIBI!jTA$x^%6uYC3#Fz#mZsIEru`;Ot4|e01p0j7a##P_9@-XH
zEM3!9b{$gDLu>8!f~zG<TXa_1(jMBsp0$Rut$a3gI%h$e_E<_<b(*#+r5o38q`YV5
zllf#9&%typ+U05U_oel&{=e&??Q_j1-~AawKFHD@?D`y8ZRq}l>tL3)QBSMsp>5R<
zNhPUApZ7YQL%mj|q&<~JBfD|^Q9SSa(mmTUv_^(cJ)5IRoz|pyR&~*;Q@4}2CoS`p
zF4~gLXV-So-ss%_)h=4Jvly_Md0+ZlSN{W9+G^LwfL{NZG34ni?Y)fOlf~lh&$xb@
zrTt1zTc4#puJ5wya=~w08GE{G&$^z&Ty%eC+S}c=FEY>B-Cg@x_xUPQ>f3#R>({O?
zQncT8TA+qs+R#IL1dWhKI``ajuJ*^y>!3rk{2tm8I$=rrc`x+WmZkp|0x;8aH1Ts*
zpW>$O3sX0e^;>C~%e!dzch+C(qBV5x4@kG)(T*JLHJ*Ph#r=F2?Y`7aJij|F^Vu$1
zxU>GJE?RBp{(tPE{l$J>6_WT@VO>_Ru*ly$^`CD^mutSV`AGXJoF8t@bAIFj`TNYi
zFn?B<U)p~;fAW#M;vZ+(a?L&Yt5E;>CQbh4ssD2Sd$grXYwKZGYilDPjZZc$)U*~p
zU$)-Di;NOi=I8NCX+LerAnj^C@+W!mmCYyKN*;5OVEsNkk9+(%zbi;fd<K?|95{7k
z_N}F*(@Fx<XU)tmzIFN?(?}Uus@+|#-CA;6aK^Nmf$W*H0@=m0f-|RTQ*NCpKgvp`
z2c~5QW@Q)iyf!m9<HyrVvZt4lGAsMX({Iymz2lBqQ*I5+DjEH~t45BreoY%xI{l~9
zZYH~&>~GHeX7;o>Q>IOuTADrM);ZH>1ZQNI24~NnRT7vsHCvve0#qS5bH=TKDL*0Y
zo8{lko=y#Cm5`EM8Yr1Q^EPez%sX$rWBSxKsll1I&zx13cy{)*DbtImPb<-8OfN0v
zwT|<$npRpiodUCqOJ>cWW;27g-XZP0H5iyhxznd)$2(>E%&F7nNF_RWG4VL>TDf%a
z;;b37>A%YZ(`QV}rjb)_FO`;L&%AX84Yr>z%`TbtFTv?0)3V21dg<U?yPM)|58O3-
zT6Sr?jqxs-e#aeTdTYt8QvwXmH}C#t{0#=}4$baJ`$fBy(rkuvT8X2jr+Bn<`fW2E
zRgHJ>>=L@XR46J@u|%3skkCXKuS$CZKY?`Y=4MNK5>>T^J6=n9URo7@A{Z#n*GzKA
zo;_>&Old6H%?#4U+}zx}+`+j+a);&)%N?FOA~!#`ATKvBFK=+(ki4OJ!}5mbjmXQ-
zD;S(RIB)Ra!9xZQ9XxFC@WCSn=MOFzk~<`C$lxJEh727tY{>8-BZlM;DHxhNG;iqO
zp+kla9Xf32@S!7y<_|3xmOCtO*x+G9h7BDyY}oK&BZlP<D;S<TJa72m;X{TG9X@RM
z@Zlqd=MOI!kvk%9#NZJ_MhqP>Y{c*pBSz$pD9F#v&&wa2KO}!>{;>Sv`6Kf4^9u^7
zVgbb$kaYpC6_BI_N`lk0;#==1ou=jH4IVOd*zghg1@5uqJcZ*O3Ag@u%G7Dans4HG
zdZ$>M=$@#}ymh8FbJ}fC?w!-J%cf5a{6tg#RTnV~(qFeRGvd$0M@frcwS898CJrf{
z5g2@De%@e{if*1(QZlQgP#c-8sjF<Y?j-*GKQj(ilM-WKb-8x=rP&u=C=0LpXSdwB
z9@~qw^BWU2S=P0--w%^6J9gXeKKK)4ch%Z{AKuX_9$B@v-?!Y=(h3Krwf(MLdAL>f
zm$u&(({F1PnOoa$?ZU1n;0|bAoA2S%*2tcuo#y+mUyQr<vOjH{KlqEDH#Ofp_OYu+
z{bJZ(o40H@Yl9X#^8CUtefKo|{DsYdU+sS6#ybagKD++AYY%PxkA)95Uq347d86m6
zzZg_={}SyNGwS~HvgVg6wDq5SeD|)vq^0NoTdZG?`=_SA_sVZ>U9!CVnhQQm|IzvP
zFFJJpzh3j)6T=7pu585*_ZF>r^?@Y^cKu=5$mY4{FV5QW!;E2n8Sq@sv!1(l>^WEL
zeZ6|ptc=%Rxv%wi177Ra8hiH7Z+*0KW6Ocv4?X$ZaQDr#jW0LeTG^xQ_1~`?`_uQ{
zdf?C7mQTOq*|e1-77VDIaNdMJto`j})B5havG)s`NAI~V@^3TG4t3l9`0OjYZh!oZ
z*Udla8vZKOe-10w_d4tQg!w&24t4xZT5Wz0_)L9QJSZY%cKBCbRo{bdKcv2ocUmIf
zV_q01!V)d(NmJebTklu?oSzk+WgmE+@1=Q9-@Kpi)IYC3ZxP>XuXyFLKl0X{BX95a
z4)~>!dPzf#rv3O2Yh!bs(JFr0`-N|8-=Qu3!_2{R7A(}B`+nD}&;7~M+OI!)edBqn
zwl1ygIp)^y{Gf8(lYJMz_~fi7N9x(1ee-9pZLG|A;MkmktLMMh?Zx5SyZr3e?@YWc
z^^NsM)<1ah{K7GFXMOR=^Rq8~>Y25Vr0w?)KfCXUwe{yUt-fJT<<TGZxMSpl-Ol;N
zpL%s!fA_|JtIgi+eYxMNm4`p8?*9Cwf4}p=yx63DPh8#el`jXr*Kg5vePgeV_&@Aj
z30zgh+dha3xngQrW|FxZ#$^*T3zTc1q$HSD+GV@wRRjW5%<NC8C7DUPxfGR^m6es1
zw$iF?YMWV^QEFLPT3J~xe9v>{J(qjWJ@<lZ|Gw{=AMo(byUaVwnKLuzoSF3-R(-JR
zmd6?eH|qY@qtBhPX3$$Jp1Wgv!I&SWuZz5T{@mZToqFvnW1r5CxclC$vtz2Kw|b$?
z;vGA>4&VIZ%ln_4T2pc2+VC?5G~Ks#L3n&k@z`~pl76U4dgSaq1yx_Yy=lnP4=%6;
zH&|RV_VE{UuK4rrkCt6G`h-PacG>t?|0y>%KIP}n=Y6(sLC9Zs-}1rs^*;>DNj>wW
zCtl0mbNb)s&wFS7;yd4bbl30mPHNOKbVAdC@4fWM<|WrxT(W(_d6&&=xh-Vxx<$+8
z-&&Zs`r#o<r?t_(`|`1c3%XCqUUqxG>@QE8`&O5<C#5~3emsKF4#IXD<+t*av<o)G
z{@Ng9!s}fNn{7XMUBTtgbZe0EQ@8bxo^bhrZ{I(y-F43mp83Trd(FgGBJN6i@TrIG
z&);(94b5JAbJ1nDTzA=Z4L`rF?4o;ncUZclagUlmLqB_}yLRUXYp;xZ;rR#Ca}!2C
z@!|IJ4-fAAVN92+i?=*{#nO30q8|9+{3jl5)vnRfTh83^$+kgRxAyNedBT8`o38jS
z>!i<Dt^ILO^V7@vwtBbuR}Ds7IfA?G>w$d@!zl{18G=`+>4z56Tt%FK={Q3;A5I{A
z{kzh1zTZ)&rHN}_w)|e#ylBY0mSo&s{8|$6`-Jx<QgdGNfm7LEy;|_=b!P&lk!zoQ
zzdXDY9p!+VGq#P!x`}P$H<MqySkr#*lYimkPX=jk|IlsbxY7{qr`unf-{{g_Ml;vC
zF4daOeW!E7)zQI`&+U0kO@d$-^Wju2p<((+dr*42#M?)X9N9Wu@|>z+x2=X+P<l|j
z)+iC2kt5R+E^5>;-99q0UE7f(FT&bXsMb1EYo~=8#YBsGXxqr%Ff<{-Zog>c$kh1s
z)R93AakO5e)@|FhPEBuXZ=KL6UYAQvhaqR9(AM#dLfeKS3HwE^6I!=xG;$=YBg|=V
zT1e$5^Z%am%6a$w=j+FxpR#;pMA*KQ=Kc_~ZtRfqf$PKjJ4ZgUV&cND?57S0UVrMh
z@4U5e&B+G~A2qIz<{Kv_?7I2lm(Sh*pNhviZJ0N6;YeGLF&BOG%-at>Hh=jQOWvLP
z^O;jSFaBXtT50^v$?rWrYTdJAr=582wS6z%cVX;pp|1^JkQ7(&!yOfC&bhYhyR%C^
z-E-$FcfP;=y2|a#d!4+XY4om}o{H(UZ(Q6{{m*~v!>>MGJL~!PKRUI0;+JpU@pji2
z*4;Dl)>#i^&FGT1{EI(6ceEIt`{@1MetCV%t$V-uZB<##Bg-Cp=9#%euF7lV$htl)
z;??Mknit<5+3oq8Z=5~sj+d_PS=eRjUti5%wSCn+FMajkZ8J*dtam)TcfDM96Wg_V
zW$*5g8=ke<oFlugcz^kSrf+!boAd8#+`o6PH$um3`{<Tp*Iiw@JYw93jQfdkUoiT2
zy^uB4Ppke`^_xcjXY^x*(jSd4`~K0TaUXtS@4WEjZrz99(|z9?AKUKB{%P4`Yj2Em
zZdvh#^U+gp3RyFAVaF>5{?&2p8>7GL@Zedl3vc;hUg4=ZKL>q2Wa_SkcilhfzS$FJ
ztejqY!mm@?e>v^mZRsnG>v_P~JJ!CL7PI#0$~*rav$EIiTOE~my>!puEnRQy_eJz;
ziyjzr&w~4l7QXezx|hFCPkUwabKfL%{`KVF_Ro2sbj(MK)`h+IRoWTTf4lUg1?NO`
zx^we0mEYX)^wu$HAAGj#+{A~Les<NOeW8g<A4*A?^1`W$<DcDi)1!0Gnl<Xd&|RH2
z^t9dl{r07yi<UHBeDA(Rq2Kk~(?9F8upY~2uYc&u%ZDbGg@3s`IDXq1ugtGWy!`CN
z<8De=b>reCCr5q!aEGlcZ~5YsyFZ)y)${qU-0|bYpLZ|n-{5+_>Y|5p_l??DwC~1!
z5AAz(-{yUP>}$RMto?)cXYQZA|Bn4n?tgdxxBImN9S+1CNIfv|!0ZE+2cAFh$$?!5
znjY+W@ce_99xORH|KP(1-#GZy!M_f+t?5&fT$5dMb<JHhPuHxg*@5xW=~|qYrcKi3
zX!mI^VZHWOtwm7xpn*YSf~E%D60|&MP0-gt`-4tuU~7=lAh*Fa4Hh+cw!wx5KQ?F_
z92VR^cw}&4@Z8`Bf~$f*5B@#4Rl{BwXc-rBQ}I7Xa0mJv27aE(P^p%;wD^H)?aR2O
zyF0vh7WUT#w>3-GJGvcHlCWG_dsDA08rGfztoSQKf8$DG*;`Am=JxUK9`A;+rS@#N
zlk?Ei&sJmMTHV*(<MV!5nZ>Sb$0X;Zf}&}TtjW2#&Z6WADU+fi?ZeVaq8tueKlfBU
zd4e6mJ+_a{ah6~;Al6U<3k#!O0e<MA0YY$aL$|8UGTH2uNih)-7U^aON*ByJ>`wJ(
zcWNNJU>fc#<YGxD{IaHaPw@`%I$6fQ`asxd0eZCl2X6*xyuEQ;Z50^LF}mCey+mk@
z>p2`ZV#XQObIknLIFkIN^!sklCpT|!^VR##nft|ft>d@vHhX4oTdiN_YvW(CHPjv$
zJn!*WHfq`#Ex+&l8$M8+w7AbXcf!BqP8-kTI;0Vdf0+h@F+OEl3{3C$9%JU~gI7t{
z7P9=btIm(P+(^H0-JB1fYJSCX!;cm7hmGAme(M~=pNpSuH7$F3_zuIbsa=A%t5LJ^
zZ)lToYuabN(b4d8;JOQLn%HJfBg5Yoe>^mN`jP|h)9=asZf@?%`MK5h*)_k9LMEO(
zFLnLb)mgFO*W7g{Zs*!d=MVbhud}XPdcuXPX7Osc<iU8Gv!H!C$M(##{fzj+3r>og
zI>6DS3+aT)&#p@NVCl98mPhMV+am1E?Vt5bUz5J8P%j!+<5&N_x&PExr@oy`ajo6D
zOPr}iPj=h(sy^({K6q`*V-IgF|M<4wRPBwOcUJie89ORE-l>ag(}ovxcx76j)PAQc
zdV8y_6EA7MadR_i47h6aOC-1<LZe2F8aHm-1R*3O<b)GWXo}FRS+nNNo3}t{*|KG;
zR;@x2TDNX};)y4=L8u*vDD&EXYrmt<egk(tE`L|6E6~*nrl#iCm}qlAb!>v!u9>bY
zRkOUA{%_UqsT?!93AdXO^50P48Crt`gVFvXC0ZsC>^FmOdocJ0R?0upUVZp0gddN~
z>VwgZ-1d8jeNFDCze28cvxaVdy1{3Mir~+FsPOR~zomZ>!haQ>d8VId*q7^fkcmG>
z_^EQExK;PUJuFZZ{_Yk&Pj2+Izd-ckd2dJX=YOj3xd7mq|5c(NDvBrRR(#Ws5WY;i
z;DvXH7yc#4C;ao_S4#sfg_>vmZ<6#g*cl_72Tf1^b_l<cH${Xn{jaZoRl;wGdaz1=
zgJdie<!HsPR?|hJ<@xx(Tl!-uMjyU@!-sGF_@Qjr2;K2()xP6}Uj@Er`GoL=H-<3%
zua*OVeuAP9E&M{^Kcm{ekAD$oDvdjE9a!amL$|>E!d{Bcdo1+b>7OO(M__{{h8Zel
zpY&HmEB>>7_=T~GAJN9!e!SSPOji6T<PYt`$9^?C7KAGNdY0cZLqCOFP0PlwXZckL
zKlDPKtzF}%{3?elerKicll}(b4*@4LDA<P|c9GJ*0~{;=t41h3545tXpHvQB5I*)}
zKjIR_=TOu$|L;lu%7o8qv}%7Vgg+3=C!Y1YS@boBvLAx<Vc#czp&5$bO>unq@tKOB
zuE2+1SqERsQi?ns)2e(o@WMctt-!~Ae6C`g4~~`pW#bfop&x#jOY!ejmVNARm=Ks>
zmZ$h1`td)bK=J*RZ(*V0`zzndD-_>f`D#Uh`5D6Rg#N**e9I;){fpqgRr{@;s`&oe
zXVo;t=ZRdN?Mq8jMY&<R;yVFW_T#To{Pup*&$wFgS1J2G^%HiD;t%noUpQ0oKk}oW
zdY$5r^uu2<NAat0AN0&$Tgl%Fxv_Ko((3w-xI^i`2=Kgq&l3IJ!jJRQe@84-`kyNM
z35vpWU-Uzls2G3sv-@tvUxJdes{e{g#pkxjR{YTW6#q&;{EGV(zqcR%s~%MR#eVo1
zk0}19ru)wr$zS}_ijOz4Ed8r~M)A3fVpaZy&nZ58Hmm%V;T1s!9>eQdzjKWAUr_v8
zRR5izC{0@`{OVU!%o^CYYTqkfRs2^?`CBRaW$!5d=PG?z@eUd9E83s`h3gcb{g0>r
z+r)nA2a4as)c<R;I-Rjm@wfQ#KOQeHGW@3MFF{e5Ux|MFW)<_40w4b)zEli<?IWXF
z@n@LICtmDV?@;`~uxwSo5kDxtzy4wOPQ~|Ee%jB9FXKmd{t6}i(BBn5+*H1|8TtQH
z@!$5-zC-sZ{_B3~xB7tMuUGZsTYfSmdKF?;`PXDf-rmpnH?_Gk+22q46+A#3;TM3_
z^-&>@B+iAt6@SBtO8)}zt?s{J?G#^bV~WsIRDU)I{~U0v@)vrtQc3b-KjW0Z_Crrq
z{Ata+ua9L?e;c|g{^J0v{FQZA{Hy%%wVsO4@v)_TFU22)Wg^e(vr5tr>!<kKFWoBt
zh5V8b;Tu2pGdQtASm}o!7O(jC_~BP2DE=sbRr+Cr6#pmF^}k8{54}L~zcukgMyhyi
zsKPD)EBg^Cito377_RvIMBA!;84F)QSB}tvN<)J}n>PumfNU3(3Fq{4uEj<P2t8Ry
z3<)hmuWK-<MPo(ja*6oATI6K9Rx3AfCUU0iaj3UR<S-mi!NT5c;DlbM(hVfXF~Q#1
zN{+tj!La9%?lv$&%axoAH){P8HRhL>`lcJ|PB$8IWpkC>NuqC6E@L29Dss*J$eo4w
zS&+*RIj$4v!N^DI%qBNBp4aH6hV$L!$hKN>t4cpi#Lel`?q<l%5joEP^<dad_O?s;
z=IA5F->K}fKlhR!;w{heVxN|Dw~`M+T3+%(QZ5H_5%(xLSqHEz{~ICKz8-QbA*YF4
zcS*;cf2nsp|B#ETROxd5uLmRlru^vnM+vXJPswvVz)Su@@BCAqyYR(5SU-7|LmuSE
zKc(blJ;1UYZi8Ia(@IX(1$^X~{)>>CvsTG*{;vlke?w<BzR}%kG>!5*A;0!rCC~Z1
zm%OPw=r4Cg>#<JBcNTGXIooTm>qN*!h#cqndNBMLJX80A>E}Ui^m=8F^L;P53w-@u
z4EePilsxDEUh<~;=mO?@km>P>lK<FjU;Lol9>_&-0~mx}%4%)-dh{EoVN5Y+vy$Wd
zQx8VIE|}TyCX^@bB|@(7OC=}s&{}(<M!7u5m2OdTG9R^+<2NEJ>LK?c<aUT0=l^;z
z{7Y8l&UCjyuHtKz?rag$l70K}=IDDieWT>K9-s%qo=1M8A-8+0lH<C7Ke;iG8^2x2
z-D{Q;HTpM;_P(uKZaL&icPKfI*Y#ld=aJu!As6wZk_%LC`ytn!y8|Hvs<$ra3&Va=
za)IhC1#+Y7Ay)#q3X$Wwf>l0vy)1^@oZTv2t}l4WnXVU><9m=_^{bNi*ZygD59G@J
zP;yRXwYD9a>{7l9<`z{V&vgbp80Bu!&!j_s#a?Bf^9nC{Q$IudvmhV8Pswu~!b{%5
z{z}Ma98mIHm++D|^$WDW4f3J-(_ftXTo3uSxJkvg(3?e#@m`g?-?Olv2>H}dCC_z;
zK>o0vN@)KiCGW4ED93%c_nxfexc;CAquf2(J6{kj<na;+T!-){w-a(}PgQbUkFb(s
zd9}r$E9^8S$8n{XoK^lQ-$}`Hog$FDo`1*}_Ez#-m++F8e9@1^klPWi<hVZJC1+|!
zdi#fb(%DL$^Hnc-kNeOb$W`=Ja$I-tlCx-UT`>321}b^3GkD3H%7cESLw-eK-F{pJ
zxjEcA5rOLmUUp4>(C%``$E7KGSud!)ZbhBt_A&j%_b&|fslSHJ(H}T;@fxlZ=)q`b
zru@-<G~_EYlzd&+H~r3md<3_pLI_kZH$raoBqhi706iFfnChE;ya@Tdg-V|5177kL
ze(!|*f?_4l^@6(OPs7_jtEMUWS4G_24_Nq<0{PKbDtWFac-c3N<LUoZkT1PP$#Z?d
zOWx$aUjLAvGgHZPy}?V~qd)i<av8Ig9LMPX<n}ZD>y;eWAH3u|?)P0V_pU5ga<UF#
z+3r#x*W(5y$Mpy=dlvb*3i5Gtl|0ucyyQL7UkbU5d4bbs`Md|YWp^n#u19#;^C+J^
zkc(KP<hU;3Pwq6ls5FNk2q5^3*FE~FM97sbS8`m3@Umx-?-IyY^6*>)u1k2yd-%B+
za^s&=a-8#d$)(he@7{o%_Oz1YI)#^<ho3tkSGrQkalOJz&Z0e^hG)}rUQ+U0fAEqw
z<%{h(h4L>e`MUZY*4I^(e^trrTgWj1<9Z*Y#@EKYKIqES6n%xF$)bjk3N_X#m@aLF
z7OC;TQ2fsj^4)97u*qIDcpSrJh<v=XyO1>|c~kzVcO!mFOH?|);(vya7fgD?yyr30
zdjr3Pla=19QjQ^uOnRpNfqMICf2z`xWh5=+KXvOxBaNz3r8m$>Z<I;TB7b?1-GT2}
z82CN}L&*6iJ=1-O<-Zhq@z*FlzQ@22(%qyd^~rp3%u^xqvizonG%?AW%8}`CeIjnY
zN~a1mL&z>^Kt?@Fzd?ESeQQNNN0)~DrzUxs@6oS3$cHRc_W3-YA>?V3yhXWjfBy{+
zC_O%>*Y)O`^i1_j|28wd7fkti#iZwvpXTUW7KnVdN=6HL$RzKv{=xN$y=#<xyCIMB
z67*n{mq)#DeIiNL6ZpKFAtc)*Z^{SDZ7KA^WM0PSm<%DqO?syOg?gKzw@Ky|d_Kq!
z(%YnGDsPrsTl4^74OKR{2FMW7%%msf#&ozou^Zn4Gw?YeL&&Zw6=9TvMZT_r-VPam
z^ZA;t_fg$?E1|cct1{2$V!Ga%y7hKKZ#1`9N8s}^UGLGl^}3+0D*7lrJ}1-lu<^Yf
z0_1ND^xF4VV#a(rWP06tT%V{Kp!E1$Oi#~Ix88e@EtPRGpNHvsee2e1h<SQOib{{q
zxpcj=>()CLdTTFHdd7NYNcXz+N}y+qZ~5FxPp?hgdR(6vFXJvgFVXdOy`mg2>cP~W
z**>>1z1x)-pL6JX>rHwV?ejE@F+(0#dVId1>pfAoUOM!uWL&}L4!Yh$f%Vp=25As&
z_nhDpg7*vd1$NN1j+^nk;Z)#y;3>e{fbD_T08a+mfphR#QW>6G5HA7Z6|;`5fvKS1
z!SjyyfR6*42WjC2LjQ_|#Vv^c0k{|VE)b8FJH7zKoFaSyFgOUGBME<+@W%s3LB1Oh
zV}tPDu+8KQ;Lku5d%HJ*!$Hpn;*x7OQ{t}@yh3n-V0++2kl&gVq~UXc@TY;D;YTr$
z{xlVOE1v7n-UmRI+na*R1;+qqLO+@`{5}E5`~?A-zi%)RqrDG-%-<70$}IzuUm^Ve
z0GYo5K<4j&UFB~tkoj8=Wd7~~;__>Elf+*yc$MH}!83u(-_MCEf6oD#zo|g_6Dsug
z7?9B3XF%p}z2GXrJRtLzNE&{(0kYg%0_j&1p&JPOJq9Xl4+{iKfovCN0k1~<UkNIm
z7k~{=9`}%j-P?haz>kerbSRMgU$B5l{&zs~r(vK$dKi%WNTGWG$^UeK@@s?OPCPfH
zpW6km15)1sr2e-4ivAKvzuy5q1RN*yVBqQS{|-!qXlIaMBoX=_;<+Vp5Ri61ic|If
zE|B&6G?3->IFR}e0h#VBAmy(FGTjUy{XZ8-xwO6t2NEIwajcTN7f63@08)M&kn*p`
zD13@Yc?=#u1OFu;?cWNd-X%cleH|5~eF}UBNd6T-@&^Gofj&#(8%g|gkxK3+ApMTC
zsq}gaZarJkn+4zPqw>ETcn$2`47?av0AzYeK(>pkdn<qM?4|5Z1G0R^3Y`X|zbExn
z{JlLCe>0GNd<Z1}j_!)S5=i~ag-!>Oe=?Be6e^h1P0<O0-*#2{vw>S6KLg16n+Rn6
z<pQbi0Mh>XK&Br9WPUmTnNAZR<^DWV;cGy>{DCaralp-xOOyDsB)$=l`oDBmdUpap
z2R#!={V_o5Hw1nGdiNPB{%s)Rw}&ac=YW*I85j)z#&%Ni7YinwuIO_F(>khr4gg*Y
zy`DhUQ&S-AY&}iY)2vg2w0DqBDezrj7a;Awe~K!fwLs?kRiR%L`Wc~D2%RqUaG{fc
z4N#tgB>p^!?<;hq&?f<z-U+}7@N47A3afyNKz9L>-x$dH3IfufX(t6~&0zmBU?^}N
z-m@To4v_q7guY7X$wC(j-A3q^LN@`@-v$zYpslj=2atAu5&9D#{dpVcLi`<V6qW($
z?>4+ILjGDH^<D?kpBIIGPUsavKPvQ6Ak)7`;ulK%twP@<^z}ktD|8N!=|urqe!sL1
z;wz`&l_(U(&j8X7ygH!!afQ%%LOX@d5c(3K(}lheNWW}A+G_)3zCURdq-6jfZmHt0
z2Qr;&fz0o8p{EFau!Z9P1tfnvkoC6)2$SJ$F_@r!D<JtHLI(@IAHwAS2_%2F&_4>j
zP3W(L-UOuIA4&W=iC-i1YeKIEUJbiTfV@vmA|juc0RMydeNBV3dw^d6Zvd_qd<aOt
zX9DLTJ_~pw&<?x_*aJ8h7z!K){NV)U_g2BxK&E$(;B;Ua<Xl201L;?|(9eYgX|q5(
zf#ZPjz$9R^CTbiu4L1jl-@+Ox|9@(z%4-LZ<+Tnt5%Nz0;Zk^o&{;x1icGV79|ThV
z9-$WseXGzn34OiL*9tvd=qW;H14qMN9B?r(3dsC+1mczLa4s}20sakSd^wQiJPb%b
zqk$~nlYuPXZ9!_B^d^x0y)5_?kou1RIi9;q=n}!pfRs-cOp^F`Ajd~%3f)AoN>lZ9
z7m#|l2#yBc0zb|J-VE#lybag_h<8@P|ER$n5BL>uK5z(-<!J}fPB`!t(9a&k#)H6#
zK<0D(0elaMd_Dn0(F}M1$os`KAoT_dR$;M;{q_Su@+SjzyMp)ZQ~Vjg)6ouk0ckJu
zPfZ^m_5*H#o(;(R--*B%AQu8;`rH3d@>_uPYq`+HLT3P}HvmYzC?Nf41LU~s54=Z6
zy=8(Eft2e9q#w<JOur$JcDC<P{7->Qe<hG|j{(WQUHEf>v_Il!CEpQ9xyydS4vdIz
z0p$4i$L}?54Cn<w`Y}Q<2uS{CJ5>4~0AV7W=iJes=YdS`0il-&{rGn({x0Ag@Mi!E
zfIWb;x93|GzY)mtz8?50_>(1mq{Js|S8~09Rp6f{^!{y1Z|_!3zc2R?eD51gdku0g
z0GaN+LeCev0Lb+Ee68|v60jO_O@X_x-9s=CMH0RrkvoBQAnlZWsqhjY^?%;1+UNJc
z#%O0}16dy3fh>;@AnR}M7pi_f0kYiJ0m*+B_yYJ307rq&2BuISI0M)jNV|Vxu*3Py
z3qW3PPXZbLh~Pbf3j`B^oZqwpUIyHZ!ER@yvl#dSu&>Y|K-#-|6SgCV+!P@FI|s=2
zbehm70@+RveyY;FO|W94vRewIUK)`39}3(HJPXM5Is<91<`X6NJCOFa0GW?Bfs}s`
zNcqLWF9SY=_=!TN0x92H@PUsNJzcQoBSl{?_~(bh7u@@SqVEJUonj#UJ`YI0V}bPJ
zL?HcLy+QFG1=8Q!fJ}cnkaCv*>EE{XivKo{{L2M*tyA>VK&E#ikm<eqKAw+5Zw8R{
zaxswU1p&$b8;b*Dz<(Av33wlnc4rAT7kubl72jF#2@FDMZy}I&CIOi*Cy>|c#X=7Q
z(*IbY`v@KRwu(O$$o774t)^W8d<sarR|6TJ0X!XaYv3E8Yu2dvuYiny?JY$w2fhye
z5}{`R$)EbBx?UfF^2Okf0wOAWFp&1o68co3|ArCjEqP7lV>Xc2>onjlT(3pIpFmFp
z?gak&D)!!l{I@_9O~?CzEZ^BcmdkV?%XJ*EG0OEs!O$v|PafVwxplxTkb4Wr@>&X{
zooj?Y6-YZ7K-#$gNV%>Oe*%#0W6#S<?lU0eRtokPeB>n+f1cnAFDg1oa1$C2^=1Lt
zj>h5-{p$nV0{h*7Ot%4${yqG>;x7Wyzga-)PXtmf8A!i)jyd@+1If=4Jh)2HuLEJS
z<6<Dw`}{dgD~9|$U}wbt_N<b7PVj2Mjn61Q<^ZX84Up}50FdeR1Twv5f|V;3oh<nA
z(~6!5WI7iEX(tNE{PqU2J)b6YTOjkb|0%`a10=l~h$b2S5RmQadf@4>*XK#aKM~0I
zKUUz`74T6Y)5`@iJ_$(q9Zx9v_kfIl7WfwMA)&7aQm*~usy)X)rtrJvSeu31Mj-WG
z6#5aNZvawnz@sWZU4d-ZrvP`MU7ra233M~yPT=j2Xc{ifj)Q@;*A10Oe?x(!zkd(}
zejWgluD)O4Y9QmU1G0Tg0J1zYfUJ*h_bIv&ko@oORrFUt@*k{JbUBdxNkV4>$?pzq
zjQR`{9Dk3ZGX)z1nO^nXn$`yL8-T2zoF$s}7cdyO1-Ngqir)-G)9<)i=w(6|E`%MV
za}kjI9d{_bY9Q^c6?{eFXA3=5Fbnt{<VFIg13Lnl9}P(V{<>Y2*LEO^G<?3$<AJQF
ziMOeIohbPGt*W2-9{4W!8-TQv2V{P7fb?qwa0c)~Aj@emkm+^<viwez_!DnY{LMEj
zKb{6M-D`lfJ5}N{fg5R0=&nG@H3HJ!FBQtp&A^XA&j7ML3<grJ1@IHlf6Z6%9|9TQ
z07(Bnx=F=924uRo%v14m1uJh<^j(6_&Q<xW1YQffHv%sPP5?69K|r>@Q_EHReFKrS
zdoPgXa5IqU4wd)>AoI~%;<sL}_#YA>Uo3Q%(BE9A;wJ!U_k1Aj_GUcn?wGCOzXsCo
z8X)6m3KkI|zjc<1|Bwi}v)~Ogm3}Uec1H`H45Xb9p${VSwEqK;@q+~00O{ANYgBv=
zkoTw2z;}T$K=RYCR`v%2N%sZP&hKbEq<;j`{-;33pD!3H{I{-B@l$~8Cq@FPw+4-U
z3-n$A9t5rg)&Q3Sx1*nV0JsNuH*hQB?*P*Njlg}RuhjJC9`V3aVK)kR3h?h~c(w-o
z4tO$f1+Wd|D}ikH(WUD8eq*YlADOJ^=|H#~J_X2h3WS~@bhgl!3q4Bc5khwYqH4mc
zOYkfT_&P8d_*Iee<5?j2Lx2wef4BnAZ-KV}neIFw)14yp6+%xC+9~wqLSG_uPNC9w
z0I5G(=ro~IguX!Nc%l0X9WC_PLT@R+dt>lt7?6G?18H}l&;x{y71}0rFQK~%{d2y`
z?-M|l$1OmXM@^n8kBvZ<$0Q)r84qMSnL>{ddZf^)LccUY$*%%Z{z;*i3;lr5l|rB7
zQu3{Vly53@BcTt%Ii~*?ko;eT{z>R>h5lOT&xQU(=taP6=uaP~>`VdDPJz%9gw7WF
za-l~FJwoW-z)aYA6NOKIs(`e!TIiKRKPL1tq3;!XvC!DaS})hLfp9JSL|`)TKUu2W
zF9yy6{R0wP3cLY$KQI!=bi;v6_avcP3*A)cMnWIVka7c3zM;@H4n^+;(%x@E?-cqw
zp{s@dLg<f$UN7|3KqvHnzFgD31bz!-f3XF~>-ZJmOSr!875ZACS6-%R{lMRPiQ+E+
z{)v9%X5iO|zY$1(uK;cV?E)SIUJk4QUJU#O^233@0h54j5kCOPekTmb{v;GgKbDSC
z{YSTSP5T>k(-E3>CveF{cxME-ayYh-1=ggf^!^0?4Eh_vb--%SZvuBCy_bPMfqoje
z6Sx>iKW_t4Z;sGqK&Ib8;#&b}r!kOrYKAI1dx1L<e+RGvI2*VG*bSHld~t}TuXjBT
zTnyR)L=lD$24aafd@&l2o<5N2O$M^u^MxKRbdu0Lh3+hLu+X0+DgEaK7YSY^*cV8<
z2QN_NHhZwbaX>63ho1{1zq#OWyNX{j04H0(ugA{C9-6>6`zw0aISM0ztcNp!<PYno
z=>9;`Er9q5e<M!Cj}rX5ucFrj$zOs>Wcpb^-fz=^ypP#|jnSSu3Ed9J`{BVD6~9QZ
z1W5VQg#IR4-EThyz6-lA1Id3FNc)R~z7a_KE}^r4v_Dkhe~(i9^+4*+6*?XGHte1!
z@xegW<Gx7M-gg7p-gf}O>i9Kq8SrzU4e=iWneJL3+x<pFrUA3g*0iyZI~U0I)El@2
zxT%kde;s%m=x2azPY(kx1zrqfdwQd{@@qQqa@Z*W;!^MUdrwuLD|;wB35Z7#;j6nV
z9NA69x9zHMau*ffUN9p}<!?0bXQVe!un({rbXVXmTo<PUd4073^19gHN$KqYQg4UQ
z)j+oQ=@MT6q@7$K?Kpt6Ga5)cJ%#Qpbk*s27YX?q0bB<>4Y(c{)d5F|02iL3@Xz)N
z?ZCTX$9}RxoGYSz2)TBG6WZcCRM5Y+QSm*2q+dKy)9!`d(?C2T7_bny1@tXI`ac<X
z5I6zIc9jjR0eu<p2jn9i_$%;2AewG?ERgjc4#X08cvm3nzX6c#YhP<+cMI?Y@T-7>
z!M_>!0{kfjQZ5}xKT?29KLN;e`vIA5B=A>YZy+v-@Y8`zw;hn_wg58Szd}_yw*zN@
zt^iW5T<BRs&j2!ir4nB(@#BD_nJ$p+F&Y>Q{m#HkKnDTYe)qRh@mqlRfL;!q2%N!q
z<Yx+y&n+^5^AH~m91d&_q(6-W|7xl1`~qx<_^*ZLA&X3RA&~O73SKYq{{c2ae3sCI
z1cQOYkj};yN^ia3?Z8_Q?*h`lEFiDDenLkAZv}mV&<%hUpg(J_<QD>O2AwbTIN*HH
z=LyYk8EE%?Aj@Gj@O|JtKt5+G1zrz&g2aadCxZUFsfynLBs~^LJ8?kPUuWQjz|(;J
z(O#MYzXZ*V!t#N;PEh6i9q<6?Z-D!Op96mYt^v}{Ye1Ic;}ZV>Fc0y!0a;J8fM0>0
z4%`8B0e=Jz295;w0kVB|1M)g)3w#;=JQ9L;yFl~E7(Aj3cL;qVko@zTD80Tw>hXI6
zw)>Vqw!a_Y6!Xh>%gBEdNd9Ud?cD|Z3-MXN!N4dW`KJP@_Y)cc{n`$s{#!uu9|F?;
zEFk4(2!A~Ad&s2-9S)@Y89=7@CmJEsdlAU=t^txi9?0?-1EjqkK&E#p@LOPG!JpA+
zSwDPVjr@0k^y4ug^&XUXev^qum*H0d*)J3T@d$E&4aoG`11bM!1MJxVJHG;1uRDRX
zzfF+u=92zc@EsuQ`%NH<sNIV~KPU9PK;~->FbL^P10t!8sleHYKTYCW1FuAUV_+$8
z7lbLl1%IgjrqIs=A=0r7cpc)CB_6LUX;Tr8*K4$CK)hz5`-3vn@3RjAzlA)mDeZai
zZvbus4IRBc3xEef=K$FcjsZqN4sB7t@8TNQ@4NB9ec*QmvYf(zcoZCd3a~Nqk8VaU
zSG;zlJ&s#y1n_BK58xlbFyM2*_Q2nPxE8QSu+|cFqdfvd9cn9pyMfODcL1qZ4O|V}
z1f<>uAcjmW*8-OVR{<XbLRWhVxC}_WO5n4=1wiUm0Q&;x03QaH0-pdD0#^dZ1F4q*
zgw2+tfz(R{_5&sX9|gt%as9T807e3P08w5o!+^_xp};-B5a5$QfNqyK6m%H`kmbf1
zg7JcJK-6#J2+~2YC-LniK2+j0iLXY1(@vFOrC^z0hTv!*?WU53-FS%)6VwE&;VJEH
z0#behX~<Vee5GKSV1{74V3?pL$eodO{{$-q%LFq7;|0S6+XI<?C~2gxN&H^)|BT-a
zWPCLdbd_MGV3}Ykkn)A3A)g`f@q%H3?SXoFq?w+?S2t7kHv!4tKpOliiC-o0D<r;B
z;>!dx1V;m@pGq3~@e&^<*k1Ud!q+5zFYY_k+YO{%H4!x5izikJmI;;uDPKq$@);5z
zFBm4M30C92qT3U!6kGtLoeI*hQzr2lf}@4ceKPg@NPL(e_s*t%sPHw3uf_$Trzcn`
zSSFYu7%vzHq@4)T@FPs(HNk4!*K~V=m4ao08G`YGVS<`qH99R_U$9cJOfW+*UNB5h
z6RgI4jQX2^^m7Ag_*o_Km4XX|Um^T5iO&#>7Yq~B1gmkM)BO`%1!OuaNF$v}iC-Y`
z6%t=2@fm`ng`X<?c!>`a)CBk9=0y9ufwW&u1YIRqDOe_03Z#4?X~<_t{Ah{iiIt3x
zm-sM2O|Tlux_!Y)!7{-N!O=kcH0FI%w<qy&5+5P)VG>Va+O5VP-M-)|AXtr8kY@Qw
ze3@XW@C${XA@T8oysuH8_ciK=Nj&dojOYD~@tVX}Ym&Yo?kOsL(oA3C7f5`C#Ft5Y
zhG4uP?>l<>q?x|N1DIsvr`7%8!o|RIQK=!gDfIx3c4}HRu<%w*iwEx6toSQ1=qUx=
z9)qzs;B9yhk$NBFy-4DXU4wM_O~^R)o*9mt7aVZ!Lp%&Lu7#1KkUGLUv7m8ng<PiS
zi9$CM`fkcYzsE(2-$-a<U*X*;if`-#9G|M_IU=9j4m4Da{SogIe~f*7&l1|$r}x$i
zmA<iWZcm|ih`nEhHujAz6WZ7(cD~p%_HCUc{u=wNekJn8zNwRhHugz%qMxF_#(tyh
z4@n#Qi(V@BjD1Jn6MbVJ(O%@EJip6T<&}oABV9F4(S`V*v^HMR9fe;leD29Xewgr2
zmh_B$B(Grpz;{km`n!b=5&Ck;zp*dl1)^{4v$$IPHTF%+CJlQNME`Y>H})M&6?tPH
zzy?Aa`~Izw^o)J{R*1f_?_RXwf4cJbLD4t%&AVCJi?Pq$`C`x5ckTw!H};u3SM-g2
z%chIGv5#0g;T!vM{VjZBAFkb~-%deQS{WNZ!a}%(SEIF1^rw0dx>CrsK=N@Z>7nn*
zO1~0z89o@I_z}W?8>ri#toSp9Huk4HPiSMmTlU|SH})4@hq_>TyiYSM6FL<4e}*$L
z814k#iaa`ncbZ5yDbse#_1X>{4(Uc?6o0eun+koQ@NuMvuK$$q!$g0I@I!_Fd`tRM
zhCjNvHdAP0zv%AqiqG*1Lt{)V^zu@q_Dc-uD$Uqm?>qEwq>cS*W6oCcsmLcoS|aH(
z&Df9mg+Yq0Oji7-PEzu`A2EE_oiyy<ujuhT6>aRd`FIaS8~dw;iM+8NW31jDaJ`HF
zoafS>v0rn4J$>}SQXl&UlCQb<E588ol#jSWrGHa@MQ2nidLt%1<ga*D(WeV-?Du)M
z<k#50y0Os4e%0@^SNg{Oo~zK`c4|_k?RKjA8=}`A%2Vk3^!h{l&Qkm(ZIr&TKVfcb
zMH~D59z0Re#{Poya37+-#(uxiSSQrWqfq(Z*O1Rp^Z}F``NsZ=^NjlDjTIqT>f6|V
z_^v)m-q;WEuW&^h`xoxk>lfwugR=j%q;Kq>`{c<Yf3@OIkos7mNG-Xy;v4%_wmwVI
z@mMrqcwG3#exO}?DLxl#8FmP5?1y^2(8m6v)tFT3*F%^tuH7eeCF+IY%Lv7<%vAI^
zgT6x1X*R`=7ycf-{g>%4sZwIWxx$z0ZGh0m{@=}v_NvTj=bTS@w68fT;>q(AUDivL
ze-ELJ{U2YqE53WbMWK!Tdz<UmH`)`%8w^}`)Z0UjqT5RS8v8k46Rr4MbZ4m6^N0TI
zfTCMpp!mDx`glp|t2$Ki2Mreep~~OaB|pY~jIRz*d}DvbONDmt$Euf4m1gYESS9Vr
z*iZR-p^g39hY4-$hulu+)a#T#o29*kU8Csxg*Ntge@*%aW54qf;T!v#KL9noJ}y!E
zOGVz;KmA(0eWQO1Q~VJ^8~d}D>g@s7AI5bIv-Ru0Of&ZPj~CiF4}kL#rdQoj+51uN
zKdLlizt!PG$=5XFe1UV&PDvZ*5xgOM&W{*cwovx?aR>v~b!p$&-+Q6(js3K{Lx$Ib
zvH$-HsZV3S=Jvck&}Iu|d@+9r=`yXo+`lr>uajON^x`B%ZxZ=UY(L<S7XBjk$Dl)m
z9>VqndXCUdg<dQA?<6RGlJNKG{UiGCOI7(^NPn7?X-#DO)rtOqZXx=Y(I3ziGM>AG
z{(yFf{PaPJP87Nq(+7Wu=>Nd<LBA*Zj|jb3<hRftl+PTIZ>E<I`gftf)XM|+Bk})K
zp;rh$T`wQ>m%{Jg3ig7k^oKXBKSwu38~gt@?V{-TKgq>f+Zl>B_7}drtD=qlmgCP9
zdZUv6DNNC2?<o3Rv1jZrJ*BhQdqwfPh`h0Xb&n?CH^KEP<BPOZMQ2P1(iOOHr}Kqg
z(@xpT7_Ru&8uwc)1~Y6NrsT2dtWI;?m--bBMOOhxR}23J;fIY?{4Hqr<j2c+`!=B~
zg}%HK_$W_f|M2Fx&PZ2O>d9%(pQ>nMfA9sTE85tvcJOJ6Huk68bBdyk{b)ZFd&d5|
zWgQgX*l)Lw$Q%3X=Fva;gM2W|0<ChQ=<5NV^o0rD^hUHbPkw(8o^)@NuP6PyNuI-a
zPyV;2^!~*C*^@ulq<=rIFHb%`L-eA@o9tZ_>&>5KlFv8M^Ao(~OH4GnTd(wD&_BV1
zJERAD(-Tbebd&r=Ci*;+d<HCg+W*DGUtywGo9LbB-#ztfO!P-4c~qa5{52;2=fl1E
ztxWbVZsN^fV$#3GM5meT@wt<yzb=!#vrPOOO!k(UXxj3$ccw{y6_}p<P!s=qlRb?m
z{ACwT(;N;*c4?-gWPDM<R1lY@mGr}T=#yOenI+CCj2Jdlj_#J@{cI6=1=*Q-PDhb5
zH)@=-Bw3CHj8)M%lPle!E9T^-Dg)}+KwIoMXFgAfcVxr#IGiqM7yD@?wy2`X`8?BJ
z9Sa^kb$n)taJ>_c&2o*y0pzj8S4_?<a(at+A1$63DO?}xZjR-V<cT)79uGUTMHWvh
zE^$s$j(IR`k$KMiaV6t@8QyvEP@z33CF|HhM%vb%MbI-;Td}i*6?3U^Y?@R|znr4X
zaRvEV1*Nv=?9A-(PDf^TwzIgnpeQ-V&eAVI$s;<)QCKk5S!8$FBW?K47J-_~E|}uP
zagX{@?8RCh8%05WaY-Lkzjp=LY?DiJ;~Y8A$Z^_Jhi0cvNOko=b2%KX%;Jf~hnSOG
z>zvr)R8ERr<MLg(uI$YGoI|zjr;PkrPQMrp%c~7AC+W$4W4)UNgjH#)3vqlABZ^CM
z3MQ8n%D<=#{L9O9k{*?HrL(AjJYKJI1}83<(rjm8iK`&r;N%uLy<&??iqKNQy)=L7
zB!W?+)@N=8JR3859C`_RJ*)&eFtpxA0v`NVZz};05v{d?!q3c}=*S*F(UFToOg#(A
z==h>?3yLOXmN?XPhGR)>j>z0XdzNbi|22+1#qpyfTo&qwe0f^fknS%p&2E)~aBY#9
z#k>x9ncE_CNxjKrIni~p^UWR)(|VLMKgWnD&Mz!N&zh?_a*cn`^d_NSK+M!4SBdk`
zyM^NMu3YFbvAoRuaY!mJ&*8qiAbw>2R2N(r;Vhm!iE;t@w8*F&*A!Q=D+_m?tZAwX
za}?w{V(imgb{m-`&f*eBNhSmi*V2S~S+d3C6rg*=4a<>(yHQE8eS$s4NY|qojl(S}
zhs8O$B>OPSE}J>2y<Ur)g#|?=4$nK1-Gx5bTS{7~mlRrPghSe~M?*C$8!bIf9}YOg
zl73fUU+<ZYAsVG~9plmC<~fVv3i4IA<`!2s|CGoGhZ<uzJa3yODes#t?uNtC9JUCR
zfN{Ukeek)b4~q0KWwYfKjKerXSM=am-c^x`ku!7G?alJ;zdd-S8)UTJC>-c1Cl|W%
z$0cXm;Q~7d&w-OYi}`R@tx=f$3Nwp}okqE%=ca*_tO$GdrOLt-sgjZc*tJjb>Uh!}
zcBB*Gu=Q0(I4gC>6qj>qa$1auDRwf8#uZ}#7vYGEP)ZVyyMKwZ)IGMd*$|QA;%z1~
zFL`uvQ50@feO<+l;><}-UEdZ}GOf_*aOF5Ljw_j_Cm78rJN%59l9@NzsXG^!Sy+f(
z2g8qHX@m4s(dlCJ;6%GdA5)ZBg5k=rv}i|i+68bKL0J*XryT9JXmMFuAWCIeTAU*}
zJp$^((`^p>uvoqOD$34dO{a}^ST$o_)2i@MB*;c`_6WVmBcoI-F1@_WZ096o&ynkL
z=D7uI5r<tTvB$ekkYHVPlIXuqVo)bZUUj0V`qWA4(6m@b+DQHkXU*6mTse-+oXkR0
zx!tZ9{5#64a{8&Ng-kMPE_;eSMz0LL!O0~PiIzF3(1n|Vswbo2W)DMxHt)_!Z%&En
z*?Bo7xrL4x{eFm>b-KSa{as9G(Z}5v*P*5ueOS47m#Qkw+`Iyecl0Z}xX_u6f=4%I
zDpZt)9&J;?lq<H67^)XuoL8r!vy2PVtI&=9&tqyiC=#jZ=grqnEJqCWt}81wTfNnc
zOS`bhS&Yj%lf9dsS9Yzc?tNI8+gf(qhu;ZAAMZ{83D(sK4D{a#M4=NH?9~Y<%C{33
zX6~77F(_Z@tW_)F@FQ)6WlQkaAKO$H;6Tk}V>DQhkB(ZkO5G&J@6POr=r0%-Y0H_G
zpE(I50mYL$gz)_K8@^3k?>O)$740w0&L7o@^>usU(U<9bN?mYh8MCQNZmKJ%Wc)vw
zsVLopBhQd=d0E{#RqYsUK_BM0YYsiPZw(9y&=)5}IdH)m)syH*OSHVl=nU}Cd=F&+
za3~GV7UkX0lv}FV40NOo4Ag9NK1AT*A-Px2W>Zhsd@BDi-8#CJpU~Hl?W(O}kD~M*
zM%3YK-|T|IX_%lDIr0l!`FXB<XL2@rAi2$O1Z+7L^_tq#3k)hThGAVL=yl~YjE_Uh
zb~v%thG}9B=4_Z(C#wN`l)idaQs4mEV)Yr0^?;pCC#s7h62n=H-7&NuHgsejyUTtK
zJ7&{%Abu?GMFCQ0pEtS0>Ci86xySiV7MQjTg~b^zGl0o9a!^cHqCH)S6IbFK7;sxO
zT4SO))gG%x{mD~dL+?cU29nQq%fpiZ^0r8s5X%I0u=jij%DlnYT^I>kc*h)CH-`vE
z?JUJz+kG7-Gv1Tc<RK_DX-VE3yG!r8`gsq9)YL9}NMfPRHO-z--|8L>qltyXO(`40
z9?J}%Ia~UV;dhKG23d}e^sM+~s9~`?dwgb*qogPkiyCSW<me|0jhL0OS)j#^7-|^u
zp7?sKZ$+SiV};l?36sTK7E2^1zY>A<kYr@fen>`g4#|iuTA%P?X|%8)A0s<v&QvB5
z4j0<8RjaUJ@r;vEE&_7C=t_&y<;)j(Ka~bAZEx#ps_wzghJ|TpN9ZzQ9O~xg)^%XE
znaoLQz!9@PL^LfR*hl8Uu04`PnZTaNHGzZfei)x|uAkOdbs3b=`-`KIi-P|ZxtQ?3
zA{WQ3MX@pd`&-m;&BZZmQO7kG$E-zhCGOwfqK<1Wj#-O3!d%#*u}-S)Uixy6>E6e?
zo98&d<DQRk0B*y$iTSRNV_boGbw3A|cOvjd9}rot9Px6{ZFsFU=`kKFN07l-xsDs(
z;b#P6k$+i6Y|(gY!WfWY{8fkleg7pD@lUj<$N*!he^-+_!kql`ZR!X!@L$wTMf|U6
zR7aSTf4)(9X25vvZcMi$)qSrpGbhKHlbpiaR7_?bUbIkCbw1?voMp-bM4L^iWlh8T
z3CSs#bw=8=^(h*reVC=`cRPzGwwP@Px)t(1&M6?~dK_KpD_@jP!2AzWKl`Lf!_y-z
zC%AQFgAd*7l?~g!D;xUyTZ~>8$x{B9kozxxu2BT201Q{WDgetvyl)OeO{n?&QLg~y
zJC-i<b6xp(RPL3FEWH_74w@t%7<qY(nmihh+jl-T=NQYs?|oHc_IS<Cyttw-sQMk|
zp~&MLNW<mAV9&aJ)}6$(0OLp`5PQT4OgQQZn69b7h2$<HeK=hIVlpKXsF>WPbYw{c
zDyaG-VZ5=%*S97W;Ee$N#WgN5TDA@2^7YQ>v=mnarx2)mEKl34Iz4N}(!*6OI9$d2
z!&RJcxQed271gW3o{viPC!{uyr<?LrRlhaZV!c+fxq!*~@cROh*Ubd=q-JoYmk6*_
zkNUH&Jb(Vlv#NjAw@A+y0h3c)(JFhfxmY*XpC?Vm3UOfxUUJcMXtCnlmoH`?YALeB
zt={wE8ohm3I+okz;VKN<N3hS0u(~era<kV9XMA@f*~Q*3z<V|5+<j^fk12fLtEqpI
ze8Be)q>2Z}$3N8oRd-CC3G_(z|KBd;Xii<aUMorFcUbri2*%uLSg%UgpXOU!(1-HI
zz_EEn#r+P1m3Q@gVc__C7N~)$E902FFfz!27g6~>k40e}U6)L+G3Zb2{3LuRZ79&I
z9Rbs*XG^HReXsZR)T3fmtmcQOw!Tu89`AO0z01sJ_W?Redq4Y#5yMB|A{@b5JL=}6
z((I|8%^@-xuPB#f;?-t+x@Nq?rZ0foJ;jWbf*3VIa!o4CbL3=}WF}9sqeAsht&C^V
z#g>Zl61JfeG2U5fd}Cmhj<<NMe2q}IWMo8<Yuxw}yfT}UgE!0_`ga=j@~B^)Gxsp`
zVmM)}PXcjxqb}D~>a>=%Dp!jSzx1L_zt~v6@%}DQG1CGulLIr2_b0qQuwbDhNqkI)
z4{J&@vs_bb{N$n7g|$7*YScTluKe5r!#Ph$TVMSP86Ppj52Ibh8P8Mn7jhhIUwow|
zUA<M{dE>Hb16JC&&g!ZCZ+P%ymFvUy`#3)5IXu7rvDH#5ck#tg!Q^6ocIhZ~7P_0J
ze&3Gp=HYeg$$2IEOF(3MeHK$+(`dIx!L;?VK(1-Ztlx+HEv?lj2iD0rk54i=M>`o?
zoLU3Kyw>AAN)}S>TXXU%LG;mk-N~|H)a{78vGmV7A`kSBts~YA&Al`h=-ImdM4~>8
z`3SyuipC_%b5K{iL~)G1K|_Ma<5LH{Z4UJs{Pvs7&-n1cSczT#^fJ<wqXv9RDlUIA
zUc}AMF2U{FFDu*4N_P)eWF%1gW~~}dxJN90`2O_KD(QT>KYfGmPaiL32h<n7c^q?u
zqkoIOAV&XY*`A7lRPo^C6t8CH`5h$g8y4C&(`(u4QJ$amwR-5QXJ`TR{Z^>>=eI)q
z_#Y{kl6oh{$+bp@zKrMn%*Q;%vdT)d@gcb5C>Znh3nQwd=hu-Klb3U`ENgyxHObvs
z+8n6?-b6xAW>t8#Z~Z#--B4Ut;z_aT)`%*^>Jgq)L^$*}cCnCaIk@11I6hFcc$TI=
z;XTas3yxv>f$u+_UBBlwS=W<RekQAD*1Qpo@0(;X_|712nyJK9hGYFcX-7p^)@F3B
zD=*K|R<vW1s+m}dI53tqOnA&X<%NH2qJXV#99ffdbMaYPz}+=eU+V5_4`Y80Wx?H>
zAGU?sxwB<10`2ZmuT0c!ppHD$ZJ>@U1l(JsUU{g8g*q}(w*|`&O7yRWFm3W&J3~L=
zupQPH9V)MNlvcn!RO(e)^{`M!Y1M7P7-ra_rg*K*;7;iGX_+Uh-s4fvsSbJ<Q|~cF
zjYT{ydv<qF@MImGMElAn1YV|(d8)CJ)%py(j((nvRWYko!Dy_uI*YhJ4A$9VqwU%S
zg9gb~NotFjem*gAzEQSFi#UrYn{QlP9JYMvgBs`)9p{r&ly6j|Z<Nh9s$X9pTYY__
zqJ5*He4`?Lqhfum$Hp4ji1cOli}8`~>l+pA8x<9!rKrNO`7&)0zH!k$3H9@hii_qb
z!Tc=1<2}!M?uuqpji*@OT?mcGCvBTWR0I=uOy)L3t|%XkzEMUoM*A{tk-l+Jkv=wT
z7EwMz{cLn&TxqGJ&{<T>-CD32i(^WJJNXD76<bt<Rk``@ax~4}FRQpH5_{{|EUeVq
zNMr=}F>~MxS^XN-i`mj3c8tb8@3ymTkzuvL78?`O*A@{G)i*3GCc*|rWCXd0ij9s2
zM%tp|bn%R)1;u@`v-=d#jJE#opAK>hMr?zq?~~XNsP7#bhJO&Sy{J|ydx`21razV3
zFcTq^1`rGyHZ|jy@z~`E`{wXJ6&#Lq`{;Cos>PMf)c>?cUsk|@b&P7Ll@W}9%FM=2
zM*1di?77VL3_HtZ^T#)^Pj!H7z`tyDTaX0I_A;=qF@sI)70Uk9D%RIF>~W(&gAMzM
z3F!%LQd<Cj7_gnK9+tJ%&k@tY!c@6Qv>SZwd6(Y~v4`!d^{^NA0tMQeRG67v;+U-V
z8gry1ddj!QKEZmBdhLOI-TCk6FrG7_2e0D9u6^SjxkcFaNHNXj*B<%|b6BYeJ+N;t
z?ZtIg?GDw>tzF%r3;xrKxOr1Oj)`GwYb_q~DU9h31?(Nm=3<l~li)A5*wrHNi>-AJ
zIgCsy-<~x0{G{16B^`HAdv;YxTm7H8aY^%H2A~;?{hsk-Ur#Duqcd{*wCXgAQCh1`
zTB;tU|7q0;C0d8QpPJWUkNOFt5-v_lnz^%ma{0#O@;{Tx_thquQeKl%{)e7kQh9LF
z?5fG3Ix#b@Vae8{nf<krW=S*OXn$G4<q3|lufGxoFLi!$`CB^9jYuh<u_0+*yUFk*
zW!{AwR^vbbEnyWXEv5WVWq2+&b=S0{xu~<+*dMi|^4HxW<zMNd74%mXP_8@w^uBzb
zl&W$sX^q~l;BF(hX6+c9T8HXg&6ey=$I=xGM~o_=KYH2017xq-ZmUvxD&M4+%h=az
z%d%Ccc)h;p@7(isv6*{oN&<Q~f*xXz=R^0<qkN3|O|Y!r#PUC$Uy5!=JTDK1Q<GaM
z_fX4U&g@@P-%75)#dPGATw7wfmi0aN{Fyb@m(M|LKOE@tQRVMn|K)n=tM;a>sB&5p
zT!T<oYs-N3!)tA|C8A%iXg}BNtU#k^HL9vrPkS|fH{h55ufT65ek<@>)~e_1Lih#9
z0HD{I_YD7Wx4h7#x%R50Yu=!#K$ppmki%_+dj0ABOR7cZg8po7|CI8BDdoTFJ|(f`
zCAnMPR;%s=S8WO1VP8?lRXe+?^d($`A<{WnT*az=9c}-9z`$g6+oR~8-aCh)hbf=D
zQ~FGH94*ly>)lLfpvt=f-lWX4?_7Om-5&XNxSsu6!d!I8_G)%>3EcNu_4LYx_Lq%)
z-QB;jzez3sExEj=eDb#1wo87(-1Ez~s2WCH4|mt~cYf;nQ|zaW1h=j3sl30ie6OyP
zWZh8*tZl<T_SZd7n#fPW+<wT?hNSWt%+`j4RlFG_$<0RPtOs&dn+N^+)ANV+oM5_H
z>g_qP{GdC3>K4y?<#&4A-1a&ol%JklJ~+gyZK`{{`=0N4fAP3K{{gpE$J0i)WOO{O
zW<LVQ6Xu@Bo>7e_64o@vwT@1y)$CQw)Eav=Kuel8L!GsN-fDQ_+!@t#`%}kk?sbSJ
zmiLFiHh)&XgNVKSJj>fZt~Hh62wblNu*dsq4xEgF{c%KXZF@=bbSk}vbW8T|BiYt0
z>D?d<eLvb8F*?xiQ&QdTyS7)WGK~Ca_hV-MA(?5_41*%K%`-fSxE~w*sCh<&gGgY#
zbV)2%{WZpks`32T%V;DbGdaZQ2R&qWs^aIE@_USJb;=Mk^o{F5zn|f1JvjHgr1Fir
zC<b~Zt&__etM-*rzB^D4Q;1?%eHQB1oq$&{x?_EN7wLa5PJ0E%P)K)zUOV83=xnBj
zQz{NUH6y=isY!E3g(meM)qZlvq}d;qw8ur2G;>W@(%j+@mHRb=LXm)`U!Y@OuUXV0
zsA0QCy@S~2A^6ZWL2b0la0_j;I7rJq9Y?y&3hGU{nxN)dw5COOaB9QRf9Z5LP3zWS
zl$N0AHd+SG!fAAGkT&u3dxErbrN{J|we01Uo+nMakvK=VL$-FIveS}>lTYk`^sftI
zPsy}eXhSq@NQb#WniGda_>XJO1C`@CP0~gwTP=8i^x)3rLE3mYPrXI0gF-r==m_f9
zXjH9FlY=H{E=_YaTHH{Z8`KB~$yEgP!eP-t9exbfJ_*A7Zd*_X9Dh*5e{X8g;k#h%
z;Ra`F+ItN;e;%y;+~6eW%?bwZ*5J<X2W!s+p9B-{2IIVqYZ|t`tzpnD4N=LDHEjKH
z!=RTNo~~wbQieFg?3@l0wUNr-<~XoY>(Sv7Z4hYeK%ZYw5|*7;Q0xrDQzEAkQ-JMn
z^@y<PGmJQV0ivREoW<Eiu0rgA>%+<{!In{3*u1OQU==wtbHZ|q3MP5k*WZZ=D=F}b
z%$Z!6hfVQIlq+Gi$#^&sNQU-m-OWbIFjeR(bmt1MI2L5{<=8N+E;utMg-vypj1QD2
z^;j&dFmoJK@R(Gu-~fO0>%fC=rpc1a!b3{ajAsIU3zTDacZ}&(2`tNdD&n{{h6DvT
zV;l1yhExSSGn>K9e?#~cDxPO^<0zhBH~(Yd$BUDgpfCuf2>wl#m{R<IhStEXzf<%#
z2p`J>P&TdtYDz#S%P;}Ip8ESmzfkxq!T0p9IVZvh5$M$z{P`Czd|dVnZvVQ7ewiPB
zwD7BhKLyI3{v`@O9`{oQmY*j-UHH3&e>eD^{*M<v&nadw^RE(q1jca;W%%{9Um^Sz
z!aoaqtMaWD{$lVw)2|f$GK_K=(0y3yR|$U{_@4SJ4gW%@t!ZOWPoDg>!spDE;cEPP
z`X4Xrc07lhArHTv{8ZtW37<WxRsPyi86oJ(5n51bXi#YLCLtAQb6pU}b*7MA9L&|!
zh#P1DEkmzsFsOwTi!PT4xk8a+JJo|BXP>FJ0NSIE%XZgo?=~9PqvX!w{|pxPUPSaV
zkz@Jm!9s2u7-f5vJ(hzW47q{IKVwZT=*rX-y(F3}Y6!Vdqde#b^RQ~CvLpQg&JPyD
zhCSW5rcpi}znjeR{r$_&g8UAV=k>r4(!nI3JhRbF4d(~b{!09o{-pe2|G^LvY?2=|
zv*Ass0m`!+_KH0F3x<%be<}lp{~q#f(GKE%R&1ul5c0Z7-ou|n$ZryP=`Xa9M@{m|
zjP6ef<ae0m=lYlDV$oiaXMe&FGSMXO;s3{wPm*@&F3+JR`60FC(-7C-T9Ide!Vq${
zNq%r``A0)OPTI3uzKwtR9LO8(zf89d`+xr7UH%u;`g0rPd;Fr<?0*<SJ~hdE`11zj
zH;Fv^8-|b<{LAlweEVOOefB@P{5>XlkNWL`c9bO78~Y<&{yUSrNBQ$iu>~TZXUMOy
zmcJMM)ESx<UJ8r=76SVNoxpQ}V}ZEl23!opwLV}tunpn|0+CF+e!u~sZ9t4V!#e_p
z0Gk47uK|$u{zOMcd%J+Nw*yFfUju3HV<7Fl3#7f*fwXr&a1d|~@N8fikakOfXzSs{
zK<Z5ZQZEyTBR#_}0a7jrNWJrfA0zzEK>F2Mu%Y0eCy1Xw-A|zIC(s7@_km3B4ItBd
z5lBB*0GYpKK<eEKq~1ax^{xX_Zw8QhlY!Km2&7&%ka}Z))Efz8xg-IpcRrAMeSy^D
zxq0NDF8p@FZz233;qSqHj`}|WslOFS{TG2Or-g#o0h2)I3O!WtOd!jzgJ2L4eR=rb
zxWCfgZozMX37~m?H1k^u)Y}t~<$NiS`5XacK8FIC&qN@W_QE58^s_sVb~^#-XQ<GP
zfwaF4H$d874y661K-#|xNc%SfY5xWw?au_ZMSKyE_FX{Q&jiwbA}}7<3rKsNfwb2I
zNP9g0j`sEfY3~;x%Y7S=_Pzkp-bX;%dqe2ez@eaT0MhQYK-wJ#q+JJ)c1Htg_aY$e
zCIV@<Kah5#fVA61=u?2npnt?&l6JQOX?GKlb~gZNm*;}h?rT8WeFjLo%Yn4J6iB<X
zfrEjOK-%jCq`gi++B+FYd!azuI{`?0`(cdse#0Ny!yHhz_aTt&>Tw|3%~Bw*)4PHA
zX?HvRQ2s_B<??})%K=jEav*-%jl>_yr2r`x3+w_61Jcj-K>FDXNI!#t^m9M@Q~LQk
zknLm(5Uh3|0BP@SAoKl*(02nb0G$h@-OGWrn+Bxap+MSA1k&yRAoCvqq}}d7+U*3S
z-Dbc<;5OU?nf@C<+I<m7yH5gX_hBII-Up=JML^oU2}rxMfwVgVNW0m<fxyAQ_CTJa
zNxM-%+U*9UU7l}AyC(x_Hxx)e{=$8Lc6S14cN>s)-w^sapdIvofUJ+nK-NbAkb1d5
z>Wu}`50se}1H}Itrsv_%(e=6lsn-cey_0~{<FJ@|@xWd<_7}cu;lLh1EJw5q17fVy
z5_!}50z-k_f#`0u-oWYx97k)7Hv#d}cmw{NhxjUqUnTJ?B)(GO7f5`C#Ft4t-$B4n
z<3fqgkob7PI3Ru+N8k_B36pq6(vQ9PL;h|c`PD$iZ<2V<A9epEp6ln7Um@|862Cy=
zD<r;5;!7pIP~tNreze4=N_@P;$4PvI#D__|Cb$>nsQU}l{RM*6c$36$koYQzuM}JW
zq+SJ(dSw!yAvhXHekzdsc!`gb_y~y)llb-$A1d(x-H#5+?+bgQ!dt?iu@3MY`hC*I
zynmX|#yme#Xk*^qLTF<iz61R@^^JLVs@ON?(G7$)=FOW$-<T)gEwnK&&K2622lM_#
z`^LPN_bt-KJoj%&-<Y=!F!I-&IoGsZB5%w)-xk`KXU-Mcm{(>)rxVJ`n19AKROj<<
zKpevWTy#9I*O*`Pd{@%OeECkuP@nCGVVAD2Y4JioB{b`sp$p=5c|~d;0ZAKyV|UWV
ze1C?}#{B&N?pNd+^YOEUjzBpuJT3N(^@isWr^~}{hWCYUtT&vY=LhAB@ft&lk-o@x
z5SrID!ywTw6aKG=qy2cHzc=_8r!t@o>wGq9hO6<b%cEQvhM+z>H7wIs$onzhGC$x|
z3C(dtr$%Mk-$Jh^AHT-?G^<43cwdM87V9UT#u2uIhD+`+0rouUeI|YrFg^L~cRgvk
z;Yklc`kwU7COX$do6kGG-IV?u81uBp|2=8;SDth`)Vn9W$z(6nB>yDZzo+~Lll%iF
zc^-T2DSx+#9%Zukn2G<D$v(#sp7xfR=qF7yUd+-@d<<~TuYA|;_n2Pe_`E3fEd$Px
z<+?UMfpF#*n2zGLVM&{7yIk58mhtrlKdW#?doZl+#^_7u-ez@GD~8S6C-Vuvx}G~y
z@@ajrueCGo<9day464(5jbmJ~evZQ)^};X;yZ(o?=JK%s)N>T7zqLm{sxsq(zddz|
z*YT^WNc2U2Y)#|MGuFIo4>@(e9ILBE!Da7*MD=L>xWd}6lH`3sb&eob$-Pb<RSNRG
zn|#Jpw?Z@$j`VXdDc;=28-+NARL_%Ml9p$O=IZT3!}bbz!lF6!hY>ypin7FD!kukf
zzxo`Zsb?xy)di1$@Ur05Y?6nJ;JGxGpJ^P8b3eR~N%1~cglS`&yninFW0|t|i7lqf
zyN(8moxi<m%)4(e&fM|SSWU`$Q;25c!Y*pquT^bJh|e>vIuYYj8qcjgB5e-Glu1Xl
z3rOuZWyS?<`r^hr+Wi@gSG4gQOl3%2fA}0!KVZ-6Qz91K(fT~~ANUZ*{GEsIHxw41
zRrr1hVe|dk!S|~Ke7xYu#kN2tU6O|lPqf$XO99_^{ViVqw?%0V){)Q4`W7+1Q5Ihc
zMB02z+5CMfU@k)6m;EDsqwog59?m#7vnYG~c}?-&zIrh~Oa<e;{TQ3|d;5{LNRiKI
z>TvW)yX3+|`(R~K|2rDv%@>eHk2DoY48y-fj*W?91b@duAn9kZ5I~%Y1qUKNmC-Q>
zlR(n%3f_hV2hx{g!GPEU3m3#+1Uq2?gY;Oz`GTin0fF(i!vW%tg7)(jeV^cd!NKt=
zzC!Tg1Vx`VP~kU%%LXYrKT#n*U()UWEm(zuVS3kHpzun`_a4C_3=GL%C3sM95XOXz
zFBg1EaHn7!%st2-D0rpd(}J4?8)IHUIj+qSU4oT@Z(*#?_@4!bq3%d?&P(i#u`Y3n
z;H!c)f^T6gPX4u6D<+<cITbM&b0Ojy!MT{Ll73$BFTsIW)M5O!g0Bf45L}MQ2l+Xz
z6rP4jKWUfXvx2`0_G+#8*@E{7#-6C+o3v5*px}S7uuFSqVF8)=n_$Jsiryo53l<&7
z?{kX6b%O0qRrCzO*9A}NpyH<sZV^m4O~o%2Y}8TFxq?dtzY!dLy5g@BybO~w`ms*1
zXPBaA2|ghhcZQ08Rd7gWMZY6B<V;21CfK5jqALYY=%(lt!5aks6uhjv;=d-?vxlN9
z1m6~H&{M_t7c3EcOz>O5P%P*%U*`*E36=@25UdvLiUmE&PY`@fu<uza{u#mE;fj7v
zuy-FtFA>}**cXeBw3jY;hu|i`Qz8`qGQsJBiv+(A+$(qv7EEdHD#4coYXm!Cfm6?~
zphNIKf{O*W2!=%|`Aot41+N^6=Y&@_(0ZjPj7n1YgkYa!MPDR%li<68KM3A^fs*@8
z?2Q(Cw+sEe;75W9!fz^g!Vsk&CKxB^6r3rzMDSU`4+Vb~>?HP61)YMc#lJ$N=Q&9*
zcCAq7$Jd?@Z_Ew7_=yqTb5!r$=FAgE6F1VV>-pXC@jO!S9~h~5mbm3E0|7tywwTje
z?{*OIBl~(=nUFFmio3$-<7JOC5wSszz1~IwZvJ3tMLrJqY!zxhA>WtRc+{m=E3Vg6
z_YgO>^xkmNc4+%k+75H`$iv>PvfjH+)_>>B!245r?7%pv{^yW;Zh&`4r=H6<|BjLZ
zp3Uif_$fD4@%-doee|goaj^M}H?!V*5UA;*4GT0mE*_VT^F2ow7ey79<n(o6<3D^A
zsqdF!GaYBj1drQBT+&M$y94+;&(oL?yXES4{C52}!!`R+Kl{gj+hyC4Z(;AgtEnxc
zj$~^llPTwsY#DWA#{>T#Jtt>`+6!K7<@67qHgl*|@UJ=J=YPprQ9jvFZO3vKG;A;_
zTaWcUqOH#oxZ+)V@Rfe{cv_;v|B*#?G@?Vy!!+D!v3=Wd&V%=P8*v5s>Y<bQ;e>H7
zi;^39PEqE#f_#hvaGnQ_eav#1Hvk;r^)Sb+Ud(eq9OJQ@Zyxq6%eEUwl=vM{@Z$-O
z@x0s6A)Iz!4}Dct0k%~%-_w0Jh|?b(nD!jbvP!z{ZKMCIwqLH>U5|ZmJda}kuixd`
zkKf1f@K4L;VcI40h=x2zb<53YwJEZ3&VYG?OMQP!7Y5{3xvJMrS{B#2m0rEhJFrsp
zx1qoJ;*P;d#A-~9GmadtoMiWbi}f362O7!i$0_n?4!ccGnaa$`EG%*27$<eqBL5~@
zm*Ek*b!;X8c1N0BKjg$BLpl%av<nU`LouqHabiQZs~D3(RDix)X_UHs$hlmY5c0q%
z^DPB8ah|1vTd7A`dz?6S<mG(`?j7?ox6IgKmisY1lg6VmB3w9+??_wy(RJ3}f(C{k
z2{_BEwoSPYK(gDsv!OF^<)#fjq_!R?8%KI}7Pq(c%-Atsj6s5REyg73$N6PXbl}(<
zXHkg*$Bh<c;;Up_%rQ7%Hi=_!EPR$s!+Q}z>6f|30+`)yd3IK;BW)yqROjklIXZ*v
zQP!1nbo!fsM<V^>orb&RTHT-VYF>%M_n^lAih~gS_~y~`{j&!(_RTIRoaVqXsK=od
z`Z27Yo4I0iWaI1<^E(_PYgGk)&FD*`JOtD7s<AnYE&Ek3Wu$}tHlhCM;Iu+ZZ*ft@
zSX+_K#B-})UZ@_<xIFtF&sAbSb2^LTdA+^LJ}!sb9_h)mwz~6iEY8n0)nMSFIx2@H
z2P&wea#(VpVyZ_1M|LWemG)Gw(D>YrtS)A&(@!~&pz{BP15g88`p3Tr&=DQeQujWD
zN<TXdU7ViiF*u+KjqoU$E-IL6oH(d=<Ng-?>TxX7aXEyjKIcRI*Br}qd=9FzToCuZ
zYaYvEIc)VvU)Hsc$+0BH><KFc#m;=ZFN?(j{Xj%MwpM+R4+~wmMUQP*!dv`#I9zEG
ztl^UjXC4=SRQDkR9vR3OYY=*mZa%eo$RV7^dUO*G(C>QBV-NRi+9REl#vJcCDH5z}
zPCCf{oHQD9(hI!iq>5sb@O-<%&z!W5^PKt0{Gpx$V_K{{vg4_a@v%DIFDe91Ed8jQ
zA!nV&Q9r5BI+^2i?&5JeMbc$D-qE7dv@V7ThpU)>xQYdbt5|xtiqq;=jLmY5!%3F5
zNbF#TGm3d8fi1%O8#j5HX-G!ljE6}DSR2(9a734U6lA*OMLf3nipiNp#y61Omzs#=
zrTIxu9T}BvkHx80&V1bC@RFClWbXZ0nA<-&V#+O#F=zmJ&j)KI1r9k{I2li}h9O5b
z&xeG3nap~H!H*F<ojVjG>XFq^JdW+3ID+S&Jq+icIRL1i8g5~A7%Rhm&sfTyVpr>`
zx{x&20Q2iuJTFo!R`LphzS^9ao}HIdl3VDA$#UY7#o>6~Lqrc>u&i?2({vqbiqVIb
zOXKrtDL&6(O%#@eQMCFBWUPMfpc5sQ?wF$A49tqYFGU>Lsd=?$Rl48ZQ}a}&?!i3t
zcf8eSj_&Un599srdRYkcZg;&51bnaCWWm%~%OY!SF`4*v9k6N~(CRKElm1loVovP`
zomO>J$BBah-@{kgtHVOTckt_Fq3$}W!-aa(k=uf)42?SS$2aQ8AK$1We|)2kYR};F
z`oKh$Pc8FsucJCF)T55-uuyj$)nTCSI&y!=FIDvahf(`Zafg|oyV_!~++wVY@XbCu
zzZFRvp)aublxW>=lKo>ZzS)Nj#fzU&4toT4eXz@y`v1xdME=_|aAf{_&KhLi;m9rI
z)I%-Q`3_O^@l0AjtUloBEYIGp-Jis>WhdkDty*~ZKKR<=Dmgk$>Axr^N7$zRi*j;I
z8rN}rVf1MAQ+}%CpUBCvX<YwAP69P9zEYZ9Fc}XOa<D2?Qf!}KkHMLXIJ^N<8J`=C
zkMuOVpR+CNsqJyRrj<q<dOC+QGkZLI%yAYLVA(2JE%Zn6j6)m^;h5^mDH$)1RI)OQ
zUD<r$#g#wKy?K+}h8I|vL7Ko~7i<(`m59gDJM?DDkwKipu9uSjZG~ml`>9v4jILKt
zBRM52!k+#APagE=5WY7Y^Qa7^J`5$Tj*cJB`_`~neI2X_V;k1OXv^`LN1t%G$Jtu6
zt;4Wt@tU?(Q#o|Ykv4q|)`8cG3#K@Wrm0U|iVx9vuHB};k(Q0?1v}O0N6p$@cH1Gl
z9m(}xyx)voz>zgg8PZP%woiaLGI1nJi8@p|u#f&NO{<?JwM@#(p5vc5wJMBv($z&*
z`;a#|8)IX6)*qwZgo$$NI`Fo<8YTrAMj4|huNOLv!8aCz^_M7J6KJ9z9=`E;A>NsD
z-}nM_vL0^!leyqH@!y{dZvS@Nav?8m{L5R^G0VkqZBfT87ss_l$=f&o@)mW>a&cT+
z)G^D&p|vR7IWjR`&BoTLI7z)|k}DsFit)Z`JYKa~Y%ME~Rn7ZjV$s0Z;m~W>&ZDt2
zr}x|8=9K?0?F#C>y=Faj=RLF?IFIJupFX=WdHe3(Az0dzzE`H7O>%3uuywc0dTp&~
zG-D-f-dNO|>wmvrzk4I=!#qqMyf*^Y6Z5m7t<I~XO1!=jR|@hiwx3;8eHF|_uUjz}
zxUplY=Uzz0<4aRJ@ZNUX5YnxB>@Ds0xtj4z$Nk*QNZRx?>VMdK7q}?TGvWJwW<civ
z2nrrB$$&NugVDrj6w;;)nsgP^R-^~h-GXtu0Y*(RNvlZ^)MOVJOhl6&VBex~yJ0Y<
zO`?r<_j|?I_A?=|McTC6e(z5(>2_c=29p>_CA|OZdFB}g7>r5VJ$>=_!<l&w_u)F<
z*LB_3{XwCi;je|`8<CfzOSG}-W6oa?y*}pL`8Q@Sm@l<7iyg+Yd(PUmbMB_%qw(+O
z@11);E>sena*vAAi>jG=jVg^l{!v;`$=M`h{quZH-r~Hg&@<-m@m!NXyWHeo5mI^6
zy~cOrcj4_{E*$!8ezRo{wMThLWh>RxUr9qTs>*yuK8uR(TD!LBYn#@7?d$p?s;Fpq
zduBTs)RvTgzxcFfmcTbIjQGE(Xq~=UZ5_2e<=@EmZoJhPm(94X`aGJP2NM1l>L&a<
z+#VHS<=@EmJfZe>hTgE{YD{tHU&7E={To%-@7{3F5CBKE_lr<_pGz`c{LYB>Ml{EG
zLgltYH%7MS`kXP}1))Lxp}_cUwj;QS{5N`hx8)Y*4n6VZRmS^(P5+nnB?Eq*eVUp%
z^jP>?QPJP7xpz(YC*vL7-ggR(hD>}EQ<z`y@nsHo3w1H{GT&r;>%YEc?Y%|!ZTM#C
zhQBQ;T6SCH1A9X4?MXDQmW0|XroC5;OT(s2DMUH9Ce)XcZ}LY?PX45c6D^whI=GOR
z<hd*k%#pJL4!3LSH_*L2{dxZ6-=@&t0Y0zg8OkYs=zoL9Rr|mL7XQF@RS!&d+B8qU
z{B`-1ztgJvX?AD2QuUoyTMLapCVy{#?tl9S9?<*)i&g#GR@I^`RRwaLGmu)ktjYRw
z=6lRz=OX?6N&0npzSC-a?+iUV@W4_3fK}B?8^##)vGfl-aICr2TJ$Q{lLxJq_V@0x
z`umDv{1?9z>wo)m;~2wu|G;sLF=#E)x67vbDSca>QMmOEyQXe(C$-+;PErL9#*n9}
z`lYK&`!Y0}uk_Zc0{5YshK#LC+BlbI=c^V~kG$GR+0>nf_+F`O!9c7k?6X>1-nCj<
zs#R6N#hJ>VX7vnoI@N$VMr71ZH|++V)cgVKWac%w1+q^L$XGaP%wti7_GC|1&O2H;
z2rtYzr<JD<4i=tat^&_4Yl;Dr!NDo=e43r-l_y)CKW5|jM!Tx#xWp;%u2p`s&p@T-
zH(~p_-p-_!ZH#Z<w5ozwRdq^W7&%_^JsEf8c+Ih1j2NqpvARNIbqyQq<WXbg+>k;W
zW0mK-m}jfQ7^~S|pi%*o<jk?gyWKi8-hl`H3VePRyxtCeZ}Y!**J3~Tt`Ff}M4e6>
z0$aX^f2XOmU&?$V|Adyz-xt61|IjXU8lvyP?Y4HojR6NwzZ*LDZ@;>45^dfC-Z`|n
ze*RWf|JEwyulY<>!Qge8@IbxNa$fEH2an&N4^RI-i>H4EFqeL+IHG4Szdc%*2l_k5
zd-`1}Ip{Ht;C!rk```3M_L-yEg2%YWc<KipSi~4}nfq~*)*lPNA41QJbyQm>@6dO0
zB;N?H$hAv%{}}jbz|lgRR@#nX{;}|?RzGO9w_mizK-1QiKIpn1zIlg!-hvhlycxXT
zygjv#wjL8+rR49<2Y^9fyQ)tGHh=V5{M7=RnO1)%*Sf6JTFzLfw!CJY((*d=Z_?nq
zzgy%#{Z-YwC<Z>7sp>CQs_cs~>d-sZluVa*LDnB9F}EoKr_?Z<UgJ5LpYX+*kZcH4
zwq}>8z6AnP8B_E2J4V5BE40YmfaUGX_crFenE5XP4!QnIcmGU>>xo71__+snbuwOQ
zhcmZZGOW4JUYrSz$1@h@(8V0iFbBCGZJb^24Ho_yew6z<ei&PZW{hndu$ODm=4ImS
z(%t{UxHQIRVVqX*0&c9}1-g74oV*53&VZAys5qJ4hd$VeO;rzF)K38yeMKsS3xiHg
z*uT@^@izhc7vRf#zpAny<CO8rviVueIYduW!Z2^%{*_Vi%oTX*w0RrjT+DbEF>Zn7
zPjy&U1Ix)eEDczlu;e~_?-R;jY*GCJgONBK*>~<GWMBjwqm9di+2CT;F8B$+Z}v-@
zI$T$6y3jMeDb;n=*DvIAtt_dQ?<E(!;qS#4eBtk3zOX<1{qq;v_@1ZvQgbxbYvVop
zX4k5K)t1=<-7V4J0nL+bLvPs78yWT``6^u{(Z4Q-2DfYIpXhw`4tTp5(m@c%&UcX|
zQ>(yHv4I~~nn7ctr-~9)FQ!Xjvt_bxTD)q18+vQ9Obc4L*2y?Tf10!}{FgR3c!)NW
zPgqiXDOz%{3Y_+X|G|0c@Ss&45&2}iW9Sm(dA-rj<ZwHk$S9kd-1eBo=Ci43Z7wY(
zD008;{lUVLPv-iySXG~+X~8qdq!MHqaDX4s(a60Lho@iemyYxFuW_JXH)kA{d(n6e
z80oM==O?41l4bnggeHo4*QKV0Y0lL9@KN&MVy%57KfDDz1y&-PgxAoQ@I-Q^%=I-H
z7uR&T%x9~n4$55Q+A)jriC#Ms(yQh(0}l+*G5w9wE22lF4bd<1X}%|INxMdWM!&D=
z_fup%^kZBbqkYD0@G|e4Ix8%*JGm$A4j#8Ke;a&eM;<t^!z}gha8LMXxJ<sfugIo)
z_kyEli)VA`4<0RWX?Aa#Qx(4BjPVbyQb*o;G}eF6V)4EH?Q#C12URa;Tox{}se^9;
z50R-dzqe>R2i;UWUKM79^nE9^7uNST2=3+i5S(vN{byb?<+5ShiF^{=h;5>`<)*EW
zEuiuJOsEYVZoCiO=yU4g`2cN+USsW;EO0htz0udmexwi4qkEuv=A13_ka2pT+dbn{
z{WgngTQec7cU!6k1`iFjX^d5u%i%c<;Vha?-a1ni4m^+tE|wzmmiWPqPAl70-}9Vv
zw^4L9gq>W8jk$b=Dy&ZQ9I?$%^X;)}Wlpv#FBupttd8;YKUU~*JHWZvoIcF@Wu>KA
zUVEIcSaZD^u-=?`a7*!XRhGNHXV?U)K3!|QwaZ#{tINIa!rtlFeXYgU2<|nx?yS1C
zc}r18lSTEGBEM#QzebMI)$LBR59j;mPp#4J`kqQ#b4?>~mG%d*zXm4>O<4V}e>=tx
z&gu>L0vGtY6<kDv!5aEE<aaVWJ{%U{GdbEj$EJPwchaY-LK)|W?Q6~C4}Q;&y=B10
z)1QYdE7I)2y~)GhJA=&=ZGO?-JvQ;m-c|oT{s!o8U~s0&9^9=q*<z{+0?(<#8Q?9D
zqq3W>Q5(fJH}Pjlsg`4hS#z=8(P|n3KC6zW*F*d!_JHuv7r@nrmDBS}GqV0l_{};$
zv&wRv9FMHiOqkZLwr}iWy`fsuhS6HJL2Kn>(%PFpC|ILica2I*zh<e7`BUmh_e|B_
zwO!SZ9QSqfFF0mVbI_FeQRxR+v=!OS7?Y#If1CmTt>`alN91la-0ARlsR5n-ty=cr
zq!<GS^I{AfxU}q%GUomF2d8MBHP;A#rTuF$Csd$Y{=w>R{_QtAtlF1%b%6_Gy*3H?
zX{@h$d8c~ImpW3ksS`C%y1ZMS_OEHiyDrtgZ%c7UwD(@)J=!;Qfw^vp{2l%txyBZK
zXy_fSB^~;aF}l>G;CAHEzyrC+s~3#51N0{MM0d!iQl2B|VSW8BYl>~5b-HoQ({HTJ
zL%N>lMPKWBpYJBVF5UgF$U==i@DV(K&3YW$<G8JTw0^p(&s<9f7OVOc>{EHqSSwik
zom?~R)6R}uzsy7I98;f*oaell!i!GT-#J0-1=i2ZPv+6Q{ja0jsK;gfw3x9iVvJ&+
z{^SGUAZun57S<3x$AX8szKn#6*f#Pz+Bi*^jkM(r9%uc6EMh*%HucGC5?8B<Hh8d=
zIoc|wtg^4Rto*!F%}=!0Z^9py{ENwIe$B+Hi6z^r3rZ||HfC1XrZ1_OJSnf@i@Q0y
zvONv>Ih8Fx4xHC%w)}YT%o&dL2Uf4^J6pP|V3~E#MsG#j^f}9Y&fxf}0<V^k|ATAW
z8l3mLR;jPL=EbF*Os%hYrSa^(odxS|ZP|GJmbk{cfv<I}iL07ef4eq4$1=gY6#Jph
z9_OsXPQGE>=kni7QAs~^s)dPLv{lc1_qzp&Tau>NE&aSR@iUfHuAAnSmpD}6n^tG$
zfr`Y&H>?Ty2d+KYz?dcuYHH&fQ<_o_XbE}erm6)w|4Ws}A$xMJR^>tTfGL~YuVnf%
zul2a|DxA}i+1>zh;b*|&1$-fi7Bw*kK8ta9?$4N(d&_?MlK1n)uR?p*^E(k3@LYXj
zg2R`z$m5>7MKO;=FK5RW)}f>8<Ejc?7FlY-G_9(@F?e)ihTAsX25d9GwWFZr($S5M
z3di(W%WIuI_$cy#Ew;+eI$&G3x~#AEYs=c=W2*`dXwLk+YhP)2WX&?)Nj_(9c1=8L
z$1aGiO?|1tv+HT#^T>CPY|N`jXv`Z}+p)s#aGnH?r?q(RHs;d<-tuUp_S%;kz-Llk
zg|;eZhnlO!tHNdXxh8g6<1$r6@pIw>@za)li+y_C@}<tm>&488^KKXB#HzVIfrG#^
z1dljA!|*tn>C=Em`h&njC3;_k=H9fb%pZcMPVkiY$<~Hnyg7b>jd9dy;xlW#qX+tu
z_S|!8Q*)S?6B+E_+AR8<^RTbrjg^Nt-ktnN!4Ljw@5b4&u8BJ<5~jPLnE*7CXIDvQ
zt%)r~n$w$)ze~RNSmRsLz-1h5*!YW_hxEHN)Ne4{FY7e=rN2Ta*ElaXYQLWk^=qSF
zFa7q=SEUxG_bcCn^owsVS;j6j)%|2s>VDwq12;bCY{%dIeZl&_`{#|7;N{$PO{s1z
zzRa6cm%3E5XRf>U#Z;SS9|rRxo?CWpZEEEBWqg&Pwx6QyI@(?a@0o2kMYLVZy0etF
zmqlq?Xf(3joOm_&WpL#MHePVTnDV8c+2;of;mKh%VpD(jy@XdhyKMdUb~Gz&(pM5!
zKAoTrp465-EAr%NmpbVF`>Kg=A{#!BYzXr}q+GG9_I&2@@+Yba9)<4D-l`_fKKF1z
zT}Ax#x{AbA=d`%|1KF;Lb+OBxbrmtI*25q5+)LjTvvNJp@6j|b{^^}w;g$7Qt@3Jd
zKJQ$QA9*nSK*gj<#o*}12NS0!F5Bre^-|hziu<-!v^LgNsK%UKG3CABz^f&-SsrvY
zIv;Fnq>cU8E7y;Is3qoiS`+i@(pwvf`SV`;i-tPQ*^>W>Uo<$Cv*k_3gKX9HXX2N?
ze)v4Rc0Rsx*Mv|0yy1MTXBTbm_i7V-=dG?EpJiNcA`^cAZsRQz@^`|&uk=@Th)z1z
zUisYIw4XOrRkSy5t4L}r=QGD**`LH1s{YV;s?-0>h0as2T=3la=7qE^t&Qr^(vC9^
zR!vO0%>w-=c{#_vki*)2t+Y31+~@Ou@uEs{jZ+(O?ibo0cuePGcg1AJYWH>Fdl3Gv
ziBp9qHP0@QZ$Ghn-piP_=$1C@@Eo@)FH1!S#;EqBimHO1E0kT!fORc%^MOY%cv%k~
z=YYop@Cvv9FY)<a@VGxV-{}qEaXol^x;|#57radXj_1MQo0`+-WbOWQ%{HqQpHL#c
zfnMlmCG>N$B5C>?%OA-nRIzg|GWUj)H?*Bczm-?~ywO`Rq48*aOu6t=q9wkq6FGCf
z;unoU&AI;ui|fZPYjMsuta170(@!>R;Lm&Q%MILXiTlLM4cu#iU-q8`Pd@rzH*jCa
z`hjnBtk>e(HsE7DsX27L0`7fv=$AS0!D-~gf!G}lZ~VdXEOPh4BNZnbTL%_*2p&#?
zhtpbokn_z8m+^ir@0S@ew?1zmw<G6fZSGdq(4KcHcbWLui+(*Ra@8J^tKcDj0{B?1
zm5W>@#<r9D^(WgieJ^Bt{EHsc8jDmy(4C+PH&h&JoRbyT*kzrNfAZR64UfdDg%5(a
z#4VOpb02<8*O^JzsELVNlA(b_A7_P?pMame=;Hme;~LNMp1=bhns^$$c^17159GB?
zLT}Rlx;F-Oy6{bj(3^|{z3I=Zh;Ky31#7rhN}me*rpxNmX-s6SUA6ue+5TGxc3@6!
zNVcaV+u_U1pKLvq`8WS`p{%?0LeJU03yudJjk9Lfo$?*tcftGBpI$(g2hU)inX>cj
zAJk1N29|V)o;YVsXb~MI@^u^X>S^TaX)VsX6xqKtU9H@s%Q}bCgfB8Q=()DG!TkNA
zL(LD;UhTlrj&*syQ|l%jyl^)5*B9z+ofq;dUPgcBcf@sWFIbj)bmKBDZu$Xa><(n?
zBhc(=&FMV>ZfB#D&Y_cba1DJ}{zOv#{WakAMf7SO`k14)l1Je$$>D1Ue{;8J@OVP-
z#n%T5F9#<dJa8p&y7SKjC%eUfOUvo+p31EI;f2gICoj})eh1vV1WfL@EKF*|uGCy%
zm`8;Vv@Gy({$f{wbJCuTo@<?rnc&l=4dF^;kBO(JQy(pu^MC#cxF<{(-TVSDUdmkk
z6_!=laLLi`*8nrQFF0^6sV)d=Mn8EY`k8&|(Sr3wPa61(58;n@U#zgMnk2YOF?8X6
zt@XF)!rzK6%mMd3zZxu5eM7t(t(|VhDDCKD_~p)mS;`ng*@!Vbef%E_Hf-K&%rD89
z-;4VEVpciNJX9d?sr?Y|=>3iH-t6n@3YJejV9Yngn6LEpVnysKC$e7pY8lbj<=)Zz
z8sojEe_37dbo-%=b%M8Ps(c%GGv+mJl@FU(`g&<ZU(w#N>#!K7!*Q(lYAVLB%16#h
zn>{1ilzTGHvF>9N^ou?;KZ(b&9<{ZkqgQhAVawV{{sygDd*pgl;#YgPFMi3+nMSNo
zY##HwVQa9?4c*h%bD{6m=rntZr$4}NS-+*>8w*r=vh7!^Nj*+aKe2-HCC^khoS=Pq
z)|MpeWy6OiYe8geLFe|?PZwLNZVj+*WewC{e5cAb*QJbA_aVx9d1NfhTx-icb8O}{
ziOWaEE<eoth|Bid;$^*=^Xka9&3Gg2hsQOt?~!rS9AydaVSN?pmv`7a{iN3<w-6s-
zjpS=#-V$GEvP=qkSZ{s9lH8W7P4+b>u$Cvb@B;FvS>OjQ#lI|LYnhSjkJlV+N43ep
z=DFW$I59AI@G0z#8qMKzrK?`iB|%{Q2Kc>^zVhiuY=TGVCr3*NZo4V}J@dYmbprkL
z-pM-?(0i<Xk|+HB{$0Lps{Rq$JGm8m#yX*;IJWY@o$)U`)f$^~;Dz{YPbFHk-Zkhc
zmo_1|r=L%I#RU&^E@L{tn10w>vCC&k^trV}UxJp{mWK_A4dJV^U`z75>S50%&%^4{
z`E>QnUfMaTB?k90h99GU6H+|8+&u5&*|HQ*R%VLIIvI-(pXZ+CzKIJn_A5CK-7_ug
z$I5dM_}i}9vtr?;;*N}eEbg$!sFflkI7YSHy_Yx`GC6B*RciNLs@_e^riC?T&s{28
z)AszR2b-e^xhiAR?~_|lCilH6dz0#0_|okU7i3<mHsz?#U&ypo70f~|lxaqr`}yuo
z@uj+We+luk3{7RDW3xAd`vv1w{g;V>egb%x2(Dw*Gp+O?F{6?&zVYva?-FpEtWERD
zb1B-iHrDq868k&Dc!j6Te2CV8!G**KGLKqpL0Q+8^87I!=ftS+vFmp5hwTf$?8tsP
zBl>~AhxKD2#t;NY#2_*Qz)oPB23-gY)<A1AhxyhNpNp8>8QzVYtHg%%`SOg&2YJRe
z_pydzV6+KaXEO9zZAtOj;SYCjQI`9dTKVcY)h_n_T4>{pbwQ@$o)%-svV-H)N*%Tz
z(3jbd$e`A7D(QCm%cTDR{B{-|>b5#suy5LZWhGhSL#ljSE6=4r2haEzPhHu%tmVk=
z4W->#dD-#P^B5O&^vqVCX*#6JzmQUU2l(ynV!l&&=a-8X>bR7C#djxh$|~YAwamq?
zs&?g<mSpjMyWZC^RbE9qQ#8A8EAgN+TRgiIzP-pcE(gcRx$Ut`$;Spa=uJzB0)Iok
z2+R!lrvU%Q8w4)Va!tBtE?RHqoBUVc!CHG&L8kE7mGB~bh%NRpFMiC6|08+v(%lyF
zc%tY1i9VDV@q(+0ciGa4ujwWZDR~2XulmmO@3{IFicicwaBoMZTW!q4A9f?3arnsW
zmd;c5S3J*E5x>g7CpG~+hrU5RVjpOGp08$oVVkYmdvuvOp=B0+Id?_zF8p?~&g~U>
zXiGcMaF$qwt^K}^m-<hiLML6w+iGvi8z|nL-&|ARe8RsGU+2WUxlYz<#U1(UW0Ue~
zVv{PdC-a{1rRG&E7C(Ny=`RcWm^b%q@@_8cTUmbfs<H}OV@bt{M%zH1uXbG3M7I{_
zT*10$o!CgTstRUnN%_<8fw-;Fa~<8e*}fU{ea5AZ<f+zEr!9^k>Am<<e>ky4vpBu@
zLW)=`7w`ST{l0~&@C#as^C&*31J|g+bBmR`ce*-qp4^*w^pzWVe*?anH<9Nt7F%ts
z=eq^B-}B_gacTcp@X!By&&KhrA;+_ZoWdIKUDkM0S!ZRj&N@0yl|S>drqr3}uq{8X
zDfnvK6ZqGw3NnJ*3IYp$ywT43$b>;I_Ds$v@P{zQRQmfD93&5xuE~19c@@60X)VQ8
z*Q<M3`)_6KpI*7QG5ylojyup-x4fP@Jso|Z@y>fZM<6b_i@3%b;u^+tU+ZYVhLPt)
zN2OQ(Z{Gd8j$2-LOqaD~dSx@e*Yn#x9p6`Sy7M=wx4b@eIym9`ulYV@x~y;0o&PW2
z$4{4>f^_H4_&#pBtTWP`KjnMu^hFPPc9ZYcF7VE7RY~71ot;&w;)7NA_s+OHM-G7R
zersw=5%$_sedG$*VtjV|QyJjUaZDv)W7g&agCOtk=h<4`$0q3QPQo4qT{}`#p^xi%
z%()j`-bI@kcDvrj61&6a2(@JiwUtg=U9@$lw4*tKFXBs-G2q`yI%?6pXR)QEpYJdS
z!4rKKF45`47VKi}{WiIJAJ*<DhBmcvMr=>?J8k4Ak~3lCl$f#G(fOX2?p~zleDY56
zmBzZ0!FMVBNnVnJJ~N4Vzr*{Fjo<ma^euTqA`grl10$Axj{84k&H-y`rX6~=;mfn(
z%d>61v(LtFw-)1bX!bVoqwT}aam4c7u6pmpf7_ji4;}g^CeS81oNKw3@e`F)T{<&s
zCcYXQW9TN{kjWa?SK5<R`FmBq9$Kz0&CJT=y?m}eQtHjRf&O0v2Q{U$vcx7Er2Tc+
zo7Gxtwu^V-i2-HMRy8(&i4Tn&gd4Hxs<n8ZoqKll{yD4X$ZqDNJa_7`XK>b%%-X<Q
zLq5wr;&Cmj`8?$4Ti8=s{H&X`iyIl`VBUI8^ybn&H}menciMvQ)KMY6rNteySeI2o
zGuwf|tXRG;SG^_pH(m8wufS!ATeZ728@Xim;2FmI=6FL^B!ZI^{%)nuxqJ$(${60D
zt!`pSr}^~r`35jN&AZ2GYmOtyck-Pr9lgN%w3ZZPZiS39*gM^GWG&x&ba*?0vc?0x
znYNz_%-vZfz|#RNoes4!9++$ZrjM4sku?Ymmjm}5rE{|0ARhT>>4vQH`n@^2-Rni3
z3r_2Rc`Yz63gIb}Hfn*nDJuoOYnbzm#FYf*HPF{W<|Wr}=2PZ6kIx@+U&b1MAMKW;
zd~(d4HspN(-kY!Oe7<X+$L}KNFn}+&d%WieYp3$=Z#Sh{G`mCAse(U=3EPPSyNLrk
zR;!Ico~<MP>(YwLx6Z909##6RXKqb{tzzmb+A0r>m-n5HKv7k}(f6I@`<|^%{rx@U
zV1)9vOu9J+AKyS9&FG76#u$(O5cwsvYT?tQvm2R<jNhikJ7wJOSQA6Me|h^_atTe_
z+U&EKwLqa|&-3@PKD?LwJX!b2y2D<2Z&nWLfW6%BrY|=*>87v8STD>c&k=q;Wy%{_
zFNwYWHqXi0Fq++N$_()tneWX2r_t78vSt(*#G^BR#&;F5XF-D(&>wn^x%nN~eBizX
z@zI#M<sxegSz`D&nzy_9GL(@^YGV%q`a{pZ$yi;|XUk3Z+2BEYMy}tk*?l5wtjOM_
zHr1a;{#c7u9bCe7^PQZXTKRE&+(C4j7oApzF3WsyKYaSNj^z)>O`pAb{igVHu1&Ka
zj9Jx%JUM#IUT(uiDY}-NG-BvW(FgWkS61`(qEUGiRq)g;&_Va7RK4ttkiPbTpUA$t
zv4hO~0<+&0^!xPc4V&iB@0?J-rz84BrWUe(Ov<ER(Vfyp53*RsByj;#=a;Q6+mzYm
z+SEz^_?cTwxgBk+8sqB3<`ch(>Ay1D>_(ruY0FMq(cYDuL23JPICCq{vl1V1r+7|<
z<s-R!g3BR2QQ9Z|tN{G$xIWhp%-Zal!&eCo*GAyb5i<&hz1#7Nc@KZ@l=I>J7lJE)
zb7B8AzrUd4^3tM?yoxsPxk&KYID2ylpO<dy2;s9g!1#e(?}-n<XD9d++1ouSjL%*x
zG9X&N!|)n025{T>^yUz5Lt_B9;W1nWx4pw~yE%kg#_}iNwzo!bOIsg=+sp2KSRB{>
z`b^dT4te$$p`ku#@m+Y<q{F~kd;L}T2!l6h{g>ux{dRm~gA29(?oVm`gI4R2o_*u$
z^W^^iRDaL6E&jnLr;~GQIr7KXto3Ev<@yAF4|^I0pG@=*?$eI+%+x~9$M}0DsD82e
z2A_=eiyfUETa!8|?cW*(-%>}uqxCJs);(pnr~2-|mo_h59l7WI;*Q<O!&T$)(QH$_
zGoX7L;}KhRFF9R%J;pmSW*cLgwE339@~*u1T*Q0Za*g-MiAnC{*)D8P;eo)Xa`DMd
z3NG1R-4I}oGC$+~RO9}3_Qo(y_D~%O`0$M@bqJrh;k#wN>D&|lmfX|z8oDU(56qo;
zcXGdry%f^VkFbdXvm)A>7i#OeP+Pz#+!pu3ZILr9u+he=B=%?2ck(CgiM|rwSztOg
zriNYsCvsgrWqlyuZ=TSH?=YpsR^iz_37yl=vl-}Xn>HywgM9h>=BoJ@v1>bLGKM(m
zbF%I~vWd?e-*lJcd^5Mm`!@W*He~ZrhbqT*C=@+)(K;#fOV~Cd+X4%7`@84m>Ur{A
zz%z>+d30KRlVx&{e9%H2wxO}wSQm8Dw>y?`mCnzScbnfIJctkO)KvbYoqTMe>r1_d
z>()$ZyuNhS;qS19%frrbVH2ezJF^A`=Zk-}2Rs%bi|%AUMc{^913%zd#{WBXTx7r9
z-bF_O*2PEAH_kWzCHF|rszpc0sY%M$5}i%N(e~d)e4Ec@9#vSR*}Ti1sZNzVn)NxV
zFo|)UV_a|i&eMP1nvt2vTCNM5j{G@nh^kXL%I19qJ1&R(4<DarG|l<M>N^ih{wg_>
z1v$#$-NE%r?&tIQlht28yvQ@t_nI{(bFRhOGQ(mCZvQm>#$aQ5RH3X}Rz6tVA^qg2
zIPc5M5B}*Do98#IC3HK1cuhC7cAC7+EbUtjJ;3w}z|@@!T&xShjhgsxi&XtB+IJgX
zoWZl?WlE0irG3i(*WgWZ;nVRwe+pc^jm;DZtDZ2d9M1F3+#|t#xktzyaSD94g3o;H
z$Fuyc*T{#dIN&&{IlN`?=o`T3O?Zbj)yiILX6AV<$$1`o3f!%1UtM-syJOwq9M)Zu
zcPqI*#KFDSgU?EBg7+A35kIWhX6LPO<S<R}ioZ0IYk5Ddy<-_P?A-4;vQCR*9C6-9
zpQ%ZG9Xy@`kF3d)p4MWVE=z*9jCO4J9X?GvgIa=jJ-;((Ba7da;Pr0sdX%<*@XVvB
zr};bwJ!|0bO~&5q^z_fgXMYA9zh<44`4D*cJ+b|N2k(<;<0yDOKzlh_tk=uuU#VE<
zq&x09JYK)&)bBNg?%l<`>$o?advC!jM^(H|1E;w!H1NAG|Lx(s7G39i%Q`(XT}^69
zSL1`n*<Y0d4cPenK7FS{12TrAYJxWo8eosP?$6G9xb}{Jg}!CnIYJlKraNrf6sH~D
z+6~|N+3QrKP4Oy!?)@(jw-O#(f=wknCbTn*$5vjY^Vnk}c<h&&8pdO?KW8M5jpY0J
z&{E(ZMBYU71wDlMd5pdentk~sSKZi$6De<npSx#%Uf-wFg`Aasgl50dGk6f$)-T^}
ze3$tF?^D>;{cdDgxZm~092-Z>QQrGXz>p;`;Vai=$sh1-(Wb~keg6x6OCKU{%yw@A
z_5$Ba?8&=`e9fH0x{x(ZKA#^XXJ*Yd<V@Z5!{y9@S^qI|=6Hr7X99d)PR`tdoH={i
z)4vW}+JPzbe<}bU$a;1b@;M&)d|<hwF&_E+9B^eVQ{RLQDDt@jd~OwZy(aPF5I%n$
zf~n{MU>cbB6~8>wbz1dL+I;=tv)Ch%uoL+_TbIvq&ZEekGVK3Jtl8e4>FKYI*t4}S
z4Y|QsyR2Hi$S~1???LZ|ZcYu}iL8mFCEW&){-HIOmde_#p+R)_Vt7lJfe|(W>&5<b
z^z0~GA*9RFtyA+&9URymq33CvxZT09KBs-L4PK2g?181o1l_hk=j*n`71{%03)sk^
z7diY2a%)}`c+4c9SaOCV=bTP|I?VMs8+ydFSHAVf!JEaVxG*p{<vqsvW8(aa-rdsC
zg*@zJP6AKSn*qju5xid1b-mzqa_|ZAivkg2H*JRi^Afv4?1lig%oiAs^zk=*if&!5
z>(+R0JU$)Kt)e&1LtAemcSSFBqFV*m=vJyHRGo5#^{dkLE9)TVvDIr1%l<Oa!LG1=
zRl00_ZS}gt>7E(BGgd45)zUK8q6PO|M7EAoz18?L6f$-0mf{ZS%Y|GP{knm%p*IRj
zV$?!Uj9TEr58H*VJ1g`S>*-%gzNEc$URE<UP!L%t{*XiHXB@%(`K9+|Rd%cLbgnNg
zy*bOcR+5FSl$4LpMArV|Ulf0fv}I?XWe(4GF%~!NKnvN(m?M&Vh3q_1&R7^@(r{a8
zUKTnh`6BS7Ai%*FE{1S4D*{K@jHbP)<6LkjvfrW(irg3Z=)J#k*E;NE(E-ch<2j}4
z58q9W_W9iTKJuCxPi`&r{c`K)d^eQNK5W`t#~Al~_RtFdhwb9mLbMyf*I_#2UYPdb
zZ&@cq^2(Q>HL(*#jz7j&0^o5zxet*xodr2^IeqgcGB}z%ID>Aj4#(Y%ICM3B7-_o(
zKMb+g{(0bpy~H}co0VEvrPP9I;<0vonf|hjto!)>7I-&&Dp&6RIbjhyJ30S^MIEu>
z@33k3S+7(5o#04vW1!=phw%wdh3{8#e>?XljdB0i+z0LfeXn?w_gSxXf=idWD%|$q
z;<(H11-~?2^*forgFpGsSoBY^z2vvphStz`{6XxQG<`e&aq|hFTO;9R`gA2e{c%j}
z<CxgTF|m(hVup<#%B>2?c=X)IF)?KJ$1$;wV`3l2#KaCw4*rM6#H|0tbF)*`k^gDA
z*{#HcB6G9tX}N^hRWf@de17cx#~cnlFPq%V!ZPx*zc{dHcRKl{E_@R&V2?M4*9%78
zq@TQOBL`w~Fpo9tORP<P$lAf_AXb@c<Yk{FCVP%pV=DbzuQ_~ijyT^A`l)1Z&$gSE
zy=UH+ywDZY3VMaLR-Gl@$KEsF@_5g#N6E`hq`gEwd+{-Ll9zpkylgct=YS<)+f#EF
zDLpT{NJ|K|l9&C+?ViIMZdZrNU(xfYUu69=Dt~&r#AA)Rbh6KzwecxgYsen?L1Hu#
zCmz19o*GaOsw8}f<+f+GrrMi{NvBjh?ai!TN~ceBv+l0K?^1$pT|yld2QipD;^$sq
z;R?Zl953-H77#y9j$@v=@i8mX_*+k0#`3zlJN@vU4eWJm*_Tv#;QP}&2kyFU?}nZH
zJ;Pr?@%Rld@cD=0#0`meCT*B|r)9(1+xBdDh`;ai_cQ+1KJ@I0haP%z#rGfj;fj4p
zIR}nE^vsIyled17{@0MdQ~2qt5?oqbu!^;JycX9cbw&jC8}Qrw^4gbDPo}?^D*Nr$
z0Xw-a@Dm@E>ED#xYSTwm5~hRUHbp7(l^h#cugW?kvgW|Zy#lgU$|de2c{k#BeutQ@
zjlGyhEy>;k^jkt(ey)rEN7k21@UO{p66>#QQAdtWROK^?qka;2%Cqi>X9L8cBFAX1
zw~ckG;ny+S8A%&g`kwSJYiJ{9Nb(Mb>a#&h$%nRBCds}BfyV;i(Y!^QB)$!qXDNOH
zbDhR~%hF`N&<?R%-8U;fAc1ArFAJ{f;KOg>Ka@C+>2J_@?~9=rPg%$>yA2;r<Q&AG
zRr-WS_X+<Wc;UUfqSqFadOxz?Ws1$yKN<S|H_H@f2H$Vt`%<gTnPatknM)zLIV&Cb
zgUI{I_g3t8RN~(i-+3M5-N0Wd_s$Vli6@@H-goDDYNe4=vvTL^yAMljL-xKN!`H|h
zRu1Bylek6>@s0h+rr%gn^IhXr`F`$KGoKXe6sP2kjPzCL`TxvIo-y-Es)2JA{dZe$
z$s7#jsAXF1PWBP)euFWezEzcrjES>3d?I6xYHELQVG}WqxL`Fr;bkA^%lJO>wS+dO
z&FP!KbMdw~T~0|(S1^gVnsNp$@?G{Z(nj1S@8P(T%){&OTjeDYgC%z-2oEn~PBM=+
z`a5B<J8e9x@xI8IZ%_0bNrEmUuTS!yB;PHvE|k<yd+#ozewxTlflV9qas=Gf@cBHS
z??OY>EuJHjwW;~vf)|8#q%8~W?ts_vjU5zuBl4$|=Q6d)`89lBk8FIy>d2HFsvAl-
z9In&i+jeLZe6vgE9DZt`Qu0ib@U8WVA1hw#`%wn?a+06l!#gFp8T*|)^AqNlu{rZ_
zH@+W%bKpl!`u_VMyiiLYdE^=99V<GFpSwM8aBzMGZC+&mvVkijhFTq#AF`Ljh@+bK
zr=Ul^4KDE+CVh*szXTo1{JeZ;kFv7}n&|>|-OyDJcy&TY%QR<xUBy$5CTKAanD1a5
zck@@vy*I4x%mgjLc@o*im{$I9b?M>W)n1(r*9hLZCUG*MLv)BY6aQx;FeV?YMSi!u
zGg$a-ewXn1IG;PpAKcXj-17KKuqF6TmaF#j{Jlv&-!aW|;JCf=K$oTtyk^fia8lFS
z&-0hKNVVTcyuC^Gv$BV`oOYtgLy0q|#4hoXa~XUBcxGJM(jhgz0{Af{PS^bYmX2z^
z%XQm$btpyk?YftF?!m_?v?Xw=#-APsetpnmH*&lOp04awy)*IAmXbFz3mUhpIA5*9
z>BAo!Oq*Nyp81>&*sbe+a91tw*I39CRSw?{^lkz*>Lk{<2i^Nb#Ga`0qFaDlr4|=#
zWxUl6n{O60mX8jRyvM!VD;}r%?@LhqCA8DTJ{@_^$kQ4wFC*or=wF#nqz;bE!;*VO
z{?(P$rZMYZ8t)i<Xw&_U#2<(Q^F3Tcc5rbFelsUL7)LF`c<RL@P&Z}*HEj~9!5C97
zdTWr{s>b{H`KX_j@C%Q>2bo|8e@<X^T5|?FnWqgN?7>giO<so=I8*|MIp8sX&EZ7v
z2SfJ)R(nfwtU9>Pk?gBR{@BWqHQ;O?IEx2o=;C@?J%8_P*+o5$dK-J3er}IPHcbes
zxq0uEfVUrjw*Yv1Nuzcj_oe+4{3R^X^!;oK+*t&74}a#s3p;e$tcNapbHS1HPpnrT
zb2aZQ1BYS<5QEThDED(%AH1OBPI7ec7lVUt*~f?s{x-E@<i49+yl!&c-?2`~H05?l
znAeSZouZHA9l393uT3euUW*(FVsnxwc?x-RN@Ul1==u?4%nisjV4b{w^NokmBg`eK
z#kaL>cOAM=_F_}pq%etCZYO@w8<Bfbdr9oM-}hJUN`J3%m&KyBjZ0MZ<86t)Uv*Zx
z-+R5%eRE|><CiO^QZpiDf1T#~@k46r{<YL?_*t5&|3jK;|GtgC_XiL8lym<&758Ie
z@j-=N6<@E!StOTX(c4=(tee&xjw!kG@b(9-v}M)XN@p+DqD0j`h|Mhe`4qfv&S}t+
z>^+B_NS=Iw=*ma8cy{k3C$$%N&gJ`D@*8LBIw29c$d*a^Yg?UuSmsN+NsIY|7LsJ{
z5}PSf$zJ%Y@XiN4yJsp#ekH$ak=?HWix^9M{!grGJ~8)G;{+b;Pa{@dfB3=5U61qm
z{FcgHzt^U;y>7AiHrp(|Y;v#ew<Y;L^;V_(i+`+i|E_X+<EvY)VqVkrdHq36-v2XT
zls!|`-!W6QPj#yH!@wvAj9vytM=eu=dx*yijDFAlh}X&K_?j)&_kCcomi+aHEHU|i
zcbn(%lRqgs{O=Erqup@^>|>O^w@h*^CEqpk(2zb6{pCfUctiSx8Zq-Tng849BU!JC
zT`-)!hW69ReKR+-1l=LFWeK`6%(vup2+asD+MxMJANs%ppNHo^2k);y1}sMwETd*r
zz8~43uMI}|`Y+R#Y3B*QNKRqoUR`iVzgln)wvSEfB2u$(5BQWdn$$~{I9Unyf^B@?
zLOb&=ov4nKPL?>U-HYBTl-y#mpOH!ZgHCnCMXW40^iE0a=y!l!VSwi(ZXvbGOg`3Y
zCt^$66nW+JTZKH4wluB<oSq{x&eBYe->s=OSt}NQQu!s0-z@M?K;FcA$N@0c0(x7#
zug{0Ju<<31NSwux_rO4hA@JDApKcR<*zcx1j{{~k>^;mOSF{=!g3FdB@`krEE<1dr
zkQXzVt9<XVX0&9Y&m62l<GH?q_<Rt#=4P+ETf5%rrk$hkY%%bAiaofG@_W#&%BjUx
z*h0OVJ=ilgMIJl*EMB7hc-ocPoaVJzyw}C`CFF_QcsGysOVV4|lT*~O1f6YXFO80C
zWV#L;;9Jb|0&k6LOUNs8BzcY$0oNX2MhtSIBMEv<G4OqWYvldnlQ?G7)_qu8=_*y_
z$7!QFR$JLrp_SXNRuk2<JMQ1cwGRtZsjq6*877|FqF9rXlXieP9zc&x43M`Uu2pyg
zbqf~~iv_L$>J<*M|A#uW<X;>36noaJpZb?<cXT~i>fok%{7c4B%k*=~--RyngNJU$
z=OT|k9~jCSr{)@uUTggrII}}TnVVB5<^jVz;8*lD*7#h{nX8qz0>?D=_XEqvIwz2m
z0F8egyeBIgwvi`$Df=IY59)P{yrurEv#uW&)Li=_dqZSDx6>y!P{uP&>>aVOhqpC5
zXEXdQZTGA4PWkLr<$J(AG2o!kZWpvB{IdqW`x5=gSij6?DR6f3%wEPrA%Wzjq2IF4
zxCoh1OnyOS5;1!|vBM9R%~ADdv0vk<+q#^+<iziFUx@cJDqC`++@bf==}-C<J}KGd
z*<_o2)kOBJWR~nwn`9iV$Rb@PY-LX_{N-YAuSY%)sB$GT3wXKUH<4Mc9ndqM(d3Hk
zz0+y_h!OjjXUu&*0$b^;7&wHV1NI`v$lsJ$|4P?vYEf`MU?nG@-m}TAO}&W>mQAb?
z>RCVQK8<GTz6vj`0Y>a4YLT_K3gJ%SXJBtMdwIwKNLSe<GkA9M^o`PoVT)eA?(dcG
zk}U>){6EMc+Drq!<a_FQ{I%>&o5lX-JjyJ2G}o&NdKCM%m1hh)*ZA~=u2-4&&EKKt
zIzyj(%-^B=X`#>J(C41erziAW8v7UYenOwcq3a`ck*xon&~yp1%XKYhBLHvso_$Jb
zEu|LOV_^5iA;*`~zU+6jQ9s9~&2oyYYtkm^wxbWZxq;uOLvphQxw#v;>9we~N|BpF
z>(rpz3w`5DORki&1JFrI*MpOEJ$OcsvxA=q`FM=ym*R`aKt2Y>^(}Ou3p0_8<lpPM
zum!qX%6^DU#w*t|ror#jz1&NG8T7N2_ucTH$oPE5zx3Mujc(*}4(s(8d+se&Jhv42
zn}M%M^w>yUB{qMw>t|+)4n^<jG|c$HeOT}DeG>DE_TH7yQ{*!vab>4n@x`UFU(odD
zUQez}^$6VcSlumoTCy)wbe_%Bd4jtHaCg0qyQA1io$yRFop%u2)mYfWHUf7`foYTA
z4qH~yuJCUf-`|RYJ9J55DeF?f-3jcNk+`cxj+A2O>9}))ySak9<lr%6+x7Hw4Ek6a
z!ky^U(ra6W;jR_jma@jc&v2w96?&k)@{7QJBJUdbG1e;5reZAS*%f<3y1;zr1TYY}
zn2~-W^~Id(0&J|ZV_b_|tNuA`mq@&tc8t)B9o&f>BjXU6n#;WHjK>D91>W|DwUs#`
zeQ%FN)}Ze*Li&CNa$la4@w<dBn41G$%;%kDJln*3XQ{DP#5?EMFZPrcms!cRS##@B
zeeaK7m`C5b?sKbhD>{K3pmzACO?bi`i%%!SS803Y{1VwGDK(J|J4D9VgN)E^E9@&%
zMi{nL{PYYh!zpuX3fWfGj4OfPri`dXMpV;ZoTl2EB5W(^$Gm3RR(a5YjCC1wQ09J$
zeK18Gd8Tbe`<*gx_@JoUu&s(h_GcdR$hVWD2@N*Is&WU<vBsRZ4q4$vhOj5c`wBFZ
z$6RMIABxo-S&9saoM$B7#`^x>3ZL*=TDtZBANXXhOOY!d7N26fUWtua13msZY|OO8
z{~R0h4&+NIbbmP;b5F>|Jn<K_F<V16rfzFuV~VY5+L)ao8&hn}zm$#n0{S8F5p7IQ
z6dTi?i%hpui`ebC|IcY_j<g31`{`pp!dP;7tm~${{@9Q3u^%DwoF%dMNBR-Ow)%6(
z_^L^UjDG}~`yb&)xQ~9skMNBvknxJzwc<y};PcPvN2nq`Z2A#8#lA(h>!0`&*2tQP
zwW;_dZTemYKFOab#UJ4=pEi+w)4D&xka5O3LtkUzZ_s#G_giSwZW5n``Hb$Hz@`>E
zdTZzz>alIyO5cW$;~M>W>91st$~NEgU~~VabjummDIZn0;42#Kzo6#2_`k>UU$}^O
zOJ2cPvTv;GW5p$H#3f~Iar2GU4auyv_1cWAdu46s#@|+rkD!N`MG#ucNmsp6gTsN(
zK>X_4ZpwSlyhjX!c)wA9QQ|yON9TI#FFJ^uNe#wx#2L-niymq(E+U8J0MARDkvMIz
z727?B+Ka8=bv88@YsnRIs(4=lG0jIUk|#kOX=*LDQfsj;RBMqKdQfmLJ|U;XK6!2_
z>yT1>V`hvC-_=KoQ;r3%kK?#Q=M?r8jXoPBgII(8>ct%n{A5yJCJ+B<5dUdu$bWh>
zJ`2-_)<S&SU0QY+S>UkUoUqCr<H??tq9&H4B+r{=^JK5%dv!|cyzArefuyK;_~wl>
zE_i41wXdYw_-&&P8^2FmY<m6v6I-0CT<cZ2oHub|OX4c>w93y@tHDhTVt4FS6Q$m{
zH};x|rT9bL)0SoWwbXgt+SGY3YSZTBbFM=iZPw8ye%`!V+I5pdg+HnMCyv}(im_Y8
zpGI<Vf3-#39Jvoqc(ytm6E)&h)$kB&?(n`F$rmc7&Z3!rC})=R6&YuioLJ;pX;+N}
z3*AecAJ}ea|6eWs71_`8CEA@*)mZTBPpWwtx(~^wpC?ztcw`@_$P%f)kVcHQ_U}D@
zc}DVTzO*@g%<-tp)<?Or`21)dBK{?DF?e0#TjCd%JjGJxq32VvFG>8q;&1!WWKY(x
zI#Bp8O2Y6Ro}VUrp(6cp;d-iLtn&=IG4^8yh~Z2A-+a!D1*iJif1~QP;A?X~=vtLR
z%@$jzW{X=((d)K|+>=<h%%NLy*@)9?anzpUzDegzyR`Df`1B%cs?=@?)o*DZs^79>
zOUx=_pu_671kkZdL-ku^50%lTfmew`bV8F~1cvEW>K;%-MWbKo?={BNL%o<X>cvQ{
zX5H@+qV1Y3;%oa_$Lw~_zX;WiG5RK7AXLLed{#?XH@QQ7a}MYg*X1(t*#bXFO|Hms
z-T6m}O|aJ$nv_25<TaVHg7bOx8Xr;%#yne3Y_@3gPG@We&PV(B{q$=`2aLpl<!x%m
z(r*#{mXh~l){BYOej4LKmp(QY4U6q#(r_7kE;>j)r517-^l*q=4WVVJh5Ri`O4~8=
zZjAg0Bj<J`Etf^9g}e@$8eR)IWmGNXr}etH3Bf1yTFAzI(b4Gi-aC;=k+qQbqlf?0
zTFCpO)IxshL)1dvKSnL&KaqcX;osjPf1l;-&fgMSJ!SHqn;4D3@92rmQoAQP*n>W>
zQM)H@AlHXJYO8@~@D&F4Mey=c@~woIkHz&pKZ1^Wt<*b<R!^t){fIg~?L&2ZcD#RE
zM~JV(HFTEXZ@C;_d+@tU-L|dPzUKqvaD@1}cQLpvqlS=!8bUqP5Ne@@&?x?99B%5k
zxydnt#~XKq>IoU+(0N=R2mIIjXXEjRF<OT6c<(SC-yGs`p8pH*c<-XO!aUw<7akAQ
z4Z0kU%bv=yYK%&)Adx}CbjB1#eu)<Bwp!jRqW;AEXSOw@JhQdoXeK$x_~V<XNn+EQ
zq)zsNY}S_xD?Pir-~XboBr}&>3!APt&fxF52mF4Q`+dYU-$gFD9@ToKuGAp!cT?+x
zdL^kRWG{Bpgi+U<ooYc~;%|1leo9>?`s{|rB<>~sg42cOdBzs%Yg)0#MV197|Aukg
z-r;J$QEyM4H~S$^D2ZC!j6-WV@yGECvnQyP(Z)Rk-7Iybvz^iJA4eaV`ml7o!9(9r
zeLpf~@?>p_@8~Y(83Cs$=p{Kbx0!K&2VG^xkhk&O9J}q8QyT;Kmux!mhHF#x#9!@p
zNj)lHRTG-GIS;WZL@oyg#xG<KyD?92WZthPA6WL4pSa-4691^#SF~qOygz<H;Qr!G
zC(gJweNN^)KKh)uk+*u0yxL**3bJ>kjF&u4u?I)#M`|}kgA1`A9UjwwPd2gjcgd+W
z$2$@>84r|f3jB$%X%4|A0BjPNZ)AVb;L{9zhGc8;rT}ol9wBxrXYd;FQ(b?vcYCDW
zk`5giGJkX}P_q`d(Cp=S^KE!D+F7{)_%kQN;6>q2;R)6W3$oxf8@yN=!G}-4hwGT@
zcewX1e0UK)9DKy!L#Zuf(oHjbIQTt-4<oN*pDj2s@z-HKd@+I#Gju+jqUS<K^5Kce
zzux`g7<@PtK9ss-a-OvC;Z*o=<d~%vjl|i>)f;thW{CgFupM4v{r*Mry8f&18!^2r
z<~MzQ@Y~3_&tNZ5H#D{YIXZG)AM?xQ`DLUI`%;=Gd+;;Frk6{Oj&bI;@aqC<$eMgz
zL!OIc^EWrSsV|&Ho{Jy<UCni#g^_C|(|%t<ZOf_D(P+-}xbw;7Ag@0&|1)a7bC6mi
z?{DgGv+rxU7U$&LLoa7qIpZ{E+xqq$4Lu#T4KA)ZxB61+wl+27aQ4prBwxcFNp%f2
z%^B>U7jaH5{)C0sooF~jF4V7y5sM7zV$Xni=C_Rh)vv0J;(vT^jygCQU!c^wFlFun
z)*~mj*jAmk#FVptp+)ilBjxrBmsw|?XPp_@4mJ0BTW2BXBkJ);-Hx&3elPF0NIuqQ
z>k90jtu7c$B_BttPPPBdRK_FuX*I~H$(eS~9?oF0vnOKO#uJw6)Ed^M)TO+`iU0H)
znmyk?$Kz&iN>ZJiBY3r%Uq?Rm%ae<ri>Eeh9x&dZ#XIk2Z%Cy!*&FP5lruOdJ8!^$
z_H_Fr4YKcK_SPM#=Yew(aP}rW+VD!!j)nkrSI+%F`OmT*&cLr`+Rp)C?=Ef0((vC*
z*0i>Rz<qBB?&dl50`pGvlbJIkzb{Tuhsf7R*5^C!(E|H8U%?=It3K3xiNAiszI51p
zpGpnQH{nm4uZ%@}M3M7;V>`Kze}=hFwy8t4%srAvO26=U!O|}r+GwlrlRLVmgZ#Io
z{m_D4{e6K08WsF=o-*f8PR?|s?cw|fhtq$P$Gt<dc^~?%=l+*0wW*cRgM7-qn@4zm
zj+T(Q;Tkpnmz=S@0^EDS{m<d6Cf+&Qv7_OHW^>NgY;6hckAiobH)Csc>H+XhETFs&
zoS#UlZeSnD5zeUgzpdllHUjVaKQ!LI<u-XzYycxi=d-|~S!%<OulO$X)GR!}SWOzs
zC~eNV_(_AO*&q_)X?dUhsMr8HJy|BVMe>>W+s5KElSkzY?8(=vgHk(Yr2V0N(y%`a
zTSfM2MYlufKlw5E%b;&+6=EmIm}GycA$z2z`DD&99vW+)s5N^@df$Rh$xGzf@yx%3
zGdWZKMs3W+Zz1adIs2uEHRo&ig-m;yb081G|2}x%2dvud&;`6d&;E`ptA;aoo2b3?
zHo47<kTDk`WZKQlvl*Fo^nI(o4^h@zk+Aw8nP!enll3oS%h1P0eRF&lCHOMLmT+)}
zw+%ZKJ1Tr;f$&g?hJ4_8y{<T8u1%mOcWGHxCS$I}pVhQT#_Z6?{L{;fd8zDgjF6)r
zG-mj=UfcQ|-Pd)Ty?cL(uWP<_N}KqiBtB;PyY6SKdLPU!gPQ)MaKYXd!Nn4A;fr|I
zgpo<xA(_|Urj1dsLH7!5qz&n>3>x`D6dJKc(1_ou4xYg0GmJ(YCXHBEHO&~Jk<!b+
z`@_-*amM+-Laz#qM8bYMeu_T@_5$|+Hn<6QsZ(k4??}4-@HArh8BP4Ud!zUop`*yP
z%47I&hxj_B<rmbO8$}0^@V;h<4!}7yGvwPW#a1<Kqp)vtM1Rp_)0M7`kS*c879t}>
z?v$t@xg+xs`7?N2_5h6Y4{WD?p3cLD@7t(RKH6uNfzQmOU-#ycKH_>osaM}~oIQq`
zy=@8dsoNRrHlLwpc(2q9kLDB0jHoO9LA9*|$aK>uCUJpKZSUSv_`~$$bkDrqUHjLq
z*>%KViipejo_VNYN3kb+IeVg3T<zI)GB#_W0~t*WvS5c|A15;DC^n=Ad+=^@2&t92
z(sfZQ5AfT|TKuf8FYVqo`UY3YkCwcVWnO!UYkBBdd0%qs`?24oZ5RD!P{Y}Rjz)LZ
z2X-re0N8Zz<NK4EpE}dnLRNHwappv{dgNQt0|O6ymOAFf`GC@{>>qoS80;e&XUj2e
z*>5Q0{yO7kFWkx;#+`wjlyS#f;;9R1jQjs%Tsuq8XPMU=_}^sQ^1eB4oes83ZH^fB
zJjVJ57Hj&RN7sYw`LU^f3-AkU7oDc*G^6V~e#?7-*F4#QwJJMsx;4An(zmeWtF755
z`0TW{-dZf@9y*P44+Cq-Grv=13*8Moa65ag*e?RjNuGM;7}q<g`zC!zo7Dq@3yO*H
z$nS3EB>4@}XEW#1$^8;)WlJne?nk~?GB~(E@(kp8d5-<|;dadDqs1!Uw#Mi&s0?aq
z+caxXY?F+g(QT7?*Q<KNHc8Rf^QO!Yf73;5lWN92g_;Y$CZ^vUp~u8dX%5G&jQSeQ
zAwQ5Gy}B3ux)A+cRqOFrvwzY`8|FE9lQ}!V^rei983Kdkk=F#yW7h#Nd?f;-C5hxv
zV2f>qXHztFXajAPvd^NH@kl&zDdS-eMz6xpT^%_WctGZ93&j*=&!-vVlo;IO=%x~<
zalYL*(NVR`a}%F}8_u_*R&z?Qn7Bzl^da#Qxi9gOTKdeka`u3AO0bna-m^?=%e6Xu
z0uRYecmWuW?6)=?FG=O>$OirFNFU=b)rQWFJWEY*IXiMLeJ!J(by}Qnj`TxKks0%(
zMu~BM<{0sk>!JS*w0Cl=adu=Cdu_Kx?30dmc4RRyjk8W`lRe=(=I+qXkG$SG{QSr=
z+MH!I&W|h}<NQde3t*lfc|Fh8lGhM<e&jRUADJT(S!3X`weYQJ?QbKWWX&(}?2FI@
zYvi3%t;nyLs(uRd?K`dfPUNgjbd1(|Yv=Z@pB|j0js)4K(T}}*;!b43I5l6+Y0Bg;
zz#3fkAjzKSRO$${ebtlQgMAcKSqn>%%WdS5uzm@4fy*H8OMXb(Cq4dk=#nO`7bEA~
zR^tE2=SuRsOR#zHw^F}5)mdaEXLM5G{Z5{7@t*9#a`&FjioBPJJY9-h3?fe?mh*zd
zAlL`0(<*c7Vk|<hfmykJd9ID|n`7Po-r&t5`~MBvmU)%*58mt!&8Z1H4}nuCG$d#B
z$nQ4jg$-9LYgiZDf}FPf+vdaUf%j_Q{&(_zB+u|}NtkDb$E{5}=Tq>T_?G|0^3mR<
zR`EfR!Ln}(pF}&g=U19zssavj_KDo@V;_f0n-VN$Op-IL%Tai7(3-|RPD5T_{L*57
zU(q7=#^$m&_GkK@M04I{__@UgVgVK!e`0e;o1L`nQd5E++BMsh&(X0{;wT^2LSX;#
zP!3J>Ty&#mi}0S%ulz}#f(<<-Ye>m`dmPz$h#2Ka|5n&$#=j*sX^x9OD}o+BXkBH}
zr1;512UO8l<oh4w->SZ8vAc%aEVbJ_+1>@Y@OPX~YO#oYxDGilG3{m4<27@6h%@Xw
z$(mAZxtFvZ4dmspmW=bc;VUOTf_%=)n#EeuN#2g+@&wrbDC^%8=r5R~>dkzeHN0oq
zqtcdJt82()%_VKjqK$mB4f5xt4Ow$_^1i9Zb^AF=euc;@!=4$PXCO3=eZyV?E4EIg
zT@?j?#3cS(;BU@icPaQQyD8V7kDP77hI|bg@Pa$px9>yN$X;<>27@E<T{$#0PuBYm
z&XQ+8F7P$h`y%6eT&g}-o(C7Bo{cr0)p5ad!*CJBXETJ0Az5YGmpU$@=KDm!#eWxG
z`Y5=to4By9;tcKKxL7y>7m?4BcPe<(alv!LaPblNVk|rKA~v`1+6UR(@8A!dkInt7
zus<**>`#>U-yx^w1oU{qp$@)^e*HCersUsD#a}Zr7w1*(ou-aOG5)N6Z1r?(%aRD&
za-@D9%Eg(6ZTVf@wiMbQZd*<sWm}%4AF(Z8(CgnB_s6m=UnUplquG{|huM}dkI2Un
z+p;Z`k8>rq<;y%9-L{<6a<jhvFyJ1omK8k58e~W=M%tfOivPYb)?6vXcrJ(k6Zn%e
z*qdX@{Dt@|BK6dj_=jcP#W~ieQmiR$uYzAM^z$3=vKiY?Xh?n&!}5vjn?l~gV1nuu
z8oC94VXoDASsL={>l0_&QO;N}*C#Jpruanv)go8reEU1mE#~@U1N}UrCHT%mLq7*6
zMcRbmjJYe`llx=QP=a-eZzpXTH54bbw6Z>VA+m;Il(X$+eIjEzz?w<UwwH75^Z1jq
z?K$Jd=cB!|%=Kk*sm=54i=&)xZ>~@Bct_5-pC$WJBhI%s)+c`&4GkW*QnSg9E$YA~
zbz(Qgp=aaqUnJnmvey5RHOzagU(O*9_H9q?TY!CZV$2-Q$v*NoI}UwizT1Y*YJO{4
z*1g0z@A=n~j_0;dJ6uWp<zL4=o;qKvUicgG2M^yfEo%v9HBRA7+|nj$5}~WQ@O{pK
zE?6)1_hC1`WxcB95^Jb;sS)-QkyETQM80+LC;CX%z4BYG%WrIE&KV>hH}u=acj6%Z
zvM%Xo4(9c9dOTCwmOiF(R@pS_?o4K#=IM_%t~B(soqS~IbFTQY?BwoNvSunhUPCUC
z-8-B6tkqV&t?gNOl=aJAas)VQidqI$1xK0ZEsV1o-^y;*#wFG%`GI@Xk>rFu3*TjK
z7nz&*rb{`;)m`Ct{G-+G6BzV!PwK?^rgK&>@Te|GStZYWs-oJl?XyX%-e!(69}^aV
z%GT^2)??y3Tl&mn4Z-c6Y&H?hk7I3keP-4|8)I?s=aXE2?22=|E9*G%f6c-F^>fx+
zgRBc}oK1{vSpO2fw<0Y?_uB;-&(o!6v&?HfSFs-i|ChXP`oCnZvQEv@rsNNTYsax#
z^0X2+?zdGHJVl<7PxGa|^%c$i&LnlDZ<WfHJwf90@4iQ62fvB$Yo<D~1p2~nQjSBT
z&;@*#(%!7tnuenPHKBYR-|K!=*HE-WE3Y|L(@+DP#74qTACwsCQv6D+G4-5yiGwdC
zjx90O6k@7uh!4e7<HI^mXxe~ZyiQA^^A25Y`lg3;q0rdK=U(HQz`5ocHPOW3C;n~G
z{ac|88GkLGvR2Pv%z|ry)jh}^9dGyrJNXOat?5{H&#VZ%?aR&f;wu!qJ!Ol6H{Okg
zH}SWQ#2fG!hPRg(*GRkxU5F2?WKo9CzfWs#xkqd7-mm<A?C$QM=J&6~r}?DC?|)Kj
z?>Vm3ckj3Q{r|wd>!{BrIzqDrF9QESl$hhMurb~yo^99|8hkqh*RBYD6xbib-q;%@
z?i~O=fkb@nz~~|7Bja`QckTw(Ia<7rx?b%~QRo;SgAR{2&FQQR(XrIZT2Xo~%e<Dy
zdRyQj@0)atpCv!Ait|~Oy7^!5i&k1~-ZJ3!N3I2|(_2nVRP){R-+f%m7W!oV&T9Bt
zhn>I$*m1AE1$cGu*Zke!%YZ2`6qs^O8h#iZZhGv0_t<nh|As50+xvP34}B&Cn@(g{
z5AsaplZ?~-tHxB}m5kgBpV{wwViVBs$QbczY=Xkss{Xs+LC*U#<IB6T18kqj)oY<j
ztU~gmblJ+fS^TpiUnOtOW;62dOq;=7dQX-Ef4gQ2`8>aJulw*ltFvM#GV*&}b{R3~
z*O12|zl9DessCAvuPGNFUsQTP&gn52WSzWYtQ}XNx0a*7mZ8V;(Pw%1R+i%Xx9Yxe
zGcVBp*6OS>>;u^gAwJj#=&N-^T=a~r=STRH#P=GeJA5&hqdOZp@WO{CjfuXHx|or4
z*K=Vs-PIH%uM(QN_uP{U1#e|~pN0=e=K;;&0dvkKyhQHX<X!|k%zGlYBA<`u3klUh
z8=ij~TEAsP*nc-;|5Zo$ImG^}4#O$>ejM?Yc>mescI)e1Pd52-^8>7XB=1}DG-so8
zY`PDIx-9Yd{fKq?S>w)uC(pCD;%@d<>_m5TV}q=#_(5YGdn$Yf5~n*?dpFJETwG#L
zE2VDiX=H93{)Xk`Anxb<dLQT4`zrP~dI#2aNZp-v&%{r!i@oZm>jzv}Qr{_)&!&3L
z{Kd~`?itxZKefCgXa26>`GnBfyN}=(Im^23bi~=aCFrLm?AyrT?A=-Loy<vN4PHr`
zuR*(JyjIShm3XD;iz%%z_JzzjV4Urnz#KNvzSR6M+n0Fl5^P8_UP}?JWEr!-V0Qob
zh3(Kq4|6W!xo&)qw$){uGB}eLo(siBoyNWo=otBLoI!5x`_R{&Mtn!&6!%dhPwbU4
z=5yZ{*#q_w@LNpn7_%N;v>fm*<`TJvfd+M+EG-xn4=L|tKEuYq9LAzC;Yp$GXmKaA
zCUZuF%qqsOekE&`ve2Fy{9ii{kuxoOeQJrHAN=fm-{T*_e=I!k*tiexcb425L$)nO
zwk<-o4ee#Sl6ka*=JB>QnPtP!T-wl!0eGtf-m2cx+&CF}KS3SR=dn+ko|vGYJ=XUT
z=9$HK-~9;llr>^CeDcdvw&~GeY-NuDb<IcB{T-59y8m|ATJ@vKs*-=E-Z$~V8T^&(
z%Jo}gJ=8uK;+K-i^fisROibE>`%>AXc!m7p2cEU)9W(Y<at-y0=|gzW2Y=i%!`R<c
zI^sF}!{y>19@ftX@PrYw8mbX2G0RJLN3UHzc-+?h7Hd3_1%@2fVcFljeR^LtG5-wC
z6MTpDmAQW)U?q>9*wwpVQU2=BR22-))cno)TD$Go4C7q$2ze^9Z`k?Qq4U%~@LY3b
z5w(i+bIsF{X_4()(GRA){;2Jjz{_U)^J!nkXr6H{`7cg*#f!h(JU4w0^E39g8}Xb<
zaN-4LQ(3!64n;S5SL!7S{ofP9SKzt`TM4}sz$Vk<WWZ04kzqrK{*!#wGmm=w=AHwQ
zXMzjz)AbswE;Tt=1w7>Xj1gn)hL59-RraBpcAK<ijyEMV-kJ~{id-_s8%bXhe;7;V
z%6OZ%f2Gf`?}qkB8u>Kj^&htp=Nj&>x^%ZulU?SZF$b~nBIoD9j*xpI>*O<<JQq5Z
zc&g}9c|Wp$|Msi;{Lm^n>(FX!m{!><TE8Gft2IKa*RhtFptb)~JoY>EnhyMzspNd4
zE#y3Y_5I|h)nb1v$NqQ&8My%&`6zTO^x>>{8hhev9VL4wOwU+dvS|sro3+PEiFF(e
z*&oZWKbo;Ws<A&xDw@edUE3iwx18vEFZM@1c1IBW+{UNa3j2t`o~564^dt61NySsV
z^R<qI1M$=6V1KL#+XuF=ec%%NfW2)tcw`CohpdTYUNPhanDfeKUX{!zpZtPS=5sys
zIY&S1>E{vpA#SkqJTxvgg`?ttZu2bJn=n1VyfWw${{ZtM78{yZe#E?%gyxmcyc~Y#
z^gQMz_LS5%`~;sx%*#p+LL{G>_RkXRD}8=`!~U5=Un{VG<XzMLk@=Ot=Q2OBuS%F-
zI{0$Y?#xmAKV(}uOxtbmP}>Q#E%Pwj7MrOW{x@y6n`v9{A^2T(Vf?}d=v(k9W01XV
zI-aqu#KtqnupQq{<lF>?=KQX73<2b%Ifff)TjnqA1m7ON@CW)B9Qqi#-yO2ymVld2
z@T@#1&&yn1L<Sggo4uDIJ8%!QAo5Ch=?t>zHEVLFAzuvs3OwoYt7G$hVy{NVAR>9P
z6P+XPGp}L&l~SiVdVfaS!kf+8|9X^s&}dKi+mH{V?HTFogXBWAwTo%z8DlbJY$%Q^
z@^+L>P%=VamxR|Z(enmGMm~<bywdml=<mq&rR44~j_hi?n*TWQkdNHX#NqbBw-}T7
z&tDwTpJ^`)>nF;3)?5#Z4PE`ui~J6Ol~#46n|<Nwtj$au3ooxl*G0-Gp}&0Ol*qyj
z{-Je}!N<-puT?^y<T4kQg!ov-tJ66ADEF44XKbwFWbJY#`_a456NWuJq+iUngwW5R
zRn8x9u=aQ21Bk<3j>m4skNp5=5a0)h^kw76?mrP_FZ0N}%pX0P?U!?iB{wrgv*#aL
zJngVeeB1LPeA~yTj`nRoH#KVs^}n&H|7-cSql_yJ9DQWpHtm_d?Md2IhHv|u>d5>E
z-}VFG-SlmLnr9+?+x!0n-}e5HZ+qQ`@NH*A@ok@Fe38Cw$JL{Kq;~u<nfzVWw@rQc
zi*kkoe(gSd+TAll{_WlPx4(^lo7}D?|H=OCUtOVp`*mP)#r|#ZEk4x$7XIxH{M-8s
zAFcm6KE=O{PgeJD{~G^xN65eZJoo+s{oA%A!?*V^a1Z+#|C9XN0n@+TG34L2!MA>a
zoxnx>+rX&>c!mAjI!y6z3rzn){%zT>DzJ&>-*z*;KgGZO+@Hz6{iE%x`wlH$efaQm
zU;YdDxIc$JTY+9%j(%H)p3BF_o##jI4fk=+`^)>d1Jr;R>EjmLInu}d(pWxj=&CT}
z<7VFhe)a$UK5of5D4ke!q)dF8tV6Lu$MkWt0Wj?2zMDED6R0zCo;o8xpw5Wt>-JGs
z#9Q%mY^+5c>z+w$jN80!)Ag*C#NRExVDWdK#jX>7_t`&Ko_*@O-@UM|;${5fi*<ju
zkM*OhH)rYV%{blP&3dzUJ8PeH^chE=XX*1P`jmBN8U5t(ejcAI4#YPmY~HX*)@B<9
zZtDmd>!)yCl@k%ZZ_(v4S6NFm(f(rYja56vTqD)chgmyi&NI%&r|C=l;E&MPS;G%L
zR67ORGtv((zJ9SG*Y}NI*aq$N01MVZy*1(orw++*KX{z@!F%n%DeMO~YojpcNFNEl
zydgjMH$I{te8xxggKr$}8x$M<qxiu`<^ul({iFS1|ET?cxPR1YzpQ_>dZd4JX2?JK
zyO4i$AO6vM!v4|TweVlGJzT^5q!IhM@RjQPA-p)}(rq1GBY3eS!dEK3fnj~&EBUkb
zHMZZhSK?4%UnG2($(n8t^ES>A7{hOh544Lo<1oMJlOz15_%C$7DR9;OrsPS6{iYLg
zNBd2~x$<NBO?!v=O(VwopXxWY+ON!S8Zkf5mH17e-w*Pe`fVfprodYFn?l37-<17!
z{)JlmCpgE)^e>L|oBEQ5{H7bwFA3<EH_$InqhG@QQ{=w4;-s$A@S!$lY#!}H6`dwN
z)BrjSKk9{&iWB$?7hleY+B-8Lx=t&hKN~vD#wY&N#yRMj6=9vG`x|vV<3dNsUKsH=
zia(VNpUL`s<A&yI`cvEJ%k-zNXP)uQ^BnU$z&uC!Rp~dc;uT$|;#+MDFyE2BRhh5&
zR?Yb?3C;I1zSZ8D_<p1DwW(j1=<{wf=ItMnA1lzWAwO$)-Wk{;GH>y-ZeZRaA7}4t
zW6F*QU#C95Hp6DvJJe4C{e*n3VVi;6xUj!d_8*%**O%WMzwi<Cc*y74+l^hR(*^QF
zY>V)C@VQ2tv)BUWyd58AJY)D@+uj<#@SpYZ=>FGUcclLn{EhIx_R9Wa(^qENAA8^x
zk$d8kI)jWG<$onM6xIJ4!P{f_Uweo7Uqkke-d`wo@`3(WUCvy_{~9rdk@Drgv;Q^l
zU*G@QulrxA**C)f+It)uIGW9_`(dGZFEUQn3HV~ecDuprx-VAeLHw=M=o-@(+pGIx
zH-~(&S5P<bgM6_gZBhMPM(WajT+=hLP4c;GHHYsnR@3viMy*8)J_0Mgf*5=T>_rdN
zCNS3o<R+go<knEkL}IIUWcO6|gi-^&SI(}jme@7>hHTnY-xTsJIWOs;%_-+98TpG+
zH)=_g{oD)4Bm6>mKeyD68eVH=SbPFIrsM<SFtV>n>fB!Gdkd_S+e%rJOP-%&Lg-z+
zCd^d5Cd^`Z%B%^~%^nQNN0T|?$80y_!BR^klR7I7sk1`OIqIzRnsrvbXi<m0fPNC#
zX!0KMRQRjDhIj0xrCHq<sV5`vd`8|eYM6A6*njmSo0)4o1RL>jUFjUd^ZSsn3BMNw
zE;A$G^5RE;OX8mhlW6&4L$x|S3oYLcP2UD>FUJ41C|uh?kN<49wD%Q_<NkP_vqAHA
zYA{&p<t({M&LQsnq|_6(v_Nb6d9fbmD(4>V<+GagfAc4eb6;yx)sY(VeC)Qq=jBYa
zx@)Oh!THdc*S^$1Jbk0$cP+U;OOkB9Tbb`RVsqrT>a~hw9PIZ`mYRv=UWCt<6?rLr
zRL>mhBS5@B@<$|AD{(EeCV}YiO7`(r%@Dq5)z9-2dqBq8mCil`XO%v_rLm#$r7^zy
zu2~fxAHU7<T}S&}#G&qF-?HQdnKhJLDkZpwF-c!G1w3e*Gan`98?JZaqV`1#*Yvhh
zI2Sv~b7U5^&>m;LUi?s%z@~YMDxCZ`9=9#l({Jt*eZ`^@A7MY}0egaP5B2P%oigG)
zk?jPjF&5cQNy_MUc2E~DvYmi+Vdh2ZaJ5?Q`ku+7>Fk^DnpAbG%f0Tx)=7-NwfGw0
zMNO`cuevp`rKp3tU%jRHjc0tnronvA^anZLKYwbCcGve*+L~+r8dw=|^2vH0$`d1g
ze~;hNf8;adNsqer*obRqh}8>SJTk`hYObq)AAbY6x&!1>We@I-*<_;*UEsNx!x@Y_
zkfUXvzD8}V=DRt5OG-q&KCPx9;I#O=tXlo++Xc@l;kqd0wB0-+=G`2Ywb5&3$iC#q
zC#wFx<=udFL1wGvx@*jS!|=Y^zHu*W2i2N34BjUUc$bd}?>B!?utvM?8kLrQ4Yk-B
zWY0%8`*yn)t5IWL6oS`}*nilG{ty@*vnZdOlP!2SM!uq4H*1(J;JOaSNoqju5ANf9
z-QAWDEG-5skE-l5AsC5Hk~TAV&qqF<{!V3#e^7G&ue11jZm|Ae_Ra<_sw)5gXNEzC
z2Vqpy5lKd)1cF^a1T@YvCKejCn7FYmlaN@TsHl{blw-0jCMFsc8M{$Yi-s+2nAp;a
zWkpGb=@yl{QPD06B^4DG%K!7d-!nX855N7t{`>2{*N69<?|HcA`JQv`x#z3pDZ7VT
z>~a4RXCF}BTmU~hYwBdGTb7!X$rMi0Nd2ysch?<r(k1Qq0QdM1<w0dZdezC^1Agl6
zxc1ltoq3GTI)(hMw$xbI?^to>qdQWL4dsva*V}PV=-I#;!94VBap>c&Kp%*+Z8qt(
zwSR=)({6w0@1gcv#Rz?CE!LL$o>_UV&>g0;YaYRK<3qJyzX{)&)7chvh#Tppuf^VH
z7wmV4L4T5p-|JA<K16?E)Oj7=sFjyGTL$Sl?h0M%dM||O)h|p6&wjRh?^^i10e&~?
zC!n0!UkdyUbtX&SG<UzK$36gOJRe3Nk47S|jL0)Q3)Z{hn>PLSPHi6<eN%>gWM0-Y
z^K_m2Vxq+A`WYfIFnjXC0QB>-(9c_8K8b!l;OG>3zI)-jhvj?1Sr!Pr@d4vpx6DGH
z=p8P?zrZ(*;Y+On5$FdO$FT04le=r_ENV^fcMJ4>hi{<1gY-nuS(;;a*XmK9kj5N5
zFC6vOQD;x0{<xwKIQ5Lan%+B~LcKjT75lX=5xc&?J7!lW<Kb`co_R5JGhc$|7o9_}
z8@ibn)AJ0^3hd{Yc_nl+FL%~0SPos68<yhRWAyinLv^c5L95d5Yab_O+=Bc2>ddVv
z!O*{pZ$GH~0{iJ_-mU3pz8m>6ANrYbwy35Hd@=kahvx6R+o^WuV(4eK;=YT|K&LSg
z`kCpO^{|t%wF`0k0P7r+kPe)I;<X;U5AxZtC%e&*{YJ?iLEOH@{QFX678rlVKwqi|
z#5a{=pkE2RPy057_Bir+fL|hS@-b%p7Hyr<VVOpCuy$t5M(DCc-o!vx63$vmjDhZ?
zM=<Z7hjTz;g2n1bF&>D)H`z2VT6`g%W$+h(`vy#T*L(gH`!z8-*JXmjLOJ*#jt+kx
z`t|qMg7LsWe^$uo+cs+R4u4ZG?C;MX;SBU=ha38~aJ`dDAf*T6QM4;_tKC9rLc7|^
zdg>iv-U<17r-@;G-CBH=+k;~DL8Q&$b}Hl>JXx1hhNsV%0Nv!UlemZW4c?!`Ovk+}
zc;@q%1m%WrBhj{?XBzbb-~3Tuq>UH$57bB9>&}8_eUCfTH!A18`lvtjh8g=|2kWCY
zw^}C(I?G8Lk2Ik!U`(Rv5HFo5!tq{YJNXk+#LNSFb88dE9uBt~@w*d!MI6f3cLw%H
zdWpnl^y!Z0*4+biNoSj&%j4e5a*PvWk2&06-KpAmd&;p5D6^sLylzi<hMxsy<crtt
zTj7q{^l_ZMjy?8=AH{xqy`^*w?Q<gez%ZsF{ExI}5BsNlU8meejOyGs&^^WHreWgJ
zanp!^RI+=_Iuq~a!|2?O53tws;qM$L;F*RvG`~pW1ar?gf#xzBCyTL;^nIkhucb5D
z?Rfrw;C30-+R42^s}J)ar!?9z78__s&+XytE`=S%*+uDhoP#pP`2sV@J?RzKp`AMV
zdep()1M`daVUmB%Eyf?@udf?ACzSGaigK5ZGZlU3^7pvp){#EP_bS-ejx)`?t}J)1
zebZ=Z`W!k_0`V?$x5J$yy;x%;cdcJJjsK<`<!nSbcT5szzQSIImN{bo2guKXe(0?K
z96k1Nqn|pvem<T-^YAQ+!!zj$Jew}ZyZgDAzwq;WsIuQU*}6m5r_MRf>8G=Xkj5YV
zydTc*aOVlIo@~)i$9WyfZ3Ft3RP?7t>Z{Q<sjjB~7W$PlSSMmSo;@3&H<|R1iiy|V
zb|==(vG=w|*D}q&T<M#3`1vuqmd9bPuE#xTu9c4GsLMF$av9P7>}Kfmz&9FajI+g2
zGoHuAP69_+^WKq@PT{))pj!>PxwjM`E>~d>Gp&jD*U7GH6-d`mI@#~TJ)gvwWdrmr
zFT?mKkiw;VZB+NdcxXTD>7AAL6tVr<O^Z95)L6+^Ol;MMJh<~iJilm+Lvlww#F<;G
zYxTeWrV06a-5jwUYcQYD_o#i#Dh}U_raN^;(DRYf?1;xD=wCm8zknh1w4<F?8Aauo
z1DOBXk>9(}x5k`g9nUmI`v873kavL-t@{@{)A>Ls6X<sigbwF)SJL}Sb+>oFW#98B
z`o^vAZ#oNe@VXP9gJwj%rM#hk<(n?(bi>>e`$HGt9n5Nfw0){eC!rHN1Lfm_a&pJq
zedsb8+e&#gR2kiiGQ#&6S{cnp8TmSk&?zX-g(#~Hq<bB|$06JU`mwDR>{IW+ns+%p
zb5y?2TzEG8-Hr95IE?S=Tsk8+V;`>@_PCLL>p;{gSA&{+<2{KR)&}NZba>}{j2Ta1
zK12GV0-!V7a%)R;6Xu{8;CpSv`;Vc@CkFaK3@)>0*%7DBC<lL?*iT~(nwNWn^d5oA
zz;W(3Jy&T=;j439z8i6*`}kvS?t*w~XUO4xClQBN@%?xc>JiGNC?DYpgiGlyMIF%6
zN@>LJXV3=9H`xa5*QWZ!du@ByTpZ_UQkZ?q`}_PJs!j~73oa-V`nK4PZ!l<`hW2&`
zVa$_1pnjZk3fMhgH+D-P)=)=b-Q{YuVS1lryxn7xQ5WQf_gM=L=(v7Vpnus0b9aDP
zP3O?#!;z!Upnjl!9gaa8?pr^WB3~ay{n&{2YvT|u<(D15hpHc`ed<TK+u-^UsOksK
z;~G>yYVq9aTR+hDy$+%t%~S1nKGKtM5q&4R_?V-9)S^yl^}|{0r*$M+mqHmQPW_HL
zvW)88Fm+_J^ME>nuqn+nRxXEbIBEwQ@%szZKgT`msGmU_^`BDb{c249HCWqO_6Yin
zq3Vzh_3J!!==(gszE?e?_fq|J(9$^r1HWgR+^?^pbkOr_BibGHIpL^#S0XRZ_x#eM
zUi!lwrQa9z%YyX%Po7_6wR(uNDX<s4#fjJFKEzrvwJ(%GzqZ?f`QlZGANP+_wEmHv
zV?l_|aQ$Nn%4Mkju?Y9wqStBt<7>zV9@~uF?T~$+=gGs=Hc+=vC;LB7w0;(Q;m~&m
zqEDh{N+8_1(lZ5pC+R$;{_}3kxv37<qaC?n?Xsu;94q!)RKI3<2mPm$U1DE}*555d
zU8K5fyxn?lzdjFcPQqUX_Ha7#EnW3_<(sY_)VFO!zR(!c@m%Zk4Z(1AvR^%P=)N|Z
zwDa~CP&(>R7hLdc3&1;oy9dlQ1m2a{@qIph$4$R!egK{+#k_&~awE=1z}YbSNM`I>
zd<=DS@7eVSwR0iAPv3gJb4b6Sei3IfOhlfaacajrh0mycM|AEpQ(n#yN4;V9F78QV
zVNJG)Ww&80L(l0+7{{#ZH;(bbIHqX8IELrqJdR2H2G5(s^?3e}{tg<)Y#1Z<_f1PW
zjb*yKBT0U%stfKYUl%+}1E#&YGXT%h4A`Y0U&Z>CXgUKK`HOlmaXF1qj1!Do=y^wS
zBkEZ?+!}E%@cGWz?0f&8e4l~7{J(vM>+&DmXCUAHf9Nx?Zj5)t&X|i1eqUznGe&Qj
zCeEz0C>=%%XkEt%=T-IUF=DrP?>U4HqkupwbQtxXeea5J=c9j&!#N_3-}7<y{bC*K
zi!|$85BJq;<ThJ`AHKu9kj`?7#~D8Jb>`)6PHt|abZ&<;j~4XPX+%0#NT<;jO{dY;
z|CvsskiloZ{@ZmLVXd|Ad*1Il^Of|ur0b$0T%gy;Rp~V%T{eMAuTg;RZq{pKExjfJ
z=XTMVdncX72L_%^!v1Zq-I-@+ANv|({rOl=+~6!eqkYuqe-oc1{WqA`?9sUe?tz}0
z*OA|!-Y{>A5qZ8<H_B}r&hmO#HvzhCpu-4yq!#PkTIX-vvU6VQyu$&y35Pf6JeDup
zc#pR)@_zH^%{zCGzI!L;w);>0k@ektjkyTUbZm8$_sQv-cg8^%&6JDkc1HXFT}Qtf
zE%v^Tb?TmcfW9MFrSIr``9S*|`sV}hZ_x4qdmJ43KsrP|fvzITk9&|GN01*LlSKHa
zO`~=nL7sRn;XJ|lfo_F5GxEfYJSp7yDfB({&l5B9#1nb4ttU@j8;~bBcWwVJoRfDF
z--Z1<^5z!kLMleyP?@)&tX;5nkFq}MdqM9W4$^~UgdQYX>!tTjq$5hxgJmhj*|IKf
z<w*BQoVoZg-qk`E(l>o|AyNGpr5hEv2jAOW1szDAI=KcOLA^SH@_*xY>kiV1ME>^Z
z+}#Rv6WrR473};3b;VQXdDs{AgY;l|ppLLkB<RW-eUGLS=@X?BiRP<D-9UX<KU^=;
zSAl)^Q}Fwu1ypDLAL&K9<zk!}KFzTP-FsF-D&8sZ`+k0RIq;p{H#cEj5bvolUh$&w
zES(egeRU$$O~rR)v__6O#8{-=p;Kly##XEoX#($mp>qMSH-^UPC!rIG_rFXStP|<n
z>|@Z0r0rp$GojBRPUMI7)zG)m{}Y`^j<}J&8`g<LdvlEV+yrq&_{(q~%-6Ag#d~WU
z`^%}Vl1?N(BiXE-W8F{h&w#x;N6!=IAFl5P`+W{Zkxrz~oW>0Qt&3wX#OCj*Cs^sv
z`OFACOOEedHX`0MFErw;P}-Mt62GV5H?`r-4xLq0J~%_%vBzjfk00L4#D2_JOXInT
zqaUU`r1$TG_Bd(#mH3QedJnQ}kiMh|hZpNyT9@?Em*j%_bIK`lH`Spy{L|v+(BE@z
z&N1jq>Zv~~&r=pIKTxNZqyErZ4CNE;!=iGz5bG<$eS`Ev%Z0ul@~8DY?2&fC9%=g4
zdARyd-$3+zrhnHt@D4pjj<TQEKE!uQNLSx88jcUpo%D*PJ1G+1L{U9~&LFNMhX<9x
z<lZ_$^C-u?DSZLh!|bRR^Bmtt4Y==6{n!+39!+{^`tM0_^j~!D5cNZS=Uud}IjjyP
ztmAxjtsd`5obaw5XT4+p#Cgtl_|HG5ALl(3;G3|`Sg*KyhxOlkR{z=9V|eF>J(_*a
z>c{><NBvGkU2wGd#kyh6>ZdTYeV*#9{sH?FhuVwRyDr@OPN2{FiKa{Vt81N6hR}tz
zek9Ia7`hB;?H})v|5udZ7L?(SKCd6+ZeQ%tpzk5*`FY;+`pGTE=Hym8BYr@647JAE
zTOPf-75nLS{t33JA5|WXbNDefrgOpjl?V1S&qjL*aOh9y>sA{>tMY)mzJ2kJY9BA2
z|GaG;>p0$zd3XLAbMF}JCyHAv5^3H|{bzWhbyuVbYmaJN#B=Xkd-Mmthq3;o3$2k4
z2O^!&0e=8{)Qr&2T^BAQW?}8xO^<ax%oSdvIf2rX8#9UL1f(ao8}kF!lRKfGp4=Ab
z$;EeyftO(H--da{CwMRLFzRcCbN#)a;(U|?c$c*Yb@=qihrN&Jwt3S&a_ke`{^_}q
zk@XSQfTy&1m3!dT77^}&c?8X=NSE$Ym{V0^PIUlts!!CMYJ<+bb@|4Eof+CZ(~NnE
z=khI>Q!U0ka~I~BhcVB`Gk<?8%`@@L=$wxCB09HLN1xYMr!JlUeEfUr)ZIHq?A@mF
zCuS`6OkqxV82RL)=9?sQ%r_~Yc-}oB&=vFU0L;5LK!5B>{bq0IWeSW(K7E3G`V{$e
z0R8OiqhG)GH1Y}a*w2oj?`=muoz@j<`GoVfwx32my*|qtfOEJ<pT>Oamp&r==g241
zlKER`j`fDl)9ono>3!tWr^mMM^n7#MPSSx@uyO0oyHn@my8<)L!Z$6i*jT8|wP@bi
z2K~+$6YOupnGKG7YB?rmmLq@r=M~Slen?&|auIuDRbJ7&^CZ$qb58$Jb@!e^I%AN|
z0JOJOq;o#b{ziQ`>e`L(wvnIt`f(WA-=*p0rF^73#d?CKmzVO<7k*D6AM3PvDV4v=
z@>4Ice%@2i&+C|z246UEPHG-vPHO&Pb5hi&lc-O_%}IYq9^Dt?n3MLNd;JyWWp!#!
zO1c^9s2!qw9pyo~dMDufiNBpk|Mqyy)%%V$v8UiWzoF1{^<FBf$~Rp%=$*)v=z(+6
z;m=d<otO6N>irnwMV`}=u3p-IJV858pT>WVF`s{A@7(lR<Uu;-7UQ97>5-nfDSw->
z3G+Y4+%y1tfBSu#(P!>M^U|sj$L~F<`nbKA3k9H`J9%zo#2*m8W1QZzb_d<Pq>p^p
zfb*WeYn+~ect#+eG|%WePhEm}fn%QPI&$zlmHLYF%~R=nlBzMs?>*HM|JY;m5&u(&
z|H|{k|A)^r`1_sSIV9$Tee)6XM=c+z5682D^6?bfEcI=#qEEU_n=cFz#(+7c>Kpsb
zDe3zcEsZ^4$M*CGuOaLu2zw`<NoUZ1bfVtGY}0+#0=GE(|Fe^b13icG-9$vp!=8iW
z_zo$;IQE@;eP43Xo^vkUvD*7`de+6c3h1$%i1)ze-TDvnu5s+0GER8sUYG8<$9#{5
zXyH*G<+#svW5sCF5z&c#2X)_$jJ(cMEU+SeGzb1w|9Yy;fj3coP-`d{J75kRHRK$a
z=D$@Qee3C*o_gAW@c&))v<3I?KMyqbn+IZVAjhMpEavnpXIg7|9r3x&O)Q{&Rd{!|
zpzdO8Kp>t+&><NZi0`3KVJ&pIC-h06j}FjzFQ4z^iuHKc!|_;;KY48PPTH5^y7BHF
z9q4!C8FVT1pc{3rt@N#!W6WaAcrq#qecW5<;~KF?iTe&S`VQW|M}5ZE(1o0eIp$xG
zw-ZobY45NjujtI+7U<*d)*DuTjW$htJNovA-`S?s8Wx3vGvI%)4mMhEm~e2Gw%*Wp
zjD`Ln@*$k3f;~KiC2;c%`a$0FJ#P1%koVNXhDi_QuTRg3JMEiOjy}NmAnGv6Wf#`2
z`qoK&Lj)a?y4@{jM@GgV{p(N{ze2to#Cvv%!}uZMQ0^iki*c`sh{H^{`5JjTbR5hN
z`6CW3pML*1`1)Z?iFhI|J?#d2ZX=DgVsy*rzEQNl(@{nP``yhrJMxE=QQy1^cQPLy
z>fZT+?;ZDrZxrd<=&4_~rsTwZgmVRve#d@$$Fryd@3niMRpWP0!Wv57JR0gg#xo-$
z`i9-|p(AWs!|i+a<=|)Q?4EU!;h(8Lc&+3`dVe?c_YHIg?iW}yruo9xs5?}LIPQ*l
z#iY)UelGUM`1AZ=G0Kwq%yhx?gCOK1_sJ8`7mgpYPc|Bc?vwMKhVPTHN8;boCmRsI
zzJ1g;I9HE!Lz~eSy0QL8?eTp)$0$vXHc;*)B6p%q@Se-@{oCRRZ>=2|(H85*yxr3l
zUmegE>3fl{R9hUXj^yjOE*eo6Y0rw|UPHO9!!zE0eM*iIb(HjN?}kq03hY@~jJ29A
zPv5t5&keo$wpWhm)wjJz|HJid|7qEe(6{~eV13)%hm7snGd|Qg(6p96)Lv)DK4<I$
z(sXeD3H|T+ba3ZmEtTeu4t?8)F}{5p`(FF%;9iFQ1n=<%>EIsfd#0bF9_pW(Ud+u?
zFWa>>%)0+cS}%RmIx}<D>|J;Vz2$w(ah)(nSb?$D3e=lD=)bXVs_+Q*5;)GWrgn2m
zch64Jt+pI~P<M_7VNMmFkr|bV@3&)S;~cQjuio2+zQGq`J|pJe1?V5z&<@c@c(q}z
z4g25<_aMxT2*dHNiNal`+q&}-tPS-G5A%5~JQ}O2@IJwKwLrJkyB_1(f!}(!{1{!E
zPEJ@4cfndJzFS-GhP71vkn7?9Th>ykd<#&%ccXm!>aC@3@f~_=+wjf#GM(#|`Or^`
zwtdtM<38+1oKCuBW3Z0u;{58ptvzKp``B`nVJpgz_SUtc3{&AZkaW`a^@lYo&0kMh
z%|6zKvRbYy@IE|5S)G5K^-7e-e0;|N-9k>RTZqOLL+x)K>fOapzO1lzs+H9g<oT$+
zWi_XNSwRm?zp`@p!}^itucxf$^e-z-e@)-<)(_viKGgGpzHw3C?C*}lnyU-GZ;zRX
zZv;^{$3bsjI<3(R@vRt*MZSbizVe>$hsJ5&57D!d#)SjFRYhIF9!9a+F!7hSJ%W9)
z83@-O{Zya}eUCSB4DF+_PPE=;ak1Vu8)N*8XRXx%sJ~xh-%Q{2p|7A<4KLR)j-~HO
zd&i(O*82+jSMvva^PP{eg%Nu>$vu6?Oy`p8@O<5j{&b^ymrr)%HGQNU-cWHLC{yFs
zA@|LmyzsddU8{81W2Q%Y>94=J8|RYsACr1_KC)%zt~ehthW67M@r@vzTSoK1dC{H=
z<8pi#8g-sy{B`cr1EEv$N+0VE$Gfhr1I`IB>P%tAQ1ck9cZ5;D;4qsUzk|(Vs9)zb
z4%a~A0+&GS9SuW#*zJ(^zG3rnV~+*6AY7YijH|eKa*WQf`lQolZx<c;H;2(T-HUa)
zH4(J8#(m0UaS-2jPw}68IrjD&@!h*lefLg#`QzMkcKGT{pV7XIy2%I=-)pp>9E~!r
z=X*rbVbgcM^nKR&Xivsl*PF(aZ~ApL#`EFGg9YWACRStaTxiBz2;Zu0pRiGE$EG`_
zzeT^R4mu2dp?hm1;`RPy^BN20D-;(;eWN(hx#$5HyJ4U88H}}Oii1-pm%jMx>Vx=Z
z{X>LFePGL$*}HJ2#jZyl(;aQby=ad05!w~mU5>o{z)iQS?ia>|^L&guT*VV_y5f5~
zd}G_1im{ywzOg;IO3ZZJ(-rZhy@KyUe<bZwaF`v><z>3Nce?dCO8{$CSbM;;8gabL
z`EKpqz{!#7T!8^`p*rP{`0Pde(Y7PXovw?jLtarn{0;u`4sJE=U#9w?<qgb_AddVU
zm2o+JtAlS*N7v~+!YCic<C{^+1O85j*DqRdj$w-v^dmay0$QBL1-_`KZ)wH$N0B#_
zFU`~r)!HaNOgPhoa}9mPgjOr=L-L{4XdUxNv>luS(5s)jbMa;PmT>m2lNY|6In+E7
z;q|mni?AH0^Al)&M~8ou7en2j;z;or?wi2>>X;T@o*&<~qaNS=|CDu1e;=I+XD}xw
zU8<y0f%GNJFk1Kj5IqV0p8fSCOhNk!LEXe!tkMBYdU*%y0X~B@4u=j^dJdDh=|b*{
zP`8KG1N;r*>TuVq2bk{R&;{&`_BnC)8SJC0hJJ&A@uU9H<;Us*{vP@g?m$|G)0g0e
zZ}5MtE?_qc>y)kk0s0d1htQXB8u9C^FJakFSYN`7$&R(c-uHJ@*Qow{0KLuBM^Yd9
zFUaWm6NI`!I)O1)SzU|1+@TxTAJ3H*=t-b8N{5V|Gt23@f;Ei)mAVuD^<Uiy19b!c
zC+bcZ2i?H*?ts1>Y(k$lP&e>@btf!-%b^cx*Z=3b6NZ`_JI;)x{d)fY27SOcW6rq_
zx)O4rE8$sulj0aR_dSmv=VpZe&^aufBmRhXRus)&d3;UtVaM72cVn(~^Z)Q{|AF&g
z^#5KNL!94FI;H!?AMYpghna(u4z7XcrS{2lnz#R3@?GgR?LE7H)KBH?{^xL>$}sB;
zn^<oot?kfr8gsfn=TCUEj#CrfsbcKdGe^cejpxX{I!@`m?T4-+JPzl6?Z-K0r2BN1
z)40R4ot(D#;>>~<@EmVJ-^yz&7=vPs<)aH{?{e2UVegW6Ykug?oj9YasukziXXxMu
z>tlDq&nfJA_yq5-X}r5k7`M>c=N^O~gEj9*!{&eEuy?|k829<?2KeznTxc!B1M`pF
zn18H5czZCXKkekP+v>bw&t;=ts3>)g+4JbAJ1b7ZPb&7E;yawy6x4rTm)k$LVohtY
zlY49Y^n#t+KD&L#ZoTK00GvrXO6PevOL$=Y+_a^V-ZQ~0?y`2J{8n@wnIfKk1mR#G
zUMtUqh1aNY)*S&lk1f05_DY<yaLG6kwFhfe<nAM!d%Xnd`3Q5{y-3di{lwNL$|KBk
z`{vt{ueuZWq5k6=22Bqx=_sY|qg#+qq*HZV#)VN7R*}-Hiaj{nDGbW<57DLu<vHAv
z8){Re`;g8Dbex@`&2=%SAU)|c*G|DVFf@M4!2Rx2W&14Rx(sV$6bB;qJ;3Zp!}wM!
zzAboLKko1cde<%K*x&6a`}Cf+jd?T5e%aL7yJ%m;0o{bw^3Vr%)}8IHA{{ZCQNE6{
zZ$;UEs>=RK+=t#>Jf)Sr2g?4+Zyff0%idF!J<UCzMA_ei@Q$GD+nqdjr=aX_K-t%#
z>|a3HoAi#d_iQc29)CyKck4&BeiF8IXC=!1NxcbWZ`$Ia`}dwpOy#+p)=p8LbjGP;
zPXMh?Im)u{+SYe||2V{+wVw5mO{8<S|9Z$bH_gVH$jgpz=!^QTcl4<PR@6zV1CI5M
z^L<OtI%o}eCr;~<yk1P_`1I>joV+{BQ>-(~q38Z<yoYzJXSHCyFbU;!@^r6W5T6ay
zm-uYyJ>zAfHlN7GvybMe#y+~sKSVs^diob{t&YW^uG1RsJk;meXe+e8?~xa#<E+Gq
zc>ci+(#7Y`n*$y1qDe-&i3Rj!k<K2+ew*HOpnYN8tO;TJib<_@^cm!b&Z61(LKMQL
zvuNo2LSE-0e-z)k0qf0mJ?#PR&>rg4dh@Gj0|(KbdgIzZEUd*1+MCGbJYMMzJ%2g(
z_VNAGVI5G;1E06O?`pI@e9-f@Z(XIb7}(w&<Hx@B{NJHBv<^Bq{$urq;%rQ#&c44K
zeJ7ol9InIJsKfN1MUX$NAE))7&*FTngWtRV9FP9<{$cu0+FQ-fPDlTFkLo|~)cQ}h
zAFlu0@+14t_tAg8uKLd{L-d~oc%Gg{e`^1&wabcU=V|rq#NKS}+4&rvO&;2_({sxf
zxLt;4XCR)P(Cwu?JO2!O>W|K@@2|uCfAT)11?MXMXTMLm@ehOFr=;S2%IweieM&0c
zr{J93De3$^1?M*F)Va++h4(4_-lbenezn$5pXYtbT=d8P_V+1$&cgno?^C8BK0o$-
zN{V`)@|NRW64LLO6KeVJ6M2{N-}d|8_Um{b`rr2Zzwccr?eQ5-ugVvg6FBydWLT^L
zi-i$qp4i72HqO6o{J}eSX5g&7Zj90C{X4xE{u<-x_i>)}V|ZUsrysY)JW3oTSvSr#
z)<f2WH3%MOPteBkwD;7~-L0L`Rjwbu#f*8S9rLSimWb`$&*-YVaTa(JezPAwiy0Ge
ztgVrZ<^vo~lXf2H#KT`>oMaT<IG@AZO5Z#j#$1}_*)&h0wT>@;BX;pSeA-_!wr9M5
zc75-8kOOsa{P$h)cx^m-VV|{{zVr2;{JUbDB^MxSXYzblY!AF(&M{-g?x<GZ%4?RX
zv*YP}2-2nE*vGLvV_9{E&c!ughR4E74A}EIPK?<+&TD#*(K>T0e(xIRJw4dnI@7V=
zbJsXA{RsR7Ty(_SAtQ5)&SUwf*cbTo+uas+uMn$GPk7in<aX0S-^;}6cI+ive!G4l
z^x=*vxZSX@z<Kf*thEF#pLkW^VV(DMH@$g!t8U`-c%19(*aNy7VJ_FX&qutyX|GVA
z?&0g^-ELeMGgqv>5be`#Y2KJCaVAy#?am7y4%V+u3ApUGM=>vq$2*o^pbZ6q(O~Nv
zzt!9=$9*^4cfo4fyVy4Ju4@+S+?QKN8Lp;1OdD~Ioi6VY?f0GdE%F}i`E3m^T}f_8
zK0Ex8l~epvJ#_x5S6lq2c(_M9c@*fxm{HL>kEg(UbiUKwqn$O`J-W&GJyQL?0KZ+-
zZy)@2^WeRz<YyAhqcpqviSB_O(VianT;LH%>3IJF{{H4kotrE6U`D!?ZoKAj_klGy
z|KDx#>`|*XA-yplk6carf`Z0v-sz9^J{Rl(2*f;)_HPF2u#SNFS@#^F>8R-L*0~FO
z7~^A%7JflObU%a>=<9W+VuP+gZz(nCI`yU!gRaIYuFRmzH@HKB*Z6#OKQvnB5^Jf}
z>C$opHs{cV@WyBQbm>Kn&Z|W)O7%wkF4t!(JJ;k~Ec-O-l9kyz%~Yiq*-=7N=uDM*
z(XKOA=tZZpf9L|;xFGj@oh~69%470$79q-XhDM!=f);lxPH6PW7ReO%Zk>0W1>vVB
z2~n%_%hQWyof+mX9d4l6dxe-9bixWxcAc?GC-Uh|@MjG2Nf&Y9+HaF+!Afq6$-Q8-
z=rD1(*Ourj^@n^!v2%8Vk0>1BUgaZdjP8v-qQ$*kSMMXrMt6~YsTacQ@^Z(|{Bc;P
z5&7m)9Sn^VjWzJ+Z7lZ@&ED>nKBC>b1N}PPd#L+;pLn_pvk+!OxbV@+ZHmrZs&{WR
z>KgU#<wj9G(!I<m4voYiRH|syy%4DuC-(w_=y2k+jTSAgkhz*W#|pb!5mv`IUY-{B
zCY=a!uhfaCLsYtmtGPh$-eeF(PR0`k(colkHi$;23RuGKk_Mg62~W|cvtyyQ%@|(h
zDN0>X`l7_WNLLDjhq2aElzY@U!m81m@|{J#lMx?UmpZxQcZCz4pA?pR?TGNsk)mTn
znF_l}=hNYdg3LqMc9-xPPf?|XUFlw|tM(Mt9>zvbQQI5#alNUOLN%5-i)tr#{65qZ
zcK*olTBE2LslpyDs?qaRyO}$^M1$L*p7f6vjriT@;!|N39WKYwvvD2-BmXE5{mMp)
z0t2#0v^kqfN1|4Em5dZ+BhpanBi)NfilUKtgTQ_+sn+u5xULBCZ_)CmM2mkh;y+a0
z6rv#*MV`TkqAW2`QI;FZu*re)COc18>x4$q&Uq6oFet!3f5f2xtpmTEDJBIYyby^}
zicj81cigzJH$Feu52b_ZYu~FI7t9v?>**9aaC^tq*Ip#T?a1!#c3pRO1O5s8vmiA>
zoWsAf-Kp?|tkFy)DZ2y)+z>TWSn-dpe&Ml5z?sg1e;0<xD}SB7?w%4MYU<veI8C^Y
z9yig)cj`sGzl7dk7-4iZ47l7KW)IUCXRq;QW%Twj7$(zigpTX5D8Qct{8^&!|Hnf&
z@q#HAUlJO5wM~fIH*J1kfKeF7m@m8}Z0?l{k`}MJRX91j8eKgd*FYog^mlPT{v_hh
zCVl@uc*fx>5ex7K=dg>@`u=}Titz`vODBvYO`gt%@wM7DjPdH}H?GJIyCo_#?8a4V
zR-|SxUb<$@sx@=PEQ`>7Swu)kNN7k{$n=o#kQpHnA(0_bAu~fmLPJBtLZ^p@ht3F%
z2#pMl3Y{4i5*8X37B)RBJZwf-L|9~4RM^bvA=5*rhfSY8J$(9%=@HW-r$<en86FZI
z8XgutJv=;oMtDScWO!8g%o!mwLT7}{m_8$X#*7&eGa_e1&6pVx5)m2^7BM{{JYq&f
zL_}mnRK(24kjT);u*m6=;gK^UBO)UsqatTUg+zr$g+)z|3Xhr*6%iE~6%{peCZaeK
zx1WiiXTsY|5`~6M51$bc88tKYh9zlBZxkZ<5{s`d^^4knl&!cNb%{+q-6lEHF5*|H
zghR0ea%vv~Y3}OoM(Y#<+1}XQjpi%{GUe8D-Pn&L2D0|~_HMkh5d&$@xT%}k%|HrY
z*KaW9LjngdVk!4<-@z}t=3E){%#n>@U0&CJz4)?6V=mn}<IAt#e9hxEvFY=@zdJkc
zj;8JVj%NSiz27I@a?yw}FJJT0r^lZ9-ThxLy!7VS*S-F_)Bo-r_lcb=4*ogl>*ws^
z)z40^e>Xd!^nwRky+`jzGk#q2MCyId-adbFo6&Z`j(a}caqs-9vWT$V>#CDKxa!bf
zi|+g9yA_qQzRta%(A1dhGUJ3_m6u1=m6whE*$4Ic39DS{YYMt|`yF=cZvE4NzkTxj
zk#qliulVt*h}ny?HlIC`nm2k~{gcmMcH75)D?0Gjvl*Fxa(+JYF2B4hCS6hS(jSAC
zPW&)w!oH)?@Beb^11raDa(nx+Eb038W3SiqMOlW+uKh1WsbZbtH%u$K8M+c)Wcqbz
zwBKK>(NgnQjsD9&)p$k^^+@Q)_RV>YXnOp33o-Ctd9+8{-eLLYUa&ND*W!;r!+}>P
z-2=Y#vzkYrhOb*@EqD6|o*J7C7rt`05I0o3)S9zL*l(M#@8Y)`MPbFtu$;SoC#tS>
zjTxW5OFZ&P{gFv894pQ9vZgNhbza@$6ASl0zUuK=o|cYj+YTSeb1CY~fflBZ-S$Vk
zJ#yP4|G4@l!|Shp{_6cxH_o-@uIl>z-mFW?_q_Cb=a1qe#!QTS>E%gHFaGNNyswf+
zXU@9cZS2lx#*KV+{gDT1E$_ws#ruWl+dJ|{?M-;_mit3n6Fw}9@v1p{(Z}BR{BmOJ
zUnAdWs6Kjn#~x=V=V>oLxo_etb6&38cmKz$l25Ha5_ZS7EnhTy-+93H%*v2IJaWU&
zXEd$%{L9#qmX?ctd7|d8T~Dv;E*w)AJVm;G`%!VQwR^4Yh;Q7f+PK|6?^sp){;Q4i
zpLwD<)Jb2`ZF{OFZS~iGI97gFlFLJX_j_y4rMDD}nE2_tTi^M%*m&j-JC1(*#;L2*
z5-xoHPcJO#nEXx5*4MU`Jn+(!r@!1f-uVL4GS|!MpWl7r_rELr^~cM8@tdt4&Bo3n
z50!7bH!F7kuK8uRjurp<`<|V}({5Q(e&5U`e;>2uWxs__tNM)c>2o>ifu-G%e^q~5
zctu0R=X&F^7ca_k`}o{ltFGUBu|EEji{E(C<@&S#eBEc<UHdNI^j_ZF?&SwU9$fgu
zpLflDZpVdpyS?zzL%-Q^*Kh7Jyjx^n@W>^T%6>n>zx!*`JAa-g9ynTeThw2kdm{11
z*-3wT^W)8Lo@+am?03i7f9zUawsrpW$4|xl=}FIV&Sg6;Z24RBoEz@F)c59Pa)N8+
zzit@+ZgpMj9QVogNYBIW@9VF*?V9@>eH!&Obm4nD?YdoYwR+gkaA$#wWCn+_&kw$2
zpG#lAK(kO)T>RbRq~>$M{H@x6>Atlu#F2xOv+I|W&#m*$dQ*ROaMkB`T?nd5F5Wp=
z5uAgLQf^OaP8uyl=vyD&T=Od-zWmwBtDbsVCtf{u@ur(_TIwhFy|B&sx<E%Y7Z;TY
z*DbG2HS7;}3ftGQ#|x*pCy3dG#6@#;iQ{7LTeN7==tPy)1YtD^gU}`Ftim}KHj5S|
z&R*bbNSwPUcAVFuMGMBEX^PP%F;18q*@GDJ<>frrV46L9?%V~77A05{6Bg+V<E*ot
zM|+JMosj4?cl2y$tL88v5dkfAHjTDAo4ic8#oPrME~CdeFIt4qapmiMjHQ3u_RTE^
ze(~sr51xANmWo9omT$*zIW^;mZT{xV-Uz;Q>7w10%Xhv%*IPQh;r-9oUf%i2gmYO>
zI@*Q%Tgzvk-u|n<Mt5x}+~eD@b<@s8q5jDWj_rN*i9OpYR{#F+mQOESH?`!{iiJ7W
z?eprNy7tJkwp+(U-x>L<Z?B3dGQIH2;<%_)r|vI&W!9Y+9sX_h+Z_)ac;NLn?kfGb
zB5*>nYxwDV{yZb_+nb{Pd}++fZ@z!LF7LV5k9kjv{rgMzzk1PMjy$~l-n_?exZN+a
z;=QllT|6r3#wQ=U__G)Pac}2`UsT(>cbD(kyLZd{+)U@iH~em4$ieWG?wVH@UHshk
zg5O?!|MPbQWcjT-^ZvH#kE<Vk{{1J4ZqLqtWAU!eH&lCDKF;$%XS?z4XG24mF1o1l
z^@<Ja8(#h}=D`t{UJ`i7l-zu5$J&es{rq-2o<EM~h~s(S=-0JO7TiB`Kg<24qu+D%
zUs<XjO1GbUvMlP&zs;SxbHc^be);gUZx0<0eRRnu<$LN1qL%)n^1Y=`df#JwWz)_J
zR$q4J0^6aae@%KKDC4Rfr?zH!r+un>cmBH5J0E;(#iPGnetXsW9GB16ng4$4Bh86b
zj&>|<_t(9&a7NuTr4M|QToriVM~h1zeE#9f|8Y^l%=f}yc<Axuhl?Luv-9Pzj{Nmx
z;=%(b_I)^e>gN-_=*oXQC;8YzM=bU4FPyUei|fW0&kFH<;Kbh25AT2GqvVB0-zkrd
z{bSiXxetA7iY@zNeEcnc@h-7Gd-|Ryw*=)~`-JJVZ$m)n_LCo%nI8JRd&wi;K4kh=
zK*yywykqgN`0X2iyzTlcW9`9zuW+(9PdTuyJNEjYm)vyE?COG&-%pr+eAlFps&>3L
z@el8;d;htW2kviO{%QL|m+F7_r|565{dUc_1>gSh+k@Yp`1Y%BM|TBvUEY=2wZ7~A
zuBW>Wcm1<VoSk%b#@U3k%g_GyZ0XtO&i?J}>9elqE;<);?z(f?=eC{Ob?(r)_s^X<
z=hgkQ?s?ryy6@<Iu=|<rBi$_+A59ifVxd?e^2MX#dC@377o&93beHLpb?bCHbQQW+
zbRX!tbmR4*`gr|~`i=UB^v~)W^sV|4P8O$2ofbJ|Ic;%z+^N>-U8gUdJPr8Pv}epl
z^9Q;x3DPc_y3u8t#w@*yo4WNfe6@_r@dy`=4(_#`I6ebcvs<Fpv9;V12b~PP5Ao79
zSDR_dXuZw!#dV<l<+3}r(oGya+}*aExl3@9v_C%cY!jBU_&MG)_?~$~>e`GYi&rdN
zv1-k&i*LC3#v7NenYS!{#q_YbS1-(-zIbuy%+$=xRZCK{S3y1(mvH!vNL!knnvogd
z@B}L?jr6+^5AD+9a&j{Ccnux$woBqy%m@h?;=W7HcVAe3N4V>T3wPc5!i6PAegoi(
ze^f&B>~PEo?etR{<Z>B~fsr0pG){J0^qa=n>T#yk3z|pLcn_14=>f^xUZ4@+-*Qe~
z{M<Zu{q{S)owen?baBBy54-Kfg22qw7t)^(HHgPA-}=-6eB3$3<K)yY0)<#n^0QeF
z;NJ6m-}=Qq+@52=b5uw8G@_(?&_(z8(m#2dHrQ163pG~w<i^an-f`coBl&Os*?o0|
z<NlS~uC}$Of0XZt$FH9CymiU?;1)-G*7-So%%fb6*Oeo0dc~Z2=mJOlE<19?J<G>-
zI6LAw>Z?Ega{cemzE1JIdFFQajI>WZKmKj^m)9bHp8iF`8y_^?5D~ob!3Xg870<`a
z`RYv2ZDlT3Rp(J{{`C{q(50))i8L06QOuoU&AMWI)H=C%q#v1Qm%fub`)FD7;}zjr
z5sk9E^zl0ZiLWG{&eF0bW5mI4wqLsL;JR1mk#jNb$gh_sta<w4=7YSha`c6N?Ai6v
z=Ho?Qa7o#=25tUJN=xAd4`|NCt-o9~>A<Z&OPD#C%^!PywEWlRw@$dJ!bYvvs<;zP
z*`1x8M~oOT5|`0vba8QU#pUMa=I-u33YUk62d3X9T%$*i9y4alSX^ElYVZI5sr`mF
zVRdu>L$~6L;aXe9`C1z+1y6}FHx?JIopn*#EKBOzwM*AzXRKOjxe*=BQb;aZE7spG
zQrFyc^NOV_vn?xEWm|4sb@R$Ju_SdR8P=`I$X;s6US+uv?#0TRSKP34jU{6(B&#ep
zWZWcr`m*T6U(A}NOiTUOX56-PF@g)QOj|k4vNUJO(xqu@Eh|!UGFIHY!m{?}tgKaQ
zvX`b=$Q>epDBQdfOBPGgA)9vlG)o3zs4Zex)@HBCSb3AkSb0loW=7fo>CG#buUxgR
z*KO9)B^ftnEL|g3WUO5aZ$pQrlD2kT25xA%am}g~h}p`UQ!^=@sW)e@LQFE2Sb8!g
zV`bXX9E!vc9($d`uL@-dkE>Q>A^(E2Ggd6MAdyR!ucee&R;I2%f*tPHTGlLGeRIZ|
zrItCDToM-I$flmOXWyE&)UviGjXhbCk(r4=Q`e*}$wuK!TR*MG2MR4yI5N`V(Q%ix
z78K{wHGNWg9;a(FZd%zVsy!K;wFX(fmTFXQ#Cl~^gQ!ldgI7v#b~>t#Be@nzPj6IJ
zareZM+*7K0T-=;}W0c_PV98pQv62#t;8xy@H2zdpwnX-to0p0kQ#02t6}_umvoD(y
zJNNQF0=4Wl@9N8uJ2#4}XJ0K=rmhq#m)?Y$d&^SGx{S2!bfNvPWf6*j^6MtFj2<^V
zr6hWO4Rnj{6K_ubuUrGe9cccpn+|k8(EOk3AFrh7q9IJbOUW_W)y5vN4ol-q9*N{B
zfrUB9f0?pZ7LMVOk_u6-e&O398h6DyEX*qW6UxU4SYUk6V;`&RtJOGrxbSO~y?XE}
zXO6oFyj$YmB}fj&em&tQsqiz^!bLdjF&^)+&sO%OYFv;{!I*l6e?2#V{s8Tw#eu%*
z%TxYywQ*%n#t+ILyRsjc{xao1ndStzRQd+_&r<fP9u7*sUD=zF4rIk3`(mE1V8+zH
z{12)7TU5Z5KR9orCx4DB`$QV#;j(D|56+)#WuM4*9u)sNUd|AQI3EVt7pQTX%BDf~
zMc-jxqU`aCldeJjtCW2+ERn>X^mVB871M+PS1$hbwRfKd6D}`{29X2fQ2ARhh3#qZ
z>!}-@|E7!BzF-*p5`VTYMF#Y(zh-s+=uoz=;^=TLvq<~DJ&X+}hOw_#9Y8aN&waxW
zQsGz5VgCc~pReo_;@N&+{*@^E@T=H<VE$D(!dLb_!{lH6)$HGoF*tq7J^}vmcaXi6
zIyPMS!-QYAK-p9N58*#y5!?F><3Af~i*&`|ADqN$2K-m6(no8Lbm0{_U4!D+qU@7l
z(>MPcl>gY@u*WzAj=zKa7bLSi^*^`<**D>3B3((0LH1GCv&C@sh04AVEeBaN$iF3(
z{Z}#uwXX(cPw)2ecaZ<wCG3%2HxFf>xRmW1V2Nvxf4`f~Z{Ly5_Qk`*zhF7r50}5k
zGueK){PkbS_QU0${X6U%mAwg>J5>I*tmg1Tkp7|U&1>0yxcV8L&Gr_gACIb7HVM(8
z>R0kDEU^Pag?~cX<1F|g?Jc*m|J-5XS8^NMrw`-bpk5T<Jl!GNUnxZlSI98-4V&2B
z3lr_W&tK!ETw$8Gvb_=a$2F+_v~6SiE&x7y^2eh5w-mB{3xNC^<iBA%+f(>M^&gG*
zvOV??^=seZD*WX8*?ze4v#WKB+F|n7`XKwqUa=v|r+(-8?UPE_o}P?D#Xso}Y)|Ds
zlzmAl+qWZg`u1N5Dt!gzY=0d7hpJyGPqKXr;y+aW#_eJI=wZ^A_Y~V>w^zUMn_b;M
z<Y~4yqvZP5{}N>%x0mgyeGC=9^nGk^H1<zlh4P<ufbBbn^Zx?d4;TNk7uo*MfcT$K
z;itdM_9+A6->K~DUSs>9Vea2i&-TN$&#WVCPw^kBeAADzJsrS2RQZ&?#r6%rQ1)4G
zEB~-W{TS4K%KyRkal_ody@~C;hDo2{BeqW-#y;g^w$Fk+s?ebOH~fq3RWl!CpF#~E
z7ma_1iht2bwjVBhLmS%<7k-hlFB;f?QH8<f|26wRG)(<(>ty@FVeE6iIlsL-b$qzu
z-22yWi@JZJk>lZm#xYd=$Z})*;rhoUceZaDCVo*KY)|8Zq1s<F2F-L0XJ0s)?bCsw
z>R;y=wm*cxC+K?n_b8RV8XStKUBlGB8Z+Au?B6n#{|XD+)A)a=`}<90dvZQh`cil^
zmWW5q>)U^pIKrRC{;7ZLYhSJGi=dR8uBu_`e_RmT*A7U3o$_y_fd#IC_Fc-pZaUjj
zGKVVv7HSxD4U>N@5z0U8hnhdfM(M;FA>yq}83kg<6Cci$L0}fl{!D2BSHbMVl$DX#
zh6{5AQznBkFefo(9QX^EW0}$nVhcjN7gKg1eluWhXUcjIU0$$t2Gau0g}o0`)*-zQ
zz&;-ws}sT5;6l)<%!iO)7r|Tu#(+iOD{x;3PDMBcOqs9bd0-^ucBae)<KQn2oTn3+
zu}oVuNa6W`k089RFrC2ABDe&^5F$7Q9FK64nKB8y5#~gui~}dY9Ltne5JT(uXr?rQ
z#R#VZ`!XH}>%n-~*D+-=Xu@_%BEDgXFH&YA%rX`v_g1FNM7>%8b2?K7fs`J9rp*9S
zK6U+^({&uAd};tGpX!;iPRS2}luxxxSp!l&<%1M%9@CZ!Qa+`Dluywh^kxR1_!;L@
zDM<NL!j#1z<x>$;=7W?^c}!^sDW7tgG6AG~3J1$TcaYL;WXi^1&L<+}({W`cQa<H@
z<lfGd6=<KBg2b0IWhO}JNoU$>0@!^uQx<}hZ}}jlGaICGA=3S_l$l8PO9v^R!ohh6
zH-u^P12OaoZuDo?f)ri_NZ}DFymDnGQh24{KKLsDKLv9@3MWWWfaIS@{=3kBk(o&T
zn?Z_46Vp}>QhG{3y1yNa1LN5~GmdF1fg`fd1L?jM=r^@^f?7P4xtz_i5TyGQFm0t%
zb)p9T;z7#)IHo)?MJJx1bbwkq6py3BBX<o<Sq^IP1kn`)7b$ZANb$;1<}78-^<{ZF
zNc~A1xF4j0<S1MdQ=XX2_O)Ov<TXs00~!%-y0VW|_Eu$|cmey121mkOh%%c%3dfx(
zqkMFt6!$$bNhe(3t{$ZLR4H?rGTTA&m&=q{-t4b<BB$35q9}rMKy;Cr*-Tp&h^{X<
z1w_{rTx#a<y(Ta_#&fvsOj!+5K30M;U_MCgJ`bdJZ)eI}CC>q=-Dfjp7D)9Y8l>`#
zV%kDL3eOBuyKf)I?Y;n{{xJchb|24_aUiw(Sf-2usojS&We7;^K8Ps=NbSDai`#t-
zNaa|~l=&dlM<Uh7JY^=rEW<%^AHtN$V|BEbBtD5LeLzZ&nQ7}7!}-z<Qu^DNvPH?8
z!6lG4F=ZV{<(jS-56*>s98<c3b+B(3trOQmUeA;TAmwKoNcT@++7iKiaBncNoVK#T
z-qz&F?yEs^U&XYQgXBKRgXM`#TR2GJyDPa-$-73e`)crV#HWfWE5IvYE@#RVWuL6<
zlazg;vd?kn`(-n2R*>?+0#ZM52;);Smw{BjOPMkgq<A&Cvi}oI+i?(6>fjO=lo#yn
zpdb9@GNq4_=Ns8y9@CZpQoW7?sUC)dRIfuoD!(A6^atZ$-+@Lu5Bb;5v^9g2fAt{U
zuZ}76l{`zyGnKq(1jjEIB=<Q?X;Sh|XO?#`We7<5U;-&0+?g`piNk3|C8d0CV#*UB
zl}jU2cHqklvTtX~HjwOFn9>ANy1Rr9-#8#&LF#uJK)P=+Na-zN+TxWw2&8)I&y?;;
z-q9_D1>rS=<i8fAc-Jsx!#N?)6$aOWWM2Z3eKAv(oyB+=_C+AsXMtp&$&|^M_oTv{
z#FQZ*#V?3yGlEo3P2aNo1k=_4QaP1iUPbPUnYJ8|+$Sh`ypmf%a_@eI-5Z&<7R=ko
zeJx1g)G%$8Ai2*4DSvaAG7F^q&t%FFWgn#M{gu6+vXA?k!;NLy{J@KFKOd0F$p}*Y
zG=Px^S1@JQR~)Z;km6OxwAFz7;JzI6gZnb3j8*awB@a^a!Y|of0aF%saQq9HG9RS$
z<uPUF7wo=+DdRy(ZyZy`g5=)Hl-ZwiI#R%T#48S@`W6LJc^g2AKehl8ZPlN#ycneV
zR>YJ!N}d8@s1Tf>%t0X47k{QqYRBFv*vElK5xyTt_7<j$J}tyl*av}RZv@HSz?7w*
zu-p!kJeMiWAiCOkFQ#+{(N)JAnX;)(h{bS!f+?#&N>?S*RtQo#7J%2oT|QIhDY+e_
z=V~rf<|uhKXoEb9DJ@_!%sxyhKnl036>A@mcQR!MNcFZIB>Ohd8}=<s*{tME;LjmH
z!Iae?#k-1WD+8<GKl2nb4g5XKl~_+9cNI)qA*iJfr2FJErAf)%mE5T0Em(-S2Jx#0
zuLYAq@}C6aRZ4s!Qzj^RJV^Ny$CR;3ZUwJ{Jen!n{)N43Ft;#eJxJl!fs{Xon6eh6
z{HXz7fqgYd@vdUZN+quVDSyhDG7qG5+nKg3@EQ1z`X@64r2NVKnBC<tZOPy(kSBp5
z2rrQ-6O=q2r2EG)Wvr50K}vTtQ$~Rl?{H-w0#f{fn9^U#{lI9*Ella7<Yw?v$i0}d
zt(oK5!nBowT6u#Nh_BB_Y;R`T1W4)V`jFGn$&?)+$=g9nM;lYND0wqT@oZws6H49)
zPKEq9Q#OE<zH*TAxr}Mc1u387z}=wf1GaZ(+S;1<{w*Mtb2C#mDftPI?%&9iu}W?Q
zDZbH6X#uHT8bGR-W&hxCOTi?#D`CoFB`*SJLSD#}1xlU|MnRs(ly)W01*sp;VajYJ
z&jKSL&t%GUB~Jq>ekn|utmH{xDCCJu84uPWUqZlZArE58j=u}>D&(~w*%yPTqQP0<
zF)&Us9HjIb!M7l9J0Zm1zy|Pbuo^rLmV)<zdEi9c$Ig^Fpc&?Dri=$E9&t<=uFN6I
zYzALLI0hvbN?!XO`>SEfGG#7RW;^&RgqzEhR`7L%)ABC%w1TzZHZb`ep{@7SGzx9q
zsG2E@L2{poL{WWB2VD?e8dJuBdm#@37a%`O%G`)dA#({x{)#~p{1q`}p^_JXR4(~U
znWyA-klKANQ|2gnHb~{0#gv&!o(@udO=HSv@G;!i0;1^#8^A}wW)u>dYH$fi<(dXk
z{Nq3>&v5X5n2q2BglAw%D%|lfccD;0*$gg(xrr(3z;Q4iV#*xwK7^ADQn@EFWdca$
z9?z6MAc`c|0HP>@+fd0+rGgtl6mjq&5JeMQ1)?Z|i$RK45mOd|6t4oN%mx?2oW+z$
zAjK<@DZ{}<Fo!T@+nYEL0p=E_tOBXLD#0+wE10qn#1K3<2&{yC8wLY=!8B0oUqR}B
zLYOu`a3Acu8hCuu$&~fVT&K+bAe;u9Kyu&m2D@)&$|_~9RAzUO+_&NVPAtWnDN8`Q
ze=*b6UeEEW14({}X{!e5K2e|_{D(88;V=yJmnmD&*vMZq({>1?ab^uj<IFOU(w)Qh
znb}NRI!NIsf)suNQ$~U0&!X(z!B63?6P*pYZwASI6H^{i=2~S=Q|1(9K90_b+&3^~
zrZT51b2|!=?Aw^~#LH}MWXcNAMC)N7rb6-M%1ne=7J`)i0;Vkur1U3)lnyIM={K=`
zraRMC`4Xq67^M3bF=Z}D{?b57w*jPdw;f`4ElgRg%tgu^q|E-x3_U(tyonU=W@RQ)
zyz4=VcOBE#{DKgF#eE7vD&GR8Oam$YT?g5HC)3srJ^}Y7AjK~q^n<@VrgT?kqcR(7
z+1|jE<p=maWlUKJYWc{tWrCECY2XYnNtqKs%AaUu4p(L?B2V%lkm|iV_!qG8dA`qa
zrYr@?J`aqAm7OW0K`aRb2Pu1_vNtGua}E2WMMNwS1a}~C3g<XT;WRL1*K<4%sQ|GA
z5nKXl_fzI<WljLeUp!M<_p`suYEEw=I1T>e!3dO79McvHhC?0>P6w-y`80p1WXf`o
z<_~2|nFdn%MT3;TQA}G9h`+(r&vLm`F=ZY)D=L3GQ>KIDFO6x71*u%3LCSAGkize*
zVs{-(TMJ0x9|x&kG%#f~Nd8KdeE~@IJV%++KyshLl(EWeRpypw*uI%5)08<ynT^V9
zQ0C%4v-={ZEPI;GrA(O(Qu`)SJIPXJBDIqwkkX&Xv;~2bem{`XVFW4tjg{=~IMbE`
zQu<RsN>4IV#)4Ws1u5P2e`0r4Ai1k#$~0w8QD%cO3uUf*isMbBcpp+`BE`D`q<EJz
zZHM;YTO8ak3#9VRWXk*szHc5=);!7PYNkvEDSaKgIlOkJtp%j^Uj$M*?I6WJmnn_P
zY*1#uU2Jb*%0uNGk6Naz0JZosZTTSOvmK=NpRLT9Amv|@GAAf=@*i0q2OdRy{6RFW
z;7&x6(%Zq5wIJD-fw7R6GG#J|rODuUW$&--{gi#w<Lu7@V(Bs1OPM>$IGlE-^Z`o|
ze*I&3UkZ0MpmslHE>h+!knW$!lxdH$zrsg2y*VJY|16N&e<stG4pRG10;&Bs;bvHx
zjX%MZc98CO=ntIkTBfW7NnQxfg;fDlMk{$`iLwVZd!|eTsr-XLDj$EQ%?G4%Z`;Z8
z7N)HZB=@CCUZUiMpw=E9WcSHTTQo@Sy_DRf<OY!3Hx%<Yr=BSffma~@wM?0(?Cr`v
zSJ~$%`_c#aekDv>E*OY#(?P077558a1(QIkZwVmDyY6H96$vpP_p>miJ7_|GL8PTq
zqcRg=met!iAB(|Hai3^q_5rE9%}m)`$oD$|(*0@_tCYM*ne!Aa;LqUB3w#OTwrt~k
z%LJ)h(wVjt5Lq2;y@%UdG*kM3^qep=r3s|xggaAqY~^s;nYJd7@}m)?_#FaYLAbSG
zB+^mCl+_@WUp`3j$Ya`az<qF^2KvE$3R4=DyrY2S?M#`Z%!$gJyoJj-i76Ao%Mnfj
zQ=Yh+{WmgY6iD?VoGC*<av#K$DVsSR@nAjT6%JB6wSY&#wtS9%3)5B#lH3kbd&p(V
z6eW)X@ro@tN}0VtDqj;*#{W(Tyh;m>1}PjfNcLV#nQ#}*N`t)>BzqrFs~=2RpU3hF
zkmTh|83$5(k7Y_9a1QLvOxeDP)6vGX)q_+%B}!hb<OLv=Pd4ZW|5;4gekTlY-w2ZY
zI8%BldFMu!cQ9oZNbc+HeBU~ztpud|W-58Qk|%?7-&l~sw=!kz1`ekjBzYNAmfgYf
ze30aMOxbcf%Y#6zUt-z>NcU~eRr$cQ)q&*y5K|T^`vPTe2Ps~eY#*P_lnv|IUp-S6
zfONlnrY%U>`z!mF+qj)IGvx`8+F2u0R)gffifQw?mE-FUlHAC&HRteso0zf!B>Qrv
ztpud_=Cgf#9#gijV}ET-Sp|~6N~SGE*(WP|ACT&knJGJOVfP(OTN0@Ci(oABH5Qx;
zMuR~JH;QQs2QP&=glP)`1L4jeoQ-_<V@e+)<X$(U--X=7l(pGtpD@=jWhM9vm@Akv
z2b3^pGi5S31Lh>Ai~<9ZAATV9SLtiHUpIhc_FBW{=GEMfHGvWEe}X9+mHaq36Y>V8
ztXJ|nFbeWROj)bsHDDy<)l8WKzK(d9K@2&A+p}=MBbc^|<D0^iu^_ptTZv=ez$~y8
z^aEc3Euc5T^<hf0l6!&Skeis&UCE8$&mlK3rBL#&6&NQ#-pP~=nH+vS7zTMAQyx<C
zS}+vy8m6pP@+y$xQ^}MSN?s0zKwid_rAl4`QhbV;(gHq(bmcGS`{#j_&vvHFRq`B=
z@;RF+vy?m&q<l_i$}}ZU0jV65nbHTOe63l=`CkN5{@XJ+|8to#1tfRv=^URnkkZ$}
zl+8-s1X6yVV9G`%KMqp*8ko{@6NlpiQaEO&^ipyYNa46MrBTTZAcZ5CGGQr)6Aw~2
zaZDMj<W`XKJDMq@lsp`q3V8@q1}V8eNa6c2rA5hoz-Y+LOzEZMCh$_o-I=l`O^7|n
zr<^4muWXRwmBo~qN}di<ywaF5Mah#vx_=T=CMtOXNb!wlN+0k^+$TI$h*^+_Fr^Rp
z3gl*x>Wddsnv~ofr21lHN`sQq%U!B3T`3x6CrIIRfK*@FnX($BdXNNCdkq1pzW6NW
z`eJ6vuIt&I9c+cYKX?i}VdHQcLCTloOxd91^&pjd9aA1s@>-DcrG_c1mAne1_FBo5
z`N<r99!Txg&Xl=Io&!>Q&1T9hCC>yYKIu%ErsOFgl~XcPCMkI$NbyNv%EsRanra4H
zL42DK91YTQARMIr)C`(14kjA#{P0p{BFwVoI(AnNk~<=~t5aqoxicjRVaI*Eu4Q*b
za%WOzBDp*MD?AVId}(0X>Op_RqYey4ybm#DHAwNS1Y^N6ke*j1U;z9VGi^m6K7q+B
zWZDYAOAu5ZNYAG%ke(;WAf>l-5kEg-7YcC|%!vzxXo7tZ_yO2-H4beAE3V@Emw_~I
z%~Q+-X+D<*M&iCHOj|NY^SK0&=5rw+#or$!|31p>1yVeU<5^w+Qh0eFg=c5lazP3&
z3#9PkK?*Mxr2L2iDL+EM+mLTTOz97vhS`rPEnp7P;{#GVH8Z6Nr2J`_PbWxXU2~og
ze}ug|Q?|wNI{XRnW7wNPviD+20sbBGwk!DkLK*lt%vs<fgj+IKh>PLAm?>Lgd3@5$
zl%-%f>`R!k7~BPO5mQ#oQTY#2eieXJ|A<tt@|BrL^(qe}cbQ5~BzNh`OeA+{Ai0ZI
zaw55lQ)VK$iv`JDkdhP0oxd^@$z8)`?5+l+_z}rnwK5aQT@^^-l_)up+!ZS`k=zx5
z<StjqiR3OvnTg~s8zgthN=_tqNy<zlcUiN!UZ1cs4}ppBXTczi82byBM}hx9`FVlV
zjvFMKP3WxOhq*bDnW<PG!TxGN@>j0RNs1=Lb`0()JOfDiL!@}pppVQ%if0`<R~qkE
zgEY>qV%l<*IY*f@!F>oX3G_pKNn}ccGE*lFxjcl<m%^!K+R{LBpTd+uAkCxwnbHTO
z@x7TT4IufaP8_tgq0^@Lod8MR$h4IzbBQt+f)u}8knWemltIeuugo3j>?xdfrmYkt
z_a#i33DS5zohcJQav#sMMS;{Ggn+T2A4vUy4@muinJK+M>JLmz=?+qVU<9W^ZeYr;
z5bh6-<KaR5L02%h_f97ELvw#n2U34vQ1;YmqhFA1LFzpo*bMtZuneSgxT!zLM<+Z5
z_se6-;{lw$2Bs_ksXxeP$~<rv%yy<U`g45^n#RmS=khB`uVOATkLq*jh0IPQj_eB+
zO%~2CBS`&mi!ZYQr2e-Kr1iN&Oj|8T{cjaW{cjOS`CR~#f4eg0fYc7VCbPU9r0`lm
z3a^=IYXT{};~<4ssmvA1-06+yJj%O+DQhRPxrQmDlsR0PW6gNa3HMf}G=t+|_F~G0
z@!EGX@%2pX!)5n5OqmFh`vj(J8jJU~FrQ#be-K-M<NcVjVGP^XGiAOq=P7gjXm(%6
zlv!X4%0C^v68VtEv?YL)k8vR7TM$U~*8)=eGJ{l)O<*Yexif7>a3;(KrcHqKoNhxW
z;)8lZN3?^o3A`Ns8$o)$Re;oP%9*xOknWoYCV*MsR)muP;%^y|*5TuonMmvKR*=Gp
zX4-r}N{1In@i&4LZwiFs-Q}s#)(KL)aacLg)(+<4e$61oyNM}rTDcbQ29V-i1ycNq
zz*peD5Jb@N1x%T*<ar>fOuU^bb3w|-9A%#ky1+h*DbvBn5MDe;?KlK{6f}X<Zo52q
zpFkbB7v^G+(p|)~<tTHuGG~I<;(kfs{cs-yPQd;AnbHqL6^pkpr4dAxiZ?K2+bDit
z-@=ro;C%=u4@6auw=-o9h^if*&6IKAdvFJxEL!}$m^OFtUC2+kv%HaMYXE7yQl{jk
zN?r_}fIL&l)0I30d<XI<B@b8fAg~c~gObw$bI2cCtsAGihAHU?c}jN`Q<i{~?qa62
zgX3V%Wy)mG3+5!I6d>h$mn(<g0aAIK0KJgkhrk73G1vfkzLF<{<Ss<XeU!Nrm4L!4
zVcK#*s#lp{5tt6%iTkH9WfJIz@U37q?1MlmXFqTbXaO$+>8wN4_h71I6keB+>uD!b
zHi2Z{2tEt@I*`Jt0WSutz@LM3E=3qf=d3&ocR3)nuPl(-Ytu-)*MYnqTnIBxve(Rs
zAlgM4(V6-)WhTNbOGa=w&}XWJlM7P&NC7DvD@gARj3DKYfobb<X7>%?R@}D|r27!5
zf2dGqBJ~fYpq9T(TRKSbPXQ_Z;UL}D3#9vY82G-`Ao;6e+A2VDUjl}J`N~Y^u24Mu
zK#B*E;$cx{BE^HgkEVQd2Ps@5(^l`q;nMe$!LX<Ec!*UXm2-u%F9a!`nIQR3XWCMf
zeLVO}*hhoZKhgL6^WiRtX)}TpKO)7?pv**yAAO%p;dU@>jUYY&3_cEC2G)ZVpE^bQ
zo|??Hiq+sNh&p{Ii7FRg$&}?vUZ&)wN^S=!-_k)8ZG0M2CW5G1@d->x-(4SpyLO!r
zhahib%4YBdn46gL1c)MxZvZLWYLLRMV#*2-RWH7rDed4JaECf34niKylt{C95oU}D
zh!ShCTDT?<MOH?naNU)e2(vVTxW6<gd!ghl0{M>oZf43dkjfWrTPqKu4)%r0OoUk$
zfS16X9i;l21IB`x;9M{bybbY4VajCiG|Wj%nFzv9a2!a_tq_pPGYGsI^aByacneda
zZfNxd-6qjS`S2y0atQbh=nqPr@UVdAU^auuGY`s-4KP#sKLb1A|7)-v>;ftM<gW?D
z4LuqG^49=vgnb?O1y~JsfR*4GupA_RrQlhZi$U^N2;Kp6K8SmG<bYp+S>U%|I!OLf
zz;2k6K=PLW+F_0ZKL?{g^m85|;H@zGgUC-03y6I5Fo9Ta_b`H;Fauh+#2ql(;Q&b<
zk)mi-i~><*M}&Y^z`sSw%}Q=ka-rl+o*WL1Gss^9Nd9V-yjsaCmAq8R?TRUiNg(-8
z0Li~q$t{XzWl!S?vKLC;gp^S_Y86Wr?TRUiR>de#OCPAEPsxR1(<l|5Vl_zaD?xHk
z;|RJRjUTl9Q?x2t6oq0FDx?-a#ZpDPVv3?w(V{36oAA6Q|BaxQzaYh<R>^5Rpv6zg
zOO@QNn4(C}e{z=ql7Fj`TNKU8-lXh>l6T@cPyX6L^4A1v=}|0Iv@7O-<UR`|_bEzl
zRkSDy#U^yNT6l`3ip3y>QwUNxb|p_yv?@k{<SqmxcNQfViZou(;ty)^2etbt()fVP
zcEuD$tD;5G3{p5Ikirp4PU8nHJjGH)yJCu>Rnej-6r0fbYW@{V743>CidIF7qEKu?
zr>*%{tOhBbG@hV%mMXbjF-O^FDf<*9w<=l`g<_LIg|AquSPasA3PHM$UCDElJWI(_
zlsrkv6O`Pl<WWi<qU07O7m7`IzEk=d={XNJfOJ1PkAUQ*igv{m#Uzm2CxGPMs^n2h
zPU8!bTa;WVHo=pYpNgf5cEuFMBoKc`&~si3U&*7CJVePYN=}X`+$Q{|g|Ao*!fHe%
zNa2(!xm__w*=H&H6eYJR(sPdd({oNskCM~#jpX!vBe_uWCiMUKIigmv8r1F&YWG+2
zVkIwBa=VhJC|VWiIi%em)b6k3fOemedW)aI$=&2NQlFAGQlFGOQeUVm(v8#?=nM5D
z^>%$8{%_W`KvJWx#qTP8HT~~Y?KDzf?o@&Q+nn0*f0I)){%<z47)I(F49D?*sdJh0
zNPVSq75>i~kw3!V)ZyIe-1UFj`x>~os%zi#Wk8MJsYx|$P-AO*jb#Q%$h)RZOh!d%
zqygJpTi%4g5XSO#VG@(-ZO3M8uukiwq8$xZYSEJXNQ)LNR_q-WmFCe(lvYwvM@2<D
ziK9*wEot6=oxS#C=FC7yjQYI4cYZMcz4qFB?X|x@&OUn|m8o@1>jX7AEix@S4em1A
zG7Y^c)1Mgtb{*Y)bkETlTF0@S#~OOev8~6p0e#b(ru(Nu^6`VmXJ}(5jh}?DP98lO
zE>3AZrR@|$AODQ^RNtu?+R&-Pr|SCnsot5snb3J=2)|u3yJu=zaAwO)L-)?|&1#y3
zaAtMS>H&_<ip+`vTR+?O+4j#G`p{>GKN|)%pB6l=<us(g>Aur5wAg85r|J6W>5<c;
zpxS45%!b~x+h%K;Z+6pc#BBE1>~Uc8=YpSW`CNt;{e0~6@H@vh2PruxfZy<(kvW;#
z_#AImrWTts2Alq@fh<Gs$qHrl0^85%IHU873~ls`$QhZM|IEOdnVRp+rZWwF<jm1C
zBWGr4eP{Kbg_JzI>1_BtdjP*}UugeAhBo}g@E4IX=MJ6=`*{QNkUr;*!`z%5%+An4
z*}eGfvUl5&8abgH#3gSmFH;*?G`c8L>-}2a*WkB!usB0&D)!^oTkONH@A9V0VZOq5
z1*Cm@{M)cu-LyJG3$AX#Z(wyZen(eFRvUW%>VegRpjygX%MCqR9xER!M+#MRpfrtD
zj8`CsT&=D)7gE+W><YWUtL&(Rq{@~`<VK~hvI$hUas*UpP4Ak%H3+xLSCyd+Rt;4d
z`dHO?mDi2@a(BCX+~8g5yArwVQ-^&hlVd)0oG^Hu+HxJR`#QCUu>D7B$B%%0KT`V%
zM}MS72%9#k{!PG<>($Zgfi2got%S|jt3krx4Qk5`L<iJh0O<dj8u%I62i2A!up_8;
z61D}^_Mn=nd2dyHw*tersUx=mgWJ`X?ZCixwV7~WyE?cX?t8bZeT0GEsLj6t_T8uU
z-v?~IUk%<59OzaDyMe>qYM5}eTa6ILy45j4?*ppu0bu8YYS)9no(I(sVc&ylKjGkm
z>JVY@k7~;wfzgN6*u%i_hgI(*z@|r3KVkDDYLKw=5w(l3|8aHTap2J7>M-HR<LW43
z^l>#t=-;6Rb^wDr)E2_F9cnva=MJ@tuxE!FBJA6t_7i&lqWb;<^#4T-5C;FEwh#{N
zR0nqghj*%B!qJ^-gmC;R)%!Hr|4j}5jqLxXMhIhnQ^yFs&#1m<fWcjA%PwHsF14Mo
zbC=ph*t1Iw5%%p;`w7RMRmYzN`i9k}VPIfbZ6<6PR$B?f&#NQP1G`^VdtL_izO42U
z4!o=m5)Qwth6w|2sLgKxdtO&VuLC<?S33z~qv{y7g+rt2FkxFnZI2+IyCZ53VP{0`
zioia&M{U`oqFvanj_p>*cf)FUj~XVc&NtPrH`VSpVHJ5(jS~9aQk&iatNkst<1MxG
zEm(!$Qb)+D>21~jwi<XFRwH}W(Y?T-z3T8@u)6lD-Fwv@vTA=<?Rb}5zo+`&Qv>h8
zs{cK8fN*q7jf{cie_su}uQtCAtKRq3zV~4jd0&mbug1vO{(;)@f!g^2xW0XA(>`F^
zezko+Fyz&Gy&4)yuNLuYQ8M;jtMy;24P2`sK{je*8-at@X+zfmqd(GOKZ29sCaq<Y
z*18GC$R;hiNsDa)H`t`LGy!{?v_8W2>$Q&S$=<KE_<_wo)q+0-1_G#o!0~|Q-ArL`
z)*_p==w?`THEZ3?z>a3ElW^!}ZTM!wTeRU@fCIN^gM@=YZ72wg-m1lJ1%_|aMs9;B
z-xjTDi{{?~tDY@d$ix;c)B-x#qO}nETeLt6oJO~3u`Sxz7E<6BTI3g6^cUpnPOarm
z+%eGFuC=v;Zfe*3?QqiaTdnoCTH9}7<-JGq-2)u!)W$o3{r6}CM2GItdhdbLz`a`Y
zy;|^I7>DoG!uM(;WNf)lYrRivyAQ_E`?Sb?T9l0K-C9St)=8bN{{b!V0O3Pg;2{$C
zkk(5${IC{&Sj*HRk7&_HKt~=&{RKw<q{aROZ0pzB`+=>0*4q9IjQv>~`!k8&sdens
zI(Nb<v{UOPY<)^=dkW|q)S3o?<Aa*_uW%aus}}pKHuhIobw8u^JVQ=)X-&I;k-uxv
zzmv4*w2tSr&gWp&`<&KC=zU)EJr4{&uZ<9PzMyrz02~f$;V`@mzNihos13hJ#+S6A
zm$c!Rz>U77#Rywp*4kbMHou|;Ujh1F)tX)fhF{f22uEJiMqdMlMz!8ivLDq(2nSx*
z249EB*z4NZ>)JRON8Zpz-_Rm&fb0E-=KBY*Yq!?D8?5d<TF)LWv<Ft5Z)#m{0^8oy
z+TTQa_C>Y+DCqu}HV^|2yr&Jm2lRcQHGKf|{!{b)6FB%!ZRnp6<=?Lb_G``iVb!)@
zYbW%1^(HUIMNL1{{XYcyHtJ0qb@XZ*_3@3m*9R;Ab$Z}BSoLkv`#0$Wn_xAvNgpL_
zZ_+!OfX&zI!Rvve*Xt3&<{R|j4e;Xk>jA&s>?h+-^uSN_=AV$SpXeQgLqE}n2_rY^
z(HnuI0X-4`4s6y3Hv_{z(?@;=4Be#n-bD0G`Uv4bvp(1ik+EidtXUr?<H*hW=*@cM
zW^lc?=)PNkT|vD&2v+Z{df%;j|E(|vZ`WIH*IRD~cl35WLfCnS-gO6X<PLq5u<w_8
z|1W`KztqQn2``;@>Ros0-FL#O<1W4PF5u{0dW5j^ZoTVnUDpTi)`#xahwp|}^RM;b
zuYvww>w#bEnijoVkCFXQyFT0w>~Gfx+To>ltKPR&@81e5-!{Ez8*qH9?%f72;jQ`z
z*^hMSqcnJpcIYv}aa=jO9oV#8_Y*d6*Mo#3ztKm31MI#>@3{v!e!uShJ+SrndK+QS
z@AVL&w_Eqokhrs3?;`B$*82&)59q!JfU$0UjOdOYy|V{6*rN{-hI{l8!bp!EB^>L~
z#|eE8=}iv-0}tuVge?#0t%N-xJrn{CJ**Eu3><k_AAJ}J>3>8IJfb&00%O}_di!H~
z$7A3QKBf;5h9A>M2qTZ_QNppu^zp|i#~#;P9@kqRhjH{zdgM=f^iSY6@6dxgfUP_9
zHo}e_dM9De4n0KJw?pqI9NeJ~?SR*@9s2kV-TQxF^ggNkp46M31h@T3y@RmpNxhq}
z_es5vaP&z%LfA8)hX#Os1A0H<;DA0v*z}a{e~R#F-TyR1c08?jKCO3=vFjPV`x(9G
z8E}W6(ZhtJ&*%}tv1jyg!j>VubqE+8(qn|<L%MetuxXd>-vtq!yY#MIdN)}O@6yAB
z&41T}e<vq@*ZqX!f7iXw0)5ZxP0s^c!+Kj7*#45<@e;84Wj**Z#dSpYjp$7@?df|}
z?|&5-dR6ZwjJ>9hy$1BZt_NNR`d-(Y2>t)i1OEVaMD)%Gux+>Az8j+YcI*AS^?}{6
z^6t@ndtlYONAKIC_wOOsQN1%tuA_Q8;aF53CyYe(XcSI+-qJ&F>Ai2k*z~sUe_Ic{
z4P$>yABgFLF&Kk;^_IPQ>s}a#-_yhI=_BvK*fFMej_F-vkTf)=4--Z{(4!v!gZuQB
zeZZdmdT2ke-D`As4NPyYHG<a~E!Sdp7u{&YHUdXC8WF<qb;ihbz@h7mVM70pjlhqA
zu^WuB8-QbeW84pn{M3m46xes8(SIXEMsGA?HyUF%!m1-+bOvDM+iWy#HvF4mHU2Zh
zdlRgNZ#Kd=8zVQvs`cka+s|PY3mRiVV>}3};oFSxZNS0Xj3L6VEk^eiVEY!MV+))%
zwHW>uBhUilV2d%-Vhoe9>kgy)4x{G|7`?5AuhnR3g)w}mF><FddMCX1|H>Hn6|k?(
z=x+mt?=nX20!HpKqIbb*@NT2!Zlm>XSPk863=?*?8(r-{-&Uh(E3kX3(L>n3%^27Q
z?A>Pc5q51ex(PeB8J*i8s=LGJ=`cbau!?mUV}#!AhHpDCy4{FvH!x|u*BHAO^!WXT
z_xC{mAB?~sfT13vw+GnskP&(a82F>n{72xx!^Yslz`kCizZXIHpD+SX7|l<>s{IM0
z;|W;x{l)12i!tyQ7{gB*BTpKmPl7xCq~RSPS38Z4onUo7Wpq7dbUy{F=u<|Fu={DF
z=V`D;hm6RO5gj7eyNr%qK<~4L?^)pBv&Il%)3D(m2DUtBv_1!He$EII`kphI2*-yF
z?{g64d%<XW!SKHTtI!KZFJb=+#=r|;wTF$4u+bTY)o9p=5QbhddS3!Izib3w2KK#d
z^b-z`7~v7%;D|9q*gInM5%!E2p%IAcebwlD)#!f}R^HbP-)lhsYes;u<qf0t4PeKc
zM(3Nrp*_a%9$@btqmQt8j}at{?lxk(4NVJ0jozrCYF$wSMvbtW==P`qqej?4bW7BL
zQ6p@P8jFjuxQ_)M`FsQGXvbr%a1LIs(R2F>&{(jM_jmltLZ3@C*21#!5`v!FNL~W{
zhaw@bhvns90qA(F6`qcli}VaG5cKDnE@Af%v-=%HBYb(k$BUN<dKoq`&~xW<LCgC$
z*5E}DxtI5C+>Mvp6hC=x`BkjHkNt1?2Kb2YC|+XI^IM|fzm55SBN}P4nB(_-ieCb~
zmT1IhfcZyL`r*Hm=?$bWt-a!9D?K-H{N7(7=&vxpkLf2UK5+kMrq3dML4TFgqnG?A
zg!jK$-Zz-Pl+&k|^?#GoN8Yb-7N@7YkD`^`%ljw#I6g11{{57m2)~l$zscz*?~AyF
z_219w*Tm^3?|azH@?K|ow{!UNzK0W;miIesWPRj)4hyj^Px<HhrkQ-o2-7`Gf0x6P
z_apq6(`!BJ`wq*K_aE$JeZ$QEH;&)AMIt{m=AXdyH<^By-Pf@EUobz5;)nEcF?|We
z2l?|1UMkYFko}*|>2nw93-`n9zLVU8euwEN*!}VB{=Yf>-r@AqI6Ob|&tU!QnJz}z
zrSRLa*@>QIc<*4A7p6bQ{2rz=@m_)WBTOH~@q3o#c{zXN`TqB_KIdZdG(9?n5C7eG
z$x6>ZDSn_o!|C-OEN_I%^D9h0&Gh+1LnnE@zQ*|}&&#i-@KB$MIR2HCK5#G3yFZ&~
zgm)T;_a^Hr&x=2q-OKaaySP5c^V<73e0l!*F#DJ1rPnYm&qu$E^;yOGT*&EB$mww(
z$%8)MX8Kv?U&-{3Dg6<j5c_|H>-&YA-kaF{dg-6jYX-L;?-L*8<tV0Cv-?f#{w*$F
z=QIB@_WvcO-(>f<u={SxKT3bRG^XcH=HJi!M`V65zntYg!20fF_kUye-{<i6a{f-E
z^n<?pn4V7V5uQ9R`vj5)TAqJBpVM2OSN%KAKY2d&N)GQ84sR#tr#yf973Rm7e;mh8
zo<H3|e58Lpr~e-*e9&H|?Mw%levRS-ek;>!I6ks}e3tY>9a_oh+sx_n?_3^N5g&Ch
zSR&GQI?-suTAA*Jd5#)Vd}ivS|AezS`0qg<YCcT2G1&(sKJA;Krx}~v$iKYTW@Dk?
z(|a#^UPM_WzP$Hi3)AwRh;K42@1;4BX?YLGozR`a^8)FieNjZqd!+p6&*#8S#xFwj
zQC?;D*Wd`x_ZJFUTP$b?(-}<P&-B08{pn1f&GZXQPiOZtPoVI<N;CGW(i1*j(DGiV
zz!E`wk*@TVf0k%rrr#?t-k|h|hJ{^Go}dTH1bv!KxNk+7rRS&%iS{b;-lQ6bpyfSA
zCz$Dv_8euHp8hWhdGa2Num2m<zYzSJzAR{Y&iPU7UY;Aj<Q&15=ivX>7ukJ4_&>%h
zFDSnpzlG4#%>P`$|H3js%X<cPo3zL`a<QFhdC%DCc&|?W<-H~EoiAv4PW{)ImiJa{
z`gg%^X%*oWar*er5Og=EkGzNKi)Q+V6nQVlm8h?CjtVJZY`&uBcV>ABDcMXP`@aN#
z{e^=6!6_oVRj&y7kDesx5|^OA&3t)p!W$<F{@gW!zj=nB2df3$e6pbBJx4pSZ-L@3
z?~QnOzM$nj5ceWoiGNMG@c;d6LCbp{p8pEFj|l$Pxjx4F1^rcwKgqwm7w7m{f|mE(
zJiU}?bI-Zy;k<c*-|<Be|96?rzDLNriRr4x1%33n!o58A|IbYOek1tROv`&g3e5cT
zD)Jt(W0{usYF%h2d0s`{<1}E_2d^UUCF)_mya%e3`SM;O^{c{v7uV0b7YVwkQ0Vgl
zw;x<wm0v9u`pbKFPGef$BeD5wg5Mkw{?}e4XnBvsUbFm#l#!nZ{&KT@2q{@*g8nbg
zPkArX8(iO)eOvGga)dm2FUg}9vp$;zzmDrm5OV3+%i+s=49;C5+{=3-zRdc{dlDWs
z(<7wFdlA0Fw7f^+E-pXvUZiTK<vnaUOv`(XJ~&T=*XlLZQ66Sm-iy@4w7jS77H%Kp
zy=DKwe0fjVT@XX%Q{Ef4p4~^63;8dcN_=npUb^2h-T8IFf5|M*UPa!!cRSPap1#{T
zf8@O|D*RD-FF8s0k1$R9#^_ncw7f_0rQ?Kt^4_porsX|cwZ{v-y!YyhkYTphT>e&b
ze#(23uBG-R<3NAC1m$v0hS&U9gTg=MQbBvUe_noxphMih|F}TVi<$p*hoGa({~gt5
z$g5|5Bh#JC&tW>7`4wh+hjBFbcl#;)qrA#{Jb&0p;e&pN$JfU(?PdPOq!0L)@%Vin
z=>s~K>6<7#&>yh>Vy1i8|0zuS+5JVFKJ~2cLuPt}lp&^XG}9xbtYrQB&GZN<LFP|m
zdKUAk-cb3H_xALBLD2FZlQnY%E$<yU<xD}#dr;m!ThLXHQ0`zo;w(YSdx|bOL(uZx
zq;uH4yyxj@mM8CJx;9I=_qUTY?Ab(Fp#CU}#~0r#5%h_iUU^Ipd|fr&&o#?G>I*)q
zq34^&2zjl4GfCw$-w^(3(<(i`)dd~EW_5Z(019u2`Ij?43!7HyxtH}B<NT;%x~Nd_
zADkn?llOSJKPPB;Z`aJz1ugIC+KYNX=`Zii`PFPe%X@OZahjmzy*OWC_vgH4s-rx|
z@*-n`zJdF5c@NNH(hu?nc>J>xw9r(z-vmgc@4q0K-ga~{jXkJI?)O{xKef<Q%o63l
zY6-6d?NK7%Y4LwK%6B6F^A>qk7I}YIknG-PabIhp$1L%E&O)O&C58VB)W1Z1YK>&t
zXQ4+d?*Cw+X&+spyj7O)jy@`xztiGAg#IAW|I-%w9~SpW-X!;1Ec`EH{*@^2ixzob
z&P?Y2-r}FWOGxxTjQW;H@38RqSmZCV$me~P&{{lg7XOb}XbLMay!R~fX@6cKf5gI9
zE$OW|Yg{$u^&1qY(^<a0%;~9WsJjZp6~&%~xEQ>~U0ddHts{%&m*!N~c<k%)=U2Eq
zxb@zaU0qjRR_$^&xGHnjxI6{Ri#<6`r)|Elb~qd*PSayWb&(Jt__q0LT(xvvy0aXj
z*VHv^aIpMhk1eNRZ7p5y?sPRY)HUQ@RaNF;ZgSxBSG(8XChqx-|GBoT!IkX9W*0ZL
z3mMDo%uSIV=dfstKU>@%#mZ)H+|cN8)v(Y5Oq;#hRlCMhmC8tt%d!Jr5>hF>?NaGB
zy=K{@8M3X><)MtZVtI1fEUaiKTT@rNx^BHKx4f*p%H=F8FLyOI)-@DVI4Jc!NO@RS
zIO}nte1pU7u-jm=Wg{oc>(;p%Hi)=1D%Dgd>S`N3=OO!(1F_lY8hK|0d{np`MVFQr
zU0LKl55?the3dnRcXDs}HD%v*Ij?GPdt6RryR)oeO+lT*vAo#kwB;mQb1Aghpm>Gb
z<F2bMt1ehshJspNonO1Q#<|+<X)GvlIvj=W9J`~|Q|QiiIIdh?oaZc9ne3=|zUgXy
zuEVjR&XMccQ15a`aDchIINO=q=w4GRSm)vX_e%GASK}dON@e;?vE_?Qp#a>K?((wQ
zibIt=L3XE=JV{>XnJHXQPVvnztFL#}R-o9p%!G54WIKy<oh3Hsd5!h1a>~Z@8a)k^
z1SQ`@l}oA}rftE5w#gL+jzu{XO;i=hbT)b_>ehPd*@#90Mry!nfUCdfYN#U)wPR(~
z)C{4xxYn1u>Zuq=PGy5D$rjq827`M=?Nv1dvZUJ<t}bgtGX?o*q@1hQR#v(i3a%=w
z$;-}0(K8#ng&Yp*)>UZna@U~sbWB0Ym4!7Ze5pdNJQN}BiBxePij?w+q?9K~LDH9%
zf7e-F^<8HrTK~j^k{v=0x4WYKF>9y2vfi=Uy@D$0d`>`!UExmSotyOPV#g$0o4u@&
zDg-rMwrta-ncb^h=nkkuDX)TP(+Z_jS~S+yH=x<5RGgL4fK07HTL&Ana36Y8*I4DQ
z^uRv?t1hcugP^Lbo$($M_LtXQ<%S9?T#ajM$lWCEv^}T7z0Td}UX9*#^#;)_JL@W)
zd5#TkhmDvXSEI-2DT9N<m2~BlB-!#R>d@q)6LwahhxIf%u5{$da1)Ba8g#oAl$>jE
zfYKyQNBVBUOuKT5$$`4o;Hs}{@Hi8DS%(|_O0p|1VM(q~y0V>I1``UI)w3+6`Q{ME
znK(wE{wpyY=`_b2g*dCw^j5nX^6P3vgA{iz+JHiPwo{CooQXpLi>u@T1bX=8#ZFtc
z2tf9srVc6Nl%@6rQ8rt3-5NAXrpE+M+K~c6kukG2y2-5MmN$WC>GX5WLg7R!x3=D0
zyQZMr0Ts+%IAJj8SWWSWXRS=kh4p0(jV_t)Xmv?I;p%Kh`4vLKI?fVL9ppOJB{dq<
zUsE>Q7Kk=kcz3RIyRIrg&z;O<IT$1~Vo;jxv}X%XY>$C~$F)8_UbT!A8XI!Z$t-X;
zIvdMsT&90p4t4!bcZCaMQ_lu7K+)wx&%AYI)oWd*atHdx<;6?QP|;vwMC3xb#>l0i
z%!6)XIeN>2;)|d%HLvEFf~k~rbl7rPWiEk8mF30x&I0tg4##Eaa~;d)o6T24c{Sy9
z@k(d9VoY^fBtDV^(I_ZiVJ5jfN7$n3RhN~!Y7jkVrQ1~<cVNpt>^z~NQ(}gF<avSs
z50)p(Ce9NK{)#V7$`e6NB~OYj#aOWTa{9ZBa>kbJu5gxBl+`249S*^u-)|*l&O(tQ
za8rPsD_`fxGc&_1a9m~V7{k`oyU{6#e3Ath1F`uS_a-$?W^r0pQeIu*sjPSAnf)O;
z+LDRFOw60a%7haAvFqYK)DUwIEB3M>N@%K<+L7LtS?h{RlM^kSH`|oG$vTF)K_lu{
z8I44pRO_jY6Pb|0!o)dk3wrpqG56!HjR^2ywef<9Yhw;-<Aq7JQBbM1ak;gLwB;dv
zxv?=PB<3KZctuh@kXbrW!)OzA(TSWX$FQuf7A>Y3c8)0$gJ4(rcTsW4&TgyNP+L}m
zE?Mxnsb=1U6__TjsTG)NaS_U2v4j3ZYqB7&MM9%u^2yajhZZrLXi2VeS9q#E$w=jx
z8hrQ&$?BD^3lq5`%Yr%Hi02%d(9|5bWRga4Nsbd0R%XvKXYsPMjlIbL55@OTdg4PV
za5gT4vY-jIM6tQRS$x4{#m3~r2{b$;^`=;Crl?v<<{ze7M>g}9EO3_7#F=YgLQ*F8
z=Lb=CL3v&M2F#QioV9iC+G=+#T6%Qw+|AHXH0_`;X?{#fV01@ID+q0gnO7;}>3o!I
zrwa>tn6Fh}@`MR)ffz~Wm`ih>Iw#OJ-<)csA30Oe$(if4V_b<rG{)G=FTK2)#*qu1
z4oqtuK>VfcizW%3+Pt+`c`>Va(jd?>&~Vt0STxn72w>KW7&MY9SWY^iN<OQS@5IPA
zO`(-DzN;Mb#nKcl#H=$L(FK#aFOR!NDoo<uX6Koy*;+e_E=-=7z%xxW9c~QC(r8C9
zOkW%lm(t?7y})S^lRRrIxC9x-B`KNXaGPxxuUI9uc?IQ{EUP!UmT3$US@h8mx~%>(
zOUSa1OdA2qQea$vjDzz;GVofzJ#o55D~MQ0FRv<VaC#cbXdM>G2fKt-G%AuPu`4c>
zf|6&T32WQgDBxIrcGqBix01xzF`s4&EKHb7yoV&D;*f;ca>cr{YkhrPEk<_M<x!+b
zw$qKWoUT;Zu!=>qLRv|qiJQAP$8=|{<O@X@RJADw4@@w{oH>DA4hb8~FcD|bxyAjO
z%jGm%M6#L%AwOw8Y>r#Z<TCvw438a-%c~*RVTV^VL-=!FNg@_vd`6S*;sv6fk{h$V
zI1;hIx;{00pYm8>A@_ekEIzUlMTPOxU!p$NSbSt9>SK+?M^>U}N$k^KqCVDGd}Jl+
zL&n0Eiv>&3dsSA~m09~f>ZKCL0SSFR#sOkxm%31maRuhp3!PZr$;Qvb{UB8bvm>;b
zfs1Lquu19~X{>yZj_>dzg0aY_EF!jCY{`%VGK{|tqW^+VNk)7UCCWa@SnAVNq&{R!
zKKU~BAtUhrP&1YNKc-N9$e4Wcg(@)u@&&k@Zreq_S6^09;i@Poq;4v&tUA8Oh~BoQ
z&I4@+CW20L_nrHD@Qf+c227{X>n)(ABy;A5b)dA9KkD?TQ^caEwd=&73VkQ~I?VWJ
zjAbswU;(kF=CTrd+S%=qjYHk1A`aq>s?8>{Z}kRj*eEE(?BDJvH>b*&ej^*qQAe6r
z*ofj}LlPQKCFFp)0!i+dU>=SsxZ|+1f_5P!6{m@!Vf%DN!(0cI+tx(-V@YA+^v6=z
zWEp^AV^RiSnU2OU%dt9JV6Lki@eB~UV+pyo(p`(a0|i`)%vh{8i&5Ho%<(`qP8z)?
z6rQ;5w2y$Q{lvO25QRBm1EO`2%Usw_(`L{rp1J;!PdfwMZVbB9Hx&mDVnf<SDIUQ5
z4;=uueohvH!wA4qrzTG%TGlqx$efl;J((<lOqNWvsC)#1m@J{D5(IDXGxxLA)M1N+
zxswm|4lB257D;9GO^)aW%dXQYdt86G9_tR*W9{L3yz+28x)1JA?Eg-DWo^Exwk5n}
z=C|8s*I=8Uv{X#{t|>nz+)<U(nNTBOR<4vc-EI_il*lxhH<5n)&hV4f&7Qb3vY^nN
zE21~Q5_><*_j+rwQeW@Et{(@*FkSTW#S3`(hK9CG7vS9u?ISqEy#i@A`%FDZdfE92
zgo>BwAAhJ+VAJgzL?7~zDl^&Z>Hojwkw#Ra`XsHYS@-kM+jtD%iZP2RF?Tkkt5l!(
zcAfZskaXHjar4ASvyo^r%_b|LqGrfu>WFThS?a{@SlZi^Cb5pJN|r4h<{Qij0zOhZ
za3&37iX~yPZ8XX9llCr(*XANwtuK;o3pgvqo-=d9dC~@JG=}JgCTu7j3mq#~T($z0
za0TVs5f`6R>?les4)$E^oA#7pzcqcs!@8U6@s31ia@8bHj8fb+_0`UbGEZ5-ItMb;
z{H9I5pKna-k#~kmKiO5T_431qbm1gBpU<C29NeWnyTQGt%7cBp6&2X_?leDun36^d
zt6i0c;V+LSZBq##AG-_9kJi#APr7tX^I4kdx8$30Ei3s$O2I6ij9D-_Q|={6`s#xc
z9YNx&MSShEzHGI7osGW3Xmn$p6Eh2Qk1aOeSJp}85?$IBn4j&WIFowFa+NRNEt#8>
zoK(JOdr^tlVUgHzr7HvJe50OC(f6m}C0M#xAGY2f<2$dz)B6)!IZmf8K4Yp|+ejaU
zIvZW}@uF$=+u6xHY&~CF?Mc7GXR4y*VEMy|PCuuwv`kygerTfQEs9{`r|0R~t@OcI
zKUn>Uf~h#tv9aZgbvVo|6ZVvn_6PQZ@wSTGBe(S{ZNWIWBD{O+lUIZ{H+-~;q%UY<
z>63P`PO_+Pu1Zg(Fn@@TuyQfUN*vVjIO?POFb)BJ9G`udW%JUc!SBMg^lc%&V)Ho6
z??LVE3ehqMSM=q7{o2}c54!IOS><t7Nqo4%BY^|EjKy#wK4O`GKaqcwN>aXLBL9*<
zk$-GZpVU9|t>c&vIr>l67NmTIuz(JhK+#Gnah4t5X$0k&Ut~LqFd}Qbu%Pe|ecLR1
z-NpOS308a3gl_dOUWiTNf5MW14sz0*VZJqI<XI(Rqmzpk4xQ$DVDbwb>s&2eRC48K
z?#?41ELkrM&5oR2A4V9z=*AkW^;J|&yw$ZiizeCLg(fjw;-!6qZs}vqu{(X8@F8BN
z)9c#944+?we<a~g-jOBtA&E8mV6RQ-BVaSK)}w>0dko4QdH8svdV~3L;lQXyB)B+e
zC0(6FMx;&6+)8(Kby``u&Kl~I@wE*(abi#`MI=mL5B=N^QT5}E_F<eHA|%ASg~OI`
zU=p4-7L%PjGNniyT);u%aBu+!iNd6(o=hnYQ;=|wNE}>3+OKrXPqC6ueW23lv>n!G
zG9s=ANv%mwcbQUZO+mszQtRLnWUpw;S(miPGue`4Vxu(Wfo<ZP39XBz^;jpyB8id{
zn>%<&WF4767w{1aNuodUQ0H@0r!wq1@^O~SYw4C3bFpmeYM|3^uwaLyx0H*PF6Bd<
z!~r-9Q*81V@~Knj<)kug_Ba<Nt1w%fNhVKCeSV6Q{Cp`rH*Uf$BI2B@^X#b}Y;h);
zAag;A%moXi|J+n&PMisoRbhLol?`@Mo4Cma6M~+fA|TZ!cfRxvlQq1YR4aR`l?`@M
zg}BKUH^Bg1@=}B^OtqSyCk5rEGIQcgd)#D$3Bq$zgs0jpOts2SwOWu%Ll)~Bj)a}O
zQ#@49CQ5Rnd5{xIa;k#4@u;RUbK=YcCVQ$gTN*3aQHtas8qT$Jc9c6usa{%CV9UvI
z!epM$c3xiGlp8nY<fQ0mvmfA^Qtfe3_7ukpz+~xhQ*PXp6F1pYz1rf;114A@8n%>R
zY)bVdB?Su?I$_{wr8-&&ChHP6<)%8zi8EocmVKK&&V>o7xn})(XT7VTk<JvvK|s!R
z*`|v46$-%sg`k<RLDM5m*`^811q-B=X(0XMHrex;my<^Z@N%VNn`t7~$V4H1ft?L`
z(vV}5&h2qicHEScExBk|A%asUZpzJ0O@N#@_khWsovwbQ9vrs8v2b-`gB{0J+0sa!
zvJiVV9qZ@Bx9(=gU{<Ge0%6Bdf=N-%vVFy7&pPnf=I7-tuw`fG=4NH(W!u28XA>7z
z^U2O;x7+hg=c|sXYdo*K{Jc8zK-MQe*!{2Re55L!tBT`Om2Ns~I1B%Ha2&C64$%`l
zeK_x*o*{N4X&h5bN53jKp4EJCf*8)EVglfFmN-`8>}Tt<3d+z!@<?PW&iB_yF+=g<
zH~yfomgAH#^YBCJH?8udoK8M0HXr9?PZAC2Q!WN29D-Hei8u$H9vjOW<@3~qZK`a@
zqk}~y8}gSeDOnOHm5ZSdJw*bPETkijs#ZF2-ZZ6~^+}bNoPP5B{CVuLp7X^jN75v(
zroOD)<6JAw@pBd~lRUyc*3VQ5bSvvO3jJ_p1wBd0X@>=lg66Y%kA;c;6$QuPE0k1y
zI9EF#X-A&OopOevlmZ66fV;tPW-z&yX>k_J^iN03Q<C9G?L&TIm;G_;zN^)(`<5!3
z-_ezAin929DAxr+%^_TGL<qYFpi%&;&}{_GVf~bC`>tNHHFnt}?IGPsCyqDoyZXPk
z3b#u0k&?MzS9iYqEfwKt&{5yI?@?v*UR~Svj;?NtL08h_Mg23-S!woa%KKqOxsS}5
z(09&B%6}^R_m?zji{Bqrl&-Ko13E8-tP8fj`>iEgA$v3F9)k?U@U9?#BK{)2u^%W~
zWt>NJW%DT9t=7CNHmbs{;4OY1`4qSSX-2w`4A{?*x)Dv`65@YGx^(eEH{$;Q`oo-;
zl&)#?k~)z-XF?zHJCQEw^w_^q*(vjz;-xFzr$`2c3!X@mgfd~42k_?@iVgae9EyGy
z=!c=-Qp$4;`Goww+Ss}e`IMOFx8!<PysIOx5&wj|e}ME;Ri%XDBJ)4=FEjrim~)h3
z3qyBN29`ngQj~!Uw(egl%7DV@OzB1bsl31Q1NA`uFQxpSagh8M`Aqpw<w)kcEEkZQ
zF8@uvQQu6xLx)h`(v+nmE~^!3M(L5Mcu%g<ln1;YNBMkI+Zns;XypAdTla0$HY+1a
zU3jCuJ-kuFzlwildsz1_qC9#L<(KrMybn?S<}7}H-_@5Oe+#zme^fKevT~3*bU0=7
z-ETdFFwkaRjdlrj<{h+2F|<j0k?*Y<=`~~9OWYnnw|jo6$#fL$QW)j(V0ztokh-n>
zYya=}U3~%cSc0<rsM!vutM4C&u0K3Ny6%5eLEa~(Yv#7_3CaUXLLRR|Ih65+`-A53
z%Q@V3b2&KNw$hFA_B#3mYBSGLM7x&QW?FTp@<8pti_m`+mkAk<7cJ$1`YBl+65Alz
z){mHRn6d55qr59#KG4sgKThm_MEhe+n{;gv=_<=E#p}l$w>Qw{nepTNBv~?zr&5k&
z{FYeSVKaWn!x;#N+;}vk$utFZHM#r}kN(jvr}P2T=TrTndQbJeHKA>4hrG~HO5Q4@
zvz15f*5YYO-u?{q8E1+10%Ntj*s+TrXiekZlm+))@E1E_v6*-2WGb0T9>rtd)l=(F
zWL{D~asj6=?%bH6r0IJS-O4^5<Gv}oO)cX*2H~(oI*NWyhBdO3>d9x!F@+oxq{<Ov
zEnIaL*X6^?%2KihMHv;cF|FbLQ_v@Y#u#e`bV=%0as84>-!V<GEk=2Z_qW`Kn(2kI
zM6$_Enc4q~F`9Ji-M>FqG0R-)_*U4bj%8zdrdbAwAI8|ti*cLm9}i`0^h4BTl98Im
zLdSG%d19a6%3~|9GKPL2VJv=-{%-YQjL8zi)v}gsbt;+vSeCi?gAme`(ibz%&1KUt
zZ$Ny0a17P!1N!XWa-3>p8Oty>GoKWCzdA$lD2m6xjU`@nc9*KOsM!jd40Sq9pw6FN
zudF<mY2;S!>?);5(5J#ZE`(H#URCj{vqP%VPCnt5!kj(*;-oMWX_Adu+_Ks0l~qF4
zamsgam*nh#s;q|v$=I(RM-#20*+EsQUObtdkd<|fQXyp(DoWv8_^U?*@a*4mlA4({
zqe@+DR2<N0ty&`@-ft*D)o3?F#QW9RK|>i;PgImKb#}9%G;1)nX|n@{64K`4hFoo~
z*HD`DS@74YgV(9gjq1vvJ_{lu`o$=e#)*A~+H1^Kl(2DP(@|=aj3NWfbWM)?bR`@2
zX3wrr3ZXx)m#D4tWR+LfHM+9!Zqy}h>TunIX_0mHe@Q#+^bl4RuEz2PcRkLvPGOaK
z@X^3(oCDY>Sq-kTimb|px|$^U=9aQ7PhFB_#oGF6+<4&;s$?AqCP9hG+>pEj>Xsv9
zh^lwj$76*Z!gb}ew>%508m_XMtgGCfs>$LcE`i9ZFIxjI_`KfC;7NXvKS__3CMH*n
zBzN*n*n&Etm_v~^mYqg;8I|Y}*-!G2!{U+aJ0(n8`SsHUqlNkXK&-FC{d<{T#Y!5&
zUDBEcSyeON2XkWhLG~YI{#@ao#R!6asgbAW8vG~vZ)g7j<`03Ns9(3#50>;ys2}qS
z;U-c3Ap4j1*jo7`%r{uD-{L>UeAG_!X|wPRbX4@@(t;tL4*VzTKa2U{3HawS-_Hw#
z0r*eUe=+lC^J3V!6i7T71VO(SGoQjw^k2mOW6Y-x5f8^k5cGRarZ86n67{cO|Cl72
zk01Gz$Y0O=EV0a`_~9xs{3!D~n7`h_S9m>f?sOsle8ErAuMm8@qRh(zE&<L076PXO
zzYa8j%TP=efu-XJ?;_A+0!w4Sxo|fM{2aWF2wXG_Tn_s|;3dEwAg=73*AAp`T7eW!
zGmygZ11X#)fu%kmh2s@idJT}msR!apyTWRLiz<K=&Ub(mPCgKIcHV5@V&E(wg?A!w
zDR4Rv=~$R4a1kvGlK-(|%=N)}Q6RY=29p0lAo2T|-vuPSTNwR}*8nLV9w5b|USMf8
zkm6A#u(Ser0o)Y<NsmH-i<SW?ob!Q~0JDK4?;Ie>n=7z13rO;23oM-lBzXpq<S7Cd
zjo~6Uk{1PD0vrXByfBdD4GSzC0+PHzfu#dLN@u#)n&gE9F6su7yiOp=YXg$Ipx_ra
z3tZ#}k~<%e+^q+ayJ{fT`U|TBE?Na7cPoM9?p$CIFq1Kgdhs8ihk#_?!x#WkzW5pI
zfoRC*RRK+TjD<i96z9zXQu;(QM81v!DgXL`lpei6N{^7h(jMSNpt}W@b^)=3Jg*gq
zc}HQ3z(vhK3eOKT<H>Y2kiyLeQn<5#RGv-*Qn&_?!W~DuMB$DJER6v#0v#1t8UdaS
zcf-IL@H!-L(EyOb?E{+m0K^q~^O}GZju%MbV4i4(vl2+*ln5*>0#Z1I0!uFjQvRF|
zJQ-f|1un`4QaI-TDV!NhX9B+idKm34g*OPK@VbB$uMQxE*DkQM4M^d&3M_2_Qg{I%
z`t(A-z(qbFg?9~*!mDEXJHRVIX9Fp`bAS}yY#@a<14!Y~z30Hv=|BoEQ(&n9r0~WJ
z+}jSXF@cLBKniaJNa2Nm-vau96pjx_;j9NzIQ76~kXtRVv<gV!R0u3x1)K|aB|sHk
ziv%vZ7)aqP22wa#Kq}7)kjilcjXt$Yqd@Y9bp*mi!$9&k2qgDiKyu#-TncOflKY^*
zMFAkWZvvA0Dj=>(o>u`}0{jk;;!_Bu_$&i1gZ_&JmYxr!_~Z*L%>`2V%>p6`3ug;l
zbRv+#$plh-=-yDGL%@|l>c=QNAJ9xcpqYL^3a?sVDb^Q6`Uxyu1)K|iB|uc!!Xkl-
zE(VhP#Xt&gF7R@o0lWYhK_XCiBR~po2uR@#04cnFfu(&wiXY}Ygry-Mg@<{QnU3@x
z4}Xi=@k8OY0x3MY9~4(!&ZBYMmw*+(CBW|h&GZDC=?SFp77HvrA84khz|veG>6-;K
z(^KH06M<%W0?qVP1l<e#Cfo;sl<z*^QlJ+Ir-eM;TjT*v{;PqcC-Ppo5D49rOM%eI
z^q&nR|K|e9|2YB|WdX_mEFk$`4E%Rg6>|SoAh|05W&yEyOxK?)7XwcO<^z#eG~GNt
zteJAB@q5*2R4y)qeTePpoiF~Tb+Uac+XvY`!1i9YU(fdSY`==_7c=HFKb!ekY_Bkm
zA(AjoqwzE85eDLK8kG;Sr}AOy$M)T9PvwB@TiHIy_5rr{vi*9tuV?#JY`>E2i`afK
z+vl@=Hrr>hy}~$#bTst^n)(94nl{At18g5+`&Pyvko*OJ<j>3Ys~A@TiC+XH{$jSz
zXZvin&tm&oY=0u#157<Kv~$kQ(5~^S8Cr|hs%2^+trx%DT91~Yb?RMurq-_y;I~)r
z(=)UIW6;RdB1ROyBgUu!U(;Hr!Pm52{B}?4nU<jiGg>k-w2_Qa{0?LeX2N}D6u%>x
zqnR06?C7zhGqu1m&BtVFO~?3;$<X}A29C|t+K=tPZ|kvb$7X2V(|e|8YJ<~<@Y_Fq
zV0wl&blmW9ncCQK<M@pp7dsB&p3r&%!aboEzuhPFoRFc7o*X$jLu)=IcuIyAI;HoN
zOl|m-Fn$M58G?;>hHplu);6OZzb!LbXJlyoGX`Le&WPc6bVdX=O{e-#&CnvJMo)!q
zGyO9&HSbK{OvGj8D4A#ZW<iIU<1>+Vx1xd^kBpR$6XxU5cFOnt%ZZN+S~Xp`xWhsp
z$F!VpevfGQKl6Cup2jWY-^>25WLnN29qfKSyPwB=IX~Qw{+#^F`Cu=HC+Bx-n3nT7
zJJWLhHb(NG&o@~9D=c5m-|k_4HS>SLd^vx+k@-Jl{x!^(^S5s^|L4r7`55Ud=WkzQ
z{)5aviTQGVb`R?-=Ua2x{VVLgg!yv5^)96c;xoqlIn0;yt!Ib^|LhY)`ai|t$@x|W
z^JV`2f%pd6Om-h68XbV#Pf<ZM!j$_V${}_R%7~oTT?oH)KX;VN(4`2Q=-Kc`&l60`
zdFan!NB-ry!amc#qR4fK5YsKDZ}fq1OYSjeGM}gMOSF7WMp_ds=g~JXE$79@LU-cJ
zdG7y0+=!O*+J|8#TF&GD!1Cp~z_ZMk^Z2ir@llj4%**Jxg2SWn3_V|Bn)(ZR=vsD?
zFV`X7h8@w>?EXFG%Xu*RG?OpaO}@{xT!*0X@*Kmftm6ENQGAeQ^-R<Fc+OE?WgFAa
z5kDb6A7}S6zaKaC4N;$IKJS2rO7Uks<R#KaL+?a714JT?Z7xYP71KoiN`#+C-(jIW
z7Wx{C{9jr0yT!sM*@^NiE&Por|B3upE%NFt?p2HX=PmAkXL0Yb&>a?<`d|FTp9d}U
zZi{@~lHT`Q`2TI8vC+!B9d(j>zWKO?39spvS54-K3te%KG_4oY2Q{wRI?GkuHY^p>
znkg-rGE067L?7w6aD8%|kzQ_|xg?z|*7TZ=VN2G@dc(KrFK)^4On<R=dS&9*bu(KC
zG;iy!#Bn7a-hxPpY#y|tII&8NYf{amkx9>21}9xYEHcG<HE|^^zQcQkK=FIv(o~Ux
zw5;wZT9<U`ut*?tX&vV$CG+IUa+<q}O>a3+Ir$1+)7re~^T6@3yc<y5z=^f!q&s_s
z2mY3lKjc5Shg<|~pWsSgd=-NIg1ErfjFXv?X>Z-FG)s$uGeGbjLvfl*{wY`SQi?%D
ze2cej;Z!c4H6t}&<OSW?k|ZIi5EWdqf-aIu`w7sIxTq)jUZdoTfGBL7r})VQ|51jV
ze8rNbvLB>?;;8<l97}E~<Rw`X6jqC8vnb?J;c~3Nw}gCtB|hp-*QChLv=Yys!TxOL
zx|$DlRLz0!6=j9Ce9e_?9sfit$y&Z!5)l&h51$&FH)7fnFDIs?J5rxMe*zzQ@y_tn
z?|&xydMA|^|GFm4M>q%l*d_II7W#CBcj24g5v2K+BmNbL{HDYDjY8@t8~9?w>d2Px
y5eM~1;>(KEuQ1Zsq*@*P0}XsEk)lETONz-qq_Fx+{c-@GA6Ok(w*H%Ar~eBbh?Kqn

literal 537768
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

diff --git a/deps/fmt/lib/pkgconfig/fmt.pc b/deps/fmt/lib/pkgconfig/fmt.pc
index 6f2ba85a..dad0bdd8 100644
--- a/deps/fmt/lib/pkgconfig/fmt.pc
+++ b/deps/fmt/lib/pkgconfig/fmt.pc
@@ -5,7 +5,7 @@ includedir=${prefix}/include
 
 Name: fmt
 Description: A modern formatting library
-Version: 7.1.3
+Version: 8.1.1
 Libs: -L${libdir} -lfmt
 Cflags: -I${includedir}