[libcxx] adds concept `std::uniform_random_bit_generator`

[cjdb]

Summary

Implements parts of:

• P0898R3 Standard Library Concepts
• P1754 Rename concepts to standard_case for C++20, while we still can

[cjdb]

undoes weird clang-formatting

[miscco]

Thanks for working on this. It is missing uglification but besides that I only have one small nit

libcxx/include/random

1706

This should be _Ugly, maybe use _Gen?

libcxx/test/std/numerics/rand/rand.req/rand.req.urng/uniform_random_bit_generator.compile.pass.cpp

119

I think that 1 and 0 would be more obvious that ~0 and 0

[miscco]

libcxx/include/random

1703

in https://reviews.llvm.org/D93166 we have a definition of _LIBCPP_HAS_NO_CONCEPTS

Should we reuse that globally and why are there different values ofr the macro?

[cjdb]

applies @miscco's feedback

[cjdb]

@ldionne can we override the Mac OS format failure? What it's proposing is abominable.

[cjdb]

undoes !_LIBCPP_HAS_NO_CONCEPTS change in an attempt to get the Mac OS build working

[Mordante]

In D96577#2561522, @cjdb wrote:

undoes !_LIBCPP_HAS_NO_CONCEPTS change in an attempt to get the Mac OS build working

Yes there seems to be a bug in that code. I've put it in a block for GCC specific code. (This is not obvious due to the lack of indention of the section.)
I'm testing a fix.

libcxx/include/random

22

Please add comment this has been added in C++20.

libcxx/test/std/numerics/rand/rand.req/rand.req.urng/uniform_random_bit_generator.compile.pass.cpp

21

Can you guard this with #ifndef _LIBCPP_HAS_NO_INT128?

123

Can you add a test where min() and max() return the same value?

[cjdb]

applies @Mordante's feedback

[cjdb]

Yes there seems to be a bug in that code. I've put it in a block for GCC specific code. (This is not obvious due to the lack of indention of the section.)

Oh, it might be because Clang's concepts are incomplete and so the feature-test macro's value is too high for us? Anyway, if you update everything in one fell swoop, I think that'd be best :-)

[Mordante]

In D96577#2562047, @cjdb wrote:

Yes there seems to be a bug in that code. I've put it in a block for GCC specific code. (This is not obvious due to the lack of indention of the section.)

Oh, it might be because Clang's concepts are incomplete and so the feature-test macro's value is too high for us? Anyway, if you update everything in one fell swoop, I think that'd be best :-)

No it was the placement in the file. But I'll fix <random> and <concept> after the fix has landed.

[Mordante]

libcxx/test/std/numerics/rand/rand.req/rand.req.urng/uniform_random_bit_generator.compile.pass.cpp

122

Is this a copy-paste error, I assume this should be zero.

[cjdb]

fixes copypasta

[ldionne]

LGTM apart for the nitpick. Let's settle on what we do about it and ship this.

libcxx/include/random

1703

why are there different values ofr the macro?

I don't know. @cjdb do you know what 201907L vs 201811L represents for __cpp_concepts?

Should we reuse that globally

Depending to the answer to the question above, I think it would make sense to use #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS).

[cjdb]

libcxx/include/random

1703

I believe @Mordante has a patch to fix this globally. As for 201811L vs 201907L, this is consistent with what's in libc++ <concepts> right now.

[cjdb]

libcxx/include/random

1703

@saar.raz do you know the difference between these two values for __cpp_concepts?

[CaseyCarter]

libcxx/include/random

1703

https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations#__cpp_concepts explains the history fairly well.

[ldionne]

libcxx/include/random

1703

Oh, thanks for the link. @cjdb let's use 201907L consistently everywhere if you're OK with that.

[Mordante]

libcxx/include/random

1703

I used 201907L since that's the version used in Clang since @saar.raz's branch has been merged.

libcxx/include/random

 
 /*
     random synopsis
 
 #include <initializer_list>
 
 namespace std
 {
+// [rand.req.urng], uniform random bit generator requirements
+template<class G>
+concept uniform_random_bit_generator = see below;
 
 // Engines
 
 template <class UIntType, UIntType a, UIntType c, UIntType m>
 class linear_congruential_engine
 {
 public:
     // types

 
 } // std
 */
 
 #include <__config>
 #include <cstddef>
 #include <cstdint>
 #include <cmath>
+#include <concepts>
 #include <type_traits>
 #include <initializer_list>
 #include <limits>
 #include <algorithm>
 #include <numeric>
 #include <vector>
 #include <string>
 #include <iosfwd>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if _LIBCPP_STD_VER > 17 && defined(__cpp_concepts) && __cpp_concepts >= 201811L
+
+// [rand.req.urng]
+template <class G>
+concept uniform_random_bit_generator =
+    invocable<G&>&& unsigned_integral<invoke_result_t<G&> >&& requires {
+  { G::min() } -> same_as<invoke_result_t<G&> >;
+  { G::max() } -> same_as<invoke_result_t<G&> >;
+  requires bool_constant<(G::min() < G::max())>::value;
+};
+
+#endif // _LIBCPP_STD_VER > 17 && defined(__cpp_concepts) && __cpp_concepts >= 201811L
+
 // __is_seed_sequence
 
 template <class _Sseq, class _Engine>
-struct __is_seed_sequence
-{
-    static _LIBCPP_CONSTEXPR const bool value =
-              !is_convertible<_Sseq, typename _Engine::result_type>::value &&
-              !is_same<typename remove_cv<_Sseq>::type, _Engine>::value;
+struct __is_seed_sequence {
 };
 
 // linear_congruential_engine
 
 template <unsigned long long __a, unsigned long long __c,
           unsigned long long __m, unsigned long long _Mp,
-          bool _MightOverflow = (__a != 0 && __m != 0 && __m-1 > (_Mp-__c)/__a),
-          bool _OverflowOK = ((__m|__m-1) > __m), // m = 2^n
-          bool _SchrageOK = (__a != 0 && __m != 0 && __m % __a <= __m / __a)> // r <= q
-struct __lce_alg_picker
-{
-    static_assert(__a != 0 || __m != 0 || !_MightOverflow || _OverflowOK || _SchrageOK,
-                  "The current values of a, c, and m cannot generate a number "
-                  "within bounds of linear_congruential_engine.");
+          bool _MightOverflow =
+              (__a != 0 && __m != 0 && __m - 1 > (_Mp - __c) / __a),
+          bool _OverflowOK = ((__m | __m - 1) > __m), // m = 2^n
+          bool _SchrageOK =
+              (__a != 0 && __m != 0 && __m % __a <= __m / __a)> // r <= q
+struct __lce_alg_picker {
+  static_assert(__a != 0 || __m != 0 || !_MightOverflow || _OverflowOK ||
+                    _SchrageOK,
 
-    static _LIBCPP_CONSTEXPR const bool __use_schrage = _MightOverflow &&
-                                                        !_OverflowOK &&
-                                                        _SchrageOK;
+  static _LIBCPP_CONSTEXPR const bool __use_schrage =
+      _MightOverflow && !_OverflowOK && _SchrageOK;
 };
 
 template <unsigned long long __a, unsigned long long __c,
           unsigned long long __m, unsigned long long _Mp,
-          bool _UseSchrage = __lce_alg_picker<__a, __c, __m, _Mp>::__use_schrage>
+          bool _UseSchrage =
+              __lce_alg_picker<__a, __c, __m, _Mp>::__use_schrage>
 struct __lce_ta;
 
 // 64
 
-template <unsigned long long __a, unsigned long long __c, unsigned long long __m>
-struct __lce_ta<__a, __c, __m, (unsigned long long)(~0), true>
-{
-    typedef unsigned long long result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type next(result_type __x)
-    {
-        // Schrage's algorithm
-        const result_type __q = __m / __a;
-        const result_type __r = __m % __a;
-        const result_type __t0 = __a * (__x % __q);
-        const result_type __t1 = __r * (__x / __q);
-        __x = __t0 + (__t0 < __t1) * __m - __t1;
-        __x += __c - (__x >= __m - __c) * __m;
-        return __x;
-    }
+template <unsigned long long __a, unsigned long long __c,
+          unsigned long long __m>
+struct __lce_ta<__a, __c, __m, (unsigned long long)(~0), true> {
+  static result_type next(result_type __x) {
 };
 
 template <unsigned long long __a, unsigned long long __m>
-struct __lce_ta<__a, 0, __m, (unsigned long long)(~0), true>
-{
-    typedef unsigned long long result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type next(result_type __x)
-    {
-        // Schrage's algorithm
-        const result_type __q = __m / __a;
-        const result_type __r = __m % __a;
-        const result_type __t0 = __a * (__x % __q);
-        const result_type __t1 = __r * (__x / __q);
-        __x = __t0 + (__t0 < __t1) * __m - __t1;
-        return __x;
-    }
+struct __lce_ta<__a, 0, __m, (unsigned long long)(~0), true> {
+  static result_type next(result_type __x) {
 };
 
-template <unsigned long long __a, unsigned long long __c, unsigned long long __m>
-struct __lce_ta<__a, __c, __m, (unsigned long long)(~0), false>
-{
-    typedef unsigned long long result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type next(result_type __x)
-    {
-        return (__a * __x + __c) % __m;
-    }
+template <unsigned long long __a, unsigned long long __c,
+          unsigned long long __m>
+struct __lce_ta<__a, __c, __m, (unsigned long long)(~0), false> {
+  static result_type next(result_type __x) { return (__a * __x + __c) % __m; }
 };
 
 template <unsigned long long __a, unsigned long long __c>
-struct __lce_ta<__a, __c, 0, (unsigned long long)(~0), false>
-{
-    typedef unsigned long long result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type next(result_type __x)
-    {
-        return __a * __x + __c;
-    }
+struct __lce_ta<__a, __c, 0, (unsigned long long)(~0), false> {
+  static result_type next(result_type __x) { return __a * __x + __c; }
 };
 
 // 32
 
-template <unsigned long long _Ap, unsigned long long _Cp, unsigned long long _Mp>
-struct __lce_ta<_Ap, _Cp, _Mp, unsigned(~0), true>
-{
-    typedef unsigned result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type next(result_type __x)
-    {
-        const result_type __a = static_cast<result_type>(_Ap);
-        const result_type __c = static_cast<result_type>(_Cp);
-        const result_type __m = static_cast<result_type>(_Mp);
-        // Schrage's algorithm
-        const result_type __q = __m / __a;
-        const result_type __r = __m % __a;
-        const result_type __t0 = __a * (__x % __q);
-        const result_type __t1 = __r * (__x / __q);
-        __x = __t0 + (__t0 < __t1) * __m - __t1;
-        __x += __c - (__x >= __m - __c) * __m;
-        return __x;
-    }
+template <unsigned long long _Ap, unsigned long long _Cp,
+          unsigned long long _Mp>
+struct __lce_ta<_Ap, _Cp, _Mp, unsigned(~0), true> {
+  static result_type next(result_type __x) {
 };
 
 template <unsigned long long _Ap, unsigned long long _Mp>
-struct __lce_ta<_Ap, 0, _Mp, unsigned(~0), true>
-{
-    typedef unsigned result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type next(result_type __x)
-    {
-        const result_type __a = static_cast<result_type>(_Ap);
-        const result_type __m = static_cast<result_type>(_Mp);
-        // Schrage's algorithm
-        const result_type __q = __m / __a;
-        const result_type __r = __m % __a;
-        const result_type __t0 = __a * (__x % __q);
-        const result_type __t1 = __r * (__x / __q);
-        __x = __t0 + (__t0 < __t1) * __m - __t1;
-        return __x;
-    }
+struct __lce_ta<_Ap, 0, _Mp, unsigned(~0), true> {
+  static result_type next(result_type __x) {
 };
 
-template <unsigned long long _Ap, unsigned long long _Cp, unsigned long long _Mp>
-struct __lce_ta<_Ap, _Cp, _Mp, unsigned(~0), false>
-{
-    typedef unsigned result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type next(result_type __x)
-    {
-        const result_type __a = static_cast<result_type>(_Ap);
-        const result_type __c = static_cast<result_type>(_Cp);
-        const result_type __m = static_cast<result_type>(_Mp);
-        return (__a * __x + __c) % __m;
-    }
+template <unsigned long long _Ap, unsigned long long _Cp,
+          unsigned long long _Mp>
+struct __lce_ta<_Ap, _Cp, _Mp, unsigned(~0), false> {
+  static result_type next(result_type __x) {
 };
 
 template <unsigned long long _Ap, unsigned long long _Cp>
-struct __lce_ta<_Ap, _Cp, 0, unsigned(~0), false>
-{
-    typedef unsigned result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type next(result_type __x)
-    {
-        const result_type __a = static_cast<result_type>(_Ap);
-        const result_type __c = static_cast<result_type>(_Cp);
-        return __a * __x + __c;
-    }
+struct __lce_ta<_Ap, _Cp, 0, unsigned(~0), false> {
+  static result_type next(result_type __x) {
 };
 
 // 16
 
-template <unsigned long long __a, unsigned long long __c, unsigned long long __m, bool __b>
-struct __lce_ta<__a, __c, __m, (unsigned short)(~0), __b>
-{
-    typedef unsigned short result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type next(result_type __x)
-    {
-        return static_cast<result_type>(__lce_ta<__a, __c, __m, unsigned(~0)>::next(__x));
-    }
+template <unsigned long long __a, unsigned long long __c,
+          unsigned long long __m, bool __b>
+struct __lce_ta<__a, __c, __m, (unsigned short)(~0), __b> {
+  static result_type next(result_type __x) {
+    return static_cast<result_type>(
+        __lce_ta<__a, __c, __m, unsigned(~0)>::next(__x));
 };
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
 class _LIBCPP_TEMPLATE_VIS linear_congruential_engine;
 
-template <class _CharT, class _Traits,
-          class _Up, _Up _Ap, _Up _Cp, _Up _Np>
-_LIBCPP_INLINE_VISIBILITY
-basic_ostream<_CharT, _Traits>&
+template <class _CharT, class _Traits, class _Up, _Up _Ap, _Up _Cp, _Up _Np>
+_LIBCPP_INLINE_VISIBILITY basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
            const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&);
 
-template <class _CharT, class _Traits,
-          class _Up, _Up _Ap, _Up _Cp, _Up _Np>
+template <class _CharT, class _Traits, class _Up, _Up _Ap, _Up _Cp, _Up _Np>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
            linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-class _LIBCPP_TEMPLATE_VIS linear_congruential_engine
-{
+class _LIBCPP_TEMPLATE_VIS linear_congruential_engine {
 public:
-    // types
-    typedef _UIntType result_type;
 
 private:
-    result_type __x_;
 
-    static _LIBCPP_CONSTEXPR const result_type _Mp = result_type(~0);
 
-    static_assert(__m == 0 || __a < __m, "linear_congruential_engine invalid parameters");
-    static_assert(__m == 0 || __c < __m, "linear_congruential_engine invalid parameters");
-    static_assert(_VSTD::is_unsigned<_UIntType>::value, "_UIntType must be unsigned type");
+  static_assert(__m == 0 || __a < __m,
+                "linear_congruential_engine invalid parameters");
+  static_assert(__m == 0 || __c < __m,
+                "linear_congruential_engine invalid parameters");
+  static_assert(_VSTD::is_unsigned<_UIntType>::value,
+                "_UIntType must be unsigned type");
+
 public:
-    static _LIBCPP_CONSTEXPR const result_type _Min = __c == 0u ? 1u: 0u;
-    static _LIBCPP_CONSTEXPR const result_type _Max = __m - 1u;
-    static_assert(_Min < _Max,           "linear_congruential_engine invalid parameters");
+  static _LIBCPP_CONSTEXPR const result_type _Min = __c == 0u ? 1u : 0u;
+  static_assert(_Min < _Max, "linear_congruential_engine invalid parameters");
 
-    // engine characteristics
-    static _LIBCPP_CONSTEXPR const result_type multiplier = __a;
-    static _LIBCPP_CONSTEXPR const result_type increment = __c;
-    static _LIBCPP_CONSTEXPR const result_type modulus = __m;
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type min() {return _Min;}
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type max() {return _Max;}
-    static _LIBCPP_CONSTEXPR const result_type default_seed = 1u;
+  static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
+  static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
 
-    // constructors and seeding functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    linear_congruential_engine() : linear_congruential_engine(default_seed) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit linear_congruential_engine(result_type __s) { seed(__s); }
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit linear_congruential_engine(result_type __s = default_seed) {
-      seed(__s);
-    }
 #endif
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        explicit linear_congruential_engine(_Sseq& __q,
-        typename enable_if<__is_seed_sequence<_Sseq, linear_congruential_engine>::value>::type* = 0)
-        {seed(__q);}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed(result_type __s = default_seed)
-        {seed(integral_constant<bool, __m == 0>(),
-              integral_constant<bool, __c == 0>(), __s);}
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __is_seed_sequence<_Sseq, linear_congruential_engine>::value,
-            void
-        >::type
-        seed(_Sseq& __q)
-            {__seed(__q, integral_constant<unsigned,
-                1 + (__m == 0 ? (sizeof(result_type) * __CHAR_BIT__ - 1)/32
-                             :  (__m > 0x100000000ull))>());}
+  template <class _Sseq>
+  _LIBCPP_INLINE_VISIBILITY explicit linear_congruential_engine(
+      _Sseq& __q,
+      typename enable_if<
+          __is_seed_sequence<_Sseq, linear_congruential_engine>::value>::type* =
+          0) {
+    seed(__q);
+  }
+  void seed(result_type __s = default_seed) {
+    seed(integral_constant<bool, __m == 0>(),
+         integral_constant<bool, __c == 0>(), __s);
+  }
+  template <class _Sseq>
+  _LIBCPP_INLINE_VISIBILITY typename enable_if<
+      __is_seed_sequence<_Sseq, linear_congruential_engine>::value, void>::type
+  seed(_Sseq& __q) {
+    __seed(__q,
+           integral_constant<
+               unsigned,
+               1 + (__m == 0 ? (sizeof(result_type) * __CHAR_BIT__ - 1) / 32
+                             : (__m > 0x100000000ull))>());
+  }
 
-    // generating functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type operator()()
-        {return __x_ = static_cast<result_type>(__lce_ta<__a, __c, __m, _Mp>::next(__x_));}
-    _LIBCPP_INLINE_VISIBILITY
-    void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
+  result_type operator()() {
+    return __x_ = static_cast<result_type>(
+               __lce_ta<__a, __c, __m, _Mp>::next(__x_));
+  }
+  void discard(unsigned long long __z) {
+    for (; __z; --__z)
+      operator()();
+  }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const linear_congruential_engine& __x,
-                    const linear_congruential_engine& __y)
-        {return __x.__x_ == __y.__x_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const linear_congruential_engine& __x,
-                    const linear_congruential_engine& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const linear_congruential_engine& __x,
+             const linear_congruential_engine& __y) {
+    return __x.__x_ == __y.__x_;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const linear_congruential_engine& __x,
+             const linear_congruential_engine& __y) {
+    return !(__x == __y);
+  }
 
 private:
-
-    _LIBCPP_INLINE_VISIBILITY
-    void seed(true_type, true_type, result_type __s) {__x_ = __s == 0 ? 1 : __s;}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed(true_type, false_type, result_type __s) {__x_ = __s;}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed(false_type, true_type, result_type __s) {__x_ = __s % __m == 0 ?
-                                                                 1 : __s % __m;}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed(false_type, false_type, result_type __s) {__x_ = __s % __m;}
+  void seed(true_type, true_type, result_type __s) {
+    __x_ = __s == 0 ? 1 : __s;
+  }
+  void seed(true_type, false_type, result_type __s) { __x_ = __s; }
+  void seed(false_type, true_type, result_type __s) {
+    __x_ = __s % __m == 0 ? 1 : __s % __m;
+  }
+  void seed(false_type, false_type, result_type __s) { __x_ = __s % __m; }
 
-    template<class _Sseq>
-        void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
-    template<class _Sseq>
-        void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
+  template <class _Sseq>
+  template <class _Sseq>
 
-    template <class _CharT, class _Traits,
-              class _Up, _Up _Ap, _Up _Cp, _Up _Np>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&);
+  template <class _CharT, class _Traits, class _Up, _Up _Ap, _Up _Cp, _Up _Np>
+  friend basic_ostream<_CharT, _Traits>&
 
-    template <class _CharT, class _Traits,
-              class _Up, _Up _Ap, _Up _Cp, _Up _Np>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);
+  template <class _CharT, class _Traits, class _Up, _Up _Ap, _Up _Cp, _Up _Np>
+  friend basic_istream<_CharT, _Traits>&
 };
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-    _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
+_LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c,
+                                                            __m>::result_type
     linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier;
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-    _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
+_LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c,
+                                                            __m>::result_type
     linear_congruential_engine<_UIntType, __a, __c, __m>::increment;
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-    _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
+_LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c,
+                                                            __m>::result_type
     linear_congruential_engine<_UIntType, __a, __c, __m>::modulus;
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-    _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
+_LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c,
+                                                            __m>::result_type
     linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed;
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-template<class _Sseq>
-void
-linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q,
-                                                 integral_constant<unsigned, 1>)
-{
-    const unsigned __k = 1;
-    uint32_t __ar[__k+3];
-    __q.generate(__ar, __ar + __k + 3);
-    result_type __s = static_cast<result_type>(__ar[3] % __m);
-    __x_ = __c == 0 && __s == 0 ? result_type(1) : __s;
+template <class _Sseq>
+void linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(
+    _Sseq& __q, integral_constant<unsigned, 1>) {
+  uint32_t __ar[__k + 3];
 }
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-template<class _Sseq>
-void
-linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q,
-                                                 integral_constant<unsigned, 2>)
-{
-    const unsigned __k = 2;
-    uint32_t __ar[__k+3];
-    __q.generate(__ar, __ar + __k + 3);
-    result_type __s = static_cast<result_type>((__ar[3] +
-                                              ((uint64_t)__ar[4] << 32)) % __m);
-    __x_ = __c == 0 && __s == 0 ? result_type(1) : __s;
+template <class _Sseq>
+void linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(
+    _Sseq& __q, integral_constant<unsigned, 2>) {
+  uint32_t __ar[__k + 3];
+  result_type __s =
+      static_cast<result_type>((__ar[3] + ((uint64_t)__ar[4] << 32)) % __m);
 }
 
-template <class _CharT, class _Traits,
-          class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_ostream<_CharT, _Traits>&
+template <class _CharT, class _Traits, class _UIntType, _UIntType __a,
+          _UIntType __c, _UIntType __m>
+inline _LIBCPP_INLINE_VISIBILITY basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const linear_congruential_engine<_UIntType, __a, __c, __m>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _Ostream;
-    __os.flags(_Ostream::dec | _Ostream::left);
-    __os.fill(__os.widen(' '));
-    return __os << __x.__x_;
+           const linear_congruential_engine<_UIntType, __a, __c, __m>& __x) {
 }
 
-template <class _CharT, class _Traits,
-          class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+template <class _CharT, class _Traits, class _UIntType, _UIntType __a,
+          _UIntType __c, _UIntType __m>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
-           linear_congruential_engine<_UIntType, __a, __c, __m>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    _UIntType __t;
-    __is >> __t;
-    if (!__is.fail())
-        __x.__x_ = __t;
-    return __is;
+           linear_congruential_engine<_UIntType, __a, __c, __m>& __x) {
 }
 
 typedef linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>
-                                                                   minstd_rand0;
 typedef linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>
-                                                                    minstd_rand;
-typedef minstd_rand                                       default_random_engine;
+typedef minstd_rand default_random_engine;
 // mersenne_twister_engine
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
 class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine;
 
 template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-          _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-bool
-operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
-           const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
+          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp, _UInt _Bp, size_t _Tp,
+          _UInt _Cp, size_t _Lp, _UInt _Fp>
+bool operator==(
+    const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
 
 template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-          _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-_LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
-           const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
+          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp, _UInt _Bp, size_t _Tp,
+          _UInt _Cp, size_t _Lp, _UInt _Fp>
+_LIBCPP_INLINE_VISIBILITY bool operator!=(
+    const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
 
-template <class _CharT, class _Traits,
-          class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
+template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Np,
+          size_t _Mp, size_t _Rp, _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
           _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
+basic_ostream<_CharT, _Traits>& operator<<(
+    basic_ostream<_CharT, _Traits>& __os,
 
-template <class _CharT, class _Traits,
-          class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
+template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Np,
+          size_t _Mp, size_t _Rp, _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
           _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
-           mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                   _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
+           mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp,
+                                   _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine
-{
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine {
 public:
-    // types
-    typedef _UIntType result_type;
 
 private:
-    result_type __x_[__n];
-    size_t      __i_;
+  size_t __i_;
 
-    static_assert(  0 <  __m, "mersenne_twister_engine invalid parameters");
-    static_assert(__m <= __n, "mersenne_twister_engine invalid parameters");
-    static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
-    static_assert(__w <= _Dt, "mersenne_twister_engine invalid parameters");
-    static_assert(  2 <= __w, "mersenne_twister_engine invalid parameters");
-    static_assert(__r <= __w, "mersenne_twister_engine invalid parameters");
-    static_assert(__u <= __w, "mersenne_twister_engine invalid parameters");
-    static_assert(__s <= __w, "mersenne_twister_engine invalid parameters");
-    static_assert(__t <= __w, "mersenne_twister_engine invalid parameters");
-    static_assert(__l <= __w, "mersenne_twister_engine invalid parameters");
+  static_assert(0 < __m, "mersenne_twister_engine invalid parameters");
+  static _LIBCPP_CONSTEXPR const result_type _Dt =
+      numeric_limits<result_type>::digits;
+  static_assert(2 <= __w, "mersenne_twister_engine invalid parameters");
+
 public:
-    static _LIBCPP_CONSTEXPR const result_type _Min = 0;
-    static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
-                                                      (result_type(1) << __w) - result_type(1);
-    static_assert(_Min < _Max, "mersenne_twister_engine invalid parameters");
-    static_assert(__a <= _Max, "mersenne_twister_engine invalid parameters");
-    static_assert(__b <= _Max, "mersenne_twister_engine invalid parameters");
-    static_assert(__c <= _Max, "mersenne_twister_engine invalid parameters");
-    static_assert(__d <= _Max, "mersenne_twister_engine invalid parameters");
-    static_assert(__f <= _Max, "mersenne_twister_engine invalid parameters");
+  static _LIBCPP_CONSTEXPR const result_type _Max =
+      __w == _Dt ? result_type(~0) : (result_type(1) << __w) - result_type(1);
 
-    // engine characteristics
-    static _LIBCPP_CONSTEXPR const size_t word_size = __w;
-    static _LIBCPP_CONSTEXPR const size_t state_size = __n;
-    static _LIBCPP_CONSTEXPR const size_t shift_size = __m;
-    static _LIBCPP_CONSTEXPR const size_t mask_bits = __r;
-    static _LIBCPP_CONSTEXPR const result_type xor_mask = __a;
-    static _LIBCPP_CONSTEXPR const size_t tempering_u = __u;
-    static _LIBCPP_CONSTEXPR const result_type tempering_d = __d;
-    static _LIBCPP_CONSTEXPR const size_t tempering_s = __s;
-    static _LIBCPP_CONSTEXPR const result_type tempering_b = __b;
-    static _LIBCPP_CONSTEXPR const size_t tempering_t = __t;
-    static _LIBCPP_CONSTEXPR const result_type tempering_c = __c;
-    static _LIBCPP_CONSTEXPR const size_t tempering_l = __l;
-    static _LIBCPP_CONSTEXPR const result_type initialization_multiplier = __f;
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
-    static _LIBCPP_CONSTEXPR const result_type default_seed = 5489u;
 
-    // constructors and seeding functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    mersenne_twister_engine() : mersenne_twister_engine(default_seed) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit mersenne_twister_engine(result_type __sd) { seed(__sd); }
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit mersenne_twister_engine(result_type __sd = default_seed) {
-      seed(__sd);
-    }
 #endif
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        explicit mersenne_twister_engine(_Sseq& __q,
-        typename enable_if<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value>::type* = 0)
-        {seed(__q);}
-    void seed(result_type __sd = default_seed);
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __is_seed_sequence<_Sseq, mersenne_twister_engine>::value,
-            void
-        >::type
-        seed(_Sseq& __q)
-            {__seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
+  template <class _Sseq>
+  _LIBCPP_INLINE_VISIBILITY explicit mersenne_twister_engine(
+      _Sseq& __q,
+      typename enable_if<
+          __is_seed_sequence<_Sseq, mersenne_twister_engine>::value>::type* =
+          0) {
+    seed(__q);
+  }
+  template <class _Sseq>
+  _LIBCPP_INLINE_VISIBILITY typename enable_if<
+      __is_seed_sequence<_Sseq, mersenne_twister_engine>::value, void>::type
+  seed(_Sseq& __q) {
+    __seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());
+  }
 
-    // generating functions
-    result_type operator()();
-    _LIBCPP_INLINE_VISIBILITY
-    void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
+  void discard(unsigned long long __z) {
+    for (; __z; --__z)
+      operator()();
+  }
 
-    template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-              _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-              _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-    friend
-    bool
-    operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                             _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
-               const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                             _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
+            _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp, _UInt _Bp, size_t _Tp,
+            _UInt _Cp, size_t _Lp, _UInt _Fp>
+  friend bool operator==(
+      const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp,
+                                    _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
+      const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp,
+                                    _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
 
-    template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-              _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-              _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-    friend
-    bool
-    operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                             _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
-               const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                             _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
-
-    template <class _CharT, class _Traits,
-              class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-              _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-              _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                             _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
-
-    template <class _CharT, class _Traits,
-              class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-              _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-              _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                       _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
-private:
+            _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp, _UInt _Bp, size_t _Tp,
+            _UInt _Cp, size_t _Lp, _UInt _Fp>
+  friend bool operator!=(
+      const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp,
+                                    _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
+      const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp,
+                                    _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
+
+  template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Np,
+            size_t _Mp, size_t _Rp, _UInt _Ap, size_t _Up, _UInt _Dp,
+            size_t _Sp, _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+  friend basic_ostream<_CharT, _Traits>& operator<<(
+      basic_ostream<_CharT, _Traits>& __os,
+      const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp,
+                                    _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
+
+  template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Np,
+            size_t _Mp, size_t _Rp, _UInt _Ap, size_t _Up, _UInt _Dp,
+            size_t _Sp, _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+  friend basic_istream<_CharT, _Traits>&
+             mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp,
+                                     _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
 
-    template<class _Sseq>
-        void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
-    template<class _Sseq>
-        void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
+private:
+  template <class _Sseq>
+  template <class _Sseq>
 
-    template <size_t __count>
-        _LIBCPP_INLINE_VISIBILITY
-        static
-        typename enable_if
-        <
-            __count < __w,
-            result_type
-        >::type
-        __lshift(result_type __x) {return (__x << __count) & _Max;}
+      _LIBCPP_INLINE_VISIBILITY static typename enable_if <
+      __count<__w, result_type>::type __lshift(result_type __x) {
+    return (__x << __count) & _Max;
+  }
 
-    template <size_t __count>
-        _LIBCPP_INLINE_VISIBILITY
-        static
-        typename enable_if
-        <
-            (__count >= __w),
-            result_type
-        >::type
-        __lshift(result_type) {return result_type(0);}
+  _LIBCPP_INLINE_VISIBILITY static
+      typename enable_if<(__count >= __w), result_type>::type
+      __lshift(result_type) {
+    return result_type(0);
+  }
 
-    template <size_t __count>
-        _LIBCPP_INLINE_VISIBILITY
-        static
-        typename enable_if
-        <
-            __count < _Dt,
-            result_type
-        >::type
-        __rshift(result_type __x) {return __x >> __count;}
+      _LIBCPP_INLINE_VISIBILITY static typename enable_if <
+      __count<_Dt, result_type>::type __rshift(result_type __x) {
+    return __x >> __count;
+  }
 
-    template <size_t __count>
-        _LIBCPP_INLINE_VISIBILITY
-        static
-        typename enable_if
-        <
-            (__count >= _Dt),
-            result_type
-        >::type
-        __rshift(result_type) {return result_type(0);}
+  _LIBCPP_INLINE_VISIBILITY static
+      typename enable_if<(__count >= _Dt), result_type>::type
+      __rshift(result_type) {
+    return result_type(0);
+  }
 };
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t
-    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::word_size;
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s,
+                            __b, __t, __c, __l, __f>::word_size;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t
-    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::state_size;
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s,
+                            __b, __t, __c, __l, __f>::state_size;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t
-    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::shift_size;
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s,
+                            __b, __t, __c, __l, __f>::shift_size;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t
-    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::mask_bits;
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s,
+                            __b, __t, __c, __l, __f>::mask_bits;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
-    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::xor_mask;
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+_LIBCPP_CONSTEXPR const typename mersenne_twister_engine<
+    _UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l,
+    __f>::result_type
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s,
+                            __b, __t, __c, __l, __f>::xor_mask;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t
-    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_u;
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s,
+                            __b, __t, __c, __l, __f>::tempering_u;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
-    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_d;
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+_LIBCPP_CONSTEXPR const typename mersenne_twister_engine<
+    _UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l,
+    __f>::result_type
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s,
+                            __b, __t, __c, __l, __f>::tempering_d;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t
-    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_s;
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s,
+                            __b, __t, __c, __l, __f>::tempering_s;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
-    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_b;
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+_LIBCPP_CONSTEXPR const typename mersenne_twister_engine<
+    _UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l,
+    __f>::result_type
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s,
+                            __b, __t, __c, __l, __f>::tempering_b;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t
-    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_t;
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s,
+                            __b, __t, __c, __l, __f>::tempering_t;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
-    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_c;
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+_LIBCPP_CONSTEXPR const typename mersenne_twister_engine<
+    _UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l,
+    __f>::result_type
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s,
+                            __b, __t, __c, __l, __f>::tempering_c;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t
-    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_l;
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s,
+                            __b, __t, __c, __l, __f>::tempering_l;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
-    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::initialization_multiplier;
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+_LIBCPP_CONSTEXPR const typename mersenne_twister_engine<
+    _UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l,
+    __f>::result_type
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s,
+                            __b, __t, __c, __l, __f>::initialization_multiplier;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
-    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::default_seed;
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+_LIBCPP_CONSTEXPR const typename mersenne_twister_engine<
+    _UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l,
+    __f>::result_type
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s,
+                            __b, __t, __c, __l, __f>::default_seed;
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-void
-mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
-    __t, __c, __l, __f>::seed(result_type __sd)
-    _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
-{   // __w >= 2
-    __x_[0] = __sd & _Max;
-    for (size_t __i = 1; __i < __n; ++__i)
-        __x_[__i] = (__f * (__x_[__i-1] ^ __rshift<__w - 2>(__x_[__i-1])) + __i) & _Max;
-    __i_ = 0;
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+void mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s,
+                             __b, __t, __c, __l, __f>::seed(result_type __sd)
+    _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK { // __w >= 2
+    __x_[__i] =
+        (__f * (__x_[__i - 1] ^ __rshift<__w - 2>(__x_[__i - 1])) + __i) & _Max;
 }
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-template<class _Sseq>
-void
-mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
-    __t, __c, __l, __f>::__seed(_Sseq& __q, integral_constant<unsigned, 1>)
-{
-    const unsigned __k = 1;
-    uint32_t __ar[__n * __k];
-    __q.generate(__ar, __ar + __n * __k);
-    for (size_t __i = 0; __i < __n; ++__i)
-        __x_[__i] = static_cast<result_type>(__ar[__i] & _Max);
-    const result_type __mask = __r == _Dt ? result_type(~0) :
-                                       (result_type(1) << __r) - result_type(1);
-    __i_ = 0;
-    if ((__x_[0] & ~__mask) == 0)
-    {
-        for (size_t __i = 1; __i < __n; ++__i)
-            if (__x_[__i] != 0)
-                return;
-        __x_[0] = result_type(1) << (__w - 1);
-    }
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+template <class _Sseq>
+void mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s,
+                             __b, __t, __c, __l,
+                             __f>::__seed(_Sseq& __q,
+                                          integral_constant<unsigned, 1>) {
+  const result_type __mask =
+      __r == _Dt ? result_type(~0) : (result_type(1) << __r) - result_type(1);
+  if ((__x_[0] & ~__mask) == 0) {
 }
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-template<class _Sseq>
-void
-mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
-    __t, __c, __l, __f>::__seed(_Sseq& __q, integral_constant<unsigned, 2>)
-{
-    const unsigned __k = 2;
-    uint32_t __ar[__n * __k];
-    __q.generate(__ar, __ar + __n * __k);
-    for (size_t __i = 0; __i < __n; ++__i)
-        __x_[__i] = static_cast<result_type>(
-            (__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max);
-    const result_type __mask = __r == _Dt ? result_type(~0) :
-                                       (result_type(1) << __r) - result_type(1);
-    __i_ = 0;
-    if ((__x_[0] & ~__mask) == 0)
-    {
-        for (size_t __i = 1; __i < __n; ++__i)
-            if (__x_[__i] != 0)
-                return;
-        __x_[0] = result_type(1) << (__w - 1);
-    }
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+template <class _Sseq>
+void mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s,
+                             __b, __t, __c, __l,
+                             __f>::__seed(_Sseq& __q,
+                                          integral_constant<unsigned, 2>) {
+  const result_type __mask =
+      __r == _Dt ? result_type(~0) : (result_type(1) << __r) - result_type(1);
+  if ((__x_[0] & ~__mask) == 0) {
 }
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-_UIntType
-mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
-    __t, __c, __l, __f>::operator()()
-{
-    const size_t __j = (__i_ + 1) % __n;
-    const result_type __mask = __r == _Dt ? result_type(~0) :
-                                       (result_type(1) << __r) - result_type(1);
-    const result_type _Yp = (__x_[__i_] & ~__mask) | (__x_[__j] & __mask);
-    const size_t __k = (__i_ + __m) % __n;
-    __x_[__i_] = __x_[__k] ^ __rshift<1>(_Yp) ^ (__a * (_Yp & 1));
-    result_type __z = __x_[__i_] ^ (__rshift<__u>(__x_[__i_]) & __d);
-    __i_ = __j;
-    __z ^= __lshift<__s>(__z) & __b;
-    __z ^= __lshift<__t>(__z) & __c;
-    return __z ^ __rshift<__l>(__z);
+          _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b,
+          size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+_UIntType mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+                                  __s, __b, __t, __c, __l, __f>::operator()() {
+  const result_type __mask =
+      __r == _Dt ? result_type(~0) : (result_type(1) << __r) - result_type(1);
 }
 
 template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-          _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-bool
-operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
-           const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __y)
-{
-    if (__x.__i_ == __y.__i_)
-        return _VSTD::equal(__x.__x_, __x.__x_ + _Np, __y.__x_);
-    if (__x.__i_ == 0 || __y.__i_ == 0)
-    {
-        size_t __j = _VSTD::min(_Np - __x.__i_, _Np - __y.__i_);
-        if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
-                         __y.__x_ + __y.__i_))
-            return false;
-        if (__x.__i_ == 0)
-            return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _Np, __y.__x_);
-        return _VSTD::equal(__x.__x_, __x.__x_ + (_Np - __j), __y.__x_ + __j);
-    }
-    if (__x.__i_ < __y.__i_)
-    {
-        size_t __j = _Np - __y.__i_;
-        if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
-                         __y.__x_ + __y.__i_))
-            return false;
-        if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Np,
-                         __y.__x_))
-            return false;
-        return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_,
-                           __y.__x_ + (_Np - (__x.__i_ + __j)));
-    }
-    size_t __j = _Np - __x.__i_;
-    if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
-                     __x.__x_ + __x.__i_))
-        return false;
-    if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Np,
-                     __x.__x_))
-        return false;
-    return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_,
-                       __x.__x_ + (_Np - (__y.__i_ + __j)));
+          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp, _UInt _Bp, size_t _Tp,
+          _UInt _Cp, size_t _Lp, _UInt _Fp>
+bool operator==(
+    const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+                                  _Bp, _Tp, _Cp, _Lp, _Fp>& __y) {
+  if (__x.__i_ == 0 || __y.__i_ == 0) {
+  if (__x.__i_ < __y.__i_) {
+    if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Np, __y.__x_))
+  if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Np, __x.__x_))
 }
 
 template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-          _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
-           const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __y)
-{
-    return !(__x == __y);
+          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp, _UInt _Bp, size_t _Tp,
+          _UInt _Cp, size_t _Lp, _UInt _Fp>
+inline _LIBCPP_INLINE_VISIBILITY bool operator!=(
+    const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+                                  _Bp, _Tp, _Cp, _Lp, _Fp>& __y) {
 }
 
-template <class _CharT, class _Traits,
-          class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
+template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Np,
+          size_t _Mp, size_t _Rp, _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
           _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _Ostream;
-    __os.flags(_Ostream::dec | _Ostream::left);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    __os << __x.__x_[__x.__i_];
-    for (size_t __j = __x.__i_ + 1; __j < _Np; ++__j)
-        __os << __sp << __x.__x_[__j];
-    for (size_t __j = 0; __j < __x.__i_; ++__j)
-        __os << __sp << __x.__x_[__j];
-    return __os;
+basic_ostream<_CharT, _Traits>& operator<<(
+    basic_ostream<_CharT, _Traits>& __os,
+                                  _Bp, _Tp, _Cp, _Lp, _Fp>& __x) {
 }
 
-template <class _CharT, class _Traits,
-          class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
+template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Np,
+          size_t _Mp, size_t _Rp, _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
           _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
-           mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                   _Bp, _Tp, _Cp, _Lp, _Fp>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    _UInt __t[_Np];
-    for (size_t __i = 0; __i < _Np; ++__i)
-        __is >> __t[__i];
-    if (!__is.fail())
-    {
-        for (size_t __i = 0; __i < _Np; ++__i)
-            __x.__x_[__i] = __t[__i];
-        __x.__i_ = 0;
-    }
-    return __is;
+           mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp,
+                                   _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x) {
+  if (!__is.fail()) {
 }
 
-typedef mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31,
-                                0x9908b0df, 11, 0xffffffff,
-                                7,  0x9d2c5680,
-                                15, 0xefc60000,
-                                18, 1812433253>                         mt19937;
-typedef mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31,
-                                0xb5026f5aa96619e9ULL, 29, 0x5555555555555555ULL,
-                                17, 0x71d67fffeda60000ULL,
-                                37, 0xfff7eee000000000ULL,
-                                43, 6364136223846793005ULL>          mt19937_64;
+typedef mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31, 0x9908b0df, 11,
+                                0xffffffff, 7, 0x9d2c5680, 15, 0xefc60000, 18,
+                                1812433253>
+    mt19937;
+typedef mersenne_twister_engine<
+    uint_fast64_t, 64, 312, 156, 31, 0xb5026f5aa96619e9ULL, 29,
+    0x5555555555555555ULL, 17, 0x71d67fffeda60000ULL, 37, 0xfff7eee000000000ULL,
+    43, 6364136223846793005ULL>
+    mt19937_64;
 
 // subtract_with_carry_engine
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
 class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine;
 
-template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-bool
-operator==(
-    const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
+template <class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+bool operator==(const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
                 const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
 
-template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-_LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(
-    const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
+template <class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+_LIBCPP_INLINE_VISIBILITY bool
+operator!=(const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
            const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
 
-template <class _CharT, class _Traits,
-          class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Sp,
+          size_t _Rp>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
            const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
 
-template <class _CharT, class _Traits,
-          class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Sp,
+          size_t _Rp>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
            subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine
-{
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine {
 public:
-    // types
-    typedef _UIntType result_type;
 
 private:
-    result_type __x_[__r];
-    result_type  __c_;
-    size_t      __i_;
+  result_type __c_;
+  size_t __i_;
 
-    static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
-    static_assert(  0 <  __w, "subtract_with_carry_engine invalid parameters");
-    static_assert(__w <= _Dt, "subtract_with_carry_engine invalid parameters");
-    static_assert(  0 <  __s, "subtract_with_carry_engine invalid parameters");
-    static_assert(__s <  __r, "subtract_with_carry_engine invalid parameters");
+  static _LIBCPP_CONSTEXPR const result_type _Dt =
+      numeric_limits<result_type>::digits;
+  static_assert(0 < __w, "subtract_with_carry_engine invalid parameters");
+  static_assert(0 < __s, "subtract_with_carry_engine invalid parameters");
+  static_assert(__s < __r, "subtract_with_carry_engine invalid parameters");
+
 public:
-    static _LIBCPP_CONSTEXPR const result_type _Min = 0;
-    static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
-                                                      (result_type(1) << __w) - result_type(1);
-    static_assert(_Min < _Max, "subtract_with_carry_engine invalid parameters");
+  static _LIBCPP_CONSTEXPR const result_type _Max =
+      __w == _Dt ? result_type(~0) : (result_type(1) << __w) - result_type(1);
 
-    // engine characteristics
-    static _LIBCPP_CONSTEXPR const size_t word_size = __w;
-    static _LIBCPP_CONSTEXPR const size_t short_lag = __s;
-    static _LIBCPP_CONSTEXPR const size_t long_lag = __r;
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
-    static _LIBCPP_CONSTEXPR const result_type default_seed = 19780503u;
 
-    // constructors and seeding functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit subtract_with_carry_engine(result_type __sd) { seed(__sd); }
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit subtract_with_carry_engine(result_type __sd = default_seed) {
-      seed(__sd);
-    }
 #endif
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        explicit subtract_with_carry_engine(_Sseq& __q,
-        typename enable_if<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value>::type* = 0)
-        {seed(__q);}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed(result_type __sd = default_seed)
-        {seed(__sd, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __is_seed_sequence<_Sseq, subtract_with_carry_engine>::value,
-            void
-        >::type
-        seed(_Sseq& __q)
-            {__seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
+  template <class _Sseq>
+  _LIBCPP_INLINE_VISIBILITY explicit subtract_with_carry_engine(
+      _Sseq& __q,
+      typename enable_if<
+          __is_seed_sequence<_Sseq, subtract_with_carry_engine>::value>::type* =
+          0) {
+    seed(__q);
+  }
+  void seed(result_type __sd = default_seed) {
+    seed(__sd, integral_constant<unsigned, 1 + (__w - 1) / 32>());
+  }
+  template <class _Sseq>
+  _LIBCPP_INLINE_VISIBILITY typename enable_if<
+      __is_seed_sequence<_Sseq, subtract_with_carry_engine>::value, void>::type
+  seed(_Sseq& __q) {
+    __seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());
+  }
 
-    // generating functions
-    result_type operator()();
-    _LIBCPP_INLINE_VISIBILITY
-    void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
+  void discard(unsigned long long __z) {
+    for (; __z; --__z)
+      operator()();
+  }
 
-    template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-    friend
-    bool
-    operator==(
-        const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
+  template <class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+  friend bool
+  operator==(const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
              const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
 
-    template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-    friend
-    bool
-    operator!=(
-        const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
+  template <class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+  friend bool
+  operator!=(const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
              const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
 
-    template <class _CharT, class _Traits,
-              class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
+  template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Sp,
+            size_t _Rp>
+  friend basic_ostream<_CharT, _Traits>&
 
-    template <class _CharT, class _Traits,
-              class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
+  template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Sp,
+            size_t _Rp>
+  friend basic_istream<_CharT, _Traits>&
 
 private:
-
-    void seed(result_type __sd, integral_constant<unsigned, 1>);
-    void seed(result_type __sd, integral_constant<unsigned, 2>);
-    template<class _Sseq>
-        void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
-    template<class _Sseq>
-        void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
+  template <class _Sseq>
+  template <class _Sseq>
 };
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-    _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size;
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+_LIBCPP_CONSTEXPR const size_t
+    subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size;
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-    _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag;
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+_LIBCPP_CONSTEXPR const size_t
+    subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag;
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-    _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag;
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+_LIBCPP_CONSTEXPR const size_t
+    subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag;
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-    _LIBCPP_CONSTEXPR const typename subtract_with_carry_engine<_UIntType, __w, __s, __r>::result_type
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+_LIBCPP_CONSTEXPR const typename subtract_with_carry_engine<_UIntType, __w, __s,
+                                                            __r>::result_type
     subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed;
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-void
-subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd,
-        integral_constant<unsigned, 1>)
-{
-    linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
-        __e(__sd == 0u ? default_seed : __sd);
-    for (size_t __i = 0; __i < __r; ++__i)
-        __x_[__i] = static_cast<result_type>(__e() & _Max);
-    __c_ = __x_[__r-1] == 0;
-    __i_ = 0;
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+void subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(
+    result_type __sd, integral_constant<unsigned, 1>) {
+  linear_congruential_engine<result_type, 40014u, 0u, 2147483563u> __e(
+      __sd == 0u ? default_seed : __sd);
+  __c_ = __x_[__r - 1] == 0;
 }
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-void
-subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd,
-        integral_constant<unsigned, 2>)
-{
-    linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
-        __e(__sd == 0u ? default_seed : __sd);
-    for (size_t __i = 0; __i < __r; ++__i)
-    {
-        result_type __e0 = __e();
-        __x_[__i] = static_cast<result_type>(
-                                    (__e0 + ((uint64_t)__e() << 32)) & _Max);
-    }
-    __c_ = __x_[__r-1] == 0;
-    __i_ = 0;
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+void subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(
+    result_type __sd, integral_constant<unsigned, 2>) {
+  linear_congruential_engine<result_type, 40014u, 0u, 2147483563u> __e(
+      __sd == 0u ? default_seed : __sd);
+  for (size_t __i = 0; __i < __r; ++__i) {
+    __x_[__i] =
+        static_cast<result_type>((__e0 + ((uint64_t)__e() << 32)) & _Max);
+  __c_ = __x_[__r - 1] == 0;
 }
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-template<class _Sseq>
-void
-subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q,
-        integral_constant<unsigned, 1>)
-{
-    const unsigned __k = 1;
-    uint32_t __ar[__r * __k];
-    __q.generate(__ar, __ar + __r * __k);
-    for (size_t __i = 0; __i < __r; ++__i)
-        __x_[__i] = static_cast<result_type>(__ar[__i] & _Max);
-    __c_ = __x_[__r-1] == 0;
-    __i_ = 0;
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+template <class _Sseq>
+void subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(
+    _Sseq& __q, integral_constant<unsigned, 1>) {
+  __c_ = __x_[__r - 1] == 0;
 }
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-template<class _Sseq>
-void
-subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q,
-        integral_constant<unsigned, 2>)
-{
-    const unsigned __k = 2;
-    uint32_t __ar[__r * __k];
-    __q.generate(__ar, __ar + __r * __k);
-    for (size_t __i = 0; __i < __r; ++__i)
-        __x_[__i] = static_cast<result_type>(
-                  (__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max);
-    __c_ = __x_[__r-1] == 0;
-    __i_ = 0;
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+template <class _Sseq>
+void subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(
+    _Sseq& __q, integral_constant<unsigned, 2>) {
+  __c_ = __x_[__r - 1] == 0;
 }
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-_UIntType
-subtract_with_carry_engine<_UIntType, __w, __s, __r>::operator()()
-{
-    const result_type& __xs = __x_[(__i_ + (__r - __s)) % __r];
-    result_type& __xr = __x_[__i_];
-    result_type __new_c = __c_ == 0 ? __xs < __xr : __xs != 0 ? __xs <= __xr : 1;
-    __xr = (__xs - __xr - __c_) & _Max;
-    __c_ = __new_c;
-    __i_ = (__i_ + 1) % __r;
-    return __xr;
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+_UIntType subtract_with_carry_engine<_UIntType, __w, __s, __r>::operator()() {
 }
 
-template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-bool
-operator==(
-    const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
-    const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y)
-{
-    if (__x.__c_ != __y.__c_)
-        return false;
-    if (__x.__i_ == __y.__i_)
-        return _VSTD::equal(__x.__x_, __x.__x_ + _Rp, __y.__x_);
-    if (__x.__i_ == 0 || __y.__i_ == 0)
-    {
-        size_t __j = _VSTD::min(_Rp - __x.__i_, _Rp - __y.__i_);
-        if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
-                         __y.__x_ + __y.__i_))
-            return false;
-        if (__x.__i_ == 0)
-            return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _Rp, __y.__x_);
-        return _VSTD::equal(__x.__x_, __x.__x_ + (_Rp - __j), __y.__x_ + __j);
-    }
-    if (__x.__i_ < __y.__i_)
-    {
-        size_t __j = _Rp - __y.__i_;
-        if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
-                         __y.__x_ + __y.__i_))
-            return false;
-        if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Rp,
-                         __y.__x_))
-            return false;
-        return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_,
-                           __y.__x_ + (_Rp - (__x.__i_ + __j)));
-    }
-    size_t __j = _Rp - __x.__i_;
-    if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
-                     __x.__x_ + __x.__i_))
-        return false;
-    if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Rp,
-                     __x.__x_))
-        return false;
-    return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_,
-                       __x.__x_ + (_Rp - (__y.__i_ + __j)));
+template <class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+bool operator==(const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
+                const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y) {
+  if (__x.__i_ == 0 || __y.__i_ == 0) {
+  if (__x.__i_ < __y.__i_) {
+    if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Rp, __y.__x_))
+  if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Rp, __x.__x_))
 }
 
-template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(
-    const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
-    const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y)
-{
-    return !(__x == __y);
+template <class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+inline _LIBCPP_INLINE_VISIBILITY bool
+operator!=(const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
+           const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y) {
 }
 
-template <class _CharT, class _Traits,
-          class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Sp,
+          size_t _Rp>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _Ostream;
-    __os.flags(_Ostream::dec | _Ostream::left);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    __os << __x.__x_[__x.__i_];
-    for (size_t __j = __x.__i_ + 1; __j < _Rp; ++__j)
-        __os << __sp << __x.__x_[__j];
-    for (size_t __j = 0; __j < __x.__i_; ++__j)
-        __os << __sp << __x.__x_[__j];
-    __os << __sp << __x.__c_;
-    return __os;
+           const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x) {
 }
 
-template <class _CharT, class _Traits,
-          class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Sp,
+          size_t _Rp>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
-           subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    _UInt __t[_Rp+1];
-    for (size_t __i = 0; __i < _Rp+1; ++__i)
-        __is >> __t[__i];
-    if (!__is.fail())
-    {
-        for (size_t __i = 0; __i < _Rp; ++__i)
-            __x.__x_[__i] = __t[__i];
-        __x.__c_ = __t[_Rp];
-        __x.__i_ = 0;
-    }
-    return __is;
+           subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x) {
+  _UInt __t[_Rp + 1];
+  for (size_t __i = 0; __i < _Rp + 1; ++__i)
+  if (!__is.fail()) {
 }
 
-typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>     ranlux24_base;
-typedef subtract_with_carry_engine<uint_fast64_t, 48,  5, 12>     ranlux48_base;
+typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24> ranlux24_base;
+typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12> ranlux48_base;
 
 // discard_block_engine
 
-template<class _Engine, size_t __p, size_t __r>
-class _LIBCPP_TEMPLATE_VIS discard_block_engine
-{
-    _Engine __e_;
-    int     __n_;
+template <class _Engine, size_t __p, size_t __r>
+class _LIBCPP_TEMPLATE_VIS discard_block_engine {
+  int __n_;
 
-    static_assert(  0 <  __r, "discard_block_engine invalid parameters");
-    static_assert(__r <= __p, "discard_block_engine invalid parameters");
-    static_assert(__r <= INT_MAX, "discard_block_engine invalid parameters");
+  static_assert(0 < __r, "discard_block_engine invalid parameters");
+
 public:
-    // types
-    typedef typename _Engine::result_type result_type;
 
-    // engine characteristics
-    static _LIBCPP_CONSTEXPR const size_t block_size = __p;
-    static _LIBCPP_CONSTEXPR const size_t used_block = __r;
 
 #ifdef _LIBCPP_CXX03_LANG
-    static const result_type _Min = _Engine::_Min;
-    static const result_type _Max = _Engine::_Max;
 #else
-    static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min();
-    static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max();
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type min() { return _Engine::min(); }
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type max() { return _Engine::max(); }
 
-    // constructors and seeding functions
-    _LIBCPP_INLINE_VISIBILITY
-    discard_block_engine() : __n_(0) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit discard_block_engine(const _Engine& __e)
-        : __e_(__e), __n_(0) {}
+  explicit discard_block_engine(const _Engine& __e) : __e_(__e), __n_(0) {}
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    explicit discard_block_engine(_Engine&& __e)
-        : __e_(_VSTD::move(__e)), __n_(0) {}
-#endif  // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    explicit discard_block_engine(result_type __sd) : __e_(__sd), __n_(0) {}
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        explicit discard_block_engine(_Sseq& __q,
-        typename enable_if<__is_seed_sequence<_Sseq, discard_block_engine>::value &&
-                           !is_convertible<_Sseq, _Engine>::value>::type* = 0)
-        : __e_(__q), __n_(0) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed() {__e_.seed(); __n_ = 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed(result_type __sd) {__e_.seed(__sd); __n_ = 0;}
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __is_seed_sequence<_Sseq, discard_block_engine>::value,
-            void
-        >::type
-        seed(_Sseq& __q) {__e_.seed(__q); __n_ = 0;}
+#endif // _LIBCPP_CXX03_LANG
+  template <class _Sseq>
+  _LIBCPP_INLINE_VISIBILITY explicit discard_block_engine(
+      _Sseq& __q, typename enable_if<
+                      __is_seed_sequence<_Sseq, discard_block_engine>::value &&
+  void seed() {
+    __e_.seed();
+    __n_ = 0;
+  }
+  void seed(result_type __sd) {
+    __e_.seed(__sd);
+    __n_ = 0;
+  }
+  template <class _Sseq>
+      typename enable_if<__is_seed_sequence<_Sseq, discard_block_engine>::value,
+                         void>::type
+      seed(_Sseq& __q) {
+    __e_.seed(__q);
+    __n_ = 0;
+  }
 
-    // generating functions
-    result_type operator()();
-    _LIBCPP_INLINE_VISIBILITY
-    void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
+  void discard(unsigned long long __z) {
+    for (; __z; --__z)
+      operator()();
+  }
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    const _Engine& base() const _NOEXCEPT {return __e_;}
+  const _Engine& base() const _NOEXCEPT { return __e_; }
 
-    template<class _Eng, size_t _Pp, size_t _Rp>
-    friend
-    bool
-    operator==(
-        const discard_block_engine<_Eng, _Pp, _Rp>& __x,
+  template <class _Eng, size_t _Pp, size_t _Rp>
+  friend bool operator==(const discard_block_engine<_Eng, _Pp, _Rp>& __x,
                          const discard_block_engine<_Eng, _Pp, _Rp>& __y);
 
-    template<class _Eng, size_t _Pp, size_t _Rp>
-    friend
-    bool
-    operator!=(
-        const discard_block_engine<_Eng, _Pp, _Rp>& __x,
+  template <class _Eng, size_t _Pp, size_t _Rp>
+  friend bool operator!=(const discard_block_engine<_Eng, _Pp, _Rp>& __x,
                          const discard_block_engine<_Eng, _Pp, _Rp>& __y);
 
-    template <class _CharT, class _Traits,
-              class _Eng, size_t _Pp, size_t _Rp>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const discard_block_engine<_Eng, _Pp, _Rp>& __x);
+  template <class _CharT, class _Traits, class _Eng, size_t _Pp, size_t _Rp>
+  friend basic_ostream<_CharT, _Traits>&
 
-    template <class _CharT, class _Traits,
-              class _Eng, size_t _Pp, size_t _Rp>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               discard_block_engine<_Eng, _Pp, _Rp>& __x);
+  template <class _CharT, class _Traits, class _Eng, size_t _Pp, size_t _Rp>
+  friend basic_istream<_CharT, _Traits>&
 };
 
-template<class _Engine, size_t __p, size_t __r>
-    _LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::block_size;
+template <class _Engine, size_t __p, size_t __r>
+_LIBCPP_CONSTEXPR const size_t
+    discard_block_engine<_Engine, __p, __r>::block_size;
 
-template<class _Engine, size_t __p, size_t __r>
-    _LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::used_block;
+template <class _Engine, size_t __p, size_t __r>
+_LIBCPP_CONSTEXPR const size_t
+    discard_block_engine<_Engine, __p, __r>::used_block;
 
-template<class _Engine, size_t __p, size_t __r>
+template <class _Engine, size_t __p, size_t __r>
 typename discard_block_engine<_Engine, __p, __r>::result_type
-discard_block_engine<_Engine, __p, __r>::operator()()
-{
-    if (__n_ >= static_cast<int>(__r))
-    {
-        __e_.discard(__p - __r);
-        __n_ = 0;
-    }
-    ++__n_;
-    return __e_();
+discard_block_engine<_Engine, __p, __r>::operator()() {
+  if (__n_ >= static_cast<int>(__r)) {
 }
 
-template<class _Eng, size_t _Pp, size_t _Rp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
+template <class _Eng, size_t _Pp, size_t _Rp>
+inline _LIBCPP_INLINE_VISIBILITY bool
 operator==(const discard_block_engine<_Eng, _Pp, _Rp>& __x,
-           const discard_block_engine<_Eng, _Pp, _Rp>& __y)
-{
-    return __x.__n_ == __y.__n_ && __x.__e_ == __y.__e_;
+           const discard_block_engine<_Eng, _Pp, _Rp>& __y) {
 }
 
-template<class _Eng, size_t _Pp, size_t _Rp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
+template <class _Eng, size_t _Pp, size_t _Rp>
+inline _LIBCPP_INLINE_VISIBILITY bool
 operator!=(const discard_block_engine<_Eng, _Pp, _Rp>& __x,
-           const discard_block_engine<_Eng, _Pp, _Rp>& __y)
-{
-    return !(__x == __y);
+           const discard_block_engine<_Eng, _Pp, _Rp>& __y) {
 }
 
-template <class _CharT, class _Traits,
-          class _Eng, size_t _Pp, size_t _Rp>
+template <class _CharT, class _Traits, class _Eng, size_t _Pp, size_t _Rp>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const discard_block_engine<_Eng, _Pp, _Rp>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _Ostream;
-    __os.flags(_Ostream::dec | _Ostream::left);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    return __os << __x.__e_ << __sp << __x.__n_;
+           const discard_block_engine<_Eng, _Pp, _Rp>& __x) {
 }
 
-template <class _CharT, class _Traits,
-          class _Eng, size_t _Pp, size_t _Rp>
+template <class _CharT, class _Traits, class _Eng, size_t _Pp, size_t _Rp>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
-           discard_block_engine<_Eng, _Pp, _Rp>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    _Eng __e;
-    int __n;
-    __is >> __e >> __n;
-    if (!__is.fail())
-    {
-        __x.__e_ = __e;
-        __x.__n_ = __n;
-    }
-    return __is;
+           discard_block_engine<_Eng, _Pp, _Rp>& __x) {
+  if (!__is.fail()) {
 }
 
 typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
 typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
 
 // independent_bits_engine
 
-template<class _Engine, size_t __w, class _UIntType>
-class _LIBCPP_TEMPLATE_VIS independent_bits_engine
-{
-    template <class _UInt, _UInt _R0, size_t _Wp, size_t _Mp>
-    class __get_n
-    {
-        static _LIBCPP_CONSTEXPR const size_t _Dt = numeric_limits<_UInt>::digits;
-        static _LIBCPP_CONSTEXPR const size_t _Np = _Wp / _Mp + (_Wp % _Mp != 0);
-        static _LIBCPP_CONSTEXPR const size_t _W0 = _Wp / _Np;
-        static _LIBCPP_CONSTEXPR const _UInt _Y0 = _W0 >= _Dt ? 0 : (_R0 >> _W0) << _W0;
-    public:
-        static _LIBCPP_CONSTEXPR const size_t value = _R0 - _Y0 > _Y0 / _Np ? _Np + 1 : _Np;
-    };
+template <class _Engine, size_t __w, class _UIntType>
+class _LIBCPP_TEMPLATE_VIS independent_bits_engine {
+  class __get_n {
+    static _LIBCPP_CONSTEXPR const _UInt _Y0 =
+        _W0 >= _Dt ? 0 : (_R0 >> _W0) << _W0;
+
+    static _LIBCPP_CONSTEXPR const size_t value =
+        _R0 - _Y0 > _Y0 / _Np ? _Np + 1 : _Np;
+
 public:
-    // types
-    typedef _UIntType result_type;
 
 private:
-    _Engine __e_;
 
-    static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
-    static_assert(  0 <  __w, "independent_bits_engine invalid parameters");
-    static_assert(__w <= _Dt, "independent_bits_engine invalid parameters");
+  static _LIBCPP_CONSTEXPR const result_type _Dt =
+      numeric_limits<result_type>::digits;
+  static_assert(0 < __w, "independent_bits_engine invalid parameters");
 
-    typedef typename _Engine::result_type _Engine_result_type;
-    typedef typename conditional
-        <
-            sizeof(_Engine_result_type) <= sizeof(result_type),
-                result_type,
-                _Engine_result_type
-        >::type _Working_result_type;
+  typedef
+      typename conditional<sizeof(_Engine_result_type) <= sizeof(result_type),
+                           result_type, _Engine_result_type>::type
+          _Working_result_type;
 #ifdef _LIBCPP_CXX03_LANG
-    static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min
-                                          + _Working_result_type(1);
+  static const _Working_result_type _Rp =
+      _Engine::_Max - _Engine::_Min + _Working_result_type(1);
 #else
-    static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min()
-                                                            + _Working_result_type(1);
+  static _LIBCPP_CONSTEXPR const _Working_result_type _Rp =
+      _Engine::max() - _Engine::min() + _Working_result_type(1);
 #endif
-    static _LIBCPP_CONSTEXPR const size_t __m = __log2<_Working_result_type, _Rp>::value;
-    static _LIBCPP_CONSTEXPR const size_t __n = __get_n<_Working_result_type, _Rp, __w, __m>::value;
-    static _LIBCPP_CONSTEXPR const size_t __w0 = __w / __n;
-    static _LIBCPP_CONSTEXPR const size_t __n0 = __n - __w % __n;
-    static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits;
-    static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits;
-    static _LIBCPP_CONSTEXPR const _Working_result_type __y0 = __w0 >= _WDt ? 0 :
-                                                               (_Rp >> __w0) << __w0;
-    static _LIBCPP_CONSTEXPR const _Working_result_type __y1 = __w0 >= _WDt - 1 ? 0 :
-                                                               (_Rp >> (__w0+1)) << (__w0+1);
-    static _LIBCPP_CONSTEXPR const _Engine_result_type __mask0 = __w0 > 0 ?
-                                _Engine_result_type(~0) >> (_EDt - __w0) :
-                                _Engine_result_type(0);
-    static _LIBCPP_CONSTEXPR const _Engine_result_type __mask1 = __w0 < _EDt - 1 ?
-                                _Engine_result_type(~0) >> (_EDt - (__w0 + 1)) :
-                                _Engine_result_type(~0);
+  static _LIBCPP_CONSTEXPR const size_t __m =
+      __log2<_Working_result_type, _Rp>::value;
+  static _LIBCPP_CONSTEXPR const size_t __n =
+      __get_n<_Working_result_type, _Rp, __w, __m>::value;
+  static _LIBCPP_CONSTEXPR const size_t _WDt =
+      numeric_limits<_Working_result_type>::digits;
+  static _LIBCPP_CONSTEXPR const size_t _EDt =
+      numeric_limits<_Engine_result_type>::digits;
+  static _LIBCPP_CONSTEXPR const _Working_result_type __y0 =
+      __w0 >= _WDt ? 0 : (_Rp >> __w0) << __w0;
+  static _LIBCPP_CONSTEXPR const _Working_result_type __y1 =
+      __w0 >= _WDt - 1 ? 0 : (_Rp >> (__w0 + 1)) << (__w0 + 1);
+  static _LIBCPP_CONSTEXPR const
+      _Engine_result_type __mask0 = __w0 > 0 ? _Engine_result_type(~0) >>
+                                                   (_EDt - __w0)
+                                             : _Engine_result_type(0);
+  static _LIBCPP_CONSTEXPR const
+      _Engine_result_type __mask1 = __w0 < _EDt - 1 ? _Engine_result_type(~0) >>
+                                                          (_EDt - (__w0 + 1))
+                                                    : _Engine_result_type(~0);
+
 public:
-    static _LIBCPP_CONSTEXPR const result_type _Min = 0;
-    static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
-                                                      (result_type(1) << __w) - result_type(1);
-    static_assert(_Min < _Max, "independent_bits_engine invalid parameters");
+  static _LIBCPP_CONSTEXPR const result_type _Max =
+      __w == _Dt ? result_type(~0) : (result_type(1) << __w) - result_type(1);
 
-    // engine characteristics
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
 
-    // constructors and seeding functions
-    _LIBCPP_INLINE_VISIBILITY
-    independent_bits_engine() {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit independent_bits_engine(const _Engine& __e)
-        : __e_(__e) {}
+  explicit independent_bits_engine(const _Engine& __e) : __e_(__e) {}
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    explicit independent_bits_engine(_Engine&& __e)
-        : __e_(_VSTD::move(__e)) {}
-#endif  // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    explicit independent_bits_engine(result_type __sd) : __e_(__sd) {}
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        explicit independent_bits_engine(_Sseq& __q,
-        typename enable_if<__is_seed_sequence<_Sseq, independent_bits_engine>::value &&
-                           !is_convertible<_Sseq, _Engine>::value>::type* = 0)
-         : __e_(__q) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed() {__e_.seed();}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed(result_type __sd) {__e_.seed(__sd);}
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __is_seed_sequence<_Sseq, independent_bits_engine>::value,
-            void
-        >::type
-        seed(_Sseq& __q) {__e_.seed(__q);}
+  explicit independent_bits_engine(_Engine&& __e) : __e_(_VSTD::move(__e)) {}
+#endif // _LIBCPP_CXX03_LANG
+  template <class _Sseq>
+  _LIBCPP_INLINE_VISIBILITY explicit independent_bits_engine(
+      _Sseq& __q,
+      typename enable_if<
+          __is_seed_sequence<_Sseq, independent_bits_engine>::value &&
+  void seed() { __e_.seed(); }
+  void seed(result_type __sd) { __e_.seed(__sd); }
+  template <class _Sseq>
+  _LIBCPP_INLINE_VISIBILITY typename enable_if<
+      __is_seed_sequence<_Sseq, independent_bits_engine>::value, void>::type
+  seed(_Sseq& __q) {
+    __e_.seed(__q);
+  }
 
-    // generating functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
-    _LIBCPP_INLINE_VISIBILITY
-    void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
+  result_type operator()() {
+    return __eval(integral_constant<bool, _Rp != 0>());
+  }
+  void discard(unsigned long long __z) {
+    for (; __z; --__z)
+      operator()();
+  }
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    const _Engine& base() const _NOEXCEPT {return __e_;}
+  const _Engine& base() const _NOEXCEPT { return __e_; }
 
-    template<class _Eng, size_t _Wp, class _UInt>
-    friend
-    bool
-    operator==(
-        const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
+  template <class _Eng, size_t _Wp, class _UInt>
+  friend bool operator==(const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
                          const independent_bits_engine<_Eng, _Wp, _UInt>& __y);
 
-    template<class _Eng, size_t _Wp, class _UInt>
-    friend
-    bool
-    operator!=(
-        const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
+  template <class _Eng, size_t _Wp, class _UInt>
+  friend bool operator!=(const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
                          const independent_bits_engine<_Eng, _Wp, _UInt>& __y);
 
-    template <class _CharT, class _Traits,
-              class _Eng, size_t _Wp, class _UInt>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const independent_bits_engine<_Eng, _Wp, _UInt>& __x);
+  template <class _CharT, class _Traits, class _Eng, size_t _Wp, class _UInt>
+  friend basic_ostream<_CharT, _Traits>&
 
-    template <class _CharT, class _Traits,
-              class _Eng, size_t _Wp, class _UInt>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               independent_bits_engine<_Eng, _Wp, _UInt>& __x);
+  template <class _CharT, class _Traits, class _Eng, size_t _Wp, class _UInt>
+  friend basic_istream<_CharT, _Traits>&
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    result_type __eval(false_type);
-    result_type __eval(true_type);
 
-    template <size_t __count>
-        _LIBCPP_INLINE_VISIBILITY
-        static
-        typename enable_if
-        <
-            __count < _Dt,
-            result_type
-        >::type
-        __lshift(result_type __x) {return __x << __count;}
+      _LIBCPP_INLINE_VISIBILITY static typename enable_if <
+      __count<_Dt, result_type>::type __lshift(result_type __x) {
+    return __x << __count;
+  }
 
-    template <size_t __count>
-        _LIBCPP_INLINE_VISIBILITY
-        static
-        typename enable_if
-        <
-            (__count >= _Dt),
-            result_type
-        >::type
-        __lshift(result_type) {return result_type(0);}
+  _LIBCPP_INLINE_VISIBILITY static
+      typename enable_if<(__count >= _Dt), result_type>::type
+      __lshift(result_type) {
+    return result_type(0);
+  }
 };
 
-template<class _Engine, size_t __w, class _UIntType>
-inline
-_UIntType
-independent_bits_engine<_Engine, __w, _UIntType>::__eval(false_type)
-{
-    return static_cast<result_type>(__e_() & __mask0);
+template <class _Engine, size_t __w, class _UIntType>
+inline _UIntType
+independent_bits_engine<_Engine, __w, _UIntType>::__eval(false_type) {
 }
 
-template<class _Engine, size_t __w, class _UIntType>
-_UIntType
-independent_bits_engine<_Engine, __w, _UIntType>::__eval(true_type)
-{
-    result_type _Sp = 0;
-    for (size_t __k = 0; __k < __n0; ++__k)
-    {
-        _Engine_result_type __u;
-        do
-        {
-            __u = __e_() - _Engine::min();
-        } while (__u >= __y0);
-        _Sp = static_cast<result_type>(__lshift<__w0>(_Sp) + (__u & __mask0));
-    }
-    for (size_t __k = __n0; __k < __n; ++__k)
-    {
-        _Engine_result_type __u;
-        do
-        {
-            __u = __e_() - _Engine::min();
-        } while (__u >= __y1);
-        _Sp = static_cast<result_type>(__lshift<__w0+1>(_Sp) + (__u & __mask1));
-    }
-    return _Sp;
+template <class _Engine, size_t __w, class _UIntType>
+_UIntType independent_bits_engine<_Engine, __w, _UIntType>::__eval(true_type) {
+  for (size_t __k = 0; __k < __n0; ++__k) {
+    do {
+  for (size_t __k = __n0; __k < __n; ++__k) {
+    do {
+    _Sp = static_cast<result_type>(__lshift<__w0 + 1>(_Sp) + (__u & __mask1));
 }
 
-template<class _Eng, size_t _Wp, class _UInt>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(
-    const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
-    const independent_bits_engine<_Eng, _Wp, _UInt>& __y)
-{
-    return __x.base() == __y.base();
+template <class _Eng, size_t _Wp, class _UInt>
+inline _LIBCPP_INLINE_VISIBILITY bool
+operator==(const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
+           const independent_bits_engine<_Eng, _Wp, _UInt>& __y) {
 }
 
-template<class _Eng, size_t _Wp, class _UInt>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(
-    const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
-    const independent_bits_engine<_Eng, _Wp, _UInt>& __y)
-{
-    return !(__x == __y);
+template <class _Eng, size_t _Wp, class _UInt>
+inline _LIBCPP_INLINE_VISIBILITY bool
+operator!=(const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
+           const independent_bits_engine<_Eng, _Wp, _UInt>& __y) {
 }
 
-template <class _CharT, class _Traits,
-          class _Eng, size_t _Wp, class _UInt>
+template <class _CharT, class _Traits, class _Eng, size_t _Wp, class _UInt>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const independent_bits_engine<_Eng, _Wp, _UInt>& __x)
-{
-    return __os << __x.base();
+           const independent_bits_engine<_Eng, _Wp, _UInt>& __x) {
 }
 
-template <class _CharT, class _Traits,
-          class _Eng, size_t _Wp, class _UInt>
+template <class _CharT, class _Traits, class _Eng, size_t _Wp, class _UInt>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
-           independent_bits_engine<_Eng, _Wp, _UInt>& __x)
-{
-    _Eng __e;
-    __is >> __e;
-    if (!__is.fail())
-        __x.__e_ = __e;
-    return __is;
+           independent_bits_engine<_Eng, _Wp, _UInt>& __x) {
 }
 
 // shuffle_order_engine
 
 template <uint64_t _Xp, uint64_t _Yp>
-struct __ugcd
-{
-    static _LIBCPP_CONSTEXPR const uint64_t value = __ugcd<_Yp, _Xp % _Yp>::value;
+struct __ugcd {
 };
 
 template <uint64_t _Xp>
-struct __ugcd<_Xp, 0>
-{
-    static _LIBCPP_CONSTEXPR const uint64_t value = _Xp;
+struct __ugcd<_Xp, 0> {
 };
 
 template <uint64_t _Np, uint64_t _Dp>
-class __uratio
-{
-    static_assert(_Dp != 0, "__uratio divide by 0");
-    static _LIBCPP_CONSTEXPR const uint64_t __gcd = __ugcd<_Np, _Dp>::value;
+class __uratio {
+
 public:
-    static _LIBCPP_CONSTEXPR const uint64_t num = _Np / __gcd;
-    static _LIBCPP_CONSTEXPR const uint64_t den = _Dp / __gcd;
 
-    typedef __uratio<num, den> type;
 };
 
-template<class _Engine, size_t __k>
-class _LIBCPP_TEMPLATE_VIS shuffle_order_engine
-{
-    static_assert(0 < __k, "shuffle_order_engine invalid parameters");
+template <class _Engine, size_t __k>
+class _LIBCPP_TEMPLATE_VIS shuffle_order_engine {
+
 public:
-    // types
-    typedef typename _Engine::result_type result_type;
 
 private:
-    _Engine __e_;
-    result_type _V_[__k];
-    result_type _Y_;
 
 public:
-    // engine characteristics
-    static _LIBCPP_CONSTEXPR const size_t table_size = __k;
 
 #ifdef _LIBCPP_CXX03_LANG
-    static const result_type _Min = _Engine::_Min;
-    static const result_type _Max = _Engine::_Max;
 #else
-    static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min();
-    static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max();
 #endif
-    static_assert(_Min < _Max, "shuffle_order_engine invalid parameters");
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
 
-    static _LIBCPP_CONSTEXPR const unsigned long long _Rp = _Max - _Min + 1ull;
 
-    // constructors and seeding functions
-    _LIBCPP_INLINE_VISIBILITY
-    shuffle_order_engine() {__init();}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit shuffle_order_engine(const _Engine& __e)
-        : __e_(__e) {__init();}
+  shuffle_order_engine() { __init(); }
+  explicit shuffle_order_engine(const _Engine& __e) : __e_(__e) { __init(); }
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    explicit shuffle_order_engine(_Engine&& __e)
-        : __e_(_VSTD::move(__e)) {__init();}
-#endif  // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    explicit shuffle_order_engine(result_type __sd) : __e_(__sd) {__init();}
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        explicit shuffle_order_engine(_Sseq& __q,
-        typename enable_if<__is_seed_sequence<_Sseq, shuffle_order_engine>::value &&
-                           !is_convertible<_Sseq, _Engine>::value>::type* = 0)
-         : __e_(__q) {__init();}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed() {__e_.seed(); __init();}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed(result_type __sd) {__e_.seed(__sd); __init();}
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __is_seed_sequence<_Sseq, shuffle_order_engine>::value,
-            void
-        >::type
-        seed(_Sseq& __q) {__e_.seed(__q); __init();}
+  explicit shuffle_order_engine(_Engine&& __e) : __e_(_VSTD::move(__e)) {
+    __init();
+  }
+#endif // _LIBCPP_CXX03_LANG
+  explicit shuffle_order_engine(result_type __sd) : __e_(__sd) { __init(); }
+  template <class _Sseq>
+  _LIBCPP_INLINE_VISIBILITY explicit shuffle_order_engine(
+      _Sseq& __q, typename enable_if<
+                      __is_seed_sequence<_Sseq, shuffle_order_engine>::value &&
+      : __e_(__q) {
+    __init();
+  }
+  void seed() {
+    __e_.seed();
+    __init();
+  }
+  void seed(result_type __sd) {
+    __e_.seed(__sd);
+    __init();
+  }
+  template <class _Sseq>
+      typename enable_if<__is_seed_sequence<_Sseq, shuffle_order_engine>::value,
+                         void>::type
+      seed(_Sseq& __q) {
+    __e_.seed(__q);
+    __init();
+  }
 
-    // generating functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
-    _LIBCPP_INLINE_VISIBILITY
-    void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
+  result_type operator()() {
+    return __eval(integral_constant<bool, _Rp != 0>());
+  }
+  void discard(unsigned long long __z) {
+    for (; __z; --__z)
+      operator()();
+  }
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    const _Engine& base() const _NOEXCEPT {return __e_;}
+  const _Engine& base() const _NOEXCEPT { return __e_; }
 
 private:
-    template<class _Eng, size_t _Kp>
-    friend
-    bool
-    operator==(
-        const shuffle_order_engine<_Eng, _Kp>& __x,
+  template <class _Eng, size_t _Kp>
+  friend bool operator==(const shuffle_order_engine<_Eng, _Kp>& __x,
                          const shuffle_order_engine<_Eng, _Kp>& __y);
 
-    template<class _Eng, size_t _Kp>
-    friend
-    bool
-    operator!=(
-        const shuffle_order_engine<_Eng, _Kp>& __x,
+  template <class _Eng, size_t _Kp>
+  friend bool operator!=(const shuffle_order_engine<_Eng, _Kp>& __x,
                          const shuffle_order_engine<_Eng, _Kp>& __y);
 
-    template <class _CharT, class _Traits,
-              class _Eng, size_t _Kp>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const shuffle_order_engine<_Eng, _Kp>& __x);
+  template <class _CharT, class _Traits, class _Eng, size_t _Kp>
+  friend basic_ostream<_CharT, _Traits>&
 
-    template <class _CharT, class _Traits,
-              class _Eng, size_t _Kp>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               shuffle_order_engine<_Eng, _Kp>& __x);
+  template <class _CharT, class _Traits, class _Eng, size_t _Kp>
+  friend basic_istream<_CharT, _Traits>&
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __init()
-    {
-        for (size_t __i = 0; __i < __k; ++__i)
-            _V_[__i] = __e_();
-        _Y_ = __e_();
-    }
+  void __init() {
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type __eval(false_type) {return __eval2(integral_constant<bool, __k & 1>());}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type __eval(true_type) {return __eval(__uratio<__k, _Rp>());}
+  result_type __eval(false_type) {
+    return __eval2(integral_constant<bool, __k & 1>());
+  }
+  result_type __eval(true_type) { return __eval(__uratio<__k, _Rp>()); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type __eval2(false_type) {return __eval(__uratio<__k/2, 0x8000000000000000ull>());}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type __eval2(true_type) {return __evalf<__k, 0>();}
+  result_type __eval2(false_type) {
+    return __eval(__uratio<__k / 2, 0x8000000000000000ull>());
+  }
+  result_type __eval2(true_type) { return __evalf<__k, 0>(); }
 
-    template <uint64_t _Np, uint64_t _Dp>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            (__uratio<_Np, _Dp>::num > 0xFFFFFFFFFFFFFFFFull / (_Max - _Min)),
-            result_type
-        >::type
-        __eval(__uratio<_Np, _Dp>)
-            {return __evalf<__uratio<_Np, _Dp>::num, __uratio<_Np, _Dp>::den>();}
+      typename enable_if<(__uratio<_Np, _Dp>::num >
+                          0xFFFFFFFFFFFFFFFFull / (_Max - _Min)),
+                         result_type>::type
+      __eval(__uratio<_Np, _Dp>) {
+    return __evalf<__uratio<_Np, _Dp>::num, __uratio<_Np, _Dp>::den>();
+  }
 
-    template <uint64_t _Np, uint64_t _Dp>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __uratio<_Np, _Dp>::num <= 0xFFFFFFFFFFFFFFFFull / (_Max - _Min),
-            result_type
-        >::type
-        __eval(__uratio<_Np, _Dp>)
-        {
-            const size_t __j = static_cast<size_t>(__uratio<_Np, _Dp>::num * (_Y_ - _Min)
-                                                   / __uratio<_Np, _Dp>::den);
-            _Y_ = _V_[__j];
-            _V_[__j] = __e_();
-            return _Y_;
-        }
+      typename enable_if<__uratio<_Np, _Dp>::num <=
+                             0xFFFFFFFFFFFFFFFFull / (_Max - _Min),
+                         result_type>::type
+      __eval(__uratio<_Np, _Dp>) {
+    const size_t __j = static_cast<size_t>(
+        __uratio<_Np, _Dp>::num * (_Y_ - _Min) / __uratio<_Np, _Dp>::den);
 
-    template <uint64_t __n, uint64_t __d>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type __evalf()
-        {
-            const double _Fp = __d == 0 ?
-                __n / (2. * 0x8000000000000000ull) :
-                __n / (double)__d;
-            const size_t __j = static_cast<size_t>(_Fp * (_Y_ - _Min));
-            _Y_ = _V_[__j];
-            _V_[__j] = __e_();
-            return _Y_;
-        }
+  _LIBCPP_INLINE_VISIBILITY result_type __evalf() {
+    const double _Fp =
+        __d == 0 ? __n / (2. * 0x8000000000000000ull) : __n / (double)__d;
 };
 
-template<class _Engine, size_t __k>
-    _LIBCPP_CONSTEXPR const size_t shuffle_order_engine<_Engine, __k>::table_size;
+template <class _Engine, size_t __k>
 
-template<class _Eng, size_t _Kp>
-bool
-operator==(
-    const shuffle_order_engine<_Eng, _Kp>& __x,
-    const shuffle_order_engine<_Eng, _Kp>& __y)
-{
-    return __x._Y_ == __y._Y_ && _VSTD::equal(__x._V_, __x._V_ + _Kp, __y._V_) &&
-           __x.__e_ == __y.__e_;
+template <class _Eng, size_t _Kp>
+bool operator==(const shuffle_order_engine<_Eng, _Kp>& __x,
+                const shuffle_order_engine<_Eng, _Kp>& __y) {
 }
 
-template<class _Eng, size_t _Kp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(
-    const shuffle_order_engine<_Eng, _Kp>& __x,
-    const shuffle_order_engine<_Eng, _Kp>& __y)
-{
-    return !(__x == __y);
+template <class _Eng, size_t _Kp>
+inline _LIBCPP_INLINE_VISIBILITY bool
+operator!=(const shuffle_order_engine<_Eng, _Kp>& __x,
+           const shuffle_order_engine<_Eng, _Kp>& __y) {
 }
 
-template <class _CharT, class _Traits,
-          class _Eng, size_t _Kp>
+template <class _CharT, class _Traits, class _Eng, size_t _Kp>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const shuffle_order_engine<_Eng, _Kp>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _Ostream;
-    __os.flags(_Ostream::dec | _Ostream::left);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    __os << __x.__e_ << __sp << __x._V_[0];
-    for (size_t __i = 1; __i < _Kp; ++__i)
-        __os << __sp << __x._V_[__i];
-    return __os << __sp << __x._Y_;
+           const shuffle_order_engine<_Eng, _Kp>& __x) {
 }
 
-template <class _CharT, class _Traits,
-          class _Eng, size_t _Kp>
+template <class _CharT, class _Traits, class _Eng, size_t _Kp>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
-           shuffle_order_engine<_Eng, _Kp>& __x)
-{
-    typedef typename shuffle_order_engine<_Eng, _Kp>::result_type result_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    _Eng __e;
-    result_type _Vp[_Kp+1];
-    __is >> __e;
-    for (size_t __i = 0; __i < _Kp+1; ++__i)
-        __is >> _Vp[__i];
-    if (!__is.fail())
-    {
-        __x.__e_ = __e;
-        for (size_t __i = 0; __i < _Kp; ++__i)
-            __x._V_[__i] = _Vp[__i];
-        __x._Y_ = _Vp[_Kp];
-    }
-    return __is;
+           shuffle_order_engine<_Eng, _Kp>& __x) {
+  result_type _Vp[_Kp + 1];
+  for (size_t __i = 0; __i < _Kp + 1; ++__i)
+  if (!__is.fail()) {
 }
 
-typedef shuffle_order_engine<minstd_rand0, 256>                         knuth_b;
+typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
 
 // random_device
 
 #if !defined(_LIBCPP_HAS_NO_RANDOM_DEVICE)
 
-class _LIBCPP_TYPE_VIS random_device
-{
+class _LIBCPP_TYPE_VIS random_device {
 #ifdef _LIBCPP_USING_DEV_RANDOM
-    int __f_;
 #endif // defined(_LIBCPP_USING_DEV_RANDOM)
 public:
-    // types
-    typedef unsigned result_type;
 
-    // generator characteristics
-    static _LIBCPP_CONSTEXPR const result_type _Min = 0;
-    static _LIBCPP_CONSTEXPR const result_type _Max = 0xFFFFFFFFu;
 
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type min() { return _Min;}
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type max() { return _Max;}
+  static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
+  static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
 
-    // constructors
 #ifndef _LIBCPP_CXX03_LANG
-    random_device() : random_device("/dev/urandom") {}
-    explicit random_device(const string& __token);
 #else
-    explicit random_device(const string& __token = "/dev/urandom");
 #endif
-    ~random_device();
 
-    // generating functions
-    result_type operator()();
 
-    // property functions
-    double entropy() const _NOEXCEPT;
 
 private:
-    // no copy functions
-    random_device(const random_device&); // = delete;
-    random_device& operator=(const random_device&); // = delete;
+  random_device(const random_device&);            // = delete;
 };
 
 #endif // !_LIBCPP_HAS_NO_RANDOM_DEVICE
 
 // seed_seq
 
-class _LIBCPP_TEMPLATE_VIS seed_seq
-{
+class _LIBCPP_TEMPLATE_VIS seed_seq {
 public:
-    // types
-    typedef uint32_t result_type;
 
 private:
-    vector<result_type> __v_;
 
-    template<class _InputIterator>
-        void init(_InputIterator __first, _InputIterator __last);
+  template <class _InputIterator>
+
 public:
-    // constructors
-    _LIBCPP_INLINE_VISIBILITY
-    seed_seq() _NOEXCEPT {}
 #ifndef _LIBCPP_CXX03_LANG
-    template<class _Tp>
-        _LIBCPP_INLINE_VISIBILITY
-        seed_seq(initializer_list<_Tp> __il) {init(__il.begin(), __il.end());}
-#endif  // _LIBCPP_CXX03_LANG
+  template <class _Tp>
+  _LIBCPP_INLINE_VISIBILITY seed_seq(initializer_list<_Tp> __il) {
+    init(__il.begin(), __il.end());
+  }
+#endif // _LIBCPP_CXX03_LANG
 
-    template<class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        seed_seq(_InputIterator __first, _InputIterator __last)
-             {init(__first, __last);}
+  template <class _InputIterator>
+  _LIBCPP_INLINE_VISIBILITY seed_seq(_InputIterator __first,
+                                     _InputIterator __last) {
+    init(__first, __last);
+  }
 
-    // generating functions
-    template<class _RandomAccessIterator>
-        void generate(_RandomAccessIterator __first, _RandomAccessIterator __last);
+  template <class _RandomAccessIterator>
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const _NOEXCEPT {return __v_.size();}
-    template<class _OutputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        void param(_OutputIterator __dest) const
-            {_VSTD::copy(__v_.begin(), __v_.end(), __dest);}
+  size_t size() const _NOEXCEPT { return __v_.size(); }
+  template <class _OutputIterator>
+  _LIBCPP_INLINE_VISIBILITY void param(_OutputIterator __dest) const {
+    _VSTD::copy(__v_.begin(), __v_.end(), __dest);
+  }
 
 private:
-    // no copy functions
-    seed_seq(const seed_seq&); // = delete;
-    void operator=(const seed_seq&); // = delete;
+  seed_seq(const seed_seq&);       // = delete;
 
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type _Tp(result_type __x) {return __x ^ (__x >> 27);}
+  static result_type _Tp(result_type __x) { return __x ^ (__x >> 27); }
 };
 
-template<class _InputIterator>
-void
-seed_seq::init(_InputIterator __first, _InputIterator __last)
-{
-    for (_InputIterator __s = __first; __s != __last; ++__s)
-        __v_.push_back(*__s & 0xFFFFFFFF);
+template <class _InputIterator>
+void seed_seq::init(_InputIterator __first, _InputIterator __last) {
 }
 
-template<class _RandomAccessIterator>
-void
-seed_seq::generate(_RandomAccessIterator __first, _RandomAccessIterator __last)
-{
-    if (__first != __last)
-    {
-        _VSTD::fill(__first, __last, 0x8b8b8b8b);
-        const size_t __n = static_cast<size_t>(__last - __first);
-        const size_t __s = __v_.size();
-        const size_t __t = (__n >= 623) ? 11
-                         : (__n >= 68) ? 7
-                         : (__n >= 39) ? 5
-                         : (__n >= 7)  ? 3
+template <class _RandomAccessIterator>
+void seed_seq::generate(_RandomAccessIterator __first,
+                        _RandomAccessIterator __last) {
+  if (__first != __last) {
+    const size_t __t = (__n >= 623)  ? 11
                                      : (__n - 1) / 2;
-        const size_t __p = (__n - __t) / 2;
-        const size_t __q = __p + __t;
-        const size_t __m = _VSTD::max(__s + 1, __n);
-        // __k = 0;
-        {
-            result_type __r = 1664525 * _Tp(__first[0] ^ __first[__p]
-                                                      ^  __first[__n - 1]);
-            __first[__p] += __r;
-            __r += __s;
-            __first[__q] += __r;
-            __first[0] = __r;
-        }
-        for (size_t __k = 1; __k <= __s; ++__k)
-        {
-            const size_t __kmodn = __k % __n;
-            const size_t __kpmodn = (__k + __p) % __n;
-            result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn]
-                                           ^ __first[(__k - 1) % __n]);
-            __first[__kpmodn] += __r;
-            __r +=  __kmodn + __v_[__k-1];
-            __first[(__k + __q) % __n] += __r;
-            __first[__kmodn] = __r;
-        }
-        for (size_t __k = __s + 1; __k < __m; ++__k)
-        {
-            const size_t __kmodn = __k % __n;
-            const size_t __kpmodn = (__k + __p) % __n;
-            result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn]
-                                           ^ __first[(__k - 1) % __n]);
-            __first[__kpmodn] += __r;
-            __r +=  __kmodn;
-            __first[(__k + __q) % __n] += __r;
-            __first[__kmodn] = __r;
-        }
-        for (size_t __k = __m; __k < __m + __n; ++__k)
-        {
-            const size_t __kmodn = __k % __n;
-            const size_t __kpmodn = (__k + __p) % __n;
-            result_type __r = 1566083941 * _Tp(__first[__kmodn] +
-                                              __first[__kpmodn] +
-                                              __first[(__k - 1) % __n]);
-            __first[__kpmodn] ^= __r;
-            __r -= __kmodn;
-            __first[(__k + __q) % __n] ^= __r;
-            __first[__kmodn] = __r;
-        }
-    }
+      result_type __r =
+          1664525 * _Tp(__first[0] ^ __first[__p] ^ __first[__n - 1]);
+    for (size_t __k = 1; __k <= __s; ++__k) {
+      result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn] ^
+                                      __first[(__k - 1) % __n]);
+      __r += __kmodn + __v_[__k - 1];
+    for (size_t __k = __s + 1; __k < __m; ++__k) {
+      result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn] ^
+                                      __first[(__k - 1) % __n]);
+      __r += __kmodn;
+    for (size_t __k = __m; __k < __m + __n; ++__k) {
+      result_type __r = 1566083941 * _Tp(__first[__kmodn] + __first[__kpmodn] +
 }
 
 // generate_canonical
 
-template<class _RealType, size_t __bits, class _URNG>
-_RealType
-generate_canonical(_URNG& __g)
-{
-    const size_t _Dt = numeric_limits<_RealType>::digits;
-    const size_t __b = _Dt < __bits ? _Dt : __bits;
+template <class _RealType, size_t __bits, class _URNG>
+_RealType generate_canonical(_URNG& __g) {
 #ifdef _LIBCPP_CXX03_LANG
-    const size_t __logR = __log2<uint64_t, _URNG::_Max - _URNG::_Min + uint64_t(1)>::value;
+  const size_t __logR =
+      __log2<uint64_t, _URNG::_Max - _URNG::_Min + uint64_t(1)>::value;
 #else
-    const size_t __logR = __log2<uint64_t, _URNG::max() - _URNG::min() + uint64_t(1)>::value;
+  const size_t __logR =
+      __log2<uint64_t, _URNG::max() - _URNG::min() + uint64_t(1)>::value;
 #endif
-    const size_t __k = __b / __logR + (__b % __logR != 0) + (__b == 0);
-    const _RealType _Rp = static_cast<_RealType>(_URNG::max() - _URNG::min()) + _RealType(1);
-    _RealType __base = _Rp;
-    _RealType _Sp = __g() - _URNG::min();
-    for (size_t __i = 1; __i < __k; ++__i, __base *= _Rp)
-        _Sp += (__g() - _URNG::min()) * __base;
-    return _Sp / __base;
+  const _RealType _Rp =
+      static_cast<_RealType>(_URNG::max() - _URNG::min()) + _RealType(1);
 }
 
 // uniform_int_distribution
 
 // in <algorithm>
 
 template <class _CharT, class _Traits, class _IT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const uniform_int_distribution<_IT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _Ostream;
-    __os.flags(_Ostream::dec | _Ostream::left);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    return __os << __x.a() << __sp << __x.b();
+           const uniform_int_distribution<_IT>& __x) {
 }
 
 template <class _CharT, class _Traits, class _IT>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           uniform_int_distribution<_IT>& __x)
-{
-    typedef uniform_int_distribution<_IT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __a;
-    result_type __b;
-    __is >> __a >> __b;
-    if (!__is.fail())
-        __x.param(param_type(__a, __b));
-    return __is;
+basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is,
+                                           uniform_int_distribution<_IT>& __x) {
 }
 
 // uniform_real_distribution
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS uniform_real_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS uniform_real_distribution {
 public:
-    // types
-    typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __a_;
-        result_type __b_;
-    public:
-        typedef uniform_real_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __a = 0,
-                            result_type __b = 1)
-            : __a_(__a), __b_(__b) {}
+    explicit param_type(result_type __a = 0, result_type __b = 1)
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type a() const {return __a_;}
-        _LIBCPP_INLINE_VISIBILITY
-        result_type b() const {return __b_;}
+    result_type a() const { return __a_; }
+    result_type b() const { return __b_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    friend _LIBCPP_INLINE_VISIBILITY bool operator==(const param_type& __x,
+                                                     const param_type& __y) {
+      return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;
+    }
+    friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const param_type& __x,
+                                                     const param_type& __y) {
+      return !(__x == __y);
+    }
 
 private:
-    param_type __p_;
 
 public:
-    // constructors and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    uniform_real_distribution() : uniform_real_distribution(0) {}
-    explicit uniform_real_distribution(result_type __a, result_type __b = 1)
-        : __p_(param_type(__a, __b)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit uniform_real_distribution(result_type __a = 0, result_type __b = 1)
-        : __p_(param_type(__a, __b)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit uniform_real_distribution(const param_type& __p) : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g,
+                                                   const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type a() const {return __p_.a();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type b() const {return __p_.b();}
+  result_type a() const { return __p_.a(); }
+  result_type b() const { return __p_.b(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  param_type param() const { return __p_; }
+  void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return a();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return b();}
+  result_type min() const { return a(); }
+  result_type max() const { return b(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const uniform_real_distribution& __x,
-                        const uniform_real_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const uniform_real_distribution& __x,
-                        const uniform_real_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const uniform_real_distribution& __x,
+             const uniform_real_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const uniform_real_distribution& __x,
+             const uniform_real_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
-template<class _RealType>
-template<class _URNG>
-inline
-typename uniform_real_distribution<_RealType>::result_type
-uniform_real_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    return (__p.b() - __p.a())
-        * _VSTD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g)
-        + __p.a();
+template <class _RealType>
+template <class _URNG>
+inline typename uniform_real_distribution<_RealType>::result_type
+uniform_real_distribution<_RealType>::operator()(_URNG& __g,
+                                                 const param_type& __p) {
+  return (__p.b() - __p.a()) *
+             _VSTD::generate_canonical<_RealType,
+                                       numeric_limits<_RealType>::digits>(__g) +
+         __p.a();
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const uniform_real_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    return __os << __x.a() << __sp << __x.b();
+           const uniform_real_distribution<_RT>& __x) {
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
-           uniform_real_distribution<_RT>& __x)
-{
-    typedef uniform_real_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __a;
-    result_type __b;
-    __is >> __a >> __b;
-    if (!__is.fail())
-        __x.param(param_type(__a, __b));
-    return __is;
+           uniform_real_distribution<_RT>& __x) {
 }
 
 // bernoulli_distribution
 
-class _LIBCPP_TEMPLATE_VIS bernoulli_distribution
-{
+class _LIBCPP_TEMPLATE_VIS bernoulli_distribution {
 public:
-    // types
-    typedef bool result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        double __p_;
-    public:
-        typedef bernoulli_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(double __p = 0.5) : __p_(__p) {}
 
-        _LIBCPP_INLINE_VISIBILITY
-        double p() const {return __p_;}
+    double p() const { return __p_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__p_ == __y.__p_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    friend _LIBCPP_INLINE_VISIBILITY bool operator==(const param_type& __x,
+                                                     const param_type& __y) {
+      return __x.__p_ == __y.__p_;
+    }
+    friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const param_type& __x,
+                                                     const param_type& __y) {
+      return !(__x == __y);
+    }
 
 private:
-    param_type __p_;
 
 public:
-    // constructors and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    bernoulli_distribution() : bernoulli_distribution(0.5) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit bernoulli_distribution(double __p) : __p_(param_type(__p)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit bernoulli_distribution(double __p = 0.5) : __p_(param_type(__p)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit bernoulli_distribution(const param_type& __p) : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g,
+                                                   const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    double p() const {return __p_.p();}
+  double p() const { return __p_.p(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  param_type param() const { return __p_; }
+  void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return false;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return true;}
+  result_type min() const { return false; }
+  result_type max() const { return true; }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const bernoulli_distribution& __x,
-                        const bernoulli_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const bernoulli_distribution& __x,
-                        const bernoulli_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const bernoulli_distribution& __x,
+             const bernoulli_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const bernoulli_distribution& __x,
+             const bernoulli_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
-template<class _URNG>
-inline
-bernoulli_distribution::result_type
-bernoulli_distribution::operator()(_URNG& __g, const param_type& __p)
-{
-    uniform_real_distribution<double> __gen;
-    return __gen(__g) < __p.p();
+template <class _URNG>
+inline bernoulli_distribution::result_type
+bernoulli_distribution::operator()(_URNG& __g, const param_type& __p) {
 }
 
 template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, const bernoulli_distribution& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    return __os << __x.p();
+basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os,
+                                           const bernoulli_distribution& __x) {
 }
 
 template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is, bernoulli_distribution& __x)
-{
-    typedef bernoulli_distribution _Eng;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    double __p;
-    __is >> __p;
-    if (!__is.fail())
-        __x.param(param_type(__p));
-    return __is;
+basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is,
+                                           bernoulli_distribution& __x) {
 }
 
 // binomial_distribution
 
-template<class _IntType = int>
-class _LIBCPP_TEMPLATE_VIS binomial_distribution
-{
+template <class _IntType = int>
+class _LIBCPP_TEMPLATE_VIS binomial_distribution {
 public:
-    // types
-    typedef _IntType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __t_;
-        double __p_;
-        double __pr_;
-        double __odds_ratio_;
-        result_type __r0_;
-    public:
-        typedef binomial_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+
 
-        explicit param_type(result_type __t = 1, double __p = 0.5);
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type t() const {return __t_;}
-        _LIBCPP_INLINE_VISIBILITY
-        double p() const {return __p_;}
+    result_type t() const { return __t_; }
+    double p() const { return __p_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__t_ == __y.__t_ && __x.__p_ == __y.__p_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
+    friend _LIBCPP_INLINE_VISIBILITY bool operator==(const param_type& __x,
+                                                     const param_type& __y) {
+      return __x.__t_ == __y.__t_ && __x.__p_ == __y.__p_;
+    }
+    friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const param_type& __x,
+                                                     const param_type& __y) {
+      return !(__x == __y);
+    }
 
-        friend class binomial_distribution;
-    };
 
 private:
-    param_type __p_;
 
 public:
-    // constructors and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    binomial_distribution() : binomial_distribution(1) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit binomial_distribution(result_type __t, double __p = 0.5)
-        : __p_(param_type(__t, __p)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit binomial_distribution(result_type __t = 1, double __p = 0.5)
-        : __p_(param_type(__t, __p)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit binomial_distribution(const param_type& __p) : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type t() const {return __p_.t();}
-    _LIBCPP_INLINE_VISIBILITY
-    double p() const {return __p_.p();}
+  result_type t() const { return __p_.t(); }
+  double p() const { return __p_.p(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  param_type param() const { return __p_; }
+  void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return t();}
+  result_type min() const { return 0; }
+  result_type max() const { return t(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const binomial_distribution& __x,
-                        const binomial_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const binomial_distribution& __x,
-                        const binomial_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const binomial_distribution& __x,
+             const binomial_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const binomial_distribution& __x,
+             const binomial_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 #ifndef _LIBCPP_MSVCRT_LIKE
-extern "C" double lgamma_r(double, int *);
+extern "C" double lgamma_r(double, int*);
 #endif
 
 inline _LIBCPP_INLINE_VISIBILITY double __libcpp_lgamma(double __d) {
 #if defined(_LIBCPP_MSVCRT_LIKE)
   return lgamma(__d);
 #else
   int __sign;
   return lgamma_r(__d, &__sign);
 #endif
 }
 
-template<class _IntType>
-binomial_distribution<_IntType>::param_type::param_type(const result_type __t, const double __p)
-    : __t_(__t), __p_(__p)
-{
-    if (0 < __p_ && __p_ < 1)
-    {
-        __r0_ = static_cast<result_type>((__t_ + 1) * __p_);
-        __pr_ = _VSTD::exp(__libcpp_lgamma(__t_ + 1.) -
-                           __libcpp_lgamma(__r0_ + 1.) -
-                           __libcpp_lgamma(__t_ - __r0_ + 1.) + __r0_ * _VSTD::log(__p_) +
-                           (__t_ - __r0_) * _VSTD::log(1 - __p_));
-        __odds_ratio_ = __p_ / (1 - __p_);
-    }
+template <class _IntType>
+binomial_distribution<_IntType>::param_type::param_type(const result_type __t,
+                                                        const double __p)
+    : __t_(__t), __p_(__p) {
+  if (0 < __p_ && __p_ < 1) {
+    __pr_ = _VSTD::exp(
+        __libcpp_lgamma(__t_ + 1.) - __libcpp_lgamma(__r0_ + 1.) -
 }
 
 // Reference: Kemp, C.D. (1986). `A modal method for generating binomial
 //           variables', Commun. Statist. - Theor. Meth. 15(3), 805-813.
-template<class _IntType>
-template<class _URNG>
-_IntType
-binomial_distribution<_IntType>::operator()(_URNG& __g, const param_type& __pr)
-{
-    if (__pr.__t_ == 0 || __pr.__p_ == 0)
-        return 0;
-    if (__pr.__p_ == 1)
-        return __pr.__t_;
-    uniform_real_distribution<double> __gen;
-    double __u = __gen(__g) - __pr.__pr_;
-    if (__u < 0)
-        return __pr.__r0_;
-    double __pu = __pr.__pr_;
-    double __pd = __pu;
-    result_type __ru = __pr.__r0_;
-    result_type __rd = __ru;
-    while (true)
-    {
-        bool __break = true;
-        if (__rd >= 1)
-        {
-            __pd *= __rd / (__pr.__odds_ratio_ * (__pr.__t_ - __rd + 1));
-            __u -= __pd;
-            __break = false;
-            if (__u < 0)
-                return __rd - 1;
-        }
-        if ( __rd != 0 )
-            --__rd;
-        ++__ru;
-        if (__ru <= __pr.__t_)
-        {
-            __pu *= (__pr.__t_ - __ru + 1) * __pr.__odds_ratio_ / __ru;
-            __u -= __pu;
-            __break = false;
-            if (__u < 0)
-                return __ru;
-        }
-        if (__break)
-            return 0;
-    }
+template <class _IntType>
+template <class _URNG>
+_IntType binomial_distribution<_IntType>::operator()(_URNG& __g,
+                                                     const param_type& __pr) {
+  while (true) {
+    if (__rd >= 1) {
+    if (__rd != 0)
+    if (__ru <= __pr.__t_) {
 }
 
 template <class _CharT, class _Traits, class _IntType>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const binomial_distribution<_IntType>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    return __os << __x.t() << __sp << __x.p();
+           const binomial_distribution<_IntType>& __x) {
 }
 
 template <class _CharT, class _Traits, class _IntType>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
-           binomial_distribution<_IntType>& __x)
-{
-    typedef binomial_distribution<_IntType> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __t;
-    double __p;
-    __is >> __t >> __p;
-    if (!__is.fail())
-        __x.param(param_type(__t, __p));
-    return __is;
+           binomial_distribution<_IntType>& __x) {
 }
 
 // exponential_distribution
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS exponential_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS exponential_distribution {
 public:
-    // types
-    typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __lambda_;
-    public:
-        typedef exponential_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __lambda = 1) : __lambda_(__lambda) {}
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type lambda() const {return __lambda_;}
+    result_type lambda() const { return __lambda_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__lambda_ == __y.__lambda_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    friend _LIBCPP_INLINE_VISIBILITY bool operator==(const param_type& __x,
+                                                     const param_type& __y) {
+      return __x.__lambda_ == __y.__lambda_;
+    }
+    friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const param_type& __x,
+                                                     const param_type& __y) {
+      return !(__x == __y);
+    }
 
 private:
-    param_type __p_;
 
 public:
-    // constructors and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    exponential_distribution() : exponential_distribution(1) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit exponential_distribution(result_type __lambda)
-        : __p_(param_type(__lambda)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit exponential_distribution(result_type __lambda = 1)
-        : __p_(param_type(__lambda)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit exponential_distribution(const param_type& __p) : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type lambda() const {return __p_.lambda();}
+  result_type lambda() const { return __p_.lambda(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  param_type param() const { return __p_; }
+  void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  result_type min() const { return 0; }
+  result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const exponential_distribution& __x,
-                        const exponential_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const exponential_distribution& __x,
-                        const exponential_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const exponential_distribution& __x,
+             const exponential_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const exponential_distribution& __x,
+             const exponential_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _RealType>
-template<class _URNG>
+template <class _URNG>
 _RealType
-exponential_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    return -_VSTD::log
-                  (
-                      result_type(1) -
-                      _VSTD::generate_canonical<result_type,
-                                       numeric_limits<result_type>::digits>(__g)
-                  )
-                  / __p.lambda();
+exponential_distribution<_RealType>::operator()(_URNG& __g,
+                                                const param_type& __p) {
+  return -_VSTD::log(
+                                       numeric_limits<result_type>::digits>(
+                 __g)) /
+         __p.lambda();
 }
 
 template <class _CharT, class _Traits, class _RealType>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const exponential_distribution<_RealType>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    return __os << __x.lambda();
+           const exponential_distribution<_RealType>& __x) {
 }
 
 template <class _CharT, class _Traits, class _RealType>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
-           exponential_distribution<_RealType>& __x)
-{
-    typedef exponential_distribution<_RealType> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __lambda;
-    __is >> __lambda;
-    if (!__is.fail())
-        __x.param(param_type(__lambda));
-    return __is;
+           exponential_distribution<_RealType>& __x) {
 }
 
 // normal_distribution
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS normal_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS normal_distribution {
 public:
-    // types
-    typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __mean_;
-        result_type __stddev_;
-    public:
-        typedef normal_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __mean = 0, result_type __stddev = 1)
-            : __mean_(__mean), __stddev_(__stddev) {}
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type mean() const {return __mean_;}
-        _LIBCPP_INLINE_VISIBILITY
-        result_type stddev() const {return __stddev_;}
+    result_type mean() const { return __mean_; }
+    result_type stddev() const { return __stddev_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__mean_ == __y.__mean_ && __x.__stddev_ == __y.__stddev_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    friend _LIBCPP_INLINE_VISIBILITY bool operator==(const param_type& __x,
+                                                     const param_type& __y) {
+      return __x.__mean_ == __y.__mean_ && __x.__stddev_ == __y.__stddev_;
+    }
+    friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const param_type& __x,
+                                                     const param_type& __y) {
+      return !(__x == __y);
+    }
 
 private:
-    param_type __p_;
-    result_type _V_;
-    bool _V_hot_;
 
 public:
-    // constructors and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    normal_distribution() : normal_distribution(0) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit normal_distribution(result_type __mean, result_type __stddev = 1)
-        : __p_(param_type(__mean, __stddev)), _V_hot_(false) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit normal_distribution(result_type __mean = 0,
-                                 result_type __stddev = 1)
-        : __p_(param_type(__mean, __stddev)), _V_hot_(false) {}
+  explicit normal_distribution(result_type __mean = 0, result_type __stddev = 1)
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit normal_distribution(const param_type& __p)
-        : __p_(__p), _V_hot_(false) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {_V_hot_ = false;}
+  void reset() { _V_hot_ = false; }
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type mean() const {return __p_.mean();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type stddev() const {return __p_.stddev();}
+  result_type mean() const { return __p_.mean(); }
+  result_type stddev() const { return __p_.stddev(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  param_type param() const { return __p_; }
+  void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return -numeric_limits<result_type>::infinity();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  result_type min() const { return -numeric_limits<result_type>::infinity(); }
+  result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const normal_distribution& __x,
-                        const normal_distribution& __y)
-        {return __x.__p_ == __y.__p_ && __x._V_hot_ == __y._V_hot_ &&
-                (!__x._V_hot_ || __x._V_ == __y._V_);}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const normal_distribution& __x,
-                        const normal_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const normal_distribution& __x, const normal_distribution& __y) {
+    return __x.__p_ == __y.__p_ && __x._V_hot_ == __y._V_hot_ &&
+           (!__x._V_hot_ || __x._V_ == __y._V_);
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const normal_distribution& __x, const normal_distribution& __y) {
+    return !(__x == __y);
+  }
 
-    template <class _CharT, class _Traits, class _RT>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const normal_distribution<_RT>& __x);
+  friend basic_ostream<_CharT, _Traits>&
 
-    template <class _CharT, class _Traits, class _RT>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               normal_distribution<_RT>& __x);
+  friend basic_istream<_CharT, _Traits>&
 };
 
 template <class _RealType>
-template<class _URNG>
-_RealType
-normal_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    result_type _Up;
-    if (_V_hot_)
-    {
-        _V_hot_ = false;
-        _Up = _V_;
-    }
-    else
-    {
-        uniform_real_distribution<result_type> _Uni(-1, 1);
-        result_type __u;
-        result_type __v;
-        result_type __s;
-        do
-        {
-            __u = _Uni(__g);
-            __v = _Uni(__g);
-            __s = __u * __u + __v * __v;
-        } while (__s > 1 || __s == 0);
-        result_type _Fp = _VSTD::sqrt(-2 * _VSTD::log(__s) / __s);
-        _V_ = __v * _Fp;
-        _V_hot_ = true;
-        _Up = __u * _Fp;
-    }
-    return _Up * __p.stddev() + __p.mean();
+template <class _URNG>
+_RealType normal_distribution<_RealType>::operator()(_URNG& __g,
+                                                     const param_type& __p) {
+  if (_V_hot_) {
+  } else {
+    do {
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const normal_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    __os << __x.mean() << __sp << __x.stddev() << __sp << __x._V_hot_;
-    if (__x._V_hot_)
-        __os << __sp << __x._V_;
-    return __os;
+           const normal_distribution<_RT>& __x) {
 }
 
 template <class _CharT, class _Traits, class _RT>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           normal_distribution<_RT>& __x)
-{
-    typedef normal_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __mean;
-    result_type __stddev;
-    result_type _Vp = 0;
-    bool _V_hot = false;
-    __is >> __mean >> __stddev >> _V_hot;
-    if (_V_hot)
-        __is >> _Vp;
-    if (!__is.fail())
-    {
-        __x.param(param_type(__mean, __stddev));
-        __x._V_hot_ = _V_hot;
-        __x._V_ = _Vp;
-    }
-    return __is;
+basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is,
+                                           normal_distribution<_RT>& __x) {
+  if (!__is.fail()) {
 }
 
 // lognormal_distribution
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS lognormal_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS lognormal_distribution {
 public:
-    // types
-    typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        normal_distribution<result_type> __nd_;
-    public:
-        typedef lognormal_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __m = 0, result_type __s = 1)
-            : __nd_(__m, __s) {}
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type m() const {return __nd_.mean();}
-        _LIBCPP_INLINE_VISIBILITY
-        result_type s() const {return __nd_.stddev();}
+    result_type m() const { return __nd_.mean(); }
+    result_type s() const { return __nd_.stddev(); }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__nd_ == __y.__nd_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-        friend class lognormal_distribution;
+    friend _LIBCPP_INLINE_VISIBILITY bool operator==(const param_type& __x,
+                                                     const param_type& __y) {
+      return __x.__nd_ == __y.__nd_;
+    }
+    friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const param_type& __x,
+                                                     const param_type& __y) {
+      return !(__x == __y);
+    }
 
-        template <class _CharT, class _Traits, class _RT>
-        friend
-        basic_ostream<_CharT, _Traits>&
-        operator<<(basic_ostream<_CharT, _Traits>& __os,
-                   const lognormal_distribution<_RT>& __x);
+    friend basic_ostream<_CharT, _Traits>&
 
-        template <class _CharT, class _Traits, class _RT>
-        friend
-        basic_istream<_CharT, _Traits>&
-        operator>>(basic_istream<_CharT, _Traits>& __is,
-                   lognormal_distribution<_RT>& __x);
-    };
+    friend basic_istream<_CharT, _Traits>&
 
 private:
-    param_type __p_;
 
 public:
-    // constructor and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    lognormal_distribution() : lognormal_distribution(0) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit lognormal_distribution(result_type __m, result_type __s = 1)
-        : __p_(param_type(__m, __s)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit lognormal_distribution(result_type __m = 0,
-                                    result_type __s = 1)
-        : __p_(param_type(__m, __s)) {}
+  explicit lognormal_distribution(result_type __m = 0, result_type __s = 1)
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit lognormal_distribution(const param_type& __p)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {__p_.__nd_.reset();}
+  explicit lognormal_distribution(const param_type& __p) : __p_(__p) {}
+  void reset() { __p_.__nd_.reset(); }
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g, const param_type& __p)
-        {return _VSTD::exp(const_cast<normal_distribution<result_type>&>(__p.__nd_)(__g));}
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g,
+                                                   const param_type& __p) {
+    return _VSTD::exp(
+        const_cast<normal_distribution<result_type>&>(__p.__nd_)(__g));
+  }
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type m() const {return __p_.m();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type s() const {return __p_.s();}
+  result_type m() const { return __p_.m(); }
+  result_type s() const { return __p_.s(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  param_type param() const { return __p_; }
+  void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  result_type min() const { return 0; }
+  result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const lognormal_distribution& __x,
-                        const lognormal_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const lognormal_distribution& __x,
-                        const lognormal_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const lognormal_distribution& __x,
+             const lognormal_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const lognormal_distribution& __x,
+             const lognormal_distribution& __y) {
+    return !(__x == __y);
+  }
 
-    template <class _CharT, class _Traits, class _RT>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const lognormal_distribution<_RT>& __x);
+  friend basic_ostream<_CharT, _Traits>&
 
-    template <class _CharT, class _Traits, class _RT>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               lognormal_distribution<_RT>& __x);
+  friend basic_istream<_CharT, _Traits>&
 };
 
 template <class _CharT, class _Traits, class _RT>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_ostream<_CharT, _Traits>&
+inline _LIBCPP_INLINE_VISIBILITY basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const lognormal_distribution<_RT>& __x)
-{
-    return __os << __x.__p_.__nd_;
+           const lognormal_distribution<_RT>& __x) {
 }
 
 template <class _CharT, class _Traits, class _RT>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
+inline _LIBCPP_INLINE_VISIBILITY basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
-           lognormal_distribution<_RT>& __x)
-{
-    return __is >> __x.__p_.__nd_;
+           lognormal_distribution<_RT>& __x) {
 }
 
 // poisson_distribution
 
-template<class _IntType = int>
-class _LIBCPP_TEMPLATE_VIS poisson_distribution
-{
+template <class _IntType = int>
+class _LIBCPP_TEMPLATE_VIS poisson_distribution {
 public:
-    // types
-    typedef _IntType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        double __mean_;
-        double __s_;
-        double __d_;
-        double __l_;
-        double __omega_;
-        double __c0_;
-        double __c1_;
-        double __c2_;
-        double __c3_;
-        double __c_;
+  class _LIBCPP_TEMPLATE_VIS param_type {
 
-    public:
-        typedef poisson_distribution distribution_type;
 
-        explicit param_type(double __mean = 1.0);
 
-        _LIBCPP_INLINE_VISIBILITY
-        double mean() const {return __mean_;}
+    double mean() const { return __mean_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__mean_ == __y.__mean_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
+    friend _LIBCPP_INLINE_VISIBILITY bool operator==(const param_type& __x,
+                                                     const param_type& __y) {
+      return __x.__mean_ == __y.__mean_;
+    }
+    friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const param_type& __x,
+                                                     const param_type& __y) {
+      return !(__x == __y);
+    }
 
-        friend class poisson_distribution;
-    };
 
 private:
-    param_type __p_;
 
 public:
-    // constructors and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    poisson_distribution() : poisson_distribution(1.0) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit poisson_distribution(double __mean)
-        : __p_(__mean) {}
+  explicit poisson_distribution(double __mean) : __p_(__mean) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit poisson_distribution(double __mean = 1.0)
-        : __p_(__mean) {}
+  explicit poisson_distribution(double __mean = 1.0) : __p_(__mean) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit poisson_distribution(const param_type& __p) : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    double mean() const {return __p_.mean();}
+  double mean() const { return __p_.mean(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  param_type param() const { return __p_; }
+  void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::max();}
+  result_type min() const { return 0; }
+  result_type max() const { return numeric_limits<result_type>::max(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const poisson_distribution& __x,
-                        const poisson_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const poisson_distribution& __x,
-                        const poisson_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const poisson_distribution& __x, const poisson_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const poisson_distribution& __x, const poisson_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
-template<class _IntType>
+template <class _IntType>
 poisson_distribution<_IntType>::param_type::param_type(double __mean)
     // According to the standard `inf` is a valid input, but it causes the
     // distribution to hang, so we replace it with the maximum representable
     // mean.
-    : __mean_(isinf(__mean) ? numeric_limits<double>::max() : __mean)
-{
-    if (__mean_ < 10)
-    {
-        __s_ = 0;
-        __d_ = 0;
-        __l_ = _VSTD::exp(-__mean_);
-        __omega_ = 0;
-        __c3_ = 0;
-        __c2_ = 0;
-        __c1_ = 0;
-        __c0_ = 0;
-        __c_ = 0;
-    }
-    else
-    {
-        __s_ = _VSTD::sqrt(__mean_);
-        __d_ = 6 * __mean_ * __mean_;
-        __l_ = _VSTD::trunc(__mean_ - 1.1484);
-        __omega_ = .3989423 / __s_;
-        double __b1_ = .4166667E-1 / __mean_;
-        double __b2_ = .3 * __b1_ * __b1_;
-        __c3_ = .1428571 * __b1_ * __b2_;
-        __c2_ = __b2_ - 15. * __c3_;
-        __c1_ = __b1_ - 6. * __b2_ + 45. * __c3_;
-        __c0_ = 1. - __b1_ + 3. * __b2_ - 15. * __c3_;
-        __c_ = .1069 / __mean_;
-    }
+    : __mean_(isinf(__mean) ? numeric_limits<double>::max() : __mean) {
+  if (__mean_ < 10) {
+  } else {
 }
 
 template <class _IntType>
-template<class _URNG>
-_IntType
-poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
-{
-    double __tx;
-    uniform_real_distribution<double> __urd;
-    if (__pr.__mean_ < 10)
-    {
-         __tx = 0;
-        for (double __p = __urd(__urng); __p > __pr.__l_; ++__tx)
-            __p *= __urd(__urng);
-    }
-    else
-    {
-        double __difmuk;
-        double __g = __pr.__mean_ + __pr.__s_ * normal_distribution<double>()(__urng);
-        double __u;
-        if (__g > 0)
-        {
-            __tx = _VSTD::trunc(__g);
-            if (__tx >= __pr.__l_)
-                return _VSTD::__clamp_to_integral<result_type>(__tx);
-            __difmuk = __pr.__mean_ - __tx;
-            __u = __urd(__urng);
-            if (__pr.__d_ * __u >= __difmuk * __difmuk * __difmuk)
-                return _VSTD::__clamp_to_integral<result_type>(__tx);
-        }
-        exponential_distribution<double> __edist;
-        for (bool __using_exp_dist = false; true; __using_exp_dist = true)
-        {
-            double __e;
-            if (__using_exp_dist || __g <= 0)
-            {
-                double __t;
-                do
-                {
-                    __e = __edist(__urng);
-                    __u = __urd(__urng);
-                    __u += __u - 1;
-                    __t = 1.8 + (__u < 0 ? -__e : __e);
-                } while (__t <= -.6744);
-                __tx = _VSTD::trunc(__pr.__mean_ + __pr.__s_ * __t);
-                __difmuk = __pr.__mean_ - __tx;
-                __using_exp_dist = true;
-            }
-            double __px;
-            double __py;
-            if (__tx < 10 && __tx >= 0)
-            {
-                const double __fac[] = {1, 1, 2, 6, 24, 120, 720, 5040,
-                                             40320, 362880};
-                __px = -__pr.__mean_;
-                __py = _VSTD::pow(__pr.__mean_, (double)__tx) / __fac[static_cast<int>(__tx)];
-            }
-            else
-            {
-                double __del = .8333333E-1 / __tx;
-                __del -= 4.8 * __del * __del * __del;
-                double __v = __difmuk / __tx;
-                if (_VSTD::abs(__v) > 0.25)
-                    __px = __tx * _VSTD::log(1 + __v) - __difmuk - __del;
-                else
-                    __px = __tx * __v * __v * (((((((.1250060 * __v + -.1384794) *
-                           __v + .1421878) * __v + -.1661269) * __v + .2000118) *
-                           __v + -.2500068) * __v + .3333333) * __v + -.5) - __del;
-                __py = .3989423 / _VSTD::sqrt(__tx);
-            }
-            double __r = (0.5 - __difmuk) / __pr.__s_;
-            double __r2 = __r * __r;
-            double __fx = -0.5 * __r2;
-            double __fy = __pr.__omega_ * (((__pr.__c3_ * __r2 + __pr.__c2_) *
-                                        __r2 + __pr.__c1_) * __r2 + __pr.__c0_);
-            if (__using_exp_dist)
-            {
-                if (__pr.__c_ * _VSTD::abs(__u) <= __py * _VSTD::exp(__px + __e) -
-                                                   __fy * _VSTD::exp(__fx + __e))
-                    break;
-            }
-            else
-            {
-                if (__fy - __u * __fy <= __py * _VSTD::exp(__px - __fx))
-                    break;
-            }
-        }
-    }
-    return _VSTD::__clamp_to_integral<result_type>(__tx);
+template <class _URNG>
+_IntType poisson_distribution<_IntType>::operator()(_URNG& __urng,
+                                                    const param_type& __pr) {
+  if (__pr.__mean_ < 10) {
+  } else {
+    double __g =
+        __pr.__mean_ + __pr.__s_ * normal_distribution<double>()(__urng);
+    if (__g > 0) {
+    for (bool __using_exp_dist = false; true; __using_exp_dist = true) {
+      if (__using_exp_dist || __g <= 0) {
+        do {
+      if (__tx < 10 && __tx >= 0) {
+        const double __fac[] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};
+        __py = _VSTD::pow(__pr.__mean_, (double)__tx) /
+               __fac[static_cast<int>(__tx)];
+      } else {
+          __px =
+              __tx * __v * __v *
+                  (((((((.1250060 * __v + -.1384794) * __v + .1421878) * __v +
+                       -.1661269) *
+                          __v +
+                      .2000118) *
+                         __v +
+                     -.2500068) *
+                        __v +
+                    .3333333) *
+                       __v +
+                   -.5) -
+              __del;
+      double __fy =
+          __pr.__omega_ *
+          (((__pr.__c3_ * __r2 + __pr.__c2_) * __r2 + __pr.__c1_) * __r2 +
+           __pr.__c0_);
+      if (__using_exp_dist) {
+        if (__pr.__c_ * _VSTD::abs(__u) <=
+            __py * _VSTD::exp(__px + __e) - __fy * _VSTD::exp(__fx + __e))
+      } else {
 }
 
 template <class _CharT, class _Traits, class _IntType>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const poisson_distribution<_IntType>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    return __os << __x.mean();
+           const poisson_distribution<_IntType>& __x) {
 }
 
 template <class _CharT, class _Traits, class _IntType>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
-           poisson_distribution<_IntType>& __x)
-{
-    typedef poisson_distribution<_IntType> _Eng;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    double __mean;
-    __is >> __mean;
-    if (!__is.fail())
-        __x.param(param_type(__mean));
-    return __is;
+           poisson_distribution<_IntType>& __x) {
 }
 
 // weibull_distribution
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS weibull_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS weibull_distribution {
 public:
-    // types
-    typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __a_;
-        result_type __b_;
-    public:
-        typedef weibull_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __a = 1, result_type __b = 1)
-            : __a_(__a), __b_(__b) {}
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type a() const {return __a_;}
-        _LIBCPP_INLINE_VISIBILITY
-        result_type b() const {return __b_;}
+    result_type a() const { return __a_; }
+    result_type b() const { return __b_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    friend _LIBCPP_INLINE_VISIBILITY bool operator==(const param_type& __x,
+                                                     const param_type& __y) {
+      return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;
+    }
+    friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const param_type& __x,
+                                                     const param_type& __y) {
+      return !(__x == __y);
+    }
 
 private:
-    param_type __p_;
 
 public:
-    // constructor and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    weibull_distribution() : weibull_distribution(1) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit weibull_distribution(result_type __a, result_type __b = 1)
-        : __p_(param_type(__a, __b)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit weibull_distribution(result_type __a = 1, result_type __b = 1)
-        : __p_(param_type(__a, __b)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit weibull_distribution(const param_type& __p)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  explicit weibull_distribution(const param_type& __p) : __p_(__p) {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g, const param_type& __p)
-        {return __p.b() *
-            _VSTD::pow(exponential_distribution<result_type>()(__g), 1/__p.a());}
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g,
+                                                   const param_type& __p) {
+    return __p.b() * _VSTD::pow(exponential_distribution<result_type>()(__g),
+                                1 / __p.a());
+  }
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type a() const {return __p_.a();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type b() const {return __p_.b();}
+  result_type a() const { return __p_.a(); }
+  result_type b() const { return __p_.b(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  param_type param() const { return __p_; }
+  void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  result_type min() const { return 0; }
+  result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const weibull_distribution& __x,
-                        const weibull_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const weibull_distribution& __x,
-                        const weibull_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const weibull_distribution& __x, const weibull_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const weibull_distribution& __x, const weibull_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const weibull_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    __os << __x.a() << __sp << __x.b();
-    return __os;
+           const weibull_distribution<_RT>& __x) {
 }
 
 template <class _CharT, class _Traits, class _RT>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           weibull_distribution<_RT>& __x)
-{
-    typedef weibull_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __a;
-    result_type __b;
-    __is >> __a >> __b;
-    if (!__is.fail())
-        __x.param(param_type(__a, __b));
-    return __is;
+basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is,
+                                           weibull_distribution<_RT>& __x) {
 }
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS extreme_value_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS extreme_value_distribution {
 public:
-    // types
-    typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __a_;
-        result_type __b_;
-    public:
-        typedef extreme_value_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __a = 0, result_type __b = 1)
-            : __a_(__a), __b_(__b) {}
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type a() const {return __a_;}
-        _LIBCPP_INLINE_VISIBILITY
-        result_type b() const {return __b_;}
+    result_type a() const { return __a_; }
+    result_type b() const { return __b_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    friend _LIBCPP_INLINE_VISIBILITY bool operator==(const param_type& __x,
+                                                     const param_type& __y) {
+      return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;
+    }
+    friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const param_type& __x,
+                                                     const param_type& __y) {
+      return !(__x == __y);
+    }
 
 private:
-    param_type __p_;
 
 public:
-    // constructor and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    extreme_value_distribution() : extreme_value_distribution(0) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit extreme_value_distribution(result_type __a, result_type __b = 1)
-        : __p_(param_type(__a, __b)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit extreme_value_distribution(result_type __a = 0,
-                                        result_type __b = 1)
-        : __p_(param_type(__a, __b)) {}
+  explicit extreme_value_distribution(result_type __a = 0, result_type __b = 1)
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit extreme_value_distribution(const param_type& __p)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  explicit extreme_value_distribution(const param_type& __p) : __p_(__p) {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type a() const {return __p_.a();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type b() const {return __p_.b();}
+  result_type a() const { return __p_.a(); }
+  result_type b() const { return __p_.b(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  param_type param() const { return __p_; }
+  void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return -numeric_limits<result_type>::infinity();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  result_type min() const { return -numeric_limits<result_type>::infinity(); }
+  result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const extreme_value_distribution& __x,
-                        const extreme_value_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const extreme_value_distribution& __x,
-                        const extreme_value_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const extreme_value_distribution& __x,
+             const extreme_value_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const extreme_value_distribution& __x,
+             const extreme_value_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
-template<class _RealType>
-template<class _URNG>
+template <class _RealType>
+template <class _URNG>
 _RealType
-extreme_value_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    return __p.a() - __p.b() *
-         _VSTD::log(-_VSTD::log(1-uniform_real_distribution<result_type>()(__g)));
+extreme_value_distribution<_RealType>::operator()(_URNG& __g,
+                                                  const param_type& __p) {
+  return __p.a() -
+         __p.b() * _VSTD::log(-_VSTD::log(
+                       1 - uniform_real_distribution<result_type>()(__g)));
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const extreme_value_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    __os << __x.a() << __sp << __x.b();
-    return __os;
+           const extreme_value_distribution<_RT>& __x) {
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
-           extreme_value_distribution<_RT>& __x)
-{
-    typedef extreme_value_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __a;
-    result_type __b;
-    __is >> __a >> __b;
-    if (!__is.fail())
-        __x.param(param_type(__a, __b));
-    return __is;
+           extreme_value_distribution<_RT>& __x) {
 }
 
 // gamma_distribution
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS gamma_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS gamma_distribution {
 public:
-    // types
-    typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __alpha_;
-        result_type __beta_;
-    public:
-        typedef gamma_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __alpha = 1, result_type __beta = 1)
-            : __alpha_(__alpha), __beta_(__beta) {}
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type alpha() const {return __alpha_;}
-        _LIBCPP_INLINE_VISIBILITY
-        result_type beta() const {return __beta_;}
+    result_type alpha() const { return __alpha_; }
+    result_type beta() const { return __beta_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__alpha_ == __y.__alpha_ && __x.__beta_ == __y.__beta_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    friend _LIBCPP_INLINE_VISIBILITY bool operator==(const param_type& __x,
+                                                     const param_type& __y) {
+      return __x.__alpha_ == __y.__alpha_ && __x.__beta_ == __y.__beta_;
+    }
+    friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const param_type& __x,
+                                                     const param_type& __y) {
+      return !(__x == __y);
+    }
 
 private:
-    param_type __p_;
 
 public:
-    // constructors and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    gamma_distribution() : gamma_distribution(1) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit gamma_distribution(result_type __alpha, result_type __beta = 1)
-        : __p_(param_type(__alpha, __beta)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit gamma_distribution(result_type __alpha = 1,
-                                result_type __beta = 1)
-        : __p_(param_type(__alpha, __beta)) {}
+  explicit gamma_distribution(result_type __alpha = 1, result_type __beta = 1)
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit gamma_distribution(const param_type& __p)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  explicit gamma_distribution(const param_type& __p) : __p_(__p) {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type alpha() const {return __p_.alpha();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type beta() const {return __p_.beta();}
+  result_type alpha() const { return __p_.alpha(); }
+  result_type beta() const { return __p_.beta(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  param_type param() const { return __p_; }
+  void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  result_type min() const { return 0; }
+  result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const gamma_distribution& __x,
-                        const gamma_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const gamma_distribution& __x,
-                        const gamma_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const gamma_distribution& __x, const gamma_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const gamma_distribution& __x, const gamma_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _RealType>
-template<class _URNG>
-_RealType
-gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    result_type __a = __p.alpha();
-    uniform_real_distribution<result_type> __gen(0, 1);
-    exponential_distribution<result_type> __egen;
-    result_type __x;
-    if (__a == 1)
-        __x = __egen(__g);
-    else if (__a > 1)
-    {
-        const result_type __b = __a - 1;
-        const result_type __c = 3 * __a - result_type(0.75);
-        while (true)
-        {
-            const result_type __u = __gen(__g);
-            const result_type __v = __gen(__g);
-            const result_type __w = __u * (1 - __u);
-            if (__w != 0)
-            {
-                const result_type __y = _VSTD::sqrt(__c / __w) *
-                                        (__u - result_type(0.5));
-                __x = __b + __y;
-                if (__x >= 0)
-                {
-                    const result_type __z = 64 * __w * __w * __w * __v * __v;
-                    if (__z <= 1 - 2 * __y * __y / __x)
-                        break;
-                    if (_VSTD::log(__z) <= 2 * (__b * _VSTD::log(__x / __b) - __y))
-                        break;
-                }
-            }
-        }
-    }
-    else  // __a < 1
-    {
-        while (true)
-        {
-            const result_type __u = __gen(__g);
-            const result_type __es = __egen(__g);
-            if (__u <= 1 - __a)
-            {
-                __x = _VSTD::pow(__u, 1 / __a);
-                if (__x <= __es)
-                    break;
-            }
-            else
-            {
-                const result_type __e = -_VSTD::log((1-__u)/__a);
-                __x = _VSTD::pow(1 - __a + __a * __e, 1 / __a);
-                if (__x <= __e + __es)
-                    break;
-            }
-        }
-    }
-    return __x * __p.beta();
+template <class _URNG>
+_RealType gamma_distribution<_RealType>::operator()(_URNG& __g,
+                                                    const param_type& __p) {
+  else if (__a > 1) {
+    while (true) {
+      if (__w != 0) {
+        const result_type __y =
+            _VSTD::sqrt(__c / __w) * (__u - result_type(0.5));
+        if (__x >= 0) {
+  } else // __a < 1
+    while (true) {
+      if (__u <= 1 - __a) {
+      } else {
+        const result_type __e = -_VSTD::log((1 - __u) / __a);
 }
 
 template <class _CharT, class _Traits, class _RT>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const gamma_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    __os << __x.alpha() << __sp << __x.beta();
-    return __os;
+basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os,
+                                           const gamma_distribution<_RT>& __x) {
 }
 
 template <class _CharT, class _Traits, class _RT>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           gamma_distribution<_RT>& __x)
-{
-    typedef gamma_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __alpha;
-    result_type __beta;
-    __is >> __alpha >> __beta;
-    if (!__is.fail())
-        __x.param(param_type(__alpha, __beta));
-    return __is;
+basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is,
+                                           gamma_distribution<_RT>& __x) {
 }
 
 // negative_binomial_distribution
 
-template<class _IntType = int>
-class _LIBCPP_TEMPLATE_VIS negative_binomial_distribution
-{
+template <class _IntType = int>
+class _LIBCPP_TEMPLATE_VIS negative_binomial_distribution {
 public:
-    // types
-    typedef _IntType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __k_;
-        double __p_;
-    public:
-        typedef negative_binomial_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __k = 1, double __p = 0.5)
-            : __k_(__k), __p_(__p) {}
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type k() const {return __k_;}
-        _LIBCPP_INLINE_VISIBILITY
-        double p() const {return __p_;}
+    result_type k() const { return __k_; }
+    double p() const { return __p_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__k_ == __y.__k_ && __x.__p_ == __y.__p_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    friend _LIBCPP_INLINE_VISIBILITY bool operator==(const param_type& __x,
+                                                     const param_type& __y) {
+      return __x.__k_ == __y.__k_ && __x.__p_ == __y.__p_;
+    }
+    friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const param_type& __x,
+                                                     const param_type& __y) {
+      return !(__x == __y);
+    }
 
 private:
-    param_type __p_;
 
 public:
-    // constructor and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    negative_binomial_distribution() : negative_binomial_distribution(1) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit negative_binomial_distribution(result_type __k, double __p = 0.5)
-        : __p_(__k, __p) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit negative_binomial_distribution(result_type __k = 1,
-                                            double __p = 0.5)
-        : __p_(__k, __p) {}
+  explicit negative_binomial_distribution(result_type __k = 1, double __p = 0.5)
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit negative_binomial_distribution(const param_type& __p) : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type k() const {return __p_.k();}
-    _LIBCPP_INLINE_VISIBILITY
-    double p() const {return __p_.p();}
+  result_type k() const { return __p_.k(); }
+  double p() const { return __p_.p(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  param_type param() const { return __p_; }
+  void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::max();}
+  result_type min() const { return 0; }
+  result_type max() const { return numeric_limits<result_type>::max(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const negative_binomial_distribution& __x,
-                        const negative_binomial_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const negative_binomial_distribution& __x,
-                        const negative_binomial_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const negative_binomial_distribution& __x,
+             const negative_binomial_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const negative_binomial_distribution& __x,
+             const negative_binomial_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _IntType>
-template<class _URNG>
+template <class _URNG>
 _IntType
-negative_binomial_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
-{
-    result_type __k = __pr.k();
-    double __p = __pr.p();
-    if (__k <= 21 * __p)
-    {
-        bernoulli_distribution __gen(__p);
-        result_type __f = 0;
-        result_type __s = 0;
-        while (__s < __k)
-        {
-            if (__gen(__urng))
-                ++__s;
-            else
-                ++__f;
-        }
-        return __f;
-    }
-    return poisson_distribution<result_type>(gamma_distribution<double>
-                                            (__k, (1-__p)/__p)(__urng))(__urng);
+negative_binomial_distribution<_IntType>::operator()(_URNG& __urng,
+                                                     const param_type& __pr) {
+  if (__k <= 21 * __p) {
+    while (__s < __k) {
+  return poisson_distribution<result_type>(
+      gamma_distribution<double>(__k, (1 - __p) / __p)(__urng))(__urng);
 }
 
 template <class _CharT, class _Traits, class _IntType>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const negative_binomial_distribution<_IntType>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    return __os << __x.k() << __sp << __x.p();
+           const negative_binomial_distribution<_IntType>& __x) {
 }
 
 template <class _CharT, class _Traits, class _IntType>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
-           negative_binomial_distribution<_IntType>& __x)
-{
-    typedef negative_binomial_distribution<_IntType> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __k;
-    double __p;
-    __is >> __k >> __p;
-    if (!__is.fail())
-        __x.param(param_type(__k, __p));
-    return __is;
+           negative_binomial_distribution<_IntType>& __x) {
 }
 
 // geometric_distribution
 
-template<class _IntType = int>
-class _LIBCPP_TEMPLATE_VIS geometric_distribution
-{
+template <class _IntType = int>
+class _LIBCPP_TEMPLATE_VIS geometric_distribution {
 public:
-    // types
-    typedef _IntType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        double __p_;
-    public:
-        typedef geometric_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(double __p = 0.5) : __p_(__p) {}
 
-        _LIBCPP_INLINE_VISIBILITY
-        double p() const {return __p_;}
+    double p() const { return __p_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__p_ == __y.__p_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    friend _LIBCPP_INLINE_VISIBILITY bool operator==(const param_type& __x,
+                                                     const param_type& __y) {
+      return __x.__p_ == __y.__p_;
+    }
+    friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const param_type& __x,
+                                                     const param_type& __y) {
+      return !(__x == __y);
+    }
 
 private:
-    param_type __p_;
 
 public:
-    // constructors and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    geometric_distribution() : geometric_distribution(0.5) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit geometric_distribution(double __p)
-        : __p_(__p) {}
+  explicit geometric_distribution(double __p) : __p_(__p) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit geometric_distribution(double __p = 0.5)
-        : __p_(__p) {}
+  explicit geometric_distribution(double __p = 0.5) : __p_(__p) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit geometric_distribution(const param_type& __p) : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g, const param_type& __p)
-        {return negative_binomial_distribution<result_type>(1, __p.p())(__g);}
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g,
+                                                   const param_type& __p) {
+    return negative_binomial_distribution<result_type>(1, __p.p())(__g);
+  }
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    double p() const {return __p_.p();}
+  double p() const { return __p_.p(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  param_type param() const { return __p_; }
+  void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::max();}
+  result_type min() const { return 0; }
+  result_type max() const { return numeric_limits<result_type>::max(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const geometric_distribution& __x,
-                        const geometric_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const geometric_distribution& __x,
-                        const geometric_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const geometric_distribution& __x,
+             const geometric_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const geometric_distribution& __x,
+             const geometric_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _CharT, class _Traits, class _IntType>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const geometric_distribution<_IntType>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    return __os << __x.p();
+           const geometric_distribution<_IntType>& __x) {
 }
 
 template <class _CharT, class _Traits, class _IntType>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
-           geometric_distribution<_IntType>& __x)
-{
-    typedef geometric_distribution<_IntType> _Eng;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    double __p;
-    __is >> __p;
-    if (!__is.fail())
-        __x.param(param_type(__p));
-    return __is;
+           geometric_distribution<_IntType>& __x) {
 }
 
 // chi_squared_distribution
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS chi_squared_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS chi_squared_distribution {
 public:
-    // types
-    typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __n_;
-    public:
-        typedef chi_squared_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __n = 1) : __n_(__n) {}
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type n() const {return __n_;}
+    result_type n() const { return __n_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__n_ == __y.__n_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    friend _LIBCPP_INLINE_VISIBILITY bool operator==(const param_type& __x,
+                                                     const param_type& __y) {
+      return __x.__n_ == __y.__n_;
+    }
+    friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const param_type& __x,
+                                                     const param_type& __y) {
+      return !(__x == __y);
+    }
 
 private:
-    param_type __p_;
 
 public:
-    // constructor and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    chi_squared_distribution() : chi_squared_distribution(1) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit chi_squared_distribution(result_type __n)
-        : __p_(param_type(__n)) {}
+  explicit chi_squared_distribution(result_type __n) : __p_(param_type(__n)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit chi_squared_distribution(result_type __n = 1)
-        : __p_(param_type(__n)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit chi_squared_distribution(const param_type& __p)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  explicit chi_squared_distribution(const param_type& __p) : __p_(__p) {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g, const param_type& __p)
-        {return gamma_distribution<result_type>(__p.n() / 2, 2)(__g);}
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g,
+                                                   const param_type& __p) {
+    return gamma_distribution<result_type>(__p.n() / 2, 2)(__g);
+  }
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type n() const {return __p_.n();}
+  result_type n() const { return __p_.n(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  param_type param() const { return __p_; }
+  void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  result_type min() const { return 0; }
+  result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const chi_squared_distribution& __x,
-                        const chi_squared_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const chi_squared_distribution& __x,
-                        const chi_squared_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const chi_squared_distribution& __x,
+             const chi_squared_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const chi_squared_distribution& __x,
+             const chi_squared_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const chi_squared_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    __os << __x.n();
-    return __os;
+           const chi_squared_distribution<_RT>& __x) {
 }
 
 template <class _CharT, class _Traits, class _RT>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           chi_squared_distribution<_RT>& __x)
-{
-    typedef chi_squared_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __n;
-    __is >> __n;
-    if (!__is.fail())
-        __x.param(param_type(__n));
-    return __is;
+basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is,
+                                           chi_squared_distribution<_RT>& __x) {
 }
 
 // cauchy_distribution
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS cauchy_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS cauchy_distribution {
 public:
-    // types
-    typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __a_;
-        result_type __b_;
-    public:
-        typedef cauchy_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __a = 0, result_type __b = 1)
-            : __a_(__a), __b_(__b) {}
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type a() const {return __a_;}
-        _LIBCPP_INLINE_VISIBILITY
-        result_type b() const {return __b_;}
+    result_type a() const { return __a_; }
+    result_type b() const { return __b_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    friend _LIBCPP_INLINE_VISIBILITY bool operator==(const param_type& __x,
+                                                     const param_type& __y) {
+      return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;
+    }
+    friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const param_type& __x,
+                                                     const param_type& __y) {
+      return !(__x == __y);
+    }
 
 private:
-    param_type __p_;
 
 public:
-    // constructor and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    cauchy_distribution() : cauchy_distribution(0) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit cauchy_distribution(result_type __a, result_type __b = 1)
-        : __p_(param_type(__a, __b)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit cauchy_distribution(result_type __a = 0, result_type __b = 1)
-        : __p_(param_type(__a, __b)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit cauchy_distribution(const param_type& __p)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  explicit cauchy_distribution(const param_type& __p) : __p_(__p) {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g,
+                                                   const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type a() const {return __p_.a();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type b() const {return __p_.b();}
+  result_type a() const { return __p_.a(); }
+  result_type b() const { return __p_.b(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  param_type param() const { return __p_; }
+  void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return -numeric_limits<result_type>::infinity();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  result_type min() const { return -numeric_limits<result_type>::infinity(); }
+  result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const cauchy_distribution& __x,
-                        const cauchy_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const cauchy_distribution& __x,
-                        const cauchy_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const cauchy_distribution& __x, const cauchy_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const cauchy_distribution& __x, const cauchy_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _RealType>
-template<class _URNG>
-inline
-_RealType
-cauchy_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    uniform_real_distribution<result_type> __gen;
-    // purposefully let tan arg get as close to pi/2 as it wants, tan will return a finite
-    return __p.a() + __p.b() * _VSTD::tan(3.1415926535897932384626433832795 * __gen(__g));
+template <class _URNG>
+inline _RealType
+cauchy_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) {
+  return __p.a() +
+         __p.b() * _VSTD::tan(3.1415926535897932384626433832795 * __gen(__g));
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const cauchy_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    __os << __x.a() << __sp << __x.b();
-    return __os;
+           const cauchy_distribution<_RT>& __x) {
 }
 
 template <class _CharT, class _Traits, class _RT>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           cauchy_distribution<_RT>& __x)
-{
-    typedef cauchy_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __a;
-    result_type __b;
-    __is >> __a >> __b;
-    if (!__is.fail())
-        __x.param(param_type(__a, __b));
-    return __is;
+basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is,
+                                           cauchy_distribution<_RT>& __x) {
 }
 
 // fisher_f_distribution
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS fisher_f_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS fisher_f_distribution {
 public:
-    // types
-    typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __m_;
-        result_type __n_;
-    public:
-        typedef fisher_f_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __m = 1, result_type __n = 1)
-            : __m_(__m), __n_(__n) {}
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type m() const {return __m_;}
-        _LIBCPP_INLINE_VISIBILITY
-        result_type n() const {return __n_;}
+    result_type m() const { return __m_; }
+    result_type n() const { return __n_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__m_ == __y.__m_ && __x.__n_ == __y.__n_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    friend _LIBCPP_INLINE_VISIBILITY bool operator==(const param_type& __x,
+                                                     const param_type& __y) {
+      return __x.__m_ == __y.__m_ && __x.__n_ == __y.__n_;
+    }
+    friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const param_type& __x,
+                                                     const param_type& __y) {
+      return !(__x == __y);
+    }
 
 private:
-    param_type __p_;
 
 public:
-    // constructor and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    fisher_f_distribution() : fisher_f_distribution(1) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit fisher_f_distribution(result_type __m, result_type __n = 1)
-        : __p_(param_type(__m, __n)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit fisher_f_distribution(result_type __m = 1, result_type __n = 1)
-        : __p_(param_type(__m, __n)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit fisher_f_distribution(const param_type& __p)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  explicit fisher_f_distribution(const param_type& __p) : __p_(__p) {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type m() const {return __p_.m();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type n() const {return __p_.n();}
+  result_type m() const { return __p_.m(); }
+  result_type n() const { return __p_.n(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  param_type param() const { return __p_; }
+  void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  result_type min() const { return 0; }
+  result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const fisher_f_distribution& __x,
-                        const fisher_f_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const fisher_f_distribution& __x,
-                        const fisher_f_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const fisher_f_distribution& __x,
+             const fisher_f_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const fisher_f_distribution& __x,
+             const fisher_f_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _RealType>
-template<class _URNG>
-_RealType
-fisher_f_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    gamma_distribution<result_type> __gdm(__p.m() * result_type(.5));
-    gamma_distribution<result_type> __gdn(__p.n() * result_type(.5));
-    return __p.n() * __gdm(__g) / (__p.m() * __gdn(__g));
+template <class _URNG>
+_RealType fisher_f_distribution<_RealType>::operator()(_URNG& __g,
+                                                       const param_type& __p) {
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const fisher_f_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    __os << __x.m() << __sp << __x.n();
-    return __os;
+           const fisher_f_distribution<_RT>& __x) {
 }
 
 template <class _CharT, class _Traits, class _RT>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           fisher_f_distribution<_RT>& __x)
-{
-    typedef fisher_f_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __m;
-    result_type __n;
-    __is >> __m >> __n;
-    if (!__is.fail())
-        __x.param(param_type(__m, __n));
-    return __is;
+basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is,
+                                           fisher_f_distribution<_RT>& __x) {
 }
 
 // student_t_distribution
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS student_t_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS student_t_distribution {
 public:
-    // types
-    typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __n_;
-    public:
-        typedef student_t_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __n = 1) : __n_(__n) {}
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type n() const {return __n_;}
+    result_type n() const { return __n_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__n_ == __y.__n_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    friend _LIBCPP_INLINE_VISIBILITY bool operator==(const param_type& __x,
+                                                     const param_type& __y) {
+      return __x.__n_ == __y.__n_;
+    }
+    friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const param_type& __x,
+                                                     const param_type& __y) {
+      return !(__x == __y);
+    }
 
 private:
-    param_type __p_;
-    normal_distribution<result_type> __nd_;
 
 public:
-    // constructor and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    student_t_distribution() : student_t_distribution(1) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit student_t_distribution(result_type __n)
-        : __p_(param_type(__n)) {}
+  explicit student_t_distribution(result_type __n) : __p_(param_type(__n)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit student_t_distribution(result_type __n = 1)
-        : __p_(param_type(__n)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit student_t_distribution(const param_type& __p)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {__nd_.reset();}
+  explicit student_t_distribution(const param_type& __p) : __p_(__p) {}
+  void reset() { __nd_.reset(); }
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type n() const {return __p_.n();}
+  result_type n() const { return __p_.n(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  param_type param() const { return __p_; }
+  void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return -numeric_limits<result_type>::infinity();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  result_type min() const { return -numeric_limits<result_type>::infinity(); }
+  result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const student_t_distribution& __x,
-                        const student_t_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const student_t_distribution& __x,
-                        const student_t_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const student_t_distribution& __x,
+             const student_t_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const student_t_distribution& __x,
+             const student_t_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _RealType>
-template<class _URNG>
-_RealType
-student_t_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    gamma_distribution<result_type> __gd(__p.n() * .5, 2);
-    return __nd_(__g) * _VSTD::sqrt(__p.n()/__gd(__g));
+template <class _URNG>
+_RealType student_t_distribution<_RealType>::operator()(_URNG& __g,
+                                                        const param_type& __p) {
+  return __nd_(__g) * _VSTD::sqrt(__p.n() / __gd(__g));
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const student_t_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    __os << __x.n();
-    return __os;
+           const student_t_distribution<_RT>& __x) {
 }
 
 template <class _CharT, class _Traits, class _RT>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           student_t_distribution<_RT>& __x)
-{
-    typedef student_t_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __n;
-    __is >> __n;
-    if (!__is.fail())
-        __x.param(param_type(__n));
-    return __is;
+basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is,
+                                           student_t_distribution<_RT>& __x) {
 }
 
 // discrete_distribution
 
-template<class _IntType = int>
-class _LIBCPP_TEMPLATE_VIS discrete_distribution
-{
+template <class _IntType = int>
+class _LIBCPP_TEMPLATE_VIS discrete_distribution {
 public:
-    // types
-    typedef _IntType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        vector<double> __p_;
-    public:
-        typedef discrete_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+
 
-        _LIBCPP_INLINE_VISIBILITY
-        param_type() {}
-        template<class _InputIterator>
-            _LIBCPP_INLINE_VISIBILITY
-            param_type(_InputIterator __f, _InputIterator __l)
-            : __p_(__f, __l) {__init();}
+    template <class _InputIterator>
+    _LIBCPP_INLINE_VISIBILITY param_type(_InputIterator __f, _InputIterator __l)
+        : __p_(__f, __l) {
+      __init();
+    }
 #ifndef _LIBCPP_CXX03_LANG
-        _LIBCPP_INLINE_VISIBILITY
-        param_type(initializer_list<double> __wl)
-            : __p_(__wl.begin(), __wl.end()) {__init();}
-#endif  // _LIBCPP_CXX03_LANG
-        template<class _UnaryOperation>
-            param_type(size_t __nw, double __xmin, double __xmax,
-                       _UnaryOperation __fw);
+    param_type(initializer_list<double> __wl) : __p_(__wl.begin(), __wl.end()) {
+      __init();
+    }
+#endif // _LIBCPP_CXX03_LANG
+    template <class _UnaryOperation>
+    param_type(size_t __nw, double __xmin, double __xmax, _UnaryOperation __fw);
 
-        vector<double> probabilities() const;
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__p_ == __y.__p_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
+    friend _LIBCPP_INLINE_VISIBILITY bool operator==(const param_type& __x,
+                                                     const param_type& __y) {
+      return __x.__p_ == __y.__p_;
+    }
+    friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const param_type& __x,
+                                                     const param_type& __y) {
+      return !(__x == __y);
+    }
 
-    private:
-        void __init();
 
-        friend class discrete_distribution;
 
-        template <class _CharT, class _Traits, class _IT>
-        friend
-        basic_ostream<_CharT, _Traits>&
-        operator<<(basic_ostream<_CharT, _Traits>& __os,
-                   const discrete_distribution<_IT>& __x);
+    friend basic_ostream<_CharT, _Traits>&
 
-        template <class _CharT, class _Traits, class _IT>
-        friend
-        basic_istream<_CharT, _Traits>&
-        operator>>(basic_istream<_CharT, _Traits>& __is,
-                   discrete_distribution<_IT>& __x);
-    };
+    friend basic_istream<_CharT, _Traits>&
 
 private:
-    param_type __p_;
 
 public:
-    // constructor and reset functions
-    _LIBCPP_INLINE_VISIBILITY
-    discrete_distribution() {}
-    template<class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        discrete_distribution(_InputIterator __f, _InputIterator __l)
-            : __p_(__f, __l) {}
+  template <class _InputIterator>
+  _LIBCPP_INLINE_VISIBILITY discrete_distribution(_InputIterator __f,
+                                                  _InputIterator __l)
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    discrete_distribution(initializer_list<double> __wl)
-        : __p_(__wl) {}
-#endif  // _LIBCPP_CXX03_LANG
-    template<class _UnaryOperation>
-        _LIBCPP_INLINE_VISIBILITY
-        discrete_distribution(size_t __nw, double __xmin, double __xmax,
+  discrete_distribution(initializer_list<double> __wl) : __p_(__wl) {}
+#endif // _LIBCPP_CXX03_LANG
+  template <class _UnaryOperation>
+  _LIBCPP_INLINE_VISIBILITY discrete_distribution(size_t __nw, double __xmin,
+                                                  double __xmax,
                                                   _UnaryOperation __fw)
-        : __p_(__nw, __xmin, __xmax, __fw) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit discrete_distribution(const param_type& __p)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  explicit discrete_distribution(const param_type& __p) : __p_(__p) {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    vector<double> probabilities() const {return __p_.probabilities();}
+  vector<double> probabilities() const { return __p_.probabilities(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  param_type param() const { return __p_; }
+  void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return __p_.__p_.size();}
+  result_type min() const { return 0; }
+  result_type max() const { return __p_.__p_.size(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const discrete_distribution& __x,
-                        const discrete_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const discrete_distribution& __x,
-                        const discrete_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const discrete_distribution& __x,
+             const discrete_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const discrete_distribution& __x,
+             const discrete_distribution& __y) {
+    return !(__x == __y);
+  }
 
-    template <class _CharT, class _Traits, class _IT>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const discrete_distribution<_IT>& __x);
+  friend basic_ostream<_CharT, _Traits>&
 
-    template <class _CharT, class _Traits, class _IT>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               discrete_distribution<_IT>& __x);
+  friend basic_istream<_CharT, _Traits>&
 };
 
-template<class _IntType>
-template<class _UnaryOperation>
+template <class _IntType>
+template <class _UnaryOperation>
 discrete_distribution<_IntType>::param_type::param_type(size_t __nw,
                                                         double __xmin,
                                                         double __xmax,
-                                                        _UnaryOperation __fw)
-{
-    if (__nw > 1)
-    {
-        __p_.reserve(__nw - 1);
-        double __d = (__xmax - __xmin) / __nw;
-        double __d2 = __d / 2;
-        for (size_t __k = 0; __k < __nw; ++__k)
-            __p_.push_back(__fw(__xmin + __k * __d + __d2));
-        __init();
-    }
+                                                        _UnaryOperation __fw) {
+  if (__nw > 1) {
 }
 
-template<class _IntType>
-void
-discrete_distribution<_IntType>::param_type::__init()
-{
-    if (!__p_.empty())
-    {
-        if (__p_.size() > 1)
-        {
-            double __s = _VSTD::accumulate(__p_.begin(), __p_.end(), 0.0);
-            for (_VSTD::vector<double>::iterator __i = __p_.begin(), __e = __p_.end();
-                                                                       __i < __e; ++__i)
-                *__i /= __s;
-            vector<double> __t(__p_.size() - 1);
-            _VSTD::partial_sum(__p_.begin(), __p_.end() - 1, __t.begin());
-            swap(__p_, __t);
-        }
-        else
-        {
-            __p_.clear();
-            __p_.shrink_to_fit();
-        }
-    }
+template <class _IntType>
+void discrete_distribution<_IntType>::param_type::__init() {
+  if (!__p_.empty()) {
+    if (__p_.size() > 1) {
+    } else {
 }
 
-template<class _IntType>
+template <class _IntType>
 vector<double>
-discrete_distribution<_IntType>::param_type::probabilities() const
-{
-    size_t __n = __p_.size();
-    _VSTD::vector<double> __p(__n+1);
-    _VSTD::adjacent_difference(__p_.begin(), __p_.end(), __p.begin());
-    if (__n > 0)
-        __p[__n] = 1 - __p_[__n-1];
-    else
-        __p[0] = 1;
-    return __p;
+discrete_distribution<_IntType>::param_type::probabilities() const {
+  _VSTD::vector<double> __p(__n + 1);
+    __p[__n] = 1 - __p_[__n - 1];
 }
 
-template<class _IntType>
-template<class _URNG>
-_IntType
-discrete_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p)
-{
-    uniform_real_distribution<double> __gen;
-    return static_cast<_IntType>(
-           _VSTD::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) -
-                                                              __p.__p_.begin());
+template <class _IntType>
+template <class _URNG>
+_IntType discrete_distribution<_IntType>::operator()(_URNG& __g,
+                                                     const param_type& __p) {
 }
 
 template <class _CharT, class _Traits, class _IT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const discrete_distribution<_IT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    size_t __n = __x.__p_.__p_.size();
-    __os << __n;
-    for (size_t __i = 0; __i < __n; ++__i)
-        __os << __sp << __x.__p_.__p_[__i];
-    return __os;
+           const discrete_distribution<_IT>& __x) {
 }
 
 template <class _CharT, class _Traits, class _IT>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           discrete_distribution<_IT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    size_t __n;
-    __is >> __n;
-    vector<double> __p(__n);
-    for (size_t __i = 0; __i < __n; ++__i)
-        __is >> __p[__i];
-    if (!__is.fail())
-        swap(__x.__p_.__p_, __p);
-    return __is;
+basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is,
+                                           discrete_distribution<_IT>& __x) {
 }
 
 // piecewise_constant_distribution
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS piecewise_constant_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS piecewise_constant_distribution {
 public:
-    // types
-    typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        vector<result_type> __b_;
-        vector<result_type> __densities_;
-        vector<result_type> __areas_;
-    public:
-        typedef piecewise_constant_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+
 
-        param_type();
-        template<class _InputIteratorB, class _InputIteratorW>
-            param_type(_InputIteratorB __fB, _InputIteratorB __lB,
-                       _InputIteratorW __fW);
+    template <class _InputIteratorB, class _InputIteratorW>
 #ifndef _LIBCPP_CXX03_LANG
-        template<class _UnaryOperation>
-            param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
-#endif  // _LIBCPP_CXX03_LANG
-        template<class _UnaryOperation>
-            param_type(size_t __nw, result_type __xmin, result_type __xmax,
-                       _UnaryOperation __fw);
-        param_type(param_type const&) = default;
-        param_type & operator=(const param_type& __rhs);
+    template <class _UnaryOperation>
+#endif // _LIBCPP_CXX03_LANG
+    template <class _UnaryOperation>
+    param_type& operator=(const param_type& __rhs);
 
-        _LIBCPP_INLINE_VISIBILITY
-        vector<result_type> intervals() const {return __b_;}
-        _LIBCPP_INLINE_VISIBILITY
-        vector<result_type> densities() const {return __densities_;}
+    vector<result_type> intervals() const { return __b_; }
+    vector<result_type> densities() const { return __densities_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
+    friend _LIBCPP_INLINE_VISIBILITY bool operator==(const param_type& __x,
+                                                     const param_type& __y) {
+      return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;
+    }
+    friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const param_type& __x,
+                                                     const param_type& __y) {
+      return !(__x == __y);
+    }
 
-    private:
-        void __init();
 
-        friend class piecewise_constant_distribution;
 
-        template <class _CharT, class _Traits, class _RT>
-        friend
-        basic_ostream<_CharT, _Traits>&
-        operator<<(basic_ostream<_CharT, _Traits>& __os,
-                   const piecewise_constant_distribution<_RT>& __x);
+    friend basic_ostream<_CharT, _Traits>&
 
-        template <class _CharT, class _Traits, class _RT>
-        friend
-        basic_istream<_CharT, _Traits>&
-        operator>>(basic_istream<_CharT, _Traits>& __is,
-                   piecewise_constant_distribution<_RT>& __x);
-    };
+    friend basic_istream<_CharT, _Traits>&
 
 private:
-    param_type __p_;
 
 public:
-    // constructor and reset functions
-    _LIBCPP_INLINE_VISIBILITY
-    piecewise_constant_distribution() {}
-    template<class _InputIteratorB, class _InputIteratorW>
-        _LIBCPP_INLINE_VISIBILITY
-        piecewise_constant_distribution(_InputIteratorB __fB,
-                                        _InputIteratorB __lB,
-                                        _InputIteratorW __fW)
-        : __p_(__fB, __lB, __fW) {}
+  template <class _InputIteratorB, class _InputIteratorW>
+  piecewise_constant_distribution(_InputIteratorB __fB, _InputIteratorB __lB,
 
 #ifndef _LIBCPP_CXX03_LANG
-    template<class _UnaryOperation>
-        _LIBCPP_INLINE_VISIBILITY
-        piecewise_constant_distribution(initializer_list<result_type> __bl,
-                                        _UnaryOperation __fw)
-        : __p_(__bl, __fw) {}
-#endif  // _LIBCPP_CXX03_LANG
+  template <class _UnaryOperation>
+#endif // _LIBCPP_CXX03_LANG
 
-    template<class _UnaryOperation>
-        _LIBCPP_INLINE_VISIBILITY
-        piecewise_constant_distribution(size_t __nw, result_type __xmin,
-                                        result_type __xmax, _UnaryOperation __fw)
-        : __p_(__nw, __xmin, __xmax, __fw) {}
+  template <class _UnaryOperation>
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit piecewise_constant_distribution(const param_type& __p)
-        : __p_(__p) {}
+  explicit piecewise_constant_distribution(const param_type& __p) : __p_(__p) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    vector<result_type> intervals() const {return __p_.intervals();}
-    _LIBCPP_INLINE_VISIBILITY
-    vector<result_type> densities() const {return __p_.densities();}
+  vector<result_type> intervals() const { return __p_.intervals(); }
+  vector<result_type> densities() const { return __p_.densities(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  param_type param() const { return __p_; }
+  void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return __p_.__b_.front();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return __p_.__b_.back();}
+  result_type min() const { return __p_.__b_.front(); }
+  result_type max() const { return __p_.__b_.back(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const piecewise_constant_distribution& __x,
-                        const piecewise_constant_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const piecewise_constant_distribution& __x,
-                           const piecewise_constant_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const piecewise_constant_distribution& __x,
+             const piecewise_constant_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const piecewise_constant_distribution& __x,
+             const piecewise_constant_distribution& __y) {
+    return !(__x == __y);
+  }
 
-    template <class _CharT, class _Traits, class _RT>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const piecewise_constant_distribution<_RT>& __x);
+  friend basic_ostream<_CharT, _Traits>&
 
-    template <class _CharT, class _Traits, class _RT>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               piecewise_constant_distribution<_RT>& __x);
+  friend basic_istream<_CharT, _Traits>&
 };
 
-template<class _RealType>
-typename piecewise_constant_distribution<_RealType>::param_type &
-piecewise_constant_distribution<_RealType>::param_type::operator=
-                                                       (const param_type& __rhs)
-{
+template <class _RealType>
+typename piecewise_constant_distribution<_RealType>::param_type&
+piecewise_constant_distribution<_RealType>::param_type::operator=(
+    const param_type& __rhs) {
   //  These can throw
-    __b_.reserve        (__rhs.__b_.size ());
-    __densities_.reserve(__rhs.__densities_.size());
-    __areas_.reserve    (__rhs.__areas_.size());
+  __b_.reserve(__rhs.__b_.size());
+  __areas_.reserve(__rhs.__areas_.size());
 
   //  These can not throw
-    __b_         = __rhs.__b_;
-    __densities_ = __rhs.__densities_;
-    __areas_     =  __rhs.__areas_;
-    return *this;
+  __b_ = __rhs.__b_;
+  __areas_ = __rhs.__areas_;
 }
 
-template<class _RealType>
-void
-piecewise_constant_distribution<_RealType>::param_type::__init()
-{
-    // __densities_ contains non-normalized areas
-    result_type __total_area = _VSTD::accumulate(__densities_.begin(),
-                                                __densities_.end(),
-                                                result_type());
-    for (size_t __i = 0; __i < __densities_.size(); ++__i)
-        __densities_[__i] /= __total_area;
-    // __densities_ contains normalized areas
-    __areas_.assign(__densities_.size(), result_type());
-    _VSTD::partial_sum(__densities_.begin(), __densities_.end() - 1,
-                                                          __areas_.begin() + 1);
-    // __areas_ contains partial sums of normalized areas: [0, __densities_ - 1]
-    __densities_.back() = 1 - __areas_.back();  // correct round off error
-    for (size_t __i = 0; __i < __densities_.size(); ++__i)
-        __densities_[__i] /= (__b_[__i+1] - __b_[__i]);
-    // __densities_ now contains __densities_
+template <class _RealType>
+void piecewise_constant_distribution<_RealType>::param_type::__init() {
+  result_type __total_area = _VSTD::accumulate(
+      __densities_.begin(), __densities_.end(), result_type());
+  __densities_.back() = 1 - __areas_.back(); // correct round off error
+    __densities_[__i] /= (__b_[__i + 1] - __b_[__i]);
 }
 
-template<class _RealType>
+template <class _RealType>
 piecewise_constant_distribution<_RealType>::param_type::param_type()
-    : __b_(2),
-      __densities_(1, 1.0),
-      __areas_(1, 0.0)
-{
-    __b_[1] = 1;
+    : __b_(2), __densities_(1, 1.0), __areas_(1, 0.0) {
 }
 
-template<class _RealType>
-template<class _InputIteratorB, class _InputIteratorW>
+template <class _RealType>
+template <class _InputIteratorB, class _InputIteratorW>
 piecewise_constant_distribution<_RealType>::param_type::param_type(
-        _InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW)
-    : __b_(__fB, __lB)
-{
-    if (__b_.size() < 2)
-    {
-        __b_.resize(2);
-        __b_[0] = 0;
-        __b_[1] = 1;
-        __densities_.assign(1, 1.0);
-        __areas_.assign(1, 0.0);
-    }
-    else
-    {
-        __densities_.reserve(__b_.size() - 1);
-        for (size_t __i = 0; __i < __b_.size() - 1; ++__i, ++__fW)
-            __densities_.push_back(*__fW);
-        __init();
-    }
+    : __b_(__fB, __lB) {
+  if (__b_.size() < 2) {
+  } else {
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
-template<class _RealType>
-template<class _UnaryOperation>
+template <class _RealType>
+template <class _UnaryOperation>
 piecewise_constant_distribution<_RealType>::param_type::param_type(
-        initializer_list<result_type> __bl, _UnaryOperation __fw)
-    : __b_(__bl.begin(), __bl.end())
-{
-    if (__b_.size() < 2)
-    {
-        __b_.resize(2);
-        __b_[0] = 0;
-        __b_[1] = 1;
-        __densities_.assign(1, 1.0);
-        __areas_.assign(1, 0.0);
-    }
-    else
-    {
-        __densities_.reserve(__b_.size() - 1);
-        for (size_t __i = 0; __i < __b_.size() - 1; ++__i)
-            __densities_.push_back(__fw((__b_[__i+1] + __b_[__i])*.5));
-        __init();
-    }
+    : __b_(__bl.begin(), __bl.end()) {
+  if (__b_.size() < 2) {
+  } else {
+      __densities_.push_back(__fw((__b_[__i + 1] + __b_[__i]) * .5));
 }
 
-#endif  // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_CXX03_LANG
 
-template<class _RealType>
-template<class _UnaryOperation>
+template <class _RealType>
+template <class _UnaryOperation>
 piecewise_constant_distribution<_RealType>::param_type::param_type(
-        size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw)
-    : __b_(__nw == 0 ? 2 : __nw + 1)
-{
-    size_t __n = __b_.size() - 1;
-    result_type __d = (__xmax - __xmin) / __n;
-    __densities_.reserve(__n);
-    for (size_t __i = 0; __i < __n; ++__i)
-    {
-        __b_[__i] = __xmin + __i * __d;
-        __densities_.push_back(__fw(__b_[__i] + __d*.5));
-    }
-    __b_[__n] = __xmax;
-    __init();
+    : __b_(__nw == 0 ? 2 : __nw + 1) {
+  for (size_t __i = 0; __i < __n; ++__i) {
+    __densities_.push_back(__fw(__b_[__i] + __d * .5));
 }
 
-template<class _RealType>
-template<class _URNG>
+template <class _RealType>
+template <class _URNG>
 _RealType
-piecewise_constant_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    typedef uniform_real_distribution<result_type> _Gen;
-    result_type __u = _Gen()(__g);
-    ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
-                                      __u) - __p.__areas_.begin() - 1;
-    return (__u - __p.__areas_[__k]) / __p.__densities_[__k] + __p.__b_[__k];
+piecewise_constant_distribution<_RealType>::operator()(_URNG& __g,
+                                                       const param_type& __p) {
+  ptrdiff_t __k =
+      _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(), __u) -
+      __p.__areas_.begin() - 1;
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const piecewise_constant_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    size_t __n = __x.__p_.__b_.size();
-    __os << __n;
-    for (size_t __i = 0; __i < __n; ++__i)
-        __os << __sp << __x.__p_.__b_[__i];
-    __n = __x.__p_.__densities_.size();
-    __os << __sp << __n;
-    for (size_t __i = 0; __i < __n; ++__i)
-        __os << __sp << __x.__p_.__densities_[__i];
-    __n = __x.__p_.__areas_.size();
-    __os << __sp << __n;
-    for (size_t __i = 0; __i < __n; ++__i)
-        __os << __sp << __x.__p_.__areas_[__i];
-    return __os;
+           const piecewise_constant_distribution<_RT>& __x) {
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
-           piecewise_constant_distribution<_RT>& __x)
-{
-    typedef piecewise_constant_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    size_t __n;
-    __is >> __n;
-    vector<result_type> __b(__n);
-    for (size_t __i = 0; __i < __n; ++__i)
-        __is >> __b[__i];
-    __is >> __n;
-    vector<result_type> __densities(__n);
-    for (size_t __i = 0; __i < __n; ++__i)
-        __is >> __densities[__i];
-    __is >> __n;
-    vector<result_type> __areas(__n);
-    for (size_t __i = 0; __i < __n; ++__i)
-        __is >> __areas[__i];
-    if (!__is.fail())
-    {
-        swap(__x.__p_.__b_, __b);
-        swap(__x.__p_.__densities_, __densities);
-        swap(__x.__p_.__areas_, __areas);
-    }
-    return __is;
+           piecewise_constant_distribution<_RT>& __x) {
+  if (!__is.fail()) {
 }
 
 // piecewise_linear_distribution
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS piecewise_linear_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS piecewise_linear_distribution {
 public:
-    // types
-    typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        vector<result_type> __b_;
-        vector<result_type> __densities_;
-        vector<result_type> __areas_;
-    public:
-        typedef piecewise_linear_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+
 
-        param_type();
-        template<class _InputIteratorB, class _InputIteratorW>
-            param_type(_InputIteratorB __fB, _InputIteratorB __lB,
-                       _InputIteratorW __fW);
+    template <class _InputIteratorB, class _InputIteratorW>
 #ifndef _LIBCPP_CXX03_LANG
-        template<class _UnaryOperation>
-            param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
-#endif  // _LIBCPP_CXX03_LANG
-        template<class _UnaryOperation>
-            param_type(size_t __nw, result_type __xmin, result_type __xmax,
-                       _UnaryOperation __fw);
-        param_type(param_type const&) = default;
-        param_type & operator=(const param_type& __rhs);
+    template <class _UnaryOperation>
+#endif // _LIBCPP_CXX03_LANG
+    template <class _UnaryOperation>
+    param_type& operator=(const param_type& __rhs);
 
-        _LIBCPP_INLINE_VISIBILITY
-        vector<result_type> intervals() const {return __b_;}
-        _LIBCPP_INLINE_VISIBILITY
-        vector<result_type> densities() const {return __densities_;}
+    vector<result_type> intervals() const { return __b_; }
+    vector<result_type> densities() const { return __densities_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
+    friend _LIBCPP_INLINE_VISIBILITY bool operator==(const param_type& __x,
+                                                     const param_type& __y) {
+      return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;
+    }
+    friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const param_type& __x,
+                                                     const param_type& __y) {
+      return !(__x == __y);
+    }
 
-    private:
-        void __init();
 
-        friend class piecewise_linear_distribution;
 
-        template <class _CharT, class _Traits, class _RT>
-        friend
-        basic_ostream<_CharT, _Traits>&
-        operator<<(basic_ostream<_CharT, _Traits>& __os,
-                   const piecewise_linear_distribution<_RT>& __x);
+    friend basic_ostream<_CharT, _Traits>&
 
-        template <class _CharT, class _Traits, class _RT>
-        friend
-        basic_istream<_CharT, _Traits>&
-        operator>>(basic_istream<_CharT, _Traits>& __is,
-                   piecewise_linear_distribution<_RT>& __x);
-    };
+    friend basic_istream<_CharT, _Traits>&
 
 private:
-    param_type __p_;
 
 public:
-    // constructor and reset functions
-    _LIBCPP_INLINE_VISIBILITY
-    piecewise_linear_distribution() {}
-    template<class _InputIteratorB, class _InputIteratorW>
-        _LIBCPP_INLINE_VISIBILITY
-        piecewise_linear_distribution(_InputIteratorB __fB,
+  template <class _InputIteratorB, class _InputIteratorW>
+  _LIBCPP_INLINE_VISIBILITY piecewise_linear_distribution(_InputIteratorB __fB,
                                                           _InputIteratorB __lB,
                                                           _InputIteratorW __fW)
-        : __p_(__fB, __lB, __fW) {}
 
 #ifndef _LIBCPP_CXX03_LANG
-    template<class _UnaryOperation>
-        _LIBCPP_INLINE_VISIBILITY
-        piecewise_linear_distribution(initializer_list<result_type> __bl,
-                                      _UnaryOperation __fw)
-        : __p_(__bl, __fw) {}
-#endif  // _LIBCPP_CXX03_LANG
+  template <class _UnaryOperation>
+#endif // _LIBCPP_CXX03_LANG
 
-    template<class _UnaryOperation>
-        _LIBCPP_INLINE_VISIBILITY
-        piecewise_linear_distribution(size_t __nw, result_type __xmin,
-                                      result_type __xmax, _UnaryOperation __fw)
-        : __p_(__nw, __xmin, __xmax, __fw) {}
+  template <class _UnaryOperation>
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit piecewise_linear_distribution(const param_type& __p)
-        : __p_(__p) {}
+  explicit piecewise_linear_distribution(const param_type& __p) : __p_(__p) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+  template <class _URNG>
+  _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    vector<result_type> intervals() const {return __p_.intervals();}
-    _LIBCPP_INLINE_VISIBILITY
-    vector<result_type> densities() const {return __p_.densities();}
+  vector<result_type> intervals() const { return __p_.intervals(); }
+  vector<result_type> densities() const { return __p_.densities(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  param_type param() const { return __p_; }
+  void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return __p_.__b_.front();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return __p_.__b_.back();}
+  result_type min() const { return __p_.__b_.front(); }
+  result_type max() const { return __p_.__b_.back(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const piecewise_linear_distribution& __x,
-                        const piecewise_linear_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const piecewise_linear_distribution& __x,
-                        const piecewise_linear_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator==(const piecewise_linear_distribution& __x,
+             const piecewise_linear_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool
+  operator!=(const piecewise_linear_distribution& __x,
+             const piecewise_linear_distribution& __y) {
+    return !(__x == __y);
+  }
 
-    template <class _CharT, class _Traits, class _RT>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const piecewise_linear_distribution<_RT>& __x);
+  friend basic_ostream<_CharT, _Traits>&
 
-    template <class _CharT, class _Traits, class _RT>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               piecewise_linear_distribution<_RT>& __x);
+  friend basic_istream<_CharT, _Traits>&
 };
 
-template<class _RealType>
-typename piecewise_linear_distribution<_RealType>::param_type &
-piecewise_linear_distribution<_RealType>::param_type::operator=
-                                                       (const param_type& __rhs)
-{
+template <class _RealType>
+typename piecewise_linear_distribution<_RealType>::param_type&
+piecewise_linear_distribution<_RealType>::param_type::operator=(
+    const param_type& __rhs) {
   //  These can throw
-    __b_.reserve        (__rhs.__b_.size ());
-    __densities_.reserve(__rhs.__densities_.size());
-    __areas_.reserve    (__rhs.__areas_.size());
+  __b_.reserve(__rhs.__b_.size());
+  __areas_.reserve(__rhs.__areas_.size());
 
   //  These can not throw
-    __b_         = __rhs.__b_;
-    __densities_ = __rhs.__densities_;
-    __areas_     =  __rhs.__areas_;
-    return *this;
+  __b_ = __rhs.__b_;
+  __areas_ = __rhs.__areas_;
 }
 
-
-template<class _RealType>
-void
-piecewise_linear_distribution<_RealType>::param_type::__init()
-{
-    __areas_.assign(__densities_.size() - 1, result_type());
-    result_type _Sp = 0;
-    for (size_t __i = 0; __i < __areas_.size(); ++__i)
-    {
-        __areas_[__i] = (__densities_[__i+1] + __densities_[__i]) *
-                        (__b_[__i+1] - __b_[__i]) * .5;
-        _Sp += __areas_[__i];
-    }
-    for (size_t __i = __areas_.size(); __i > 1;)
-    {
-        --__i;
-        __areas_[__i] = __areas_[__i-1] / _Sp;
-    }
-    __areas_[0] = 0;
-    for (size_t __i = 1; __i < __areas_.size(); ++__i)
-        __areas_[__i] += __areas_[__i-1];
-    for (size_t __i = 0; __i < __densities_.size(); ++__i)
-        __densities_[__i] /= _Sp;
+template <class _RealType>
+void piecewise_linear_distribution<_RealType>::param_type::__init() {
+  for (size_t __i = 0; __i < __areas_.size(); ++__i) {
+    __areas_[__i] = (__densities_[__i + 1] + __densities_[__i]) *
+                    (__b_[__i + 1] - __b_[__i]) * .5;
+  for (size_t __i = __areas_.size(); __i > 1;) {
+    __areas_[__i] = __areas_[__i - 1] / _Sp;
+    __areas_[__i] += __areas_[__i - 1];
 }
 
-template<class _RealType>
+template <class _RealType>
 piecewise_linear_distribution<_RealType>::param_type::param_type()
-    : __b_(2),
-      __densities_(2, 1.0),
-      __areas_(1, 0.0)
-{
-    __b_[1] = 1;
+    : __b_(2), __densities_(2, 1.0), __areas_(1, 0.0) {
 }
 
-template<class _RealType>
-template<class _InputIteratorB, class _InputIteratorW>
+template <class _RealType>
+template <class _InputIteratorB, class _InputIteratorW>
 piecewise_linear_distribution<_RealType>::param_type::param_type(
-        _InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW)
-    : __b_(__fB, __lB)
-{
-    if (__b_.size() < 2)
-    {
-        __b_.resize(2);
-        __b_[0] = 0;
-        __b_[1] = 1;
-        __densities_.assign(2, 1.0);
-        __areas_.assign(1, 0.0);
-    }
-    else
-    {
-        __densities_.reserve(__b_.size());
-        for (size_t __i = 0; __i < __b_.size(); ++__i, ++__fW)
-            __densities_.push_back(*__fW);
-        __init();
-    }
+    : __b_(__fB, __lB) {
+  if (__b_.size() < 2) {
+  } else {
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
-template<class _RealType>
-template<class _UnaryOperation>
+template <class _RealType>
+template <class _UnaryOperation>
 piecewise_linear_distribution<_RealType>::param_type::param_type(
-        initializer_list<result_type> __bl, _UnaryOperation __fw)
-    : __b_(__bl.begin(), __bl.end())
-{
-    if (__b_.size() < 2)
-    {
-        __b_.resize(2);
-        __b_[0] = 0;
-        __b_[1] = 1;
-        __densities_.assign(2, 1.0);
-        __areas_.assign(1, 0.0);
-    }
-    else
-    {
-        __densities_.reserve(__b_.size());
-        for (size_t __i = 0; __i < __b_.size(); ++__i)
-            __densities_.push_back(__fw(__b_[__i]));
-        __init();
-    }
+    : __b_(__bl.begin(), __bl.end()) {
+  if (__b_.size() < 2) {
+  } else {
 }
 
-#endif  // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_CXX03_LANG
 
-template<class _RealType>
-template<class _UnaryOperation>
+template <class _RealType>
+template <class _UnaryOperation>
 piecewise_linear_distribution<_RealType>::param_type::param_type(
-        size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw)
-    : __b_(__nw == 0 ? 2 : __nw + 1)
-{
-    size_t __n = __b_.size() - 1;
-    result_type __d = (__xmax - __xmin) / __n;
-    __densities_.reserve(__b_.size());
-    for (size_t __i = 0; __i < __n; ++__i)
-    {
-        __b_[__i] = __xmin + __i * __d;
-        __densities_.push_back(__fw(__b_[__i]));
-    }
-    __b_[__n] = __xmax;
-    __densities_.push_back(__fw(__b_[__n]));
-    __init();
+    : __b_(__nw == 0 ? 2 : __nw + 1) {
+  for (size_t __i = 0; __i < __n; ++__i) {
 }
 
-template<class _RealType>
-template<class _URNG>
+template <class _RealType>
+template <class _URNG>
 _RealType
-piecewise_linear_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    typedef uniform_real_distribution<result_type> _Gen;
-    result_type __u = _Gen()(__g);
-    ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
-                                      __u) - __p.__areas_.begin() - 1;
-    __u -= __p.__areas_[__k];
-    const result_type __dk = __p.__densities_[__k];
-    const result_type __dk1 = __p.__densities_[__k+1];
-    const result_type __deltad = __dk1 - __dk;
-    const result_type __bk = __p.__b_[__k];
-    if (__deltad == 0)
-        return __u / __dk + __bk;
-    const result_type __bk1 = __p.__b_[__k+1];
-    const result_type __deltab = __bk1 - __bk;
-    return (__bk * __dk1 - __bk1 * __dk +
-        _VSTD::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) /
+piecewise_linear_distribution<_RealType>::operator()(_URNG& __g,
+                                                     const param_type& __p) {
+  ptrdiff_t __k =
+      _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(), __u) -
+      __p.__areas_.begin() - 1;
+  const result_type __dk1 = __p.__densities_[__k + 1];
+  const result_type __bk1 = __p.__b_[__k + 1];
+          _VSTD::sqrt(__deltab *
+                      (__deltab * __dk * __dk + 2 * __deltad * __u))) /
          __deltad;
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const piecewise_linear_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    size_t __n = __x.__p_.__b_.size();
-    __os << __n;
-    for (size_t __i = 0; __i < __n; ++__i)
-        __os << __sp << __x.__p_.__b_[__i];
-    __n = __x.__p_.__densities_.size();
-    __os << __sp << __n;
-    for (size_t __i = 0; __i < __n; ++__i)
-        __os << __sp << __x.__p_.__densities_[__i];
-    __n = __x.__p_.__areas_.size();
-    __os << __sp << __n;
-    for (size_t __i = 0; __i < __n; ++__i)
-        __os << __sp << __x.__p_.__areas_[__i];
-    return __os;
+           const piecewise_linear_distribution<_RT>& __x) {
 }
 
 template <class _CharT, class _Traits, class _RT>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
-           piecewise_linear_distribution<_RT>& __x)
-{
-    typedef piecewise_linear_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    size_t __n;
-    __is >> __n;
-    vector<result_type> __b(__n);
-    for (size_t __i = 0; __i < __n; ++__i)
-        __is >> __b[__i];
-    __is >> __n;
-    vector<result_type> __densities(__n);
-    for (size_t __i = 0; __i < __n; ++__i)
-        __is >> __densities[__i];
-    __is >> __n;
-    vector<result_type> __areas(__n);
-    for (size_t __i = 0; __i < __n; ++__i)
-        __is >> __areas[__i];
-    if (!__is.fail())
-    {
-        swap(__x.__p_.__b_, __b);
-        swap(__x.__p_.__densities_, __densities);
-        swap(__x.__p_.__areas_, __areas);
-    }
-    return __is;
+           piecewise_linear_distribution<_RT>& __x) {
+  if (!__is.fail()) {
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
-#endif  // _LIBCPP_RANDOM
+#endif // _LIBCPP_RANDOM

libcxx/test/std/concepts/lang/arithmetic.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class T>
 // concept integral = // see below
 
 // template<class T>
 // concept signed_integral = // see below
 

libcxx/test/std/numerics/rand/rand.req/rand.req.urng/nothing_to_do.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-int main(int, char**)
-{
-
-  return 0;
-}

libcxx/test/std/numerics/rand/rand.req/rand.req.urng/uniform_random_bit_generator.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class T>
+// concept uniform_random_bit_generator = // see below
+
+#include <random>
+
+static_assert(std::uniform_random_bit_generator<
+              std::linear_congruential_engine<unsigned int, 0U, 1U, 2U> >);
+static_assert(std::uniform_random_bit_generator<
+              std::subtract_with_carry_engine<__uint128_t, 1U, 2U, 3U> >);
+
+// Not invocable
+static_assert(!std::uniform_random_bit_generator<void>);
+static_assert(!std::uniform_random_bit_generator<int>);
+static_assert(!std::uniform_random_bit_generator<int[10]>);
+static_assert(!std::uniform_random_bit_generator<int*>);
+static_assert(!std::uniform_random_bit_generator<const int*>);
+static_assert(!std::uniform_random_bit_generator<volatile int*>);
+static_assert(!std::uniform_random_bit_generator<const volatile int*>);
+static_assert(!std::uniform_random_bit_generator<int&>);
+static_assert(!std::uniform_random_bit_generator<const int&>);
+static_assert(!std::uniform_random_bit_generator<volatile int&>);
+static_assert(!std::uniform_random_bit_generator<const volatile int&>);
+static_assert(!std::uniform_random_bit_generator<int&&>);
+static_assert(!std::uniform_random_bit_generator<const int&&>);
+static_assert(!std::uniform_random_bit_generator<volatile int&&>);
+static_assert(!std::uniform_random_bit_generator<const volatile int&&>);
+
+struct Empty {};
+static_assert(!std::uniform_random_bit_generator<Empty>);
+
+namespace WrongReturnType {
+using FunctionPointer = void (*)();
+static_assert(!std::uniform_random_bit_generator<FunctionPointer>);
+
+using FunctionReference = int (&)();
+static_assert(!std::uniform_random_bit_generator<FunctionReference>);
+
+struct FunctionObject {
+  unsigned long* operator()();
+};
+static_assert(!std::uniform_random_bit_generator<FunctionObject>);
+static_assert(!std::uniform_random_bit_generator<unsigned int Empty::*>);
+static_assert(!std::uniform_random_bit_generator<unsigned short (Empty::*)()>);
+} // namespace WrongReturnType
+
+namespace NoMinOrMax {
+using FunctionPointer = unsigned int (*)();
+static_assert(!std::uniform_random_bit_generator<FunctionPointer>);
+
+using FunctionReference = unsigned long long (&)();
+static_assert(!std::uniform_random_bit_generator<FunctionReference>);
+
+struct FunctionObject {
+  unsigned char operator()();
+};
+static_assert(!std::uniform_random_bit_generator<FunctionObject>);
+} // namespace NoMinOrMax
+
+namespace OnlyMinIsRight {
+struct NoMax {
+  unsigned char operator()();
+
+  static unsigned char min();
+};
+static_assert(!std::uniform_random_bit_generator<NoMax>);
+
+struct MaxHasWrongReturnType {
+  unsigned char operator()();
+
+  static unsigned char min();
+  static unsigned int max();
+};
+
+static_assert(!std::uniform_random_bit_generator<MaxHasWrongReturnType>);
+} // namespace OnlyMinIsRight
+
+namespace OnlyMaxIsRight {
+struct NoMin {
+  unsigned char operator()();
+
+  static unsigned char max();
+};
+static_assert(!std::uniform_random_bit_generator<NoMin>);
+
+struct MinHasWrongReturnType {
+  unsigned char operator()();
+
+  static unsigned int min();
+  static unsigned char max();
+};
+
+static_assert(!std::uniform_random_bit_generator<MinHasWrongReturnType>);
+} // namespace OnlyMaxIsRight
+
+namespace MinNotLessMax {
+struct NotConstexpr {
+  unsigned char operator()();
+
+  static unsigned char min();
+  static unsigned char max();
+};
+static_assert(!std::uniform_random_bit_generator<NotConstexpr>);
+
+struct MaxLessThanMin {
+  unsigned char operator()();
+
+  static constexpr unsigned char min() { return ~0; }
+  static constexpr unsigned char max() { return 0; }
+};
+static_assert(!std::uniform_random_bit_generator<MaxLessThanMin>);
+} // namespace MinNotLessMax
+
+struct Works {
+  unsigned char operator()();
+
+  static constexpr unsigned char min() { return 0; }
+  static constexpr unsigned char max() { return ~0; }
+};
+static_assert(std::uniform_random_bit_generator<Works>);
+
+int main(int, char**) { return 0; }