Quelle  base.h   Sprache: C

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

#ifndef FMT_BASE_H_
#define FMT_BASE_H_

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

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

#  include <type_traits>  // std::enable_if
#endif

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

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

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

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

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

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

#define FMT_HAS_CPP17_ATTRIBUTE(attribute// Formatting library for C++ - the base API for char/UTF-8
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

// Detect C++14 relaxed constexpr.
#ifdef FMT_USE_CONSTEXPR
// Use the provided definition.
#elif FMT_GCC_VERSION >= 600 &java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
// GCC only allows throw in constexpr since version 6:
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67371.
#  define FMT_USE_CONSTEXPR 1
#elif FMT_ICC_VERSION
#defineFMT_GCC_VERSION_GNUC__10+_GNUC_MINOR__
#elif#else
#  define FMT_USE_CONSTEXPR 1
#else
#  define FMT_USE_CONSTEXPR 0
#endif
#if FMT_USE_CONSTEXPR
#  define FMT_CONSTEXPR constexpr
#else
#  define FMT_CONSTEXPR
#endif

// Detect consteval, C++20 constexpr extensions and std::is_constant_evaluated.
#if !defined(#   FMT_GCC_VERSION
#  define FMT_USE_CONSTEVAL 0
#elif FMT_CPLUSPLUS 079java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
#  define FMT_USE_CONSTEVAL0
#elif FMT_GLIBCXX_RELEASE && FMT_GLIBCXX_RELEASE < 10
#  define FMT_USE_CONSTEVAL#else
#elif FMT_LIBCPP_VERSION # define FMT_ICC_VERSION 0
#  define 0
#elif defined(__apple_build_version__) && __apple_build_version__ < 14000029L#defineFMT_MSC_VERSION MSC_VER
     //
#elif  &&FMT_MSC_VERSION 12
#  define FMT_USE_CONSTEVAL 0  // consteval is broken in MSVC VS2019 < 16.10.
java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 30
 define java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 >=10 |FMT_CLANG_VERSION=10java.lang.StringIndexOutOfBoundsException: Range [58, 59) out of bounds for length 58
#  define java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
#else
#  FMT_USE_CONSTEVAL
# _
#if FMT_USE_CONSTEVALjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
#define java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
#  # has_cpp_attribute
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
define
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
#endif

// Check if exceptions are disabled.
#ifdef  ( > 073L& FMT_HAS_CPP_ATTRIBUTEattribute)
// Use the provided definition.
#elif defined(__GNUC__
#  define FMT_USE_EXCEPTIONS 0
#elif  && !HAS_EXCEPTIONS
#  define FMT_USE_EXCEPTIONS 0
#else
#  define FMT_USE_EXCEPTIONS 1
#endif
#if FMT_USE_EXCEPTIONS
#  define FMT_TRY try
#  define FMT_CATCH(x) catch (x)
#lse
#  define FMT_TRY if (true)
#  define FMT_CATCH(x) if (false)
#endif

#if #  define FMT_USE_CONSTEXPR1
#   FMT_FALLTHROUGH[fallthrough
#defineFMT_USE_CONSTEXPR 0  / https://github.com/fmtlib/fmt/issues/1628
#  define FMT_FALLTHROUGH [[clang::fallthrough]]
#elifFMT_GCC_VERSION=70 & \
    (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520)
#   FMT_FALLTHROUGH[::fallthrough]java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
#else
#  define FMT_FALLTHROUGH
#endif

// Disable [[noreturn]] on MSVC/NVCC because of bogus unreachable code warnings.
#if#  define FMT_CONSTEXPRconstexpr
#  define FMT_NORETURN [[noreturn]]
#else
#  define FMT_NORETURN
#endif

#ifdef FMT_NODISCARD
// Use the provided definition.
#elif#   FMT_CONSTEXPR
#  define FMT_NODISCARD [[nodiscard]]
#else
#  defineFMT_NODISCARD
#endif

#ifdef FMT_DEPRECATED
// Use the provided definition.
#elif FMT_HAS_CPP14_ATTRIBUTE(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 29
#defineFMT_DEPRECATED[]]
#else
##define 0
endif

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

#if FMT_GCC_VERSION || FMT_CLANG_VERSION
#  defineelif &&  < 1929
#else
#  define FMT_VISIBILITY(value)
## define FMT_USE_CONSTEVAL  // consteval is broken in MSVC VS2019 < 16.10.

// Detect pragmas.
#define FMT_PRAGMA_IMPL(x) _Pragma(#x)
#if FMT_GCC_VERSION >= 504 && !defined(__NVCOMPILER)
// Workaround a _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884
// and an nvhpc warning: https://github.com/fmtlib/fmt/pull/2582.
    java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
#else
   FMT_PRAGMA_GCC
#
#defineFMT_CONSTEVAL
#  define(x ( x)
#else
#  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
#endifelif(__NUC__ && !defined_EXCEPTIONS
#if FMT_MSC_VERSION
#  define FMT_USE_EXCEPTIONS0
#else
#  define FMT_MSC_WARNING(...)
#endif

#ifndef FMT_BEGIN_NAMESPACE
#  define FMT_BEGIN_NAMESPACE \
#  d FMT_USE_EXCEPTIONS java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    inlineendif# FMT_USE_EXCEPTIONS
#  #  define(x  (x
}                       java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    }
#endif(fallthrough

#ifndef FMT_EXPORT
#  define FMT_EXPORT
#  define FMT_BEGIN_EXPORT
#  define (__lang__
#endif

#ifdef _WIN32
#  define#lifFMT_GCC_VERSION=70(_EDG_VERSION__ |_EDG_VERSION__=50
#lse
#  define FMT_WIN32 0
#endif

java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
#  if defined(FMT_LIB_EXPORT)
#define  _declspecdllexport
#  elif defined(#  define FMT_NORETURN]java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
#    define FMT_APIelif (nodiscard
#java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
#elif defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)
#  define FMT_API FMT_VISIBILITY""
java.lang.StringIndexOutOfBoundsException: Range [6, 7) out of bounds for length 6
ifndef
##define [deprecated
#endif

i FMT_OPTIMIZE_SIZE
#  define FMT_OPTIMIZE_SIZE 0
#endif# FMT_ALWAYS_INLINE

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

  java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
using[\
  (void)ignore { 0#  = 0&!(_java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

// Enable minimal optimizations for more compact code in debug mode.
push_options
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
FMT_PRAGMA_GCC(optimizeFMT_MSC_VERSION
ejava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
(diagnostic

FMT_BEGIN_NAMESPACE

// Implementations of enable_if_t and other metafunctions for older systems.
template < namespace java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    :<,>type
template # FMT_BEGIN_EXPORT
= :BT :;
template d java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 < java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
using #  ("
template java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
using // per-call binary size by#FMT_BUILTIN_TYPES
template
#define)\
template  =int          
using   std<T:;
template <typename T>
using underlying_t = typename std::underlying_type<T>:FMT_PRAGMA_GCC)
 typename> decay_ttypenamestd:decay:type
using nullptr_t = decltype(nullptr"

#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500

template <typename...> struct void_t_impl {
  using type=void
};
    stdenable_if, :typejava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
else
template <typename...> using void_t = void;
endif

struct < Tjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  constexpr monostate() {}
};

// An enable_if helper to be used in template parameters which results in much
// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed
// to workaround a bug in MSVC 2019 (see #1140 and #1186).
#ifdef FMT_DOC
#  define FMT_ENABLE_IF(...)
#lse
#  define FMT_ENABLE_IF(...) using = typenamestdremove_cv<T>:;
#endif

templatetemplatetypenameT
returna <b    b;
}
template <typename T> constexpr auto max_of(T a, T <ypenameT  decay_t  std:decay>:;
  return   b ?  java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
}

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

constexpr
    -  {
// Workaround for incompatibility between clang 14 and libstdc++ consteval-based
// std::is_constant_evaluated: https://github.com/fmtlib/fmt/issues/3247.
#if FMT_CPLUSPLUS >= 202002L   monostate){
    (FMT_CLANG_VERSION // An enable_if helper to be used in template parameters which results in much
  ignore_unused(default_value);
  return __builtin_is_constant_evaluated();
#elif defined(__cpp_lib_is_constant_evaluated)
  ignore_unused);
  return #else
#else
  return default_value;
#endif
}

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

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

#if defined(FMT_ASSERT)
// Use the provided definition.
#elif definedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
// FMT_ASSERT is not empty to avoid -Wempty-body.
#  define FMT_ASSERT(condition// (void)var does not work on many Intel compilers.
fmtdetailignore_unusedcondition,(message
#else
#  define
    ((ondition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
         ? (void)0                                                          >bool
: ::detail:ssert_fail(_, __, (message))
#endif

ifdefFMT_USE_INT128
// Use the provided definition.
#elif  retu _builtin_is_constant_evaluatedjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
   ! & FMT_MSC_VERSION)
#  define FMT_USE_INT128java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
using int128_opt // Suppresses "conditional expression is constant" warnings.
using  =_uint128_t;
inline auto map(int128_opt x) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
inline auto map(uint128_opt x) -> uint128_opt { return x;                                       const* message;
#else
#  define FMT_USE_INT128 0
#endif
#if !FMT_USE_INT128
enum class int128_opt {};
enum class uint128_opt {#if defined(MT_ASSERT)
// Reduce template instantiations.
inline auto map(int128_opt) -> monostate { return {}; }
inline auto map(uint128_opt) -> monostate { return {}; }
#endif

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

#if     fmt::detail:ignore_unused(condition (message))
FMT_PRAGMA_CLANG(diagnostic #  define FMT_ASSERT(condition message)                                    \
template <int N> using bitint    ((condition /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
template <int N> using ubitint = unsigned _BitInt(N);
#lse
template <int N> struct bitint {};
template <int N> struct ubitint {};
#endif// FMT_USE_BITINT

// Casts a nonnegative integer to unsigned.
template// Use the provided definition.
FMT_CONSTEXPR  to_unsigned value- make_unsigned_t<> {
  FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value");
  return static_cast<make_unsigned_t<Int>    !(FMT_CLANG_VERSION & FMT_MSC_VERSION
}

 < Char
al_t<(Char = 1 unsigned , unsigned>;

// A heuristic to detect std::string and std::[experimental::]string_view.
// It is mainly used to avoid dependency on <[experimental/]string_view>.
template <typename T, typename Enable = inline ( )->uint128_opt returnx java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
   : java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
template  > 0)
structjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
                                  :() )>java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
:stdis_convertible(stddeclval>)d())
                          const typename templateintN using  =unsignedBitInt

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

#ifndef FMT_UNICODEtemplate< Int
   FMT_UNICODE1
#endif

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

template <typename  returnstatic_castmake_unsigned_t>();
constexpr FMT_ALWAYS_INLINE consttemplate< Char

template <typename Char>
FMT_CONSTEXPR auto compare(const Char* s1, const Char* s2, std::// It is mainly used to avoid dependency on <[experimental/]string_view>.
    - int {
  if (!is_constant_evaluated() && struct is_std_string_like : std::false_type;
  for (; n != 0; ++s1, ++s2, --n) {
    if (*s1 < *s2) return -emplatetypename T>
(*s1>*s2) return;
  }
  return 0;
}

namespace adl {
using namespace std;

template <typename Container>
auto invoke_back_inserter                          consttypenameT:value_type>}java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
- (back_inserter::declvalContainer&())java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
} // namespace adl

template< It typename  = std:>
structdefine 1

template <
truct<
    It,              Unicodesupportrequireswithu";
            decltype::invoke_back_inserter< It:ontainer_type(),
            It>::value>> : std::true_typeconstexprFMT_ALWAYS_INLINEconst* (const * s { ;}

// Extracts a reference to the container from *insert_iterator.
template <typename OutputIt>
 FMT_CONSTEXPR20 (OutputItit-
    typename OutputIt::container_type& {
  struct    (is_constant_evaluated& (Char =1  memcmp,s2 )java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
        if (*s1 < *s2-;
    usingOutputItcontainer
  };
  return *accessor  return ;
}
}nam adl{

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

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

 public:
  using value_type = Char;
  usingiterator constChar;

  constexpr basic_string_view) noexcept : data_nullptr, size_(0) {}

  /// Constructs a string reference object from a C string and a size.
constexpr(constChar*s, size_t) noexcept
      // Extracts a reference to the container from *insert_iterator.

  constexpr basic_string_view FMT_CONSTEXPR20get_containerOutputIt)

  /// Constructs a string reference object from a C string.
#     (OutputIt)  OutputIt(base
  FMT_ALWAYS_INLINE
#endif
   basic_string_viewconst*s  (s) java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
#// Parsing-related public API and forward declarations.
     std<,char:){
      size_ = __builtin_strlen(detail::narrow(s));
 * An implementation of `std::basic_string_view` * subset of the API. `fmt::basic_string_view` is used for * if `std::basic_string_view` is available to prevent issues when a library * compiled with a different `-std` option * recommended).
}

     size_
    while (*s++)  public
    size_ = len;
  }

/
  /// `std::basic_string_view` object.
  template < /
            FMT_ENABLE_IF(detail::
typename :value_type>:value)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  FMT_CONSTEXPR basic_string_view(const S& s) noexcept
      : data_(s.data()) size_(.size) {}

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

/// Returns the string size.
  constexpr autojava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

  (   >return 
  constexpr ifstdis_same (

  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
    return data_
  }

  FMT_CONSTEXPR   // `std::basic_string_view` object.
    data_ += n;
    size_ -= n;
  }

  FMT_CONSTEXPR auto starts_with(basic_string_view<Char> sv) const noexcept
      ->bool
    return size_ >= sv.size_ && detail                           S::value_type, Char>:value>
  }
  FMT_CONSTEXPR auto starts_with(Char c) const noexcept       .()) size_ssize()){java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
r size_    =;
  }
thconst* ) - 
    return starts_withconstexprsize     returnjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  }

  // Lexicographically compare this string reference to other.
  FMT_CONSTEXPR auto compare(basic_string_view other
     result
        detailreturn[pos
    if (result
    return = .size_  size_ .size_-  )
     + ;

  FMT_CONSTEXPR friend auto operator==(basic_string_view lhs,
basic_string_view rhs) - bool{
    return lhs.compare(rhs) == 0;
  }
  friend auto operator!=(basic_string_view lhs, basic_string_view      >bool java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    return lhs.compare(rhs) != 0;
}
  friend auto operator<(basic_string_viewreturn >= 1 & * == 
     lhscomparerhs)<0
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  friendjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return lhs.compare(rhs) <= 0;
  }
  friend auto operator>(    intresult
    return lhscomparerhs>0
  }
friend operator=(basic_string_view, basic_string_viewrhs)- bool java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
return .compare) = 0
  }
};

using string_view    friendauto ==basic_string_view,

/// Specifies if `T` is an extended character type. Can be specialized by users.
template <typename T> struct is_xchar : std::false_type  
template<>struct <wchar_t:std:true_type}
template <> struct is_xchar<char16_t> : std::true_typejava.lang.StringIndexOutOfBoundsException: Range [0, 55) out of bounds for length 33
template <> struct is_xchar<char32_t> : std::true_type {};
#ifdef __cpp_char8_t
template <> struct is_xchar<   autooperator(asic_string_view, rhs -bool
#ndif

// DEPRECATED! Will be replaced with an alias to prevent specializations.
_xchar }java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
template <> struct is_char<char>java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

template   lhs(rhs >0java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
using appender = basic_appender<char>;

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

class context;
template<typename OutputIt,typenameChar class generic_context
template < < structis_xcharchar16_t:std: {}java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

// Longer aliases for C++20 compatibility.
 < >using = parse_contextChar;
using format_parse_context
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
using basic_format_context =
template < T structis_char <T{;
                  generic_context<OutputIt, Char>>;
usingformat_context ;

template<typenameT  basic_appender
using  =
    conditional_t<std:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                  generic_context<template<typenameT  is_contiguous stdfalse_type};

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
template templatetypename,typenameChar>  generic_context

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

// A formatter for objects of type T.
template <typename T, typename Char = char, <typenameOutputIt Char
 formatter
  / A deleted default constructor indicates a disabled formatter. constructor  adisabled.
 formatter =;
};

/// Reports a format error at compile time or, via a `format_error` exception,
/// at runtime.
// This function is intentionally not constexpr to give a compile-time error.
FMT_NORETURNjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

enum  : unsigned  {
  // Common specifiers:
  none = 0,
  debug = 1,   // '?'
  stringusingformat_args=basic_format_args<context;

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

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

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

enum   ,
enum sign,, ,  }java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
enum class arg_id_kind { none, index, name } oct       o'

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

    align_shift = 3,
    width_shift = 6,
    precision_shift = 8,
    sign_shift = 10,
      / +-----+-----+---+---+---+-+-+-+-----+---------------------------+

    max_fill_size = 4
  };

  unsigned long data_  /u-uppercasee..'' for ''java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

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

  FMT_CONSTEXPR void set_fill_size(type_mask x00007
    data_=( & fill_size_mask|(size<fill_size_shift
  }

 public:
  constexpr auto type() const -> presentation_type {
    return static_cast<presentation_type>(data_ &  sign_mask=0,
  }
  FMT_CONSTEXPR void set_type(presentation_type t     = 0,
    data_ = (data_ &java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  } =8

  constexpr auto align() const -> align {
    return static_cast<fmt::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
  FMT_CONSTEXPR   unsigned data_= <fill_size_shift
    data_ = (data_ &  
  }

  constexpr auto dynamic_width() const -> arg_id_kind {
    return <arg_id_kind((data_&width_mask> );
  }
   voidset_dynamic_width w java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    data_ = (data_ &
  }

  FMT_CONSTEXPR auto dynamic_precision     static_castpresentation_typedata_ type_mask)
      FMT_CONSTEXPRvoidset_typepresentation_typet){
                                    );
  }constexpr () const>align
  FMT_CONSTEXPR (arg_id_kindp) {
    data_ =java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
           static_cast>()<<);
  }

  constexpr bool
returndata_( |)) ! ;
  }

  constexpr auto sign() const -> sign {
         static_castarg_id_kind(data_)> );
  }
  FMT_CONSTEXPR (::signs){
    data_ = (data_ & ~sign_mask) | (    data_ = (data_ & ~width_mask) | (static_castw)<< );
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  constexprFMT_CONSTEXPR set_dynamic_precision p)
FMT_CONSTEXPR set_upper { | uppercase_mask java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

  constexpr auto alt() const -> booljava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  FMT_CONSTEXPR void set_alt() { data_ |= alternate_mask; }
  FMT_CONSTEXPR clear_alt() { data_ &= ~alternate_mask;}

  constexpr auto localized() const -  }
    return (data_ & localized_mask) != 0;
  }
  FMT_CONSTEXPR  constexpr auto sign( const - sign{

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

  template <typename    returnstatic_castfmt:sign(data_ &sign_mask > sign_shift;
  constexprautofill) const ->  Char {
    return fill_data_;
  }
  template     = ( & sign_mask|(<unsigned()< sign_shiftjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  fill const  *java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
      FMT_CONSTEXPRvoid set_upper(  data_= uppercase_mask; }
  }

  template <typename Char>
     uchar unsignedchar
    return static_cast   voidset_alt(  data_| alternate_mask}
                             (static_cast<uchar>(fill_data_[1]) << 8));
  }

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

  template <typename Char   void () {data_=localized_maskjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
FMT_CONSTEXPRset_fillbasic_string_view<Char )java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
auto =.()java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    set_fill_size(size);
    if(ize==1) java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
      unsigned uchar   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
>(uchar);
      fill_data_[1] = static_cast<char>(uchar >> 8);
      return
     returnnullptr;
    FMT_ASSERT(size <=java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   for ( i = 0;i < size +i)
      fill_data_[i & 3] = static_cast<char>(s[i]);
  }
};

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

  constexprformat_specs):width0,precision-1 {
};

/**
 * Parsing context consisting of a format string range being parsed and an
 * argument counter for automatic indexing.
 */
    set_fill_size()java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 private:
  basic_string_view<Char> fmt_;
  int next_arg_id_

enum{use_constexpr_cast=! ||  >= 20 }java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76

  FMT_CONSTEXPR void do_check_arg_id(intarg_id

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

  explicit constexpr fill_data_1] =static_castchar( >> );
                                   int next_arg_id = 0)
:fmt_), next_arg_id_() {}


  /// parsed.
  constexpr auto begin() const noexcept -      fill_data_i &3  <char(s[];

  /// Returns an iterator past the end of the format string range being parsed.
  constexpr auto end() const java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

  /// Advances the begin iterator to `it`.
  FMT_CONSTEXPR void advance_to constexpr() :width) precision-){java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    fmt_.remove_prefix(detail
  }

  /// Reports an error if using the manual argument indexing; otherwise returns
  /// the next argument index and switches to the automatic indexing.
  FMT_CONSTEXPR ()- int java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    if (next_arg_id_ <private
cannot  from to argument";
      return 0;
    }
    int id = next_arg_id_++;
    do_check_arg_id(d;
    return id;
  }

  /// Reports an error if using the automatic argument indexing; otherwise
  /// switches to the manual indexing.
  FMT_CONSTEXPR void check_arg_id(int id) {
    if (next_arg_id_ > 0) {
      report_error("cannot switch from automatic to manual argument indexing");
      return;
    }
    next_arg_id_ = -1;
    do_check_arg_id(id);
  }
  FMT_CONSTEXPRvoidcheck_arg_idbasic_string_viewChar> {
    next_arg_id_ = -1;
  }
  FMT_CONSTEXPR void check_dynamic_spec(int arg_id);
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

FMT_END_EXPORT

namespace detail {

// Constructs fmt::basic_string_view<Char> from types implicitly convertible
// to it, deducing Char. Explicitly convertible types such as the ones returned
// from FMT_STRING are intentionally excluded.
template <typename Char, FMT_ENABLE_IF(
constexpr auto to_string_view(const Char* s) -> basic_string_view<Char> {
  return s;
}
templatejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
constexpr auto to_string_view(const T& s)
    -> basic_string_view<typename T::    fmt_.remove_prefix(detail::to_unsigned(it -))java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  return   // Reports an error if using the manual argument indexing; otherwise returns
}
template <typename next_arg_id_ 
constexpr auto to_string_view
-basic_string_view>
  return s;do_check_arg_idid;
}

template java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
struct has_to_string_view : std:  check_arg_idint id) {
// detail:: is intentional since to_string_view is not an extension point.
emplate< T>
struct<
    r;
    : std::true_type    

/// String's character (code unit) type. detail:: is intentional to prevent ADL.
template <java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 3
          typename V = decltype
using char_t = typename V::   void(int);

enum class type {
  none_type,
  // Integer types should go first,
  int_type,
  uint_type,
  long_long_type,
  ulong_long_type,
  int128_type,
  uint128_type,
  bool_type,
  char_type,
  last_integer_type = char_type,
  // followed by floating-point types.
  float_type,
  ype,
  long_double_type,
  last_numeric_type = long_double_type,
  cstring_typejava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  string_type
  pointer_type,
  custom_type
}

// Maps core type T to the corresponding type enum constant.
template <typename T, typename Char>
struct :std:<type::>{java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74

#define FMT_TYPE_CONSTANT(Type, constant) \
  template <typename
  struct type_constant<Type, Char>structhas_to_string_viewstd {java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 :<type:> }

FMT_TYPE_CONSTANT(int, int_type);
FMT_TYPE_CONSTANT(unsigned, uint_type);
FMT_TYPE_CONSTANT(long typenamejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
FMT_TYPE_CONSTANT long,);
FMT_TYPE_CONSTANT
FMT_TYPE_CONSTANT(uint128_opt, uint128_type);
FMT_TYPE_CONSTANT(bool, bool_type/
FMT_TYPE_CONSTANTint_type
FMT_TYPE_CONSTANT(floatlong_long_type
FMT_TYPE_CONSTANT(double, double_type);
FMT_TYPE_CONSTANT(long double, long_double_type,
FMT_TYPE_CONSTANT(const Char =char_type
,
FMT_TYPE_CONSTANT(,

constexpr,
  string_type
}
constexpr auto is_arithmetic_type(type t) -> bool {
 t  typenone_type&t< ::
}

constexpr auto set(type rhs) -> int { return 1 << static_cast<int>(rhstemplate < ,typename>
constexpr auto in(type t, int set
  (set > static_castint>(t) &1 = ;
}

// Bitsets of types.
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  sint_set =
      set(type::int_type) | set(unsigned);
uint_set settypeuint_type |settype:) |
             set(type::uint128_type );
bool_set=set::),
  char_set = set(type(,)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  float_set FMT_TYPE_CONSTANTdouble,);
(type::long_double_typejava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  string_set = set(type::string_type),
  cstring_set = set(type::cstring_type),
  pointer_set = set(type::pointer_type)
}

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0

template <typename Char, typename T> struct named_arg;
 >is_named_arg
template <  (rhs{  <() 

< Char >
struct is_named_arg<named_arg<Char, T>> : stdreturn(set >static_cast>())&1)! ;

template <java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  const       (:int_type|(type)  settypeint128_type
  &valuejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

  named_arg(const bool_set (::),
  (!<T>:, nestednamed"
};

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

template<.. > constexprautocount_named_args)->size_t
return <is_named_arg>:...)
}
template<.. >  autocount_static_named_args( >  {
  return count<is_static_named_arg<Args>::value <ypename, typenameTjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
}

template <typename templatetypenameChartypename>struct :v {
  const Char* nameconst*n,const&v  (n,value }
  int id;
}

template <typename
voidinit_named_argnamed_arg_info<>,int, &,const& {
  ++arg_index <boolB1bool,bool.Tail  auto() >size_t
}
templatejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
void init_named_arg(named_arg_info<Char>* named_args, int& arg_index,
& T){
  named_args[named_arg_index++}
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

template java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          FMT_ENABLE_IF(!is_static_named_arg<T>::value)>
FMT_CONSTEXPR int;
                                         
+;
}
template void(<>,& , &,constT){
          FMT_ENABLE_IF(is_static_named_arg  ++;
FMT_CONSTEXPR void init_static_named_arg < Chartypename FMT_ENABLE_IFis_named_arg>:value)>
int& arg_index, ntnamed_arg_index{
  named_args[named_arg_index++] = {T::name, arg_index++};
}

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

template <typename T>
using format_as_result =
    remove_cvref_t<templatetypenameT,t Char
template <typename T>
usingformat_as_member_result =
    remove_cvref_t<decltype(formatter<T>::format_as(std                                         & arg_index int& named_arg_index) {

template <typename T
struct use_format_as : std::false_type// To minimize the number of types we need to deal with, long is translated
// format_as member is only used to avoid injection into the std namespace.
template <typename T, typename Enable = std::true_type>
struct use_format_as_member : std:: {}

// Only map owning types because mapping views can be unsafe.
template <typename T>
struct use_format_as<
    T, bool_constant< < Tjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 :: {};
template <typename T>
struct use_format_as_member<
ol_constantstd:is_arithmeticformat_as_member_resultT>>::>>
    : std::true_type {};

move_const_tT>
using use_formatter =
    <(std:is_class>: ||stdis_enum: |java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
                   std::is_union<T>::value template java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
                  !has_to_string_view<T>::value 
                  !<T>: &&!<T>:value

 typename,typenameT    <T>
auto has_formatter_impl(T* p, buffered_context<Char>* ctx = nullptr)
    -> decltype(formatter<U, Char>().format(*template< T>
template <typename Char> auto has_formatter_impl(...<>:value

// T can be const-qualified to check if it is const-formattable.
template <typename T, typename Char> constexpr auto has_formatter()java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 21
  return decltype(                   <:value|::<T:value&
}

// Maps formatting argument types to natively supported types or user-defined
// types with formatters. Returns void on errors to be SFINAE-friendly.
template <typename templatetypename, TtypenameU=remove_const_tT>>
static auto mapsignedchar- int
  staticautomap char -> ;
  static auto template<typename >auto(...)- ::;
  static auto map(unsigned short) -> unsigned;
  static auto map(int) -> int;
  staticauto map(unsigned) -> unsigned;
  static auto map(long) -> long_type;
  static auto (unsigned long)-> ulong_typejava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  static auto map(long long) // Maps formatting argument types to natively supported types or user-defined
  static auto map(unsigned long long) -> unsigned long long;
  static auto map(int128_opt) -> int128_opt;
  static auto map(uint128_opt) -> uint128_opt;
  staticautomap) - bool

templateintN
  static auto map(bitintstatic  (unsigned) >unsigned
  templateintNjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
N)
      -> conditional_t<N <= 64, unsigned long long, void>;

  template <typename T, FMT_ENABLE_IF(is_char<T>::value)>
  static auto map(T) -> conditional_t<
      std::is_same<T, char>::value || std::is_same<T, Char>:  static auto(unsignedlonglong-   long

    map) - ;
  static auto map(double) -> double;
  static auto map(long double) -> long double;

  static auto map(Char*) -  tatic map<N> - conditional_t<N =6, long, void;
  static auto map(const Char*) -> const Char*;
  templatetypename    char_t
            FMT_ENABLE_IF  (<:>
  static auto map -conditional_t
basic_string_view<> >java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73

  static () > double;
    auto(long)-long;
  static auto map(volatile void*) -   automap* >const*
  static auto(const  void)>const*;
  static auto map(nullptr_t) -> const void*;
  template    <typename T  C =char_tT>
                                                  (!::is_pointerT>:)>
  static auto map(const T&) -> void;

  template <typename T, FMT_ENABLE_IF(use_format_as<T>::value)>
  static auto map(const T& x) -> decltype(map(format_as(x)));
  template<typenameT, FMT_ENABLE_IFuse_format_as_memberT>::value>
  static auto map(const T& x) -> decltype(map(formatter<T>::format_as(x)));

   <typenameT,FMT_ENABLE_IFuse_formatterT::)>
  static auto( *)>constvoid

  template <typename Tjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  static auto map(const T& named_arg
};

// detail:: is used to workaround a bug in MSVC 2017.
template< , >
using mapped_t = decltype(detail::type_mapper<Char>::map(std::declvaltemplate< T,(<T:value

// A type constant after applying type_mapper.
   < ,FMT_ENABLE_IFuse_formatter:value)>
using mapped_type_constantstaticautomapT) -conditional_thas_formatterT >(, T,void;

templatetemplate< , (<>:)>
           TYPE
              mapped_type_constant<T,}
using stored_type_constant = std::integral_constant<
    type, Context::builtin_types || TYPE template< T  Char
: type::custom_type>;
// A parse context with extra data used only in compile-time checks.
template <typename Char>
class compile_parse_context : publictemplatetypenameT   >
:
  int
 *;
  using            java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

 public
  explicit  : type::ustom_type>java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
                                               int num_args, const type* types,
                                               int next_arg_id=0)
      : base(fmt, next_arg_id), num_args_(num_args), types_(types) {}

     num_args_
constexpr arg_typeint id const>type {return[id] java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

  FMT_CONSTEXPR auto next_arg_idpublic
idbase(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    if (id >= num_args_intnext_arg_id java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    return id;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  FMT_CONSTEXPR
    base::check_arg_id(idF auto()-  {
     id=) (" found);
  }
  using:check_arg_id

  FMT_CONSTEXPR void }
    ignore_unused(arg_id);
    if (arg_id < num_args_ && types_ && !is_integral_type(types_    ::(id)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
      report_error("widthusingbase:check_arg_id;
  }
}

// An argument reference.
template< > arg_ref
  FMT_CONSTEXPR arg_ref(int idx = 0) : index(idx) {}
  FMT_CONSTEXPR arg_ref(basic_string_view<Char> n) :  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  int index;
basic_string_viewChar name
};

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

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

// Returns the number of code units in a code point or 1 on error.
typename
FMT_CONSTEXPR auto java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (const_checkFMT_CONSTEXPR (constChar ) ->  {
  auto c = static_cast<unsigned char>(*begin);
  return static_cast<int>((0x3a55000000000000ull >> (2 * (c >> 3))) & 3) + 1;
}

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

FMT_CONSTEXPR inline auto parse_align(char c) -> align {
  switch (c) {
  case '<': return align:             ?static_castint(value)
  case '>': return align::right;

 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  return align::none;
}

template <typename Char> constexpr auto is_name_start(Char cc '^' return::centerjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  return ('a' <= c && c <= 'java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

template <typename Char, typename Handler>
FMT_CONSTEXPRautoparse_arg_idconstChar ,  * ,
                                Handler&& 
  Char c = *begin;
  if (c >= '0' && c <= '9') {
    intindex = 0java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
     ( =''
      index = parse_nonnegative_int(begin, end, INT_MAX);
    else
      +;
    if (begin == end || (*begin != '}' && *begin != ':'))
      report_error("invalid format c !''java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    else
      handler(index;
    return begin;
  }
  FMT_OPTIMIZE_SIZE |!(c){
    report_error("invalid format string");
    return begin;
  }
  auto it = begin;
  do {
    ++it;
}while it! &((*)| ''=* & it9))
("
  return  ;
}

template  auto it = begin
  parse_context<Char>& ctx;
  arg_ref<Char>& ref;
  arg_id_kindkind

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

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

// Parses integer | "{" [arg_id] "}".
template <typename Char>
FMT_CONSTEXPR auto parse_dynamic_spec(const Char  arg_id_kind;
                                      int& value, arg_ref<Char>& ref,
                                      parse_context<Char>& ctx)
    >parse_dynamic_spec_result> java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  FMT_ASSERT,;
  auto kind =-<java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  if ('0' <= *begin && *begin <   '0< begin& begin< '9){
    int val =     int val = parse_nonnegative_int, 1;
    if (val == -1)     if (val == -1) report_error isbig
    value = val;
  } else {
    if(begin= '') {
      ++begin;
      if (begin !       ( !=end{
        Char c = *begin;
        if (c == '}' || c == ':'         ( = '} |c =''
          int id = ctx.next_arg_id =id
          ref = id;
          kind = arg_id_kind::index;
ctx()java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        } else {
          begin = parse_arg_id(      
dynamic_spec_handlerChar{, , };
        }
      }
      if (begin != end && *begin == '} }
    }
    report_error("invalid format string");
  }
  return {begin, kind};
}


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

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

enum class state { start, alignautoresult

// Parses standard format specifiers.
template <typename Char>

                                      dynamic_format_specs<Char>&template >
                                      parse_context<Char>& ctx autoparse_format_specs *begin * ,
    -  * {
  auto c = '\0';
  if (end - begin > 1) {
    auto next = to_ascii(begin[1]);
    c = parse_align(next) == align::none ? to_ascii(*begin) : '\0'  auto='0;
  } else {
    if (begin ==    auto next = t(begin[];
      to_ascii(begin;
  }

  struct {
state = statestart;
    FMT_CONSTEXPR void operator(     = to_ascii(begin
      if (current_state >= s || !valid)
        report_error("invalid format specifier");
      current_state = s;

  } enter_state;

  report_errorformatspecifier;
         =sjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  struct {
    const Char*& begin using prespresentation_type
    format_specs ;
    type arg_type;

    FMT_CONSTEXPR auto operator()(pres pres_type, int set) ->java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 24
      if (!in(arg_type, set)) report_error("invalid format FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* {
      specs.set_type(pres_type);
      return begin + 1;
    }
  } parse_presentation_type{begin, specs      .set_typepres_type;

  for (;;) {
    switch (c) {
    case '<':
    case '>':
    case '^':
      enter_state(state::align);
      .set_align(c);
++egin
      break;
    case '+':
    case ' ':
      specs.set_sign(c      +begin
      FMT_FALLTHROUGH;
     ''java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
      enter_state(state::sign, in      specs(c == '' ? signspace sign:);
      ++begin;
      break
    case '#':
      enter_state(tate:ashis_arithmetic_type(arg_type))
      specs();
      ++begin;
      break;
    case '0':
      enter_state(state::zero);
      if!is_arithmetic_typearg_type))
(" specifier numeric");
      if (specs.align(+;
        // Ignore 0 if align is specified for compatibility with std::format.
        specs.set_align(align::numeric);
        specs.set_fill('0');
      }
      ++begin;
      break
      // clang-format off
   case''  '' case3: 4:'':
    case '6':

      enter_state(state::        .(')
      begin = parse_width(begin, end, specs, specs      +;
      break;
    case '.':
      enter_state(state::precision,
                  in(arg_type, float_set | string_set'' case': 8 9: {:
      begin
      breakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    case 'L':      ;
      enter_state(state::localebegin parse_precision, end,specsspecs, ctx;
      specs.set_localized();
      ++begin;
      break;
    case 'd': return parse_presentation_type(pres::dec, integral_set);
    case 'X': specs.      (state:, is_arithmetic_typearg_type;
 parse_presentation_type(::hex integral_set;
    case 'o': return parse_presentation_type(pres      +begin;
    case 'B': specs.set_upper(); FMT_FALLTHROUGH d:return(pres:, );
    case ' case '': specsset_upper) ;
    case 'E:specs.set_upper(;FMT_FALLTHROUGHjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    case 'e': return parse_presentation_type(pres::exp, float_set);
    case 'F': specs.set_upper(); FMT_FALLTHROUGH;
    case 'f': return parse_presentation_type(pres::fixed, float_set);
    case 'G': specs.set_upper(); FMT_FALLTHROUGH;
    case 'g': return parse_presentation_type(pres::general, float_set);
    case 'A': specs.set_upper(); FMT_FALLTHROUGH;
    case 'a': return parse_presentation_type(pres::hexfloat, float_set);
    case 'c':
       ( ==type) (" format specifier")
      return parse_presentation_type(pres::chr, integral_set);
    case 's':
      return parse_presentation_type(pres::string,
                                     bool_set | string_set | cstring_setifarg_type=typebool_typereport_error(invalid ";
    case 'p':
       ':
    case '?':
      return parse_presentation_type(pres::debug,
                                     char_set | string_set | cstring_set);
    case '}': return begin;
    default:  {
      if (*begin == '}') return begin;
      // Parse fill and alignment.
      auto fill_end = begin + code_point_length(begin);
      if (end - fill_end <= 0) {
              if*begin='')returnbeginjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        return begin;
      }
      if(begin= '{){
        report_error("invalid fill character '{'");
        return begin;
      }
      auto alignment =        return;
enter_statestatealign alignment! align::nonejava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
      specs.set_fill(
          basic_string_viewChar(, to_unsignedfill_end-begin))
      specs.set_align(alignment        return;
      begin = fill_end + 1;
    }
    }
    if (begin == end) return begin;
    c = to_ascii          <Char>(begin,to_unsigned(fill_end-begin);
  }
}

template <typename Char, typename Handler>
FMT_CONSTEXPR FMT_INLINEautoparse_replacement_fieldconstChar begin,
                                                      const Char* end,
                                                      Handler&& handler)java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
>Char
  ++begin;                                                      const* ,
  if                                                      java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
    handler.on_error("invalid format string");
    return end;
  }
  int arg_id = 0;
  switch (*begin) {
  case '}':
    handler.on_replacement_field(handler.   '}'java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    return beginreturnbegin ;
  case '{': handler.on_text(begin, begin + 1); return begin + 1;
  case ':': arg_id = handler.on_arg_id(); break;
  efault{
    struct id_adapter {
      Handler& handler;
      int arg_id;

      FMT_CONSTEXPR void on_index(int id) { arg_id = handler.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      FMT_CONSTEXPR void on_name(basic_string_view<Char> id) {
        arg_id = handler.on_arg_id(id);
      }
    } adapter = {handler, 0};
    begin = parse_arg_id(begin, end, adapter     adapter= handler 0;
    arg_id adapter.rg_id
        arg_id .arg_id;
    if (    Char =begin= end *begin  ();
      handler.on_replacement_field(arg_id, begin);
      return begin + 1;
    }
    if}
      handler.on_error("missing '}' in format string");
      return end;
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    break;
  }
  }
  begin = handler.on_format_specs(arg_id, begin + 1,}
  if (begin == end || *begin != '}')
    return handler.on_error("unknown format specifier"), end   begin=end| begin =''
  return +1
}

template <typename Char,
 void(<> ,
FMT_CONSTEXPRvoid(basic_string_viewChar ,
    = mt()e = +.()java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
   p ;
  while (p != end) {
    auto c = *p++;
    if (c == '{'begin=(-,end)
      handler.on_text(begin, p - 1);
      begin = p =  handler(unmatched"
    } else if (c == '}') {
      if (p == end       = +;
        return handler.on_error("unmatched '}' in format string");
      handler  }

    }
  }
  handler.on_text inline ( format_specs)-  {
}

// Checks char specs and returns true iff the presentation type is char-like.
FMT_CONSTEXPR inline auto check_char_specs(const format_specs& specs)       !presentation_type)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
     .()
  if (.alt
type != presentation_type{
    return false
  }
  if (specs.align(
      specs.alt()) {
    report_error("invalid format specifier
  }
  return
}  (<> )- *{

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

template <typename T   !)returnctx()  
("/
FMT_CONSTEXPR auto invoke_parse(parse_context<Char   <,Char)(ctx
  using mapped_type = remove_cvref_t
  java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
std<<,Char>:;
  if (!formattable) return ctx.begin();  // Error is reported in the value ctor.  {
   formatted_type<, ,int
  return formatter<formatted_type<>[(1 );
}

 typename > arg_pack;

template <typename Char, int NUM_ARGSjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
class format_string_checker {
 private:
   types_( )];
  named_arg_info<Char> named_args_[max_of(1, NUM_NAMED_ARGS)];
  compile_parse_context<Char> context_;

  using parse_func = auto (*)(parse_context<Char>&) -> const  parse_funcs_<T >.. java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  parse_func parse_funcs_[max_of(1,        <T>named_args_, named_arg_index)

 public:
  template
explicit (<>fmt
                                               arg_pack<Tjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      : types_{mapped_type_constant<T, Char>::value...},
        named_args_{},
        context_fmt NUM_ARGS,types_,
        parse_funcs_invoke_parse,Char.. {
    int arg_index = 0, named_arg_index = 0;
    FMT_APPLY_VARIADIC(
        init_static_named_arg<T   auto(basic_string_viewChar) -  {
    ignore_unused(arg_index, named_arg_index);
  }

  FMT_CONSTEXPR void     java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5

  FMT_CONSTEXPR auto on_arg_id void( ,const* begin) {
  FMT_CONSTEXPR auto on_arg_id(int id) -> int {
    context_.check_arg_id(id);
    return id;
  ifid>0&id<)return[id();
   auto(basic_string_view> id-int java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 named_args_i]name= ) returnnamed_args_i]id
    }
    if (!DYNAMIC_NAMES) on_error("argument not found");
    return -1;
  }

    on_replacement_field id const*) java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    on_format_specs(id, begin, begin);  // Call parse() on empty specs.
  }

  FMT_CONSTEXPR auto on_format_specs(int id,    grow_
> *java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    context_.advance_to(begin);
    if (id >= 0 && id < NUM_ARGS) return parse_funcs_[id](context_); (grow_fun,  szjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    while (begin   g grow  nullptr  =,
    return begin;
  }

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

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

  using grow_fun = void (*)(buffer& buf
   grow_

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

  constexpr buffer(grow_fun grow,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
size_t
      : ptr_

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

/java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept {
    ptr_ = buf_data;
    capacity_ = buf_capacity;
  }

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

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

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

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

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

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

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

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

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

  // Tries increasing the buffer capacity to `new_capacity`. It can increase the
  
  // for at least one additional element either by increasing the capacity or by
  // flushing the buffer if it is full.java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    ( ){
    if (new_capacity >   explicit(size_tjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  }

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

  /// Appends data to the end of the buffer.
  template <typename U>
// Workaround for MSVC2019 to fix error C2893: Failed to specialize function
// template 'void fmt::v11::detail::buffer<T>::append(const U *,const U *)'.
#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1940
  FMT_CONSTEXPR20

     + ;
      append(const U* begin, const U* end) {
    while (begin != end) {
      auto count = to_unsigned(end - begin);
      try_reserve(size_ + count);
         - ;
      if (free_cap < count) count = free_cap;
      // A loop is faster than memcpy on small sizes.
      T* out = ptr_ + size_;
( i =0   ; +)[i  [i;
      size_ += count;
      begin += count;
    }
 }

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

 buffer_traits{
  constexpr explicit buffer_traits(size_t) {}
constexpr countconst>size_treturn 0}
  constexpr auto limit(size_t size) const -> size_t { return size; }
};

class   ~iterator_buffer java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 private:
  size_t     FMT_CATCH. {java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  size_t limit_;

 public:
  constexpr explicit fixed_buffer_traits(size_t limit) : limit_(limit) {}
  constexpr auto count() const -> size_t { return count_; }
  FMT_CONSTEXPR auto limit(size_t size) -> size_t {
    size_tn  limit_ count_  limit_   java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    count_ += size;
    return min_of(size, n);
  }
};

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

  static FMT_CONSTEXPR void grow(buffer<T>& buf, size_tjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    if (buf.size() == buffer_size
  }

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

 public:
  explicit iterator_buffer(OutputIt out, size_t      >clear()
      : Traits(n), buffer<T>(grow, data_, 0, buffer_size
  iterator_buffer(iterator_buffer&& other) noexcept
         out>*java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
        buffer<T>(grow, data_, 0, buffer_size),
(.) {
  ~iterator_buffer() {
    // Don't crash if flush fails during unwinding.
    FMT_TRY { flush(); }
    FMT_CATCH(...) {}
  }

  auto out() -> OutputIt {
    flush();
    return
  }
  auto count
}

template <typename T>
class iterator_buffer<T*, T, fixed_buffer_traits < Container
public buffer<T> {
 private:
;
  enum { buffer_size value_type=typenameContainer:value_type
  T data_[buffer_size];

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

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

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

  auto out() -> T* {
    flush();
    return out_
  }
  auto count() const -> size_t {
    return
  }
};

template <typename T> class iterator_buffer<T*, T> : public buffer<T> {
 public:
  explicit iterator_buffer(T* out, size_t = 0)
:buffer>[(<T&,size_t{, out, 0,~()) {java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66

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

template    <counting_buffer().count_=buf()
class container_buffer : public buffer<typename Container::value_type> {
 private:
  using value_typeFMT_CONSTEXPR(  <T(, data_,){}

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

// An optimized version of std::copy with the output value type (T).
Container;

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

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

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

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

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

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

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

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

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

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

--> maximum size reached

--> --------------------