//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef _LIBCPP___LOCALE_DIR_MONEY_H
#define _LIBCPP___LOCALE_DIR_MONEY_H

#include <__algorithm/copy.h>
#include <__algorithm/equal.h>
#include <__algorithm/find.h>
#include <__algorithm/reverse.h>
#include <__config>
#include <__locale>
#include <__locale_dir/check_grouping.h>
#include <__locale_dir/get_c_locale.h>
#include <__locale_dir/pad_and_output.h>
#include <__memory/unique_ptr.h>
#include <ios>
#include <string>

#if _LIBCPP_HAS_LOCALIZATION

#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#    pragma GCC system_header
#  endif

_LIBCPP_PUSH_MACROS
#  include <__undef_macros>

_LIBCPP_BEGIN_NAMESPACE_STD

// money_base

class _LIBCPP_EXPORTED_FROM_ABI money_base {
public:
  enum part { none, space, symbol, sign, value };
  struct pattern {
    char field[4];
  };

  _LIBCPP_HIDE_FROM_ABI money_base() {}
};

// moneypunct

template <class _CharT, bool _International = false>
class moneypunct : public locale::facet, public money_base {
public:
  typedef _CharT char_type;
  typedef basic_string<char_type> string_type;

  _LIBCPP_HIDE_FROM_ABI explicit moneypunct(size_t __refs = 0) : locale::facet(__refs) {}

  _LIBCPP_HIDE_FROM_ABI char_type decimal_point() const { return do_decimal_point(); }
  _LIBCPP_HIDE_FROM_ABI char_type thousands_sep() const { return do_thousands_sep(); }
  _LIBCPP_HIDE_FROM_ABI string grouping() const { return do_grouping(); }
  _LIBCPP_HIDE_FROM_ABI string_type curr_symbol() const { return do_curr_symbol(); }
  _LIBCPP_HIDE_FROM_ABI string_type positive_sign() const { return do_positive_sign(); }
  _LIBCPP_HIDE_FROM_ABI string_type negative_sign() const { return do_negative_sign(); }
  _LIBCPP_HIDE_FROM_ABI int frac_digits() const { return do_frac_digits(); }
  _LIBCPP_HIDE_FROM_ABI pattern pos_format() const { return do_pos_format(); }
  _LIBCPP_HIDE_FROM_ABI pattern neg_format() const { return do_neg_format(); }

  static locale::id id;
  static const bool intl = _International;

protected:
  _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~moneypunct() override {}

  virtual char_type do_decimal_point() const { return numeric_limits<char_type>::max(); }
  virtual char_type do_thousands_sep() const { return numeric_limits<char_type>::max(); }
  virtual string do_grouping() const { return string(); }
  virtual string_type do_curr_symbol() const { return string_type(); }
  virtual string_type do_positive_sign() const { return string_type(); }
  virtual string_type do_negative_sign() const { return string_type(1, '-'); }
  virtual int do_frac_digits() const { return 0; }
  virtual pattern do_pos_format() const {
    pattern __p = {{symbol, sign, none, value}};
    return __p;
  }
  virtual pattern do_neg_format() const {
    pattern __p = {{symbol, sign, none, value}};
    return __p;
  }
};

template <class _CharT, bool _International>
locale::id moneypunct<_CharT, _International>::id;

template <class _CharT, bool _International>
const bool moneypunct<_CharT, _International>::intl;

extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<char, false>;
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<char, true>;
#  if _LIBCPP_HAS_WIDE_CHARACTERS
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<wchar_t, false>;
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<wchar_t, true>;
#  endif

// moneypunct_byname

template <class _CharT, bool _International = false>
class moneypunct_byname : public moneypunct<_CharT, _International> {
public:
  typedef money_base::pattern pattern;
  typedef _CharT char_type;
  typedef basic_string<char_type> string_type;

  _LIBCPP_HIDE_FROM_ABI explicit moneypunct_byname(const char* __nm, size_t __refs = 0)
      : moneypunct<_CharT, _International>(__refs) {
    init(__nm);
  }

  _LIBCPP_HIDE_FROM_ABI explicit moneypunct_byname(const string& __nm, size_t __refs = 0)
      : moneypunct<_CharT, _International>(__refs) {
    init(__nm.c_str());
  }

protected:
  _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~moneypunct_byname() override {}

  char_type do_decimal_point() const override { return __decimal_point_; }
  char_type do_thousands_sep() const override { return __thousands_sep_; }
  string do_grouping() const override { return __grouping_; }
  string_type do_curr_symbol() const override { return __curr_symbol_; }
  string_type do_positive_sign() const override { return __positive_sign_; }
  string_type do_negative_sign() const override { return __negative_sign_; }
  int do_frac_digits() const override { return __frac_digits_; }
  pattern do_pos_format() const override { return __pos_format_; }
  pattern do_neg_format() const override { return __neg_format_; }

private:
  char_type __decimal_point_;
  char_type __thousands_sep_;
  string __grouping_;
  string_type __curr_symbol_;
  string_type __positive_sign_;
  string_type __negative_sign_;
  int __frac_digits_;
  pattern __pos_format_;
  pattern __neg_format_;

  void init(const char*);
};

template <>
_LIBCPP_EXPORTED_FROM_ABI void moneypunct_byname<char, false>::init(const char*);
template <>
_LIBCPP_EXPORTED_FROM_ABI void moneypunct_byname<char, true>::init(const char*);
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<char, false>;
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<char, true>;

#  if _LIBCPP_HAS_WIDE_CHARACTERS
template <>
_LIBCPP_EXPORTED_FROM_ABI void moneypunct_byname<wchar_t, false>::init(const char*);
template <>
_LIBCPP_EXPORTED_FROM_ABI void moneypunct_byname<wchar_t, true>::init(const char*);
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<wchar_t, false>;
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<wchar_t, true>;
#  endif

// money_get

template <class _CharT>
class __money_get {
protected:
  typedef _CharT char_type;
  typedef basic_string<char_type> string_type;

  _LIBCPP_HIDE_FROM_ABI __money_get() {}

  static void __gather_info(
      bool __intl,
      const locale& __loc,
      money_base::pattern& __pat,
      char_type& __dp,
      char_type& __ts,
      string& __grp,
      string_type& __sym,
      string_type& __psn,
      string_type& __nsn,
      int& __fd);
};

template <class _CharT>
void __money_get<_CharT>::__gather_info(
    bool __intl,
    const locale& __loc,
    money_base::pattern& __pat,
    char_type& __dp,
    char_type& __ts,
    string& __grp,
    string_type& __sym,
    string_type& __psn,
    string_type& __nsn,
    int& __fd) {
  if (__intl) {
    const moneypunct<char_type, true>& __mp = std::use_facet<moneypunct<char_type, true> >(__loc);
    __pat                                   = __mp.neg_format();
    __nsn                                   = __mp.negative_sign();
    __psn                                   = __mp.positive_sign();
    __dp                                    = __mp.decimal_point();
    __ts                                    = __mp.thousands_sep();
    __grp                                   = __mp.grouping();
    __sym                                   = __mp.curr_symbol();
    __fd                                    = __mp.frac_digits();
  } else {
    const moneypunct<char_type, false>& __mp = std::use_facet<moneypunct<char_type, false> >(__loc);
    __pat                                    = __mp.neg_format();
    __nsn                                    = __mp.negative_sign();
    __psn                                    = __mp.positive_sign();
    __dp                                     = __mp.decimal_point();
    __ts                                     = __mp.thousands_sep();
    __grp                                    = __mp.grouping();
    __sym                                    = __mp.curr_symbol();
    __fd                                     = __mp.frac_digits();
  }
}

extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_get<char>;
#  if _LIBCPP_HAS_WIDE_CHARACTERS
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_get<wchar_t>;
#  endif

template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
class money_get : public locale::facet, private __money_get<_CharT> {
public:
  typedef _CharT char_type;
  typedef _InputIterator iter_type;
  typedef basic_string<char_type> string_type;

  _LIBCPP_HIDE_FROM_ABI explicit money_get(size_t __refs = 0) : locale::facet(__refs) {}

  _LIBCPP_HIDE_FROM_ABI iter_type
  get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob, ios_base::iostate& __err, long double& __v) const {
    return do_get(__b, __e, __intl, __iob, __err, __v);
  }

  _LIBCPP_HIDE_FROM_ABI iter_type
  get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob, ios_base::iostate& __err, string_type& __v) const {
    return do_get(__b, __e, __intl, __iob, __err, __v);
  }

  static locale::id id;

protected:
  _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~money_get() override {}

  virtual iter_type
  do_get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob, ios_base::iostate& __err, long double& __v) const;
  virtual iter_type
  do_get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob, ios_base::iostate& __err, string_type& __v) const;

private:
  static bool __do_get(
      iter_type& __b,
      iter_type __e,
      bool __intl,
      const locale& __loc,
      ios_base::fmtflags __flags,
      ios_base::iostate& __err,
      bool& __neg,
      const ctype<char_type>& __ct,
      unique_ptr<char_type, void (*)(void*)>& __wb,
      char_type*& __wn,
      char_type* __we);
};

template <class _CharT, class _InputIterator>
locale::id money_get<_CharT, _InputIterator>::id;

_LIBCPP_EXPORTED_FROM_ABI void __do_nothing(void*);

template <class _Tp>
_LIBCPP_HIDE_FROM_ABI void __double_or_nothing(unique_ptr<_Tp, void (*)(void*)>& __b, _Tp*& __n, _Tp*& __e) {
  bool __owns      = __b.get_deleter() != __do_nothing;
  size_t __cur_cap = static_cast<size_t>(__e - __b.get()) * sizeof(_Tp);
  size_t __new_cap = __cur_cap < numeric_limits<size_t>::max() / 2 ? 2 * __cur_cap : numeric_limits<size_t>::max();
  if (__new_cap == 0)
    __new_cap = sizeof(_Tp);
  size_t __n_off = static_cast<size_t>(__n - __b.get());
  _Tp* __t       = (_Tp*)std::realloc(__owns ? __b.get() : 0, __new_cap);
  if (__t == 0)
    std::__throw_bad_alloc();
  if (__owns)
    __b.release();
  else
    std::memcpy(__t, __b.get(), __cur_cap);
  __b = unique_ptr<_Tp, void (*)(void*)>(__t, free);
  __new_cap /= sizeof(_Tp);
  __n = __b.get() + __n_off;
  __e = __b.get() + __new_cap;
}

// true == success
template <class _CharT, class _InputIterator>
bool money_get<_CharT, _InputIterator>::__do_get(
    iter_type& __b,
    iter_type __e,
    bool __intl,
    const locale& __loc,
    ios_base::fmtflags __flags,
    ios_base::iostate& __err,
    bool& __neg,
    const ctype<char_type>& __ct,
    unique_ptr<char_type, void (*)(void*)>& __wb,
    char_type*& __wn,
    char_type* __we) {
  if (__b == __e) {
    __err |= ios_base::failbit;
    return false;
  }
  const unsigned __bz = 100;
  unsigned __gbuf[__bz];
  unique_ptr<unsigned, void (*)(void*)> __gb(__gbuf, __do_nothing);
  unsigned* __gn = __gb.get();
  unsigned* __ge = __gn + __bz;
  money_base::pattern __pat;
  char_type __dp;
  char_type __ts;
  string __grp;
  string_type __sym;
  string_type __psn;
  string_type __nsn;
  // Capture the spaces read into money_base::{space,none} so they
  // can be compared to initial spaces in __sym.
  string_type __spaces;
  int __fd;
  __money_get<_CharT>::__gather_info(__intl, __loc, __pat, __dp, __ts, __grp, __sym, __psn, __nsn, __fd);
  const string_type* __trailing_sign = 0;
  __wn                               = __wb.get();
  for (unsigned __p = 0; __p < 4 && __b != __e; ++__p) {
    switch (__pat.field[__p]) {
    case money_base::space:
      if (__p != 3) {
        if (__ct.is(ctype_base::space, *__b))
          __spaces.push_back(*__b++);
        else {
          __err |= ios_base::failbit;
          return false;
        }
      }
      [[__fallthrough__]];
    case money_base::none:
      if (__p != 3) {
        while (__b != __e && __ct.is(ctype_base::space, *__b))
          __spaces.push_back(*__b++);
      }
      break;
    case money_base::sign:
      if (__psn.size() > 0 && *__b == __psn[0]) {
        ++__b;
        __neg = false;
        if (__psn.size() > 1)
          __trailing_sign = std::addressof(__psn);
        break;
      }
      if (__nsn.size() > 0 && *__b == __nsn[0]) {
        ++__b;
        __neg = true;
        if (__nsn.size() > 1)
          __trailing_sign = std::addressof(__nsn);
        break;
      }
      if (__psn.size() > 0 && __nsn.size() > 0) { // sign is required
        __err |= ios_base::failbit;
        return false;
      }
      if (__psn.size() == 0 && __nsn.size() == 0)
        // locale has no way of specifying a sign. Use the initial value of __neg as a default
        break;
      __neg = (__nsn.size() == 0);
      break;
    case money_base::symbol: {
      bool __more_needed =
          __trailing_sign || (__p < 2) || (__p == 2 && __pat.field[3] != static_cast<char>(money_base::none));
      bool __sb = (__flags & ios_base::showbase) != 0;
      if (__sb || __more_needed) {
        typename string_type::const_iterator __sym_space_end = __sym.begin();
        if (__p > 0 && (__pat.field[__p - 1] == money_base::none || __pat.field[__p - 1] == money_base::space)) {
          // Match spaces we've already read against spaces at
          // the beginning of __sym.
          while (__sym_space_end != __sym.end() && __ct.is(ctype_base::space, *__sym_space_end))
            ++__sym_space_end;
          const size_t __num_spaces = __sym_space_end - __sym.begin();
          if (__num_spaces > __spaces.size() ||
              !std::equal(__spaces.end() - __num_spaces, __spaces.end(), __sym.begin())) {
            // No match. Put __sym_space_end back at the
            // beginning of __sym, which will prevent a
            // match in the next loop.
            __sym_space_end = __sym.begin();
          }
        }
        typename string_type::const_iterator __sym_curr_char = __sym_space_end;
        while (__sym_curr_char != __sym.end() && __b != __e && *__b == *__sym_curr_char) {
          ++__b;
          ++__sym_curr_char;
        }
        if (__sb && __sym_curr_char != __sym.end()) {
          __err |= ios_base::failbit;
          return false;
        }
      }
    } break;
    case money_base::value: {
      unsigned __ng = 0;
      for (; __b != __e; ++__b) {
        char_type __c = *__b;
        if (__ct.is(ctype_base::digit, __c)) {
          if (__wn == __we)
            std::__double_or_nothing(__wb, __wn, __we);
          *__wn++ = __c;
          ++__ng;
        } else if (__grp.size() > 0 && __ng > 0 && __c == __ts) {
          if (__gn == __ge)
            std::__double_or_nothing(__gb, __gn, __ge);
          *__gn++ = __ng;
          __ng    = 0;
        } else
          break;
      }
      if (__gb.get() != __gn && __ng > 0) {
        if (__gn == __ge)
          std::__double_or_nothing(__gb, __gn, __ge);
        *__gn++ = __ng;
      }
      if (__fd > 0) {
        if (__b == __e || *__b != __dp) {
          __err |= ios_base::failbit;
          return false;
        }
        for (++__b; __fd > 0; --__fd, ++__b) {
          if (__b == __e || !__ct.is(ctype_base::digit, *__b)) {
            __err |= ios_base::failbit;
            return false;
          }
          if (__wn == __we)
            std::__double_or_nothing(__wb, __wn, __we);
          *__wn++ = *__b;
        }
      }
      if (__wn == __wb.get()) {
        __err |= ios_base::failbit;
        return false;
      }
    } break;
    }
  }
  if (__trailing_sign) {
    for (unsigned __i = 1; __i < __trailing_sign->size(); ++__i, ++__b) {
      if (__b == __e || *__b != (*__trailing_sign)[__i]) {
        __err |= ios_base::failbit;
        return false;
      }
    }
  }
  if (__gb.get() != __gn) {
    ios_base::iostate __et = ios_base::goodbit;
    __check_grouping(__grp, __gb.get(), __gn, __et);
    if (__et) {
      __err |= ios_base::failbit;
      return false;
    }
  }
  return true;
}

template <class _CharT, class _InputIterator>
_InputIterator money_get<_CharT, _InputIterator>::do_get(
    iter_type __b, iter_type __e, bool __intl, ios_base& __iob, ios_base::iostate& __err, long double& __v) const {
  const int __bz = 100;
  char_type __wbuf[__bz];
  unique_ptr<char_type, void (*)(void*)> __wb(__wbuf, __do_nothing);
  char_type* __wn;
  char_type* __we              = __wbuf + __bz;
  locale __loc                 = __iob.getloc();
  const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
  bool __neg                   = false;
  if (__do_get(__b, __e, __intl, __loc, __iob.flags(), __err, __neg, __ct, __wb, __wn, __we)) {
    const char __src[] = "0123456789";
    char_type __atoms[sizeof(__src) - 1];
    __ct.widen(__src, __src + (sizeof(__src) - 1), __atoms);
    char __nbuf[__bz];
    char* __nc          = __nbuf;
    const char* __nc_in = __nc;
    unique_ptr<char, void (*)(void*)> __h(nullptr, free);
    if (__wn - __wb.get() > __bz - 2) {
      __h.reset((char*)malloc(static_cast<size_t>(__wn - __wb.get() + 2)));
      if (__h.get() == nullptr)
        std::__throw_bad_alloc();
      __nc    = __h.get();
      __nc_in = __nc;
    }
    if (__neg)
      *__nc++ = '-';
    for (const char_type* __w = __wb.get(); __w < __wn; ++__w, ++__nc)
      *__nc = __src[std::find(__atoms, std::end(__atoms), *__w) - __atoms];
    *__nc = char();
    if (sscanf(__nc_in, "%Lf", &__v) != 1)
      std::__throw_runtime_error("money_get error");
  }
  if (__b == __e)
    __err |= ios_base::eofbit;
  return __b;
}

template <class _CharT, class _InputIterator>
_InputIterator money_get<_CharT, _InputIterator>::do_get(
    iter_type __b, iter_type __e, bool __intl, ios_base& __iob, ios_base::iostate& __err, string_type& __v) const {
  const int __bz = 100;
  char_type __wbuf[__bz];
  unique_ptr<char_type, void (*)(void*)> __wb(__wbuf, __do_nothing);
  char_type* __wn;
  char_type* __we              = __wbuf + __bz;
  locale __loc                 = __iob.getloc();
  const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
  bool __neg                   = false;
  if (__do_get(__b, __e, __intl, __loc, __iob.flags(), __err, __neg, __ct, __wb, __wn, __we)) {
    __v.clear();
    if (__neg)
      __v.push_back(__ct.widen('-'));
    char_type __z = __ct.widen('0');
    char_type* __w;
    for (__w = __wb.get(); __w < __wn - 1; ++__w)
      if (*__w != __z)
        break;
    __v.append(__w, __wn);
  }
  if (__b == __e)
    __err |= ios_base::eofbit;
  return __b;
}

extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_get<char>;
#  if _LIBCPP_HAS_WIDE_CHARACTERS
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_get<wchar_t>;
#  endif

// money_put

template <class _CharT>
class __money_put {
protected:
  typedef _CharT char_type;
  typedef basic_string<char_type> string_type;

  _LIBCPP_HIDE_FROM_ABI __money_put() {}

  static void __gather_info(
      bool __intl,
      bool __neg,
      const locale& __loc,
      money_base::pattern& __pat,
      char_type& __dp,
      char_type& __ts,
      string& __grp,
      string_type& __sym,
      string_type& __sn,
      int& __fd);
  static void __format(
      char_type* __mb,
      char_type*& __mi,
      char_type*& __me,
      ios_base::fmtflags __flags,
      const char_type* __db,
      const char_type* __de,
      const ctype<char_type>& __ct,
      bool __neg,
      const money_base::pattern& __pat,
      char_type __dp,
      char_type __ts,
      const string& __grp,
      const string_type& __sym,
      const string_type& __sn,
      int __fd);
};

template <class _CharT>
void __money_put<_CharT>::__gather_info(
    bool __intl,
    bool __neg,
    const locale& __loc,
    money_base::pattern& __pat,
    char_type& __dp,
    char_type& __ts,
    string& __grp,
    string_type& __sym,
    string_type& __sn,
    int& __fd) {
  if (__intl) {
    const moneypunct<char_type, true>& __mp = std::use_facet<moneypunct<char_type, true> >(__loc);
    if (__neg) {
      __pat = __mp.neg_format();
      __sn  = __mp.negative_sign();
    } else {
      __pat = __mp.pos_format();
      __sn  = __mp.positive_sign();
    }
    __dp  = __mp.decimal_point();
    __ts  = __mp.thousands_sep();
    __grp = __mp.grouping();
    __sym = __mp.curr_symbol();
    __fd  = __mp.frac_digits();
  } else {
    const moneypunct<char_type, false>& __mp = std::use_facet<moneypunct<char_type, false> >(__loc);
    if (__neg) {
      __pat = __mp.neg_format();
      __sn  = __mp.negative_sign();
    } else {
      __pat = __mp.pos_format();
      __sn  = __mp.positive_sign();
    }
    __dp  = __mp.decimal_point();
    __ts  = __mp.thousands_sep();
    __grp = __mp.grouping();
    __sym = __mp.curr_symbol();
    __fd  = __mp.frac_digits();
  }
}

template <class _CharT>
void __money_put<_CharT>::__format(
    char_type* __mb,
    char_type*& __mi,
    char_type*& __me,
    ios_base::fmtflags __flags,
    const char_type* __db,
    const char_type* __de,
    const ctype<char_type>& __ct,
    bool __neg,
    const money_base::pattern& __pat,
    char_type __dp,
    char_type __ts,
    const string& __grp,
    const string_type& __sym,
    const string_type& __sn,
    int __fd) {
  __me = __mb;
  for (char __p : __pat.field) {
    switch (__p) {
    case money_base::none:
      __mi = __me;
      break;
    case money_base::space:
      __mi    = __me;
      *__me++ = __ct.widen(' ');
      break;
    case money_base::sign:
      if (!__sn.empty())
        *__me++ = __sn[0];
      break;
    case money_base::symbol:
      if (!__sym.empty() && (__flags & ios_base::showbase))
        __me = std::copy(__sym.begin(), __sym.end(), __me);
      break;
    case money_base::value: {
      // remember start of value so we can reverse it
      char_type* __t = __me;
      // find beginning of digits
      if (__neg)
        ++__db;
      // find end of digits
      const char_type* __d;
      for (__d = __db; __d < __de; ++__d)
        if (!__ct.is(ctype_base::digit, *__d))
          break;
      // print fractional part
      if (__fd > 0) {
        int __f;
        for (__f = __fd; __d > __db && __f > 0; --__f)
          *__me++ = *--__d;
        char_type __z = __f > 0 ? __ct.widen('0') : char_type();
        for (; __f > 0; --__f)
          *__me++ = __z;
        *__me++ = __dp;
      }
      // print units part
      if (__d == __db) {
        *__me++ = __ct.widen('0');
      } else {
        unsigned __ng = 0;
        unsigned __ig = 0;
        unsigned __gl = __grp.empty() ? numeric_limits<unsigned>::max() : static_cast<unsigned>(__grp[__ig]);
        while (__d != __db) {
          if (__ng == __gl) {
            *__me++ = __ts;
            __ng    = 0;
            if (++__ig < __grp.size())
              __gl = __grp[__ig] == numeric_limits<char>::max()
                       ? numeric_limits<unsigned>::max()
                       : static_cast<unsigned>(__grp[__ig]);
          }
          *__me++ = *--__d;
          ++__ng;
        }
      }
      // reverse it
      std::reverse(__t, __me);
    } break;
    }
  }
  // print rest of sign, if any
  if (__sn.size() > 1)
    __me = std::copy(__sn.begin() + 1, __sn.end(), __me);
  // set alignment
  if ((__flags & ios_base::adjustfield) == ios_base::left)
    __mi = __me;
  else if ((__flags & ios_base::adjustfield) != ios_base::internal)
    __mi = __mb;
}

extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_put<char>;
#  if _LIBCPP_HAS_WIDE_CHARACTERS
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_put<wchar_t>;
#  endif

template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
class money_put : public locale::facet, private __money_put<_CharT> {
public:
  typedef _CharT char_type;
  typedef _OutputIterator iter_type;
  typedef basic_string<char_type> string_type;

  _LIBCPP_HIDE_FROM_ABI explicit money_put(size_t __refs = 0) : locale::facet(__refs) {}

  _LIBCPP_HIDE_FROM_ABI iter_type
  put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl, long double __units) const {
    return do_put(__s, __intl, __iob, __fl, __units);
  }

  _LIBCPP_HIDE_FROM_ABI iter_type
  put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl, const string_type& __digits) const {
    return do_put(__s, __intl, __iob, __fl, __digits);
  }

  static locale::id id;

protected:
  _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~money_put() override {}

  virtual iter_type do_put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl, long double __units) const;
  virtual iter_type
  do_put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl, const string_type& __digits) const;
};

template <class _CharT, class _OutputIterator>
locale::id money_put<_CharT, _OutputIterator>::id;

template <class _CharT, class _OutputIterator>
_OutputIterator money_put<_CharT, _OutputIterator>::do_put(
    iter_type __s, bool __intl, ios_base& __iob, char_type __fl, long double __units) const {
  // convert to char
  const size_t __bs = 100;
  char __buf[__bs];
  char* __bb = __buf;
  char_type __digits[__bs];
  char_type* __db = __digits;
  int __n         = snprintf(__bb, __bs, "%.0Lf", __units);
  unique_ptr<char, void (*)(void*)> __hn(nullptr, free);
  unique_ptr<char_type, void (*)(void*)> __hd(0, free);
  // secure memory for digit storage
  if (static_cast<size_t>(__n) > __bs - 1) {
    __n = __locale::__asprintf(&__bb, _LIBCPP_GET_C_LOCALE, "%.0Lf", __units);
    if (__n == -1)
      std::__throw_bad_alloc();
    __hn.reset(__bb);
    __hd.reset((char_type*)malloc(static_cast<size_t>(__n) * sizeof(char_type)));
    if (__hd == nullptr)
      std::__throw_bad_alloc();
    __db = __hd.get();
  }
  // gather info
  locale __loc                 = __iob.getloc();
  const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
  __ct.widen(__bb, __bb + __n, __db);
  bool __neg = __n > 0 && __bb[0] == '-';
  money_base::pattern __pat;
  char_type __dp;
  char_type __ts;
  string __grp;
  string_type __sym;
  string_type __sn;
  int __fd;
  this->__gather_info(__intl, __neg, __loc, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
  // secure memory for formatting
  char_type __mbuf[__bs];
  char_type* __mb = __mbuf;
  unique_ptr<char_type, void (*)(void*)> __hw(0, free);
  size_t __exn = __n > __fd ? (static_cast<size_t>(__n) - static_cast<size_t>(__fd)) * 2 + __sn.size() + __sym.size() +
                                  static_cast<size_t>(__fd) + 1
                            : __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 2;
  if (__exn > __bs) {
    __hw.reset((char_type*)malloc(__exn * sizeof(char_type)));
    __mb = __hw.get();
    if (__mb == 0)
      std::__throw_bad_alloc();
  }
  // format
  char_type* __mi;
  char_type* __me;
  this->__format(
      __mb, __mi, __me, __iob.flags(), __db, __db + __n, __ct, __neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
  return std::__pad_and_output(__s, __mb, __mi, __me, __iob, __fl);
}

template <class _CharT, class _OutputIterator>
_OutputIterator money_put<_CharT, _OutputIterator>::do_put(
    iter_type __s, bool __intl, ios_base& __iob, char_type __fl, const string_type& __digits) const {
  // gather info
  locale __loc                 = __iob.getloc();
  const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
  bool __neg                   = __digits.size() > 0 && __digits[0] == __ct.widen('-');
  money_base::pattern __pat;
  char_type __dp;
  char_type __ts;
  string __grp;
  string_type __sym;
  string_type __sn;
  int __fd;
  this->__gather_info(__intl, __neg, __loc, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
  // secure memory for formatting
  char_type __mbuf[100];
  char_type* __mb = __mbuf;
  unique_ptr<char_type, void (*)(void*)> __h(0, free);
  size_t __exn =
      static_cast<int>(__digits.size()) > __fd
          ? (__digits.size() - static_cast<size_t>(__fd)) * 2 + __sn.size() + __sym.size() + static_cast<size_t>(__fd) +
                1
          : __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 2;
  if (__exn > 100) {
    __h.reset((char_type*)malloc(__exn * sizeof(char_type)));
    __mb = __h.get();
    if (__mb == 0)
      std::__throw_bad_alloc();
  }
  // format
  char_type* __mi;
  char_type* __me;
  this->__format(
      __mb,
      __mi,
      __me,
      __iob.flags(),
      __digits.data(),
      __digits.data() + __digits.size(),
      __ct,
      __neg,
      __pat,
      __dp,
      __ts,
      __grp,
      __sym,
      __sn,
      __fd);
  return std::__pad_and_output(__s, __mb, __mi, __me, __iob, __fl);
}

extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_put<char>;
#  if _LIBCPP_HAS_WIDE_CHARACTERS
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_put<wchar_t>;
#  endif

_LIBCPP_END_NAMESPACE_STD

_LIBCPP_POP_MACROS

#endif // _LIBCPP_HAS_LOCALIZATION

#endif // _LIBCPP___LOCALE_DIR_MONEY_H