diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
index 034a7beb17424..b9b6856dc3405 100644
--- a/clang/lib/Driver/ToolChains/Clang.cpp
+++ b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -1168,16 +1168,6 @@ void Clang::AddPreprocessingOptions(Compilation &C, const JobAction &JA,
   if (JA.isOffloading(Action::OFK_Cuda))
     getToolChain().AddCudaIncludeArgs(Args, CmdArgs);
 
-  // Add include directories for SYCL
-  if (!Args.hasArg(options::OPT_nobuiltininc) &&
-      getToolChain().getTriple().isSYCLDeviceEnvironment()) {
-    SmallString<128> P(D.ResourceDir);
-    llvm::sys::path::append(P, "include");
-    llvm::sys::path::append(P, "sycl_wrappers");
-    CmdArgs.push_back("-internal-isystem");
-    CmdArgs.push_back(Args.MakeArgString(P));
-  }
-
   // If we are offloading to a target via OpenMP we need to include the
   // openmp_wrappers folder which contains alternative system headers.
   if (JA.isDeviceOffloading(Action::OFK_OpenMP) &&
diff --git a/clang/lib/Headers/CMakeLists.txt b/clang/lib/Headers/CMakeLists.txt
index cf6cecaeafc21..392ca2ae391c9 100644
--- a/clang/lib/Headers/CMakeLists.txt
+++ b/clang/lib/Headers/CMakeLists.txt
@@ -128,12 +128,6 @@ set(ppc_wrapper_files
   ppc_wrappers/mmintrin.h
 )
 
-set(sycl_wrapper_files
-  sycl_wrappers/algorithm
-  sycl_wrappers/random
-  sycl_wrappers/__config
-)
-
 set(openmp_wrapper_files
   openmp_wrappers/math.h
   openmp_wrappers/cmath
@@ -201,12 +195,6 @@ install(
   DESTINATION ${header_install_dir}/ppc_wrappers
   COMPONENT clang-resource-headers)
 
-install(
-  FILES ${sycl_wrapper_files}
-  COMPONENT clang-resource-headers
-  PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
-  DESTINATION lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION}/include/sycl_wrappers)
-
 install(
   FILES ${openmp_wrapper_files}
   DESTINATION ${header_install_dir}/openmp_wrappers
diff --git a/clang/lib/Headers/sycl_wrappers/__config b/clang/lib/Headers/sycl_wrappers/__config
deleted file mode 100644
index 35670334636b3..0000000000000
--- a/clang/lib/Headers/sycl_wrappers/__config
+++ /dev/null
@@ -1,36 +0,0 @@
-// -*- C++ -*-
-//===--------------------------- __config ---------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_STD_VER
-#  if  __cplusplus <= 201103L
-#    define _LIBCPP_STD_VER 11
-#  elif __cplusplus <= 201402L
-#    define _LIBCPP_STD_VER 14
-#  elif __cplusplus <= 201703L
-#    define _LIBCPP_STD_VER 17
-#  endif
-#endif
-
-#if _LIBCPP_STD_VER > 11
-#  define _LIBCPP_CONSTEXPR_AFTER_CXX11 constexpr
-#else
-#  define _LIBCPP_CONSTEXPR_AFTER_CXX11
-#endif
-
-#if _LIBCPP_STD_VER > 14
-#  define _LIBCPP_CONSTEXPR_AFTER_CXX14 constexpr
-#else
-#  define _LIBCPP_CONSTEXPR_AFTER_CXX14
-#endif
-
-#if _LIBCPP_STD_VER > 17
-#  define _LIBCPP_CONSTEXPR_AFTER_CXX17 constexpr
-#else
-#  define _LIBCPP_CONSTEXPR_AFTER_CXX17
-#endif
diff --git a/clang/lib/Headers/sycl_wrappers/algorithm b/clang/lib/Headers/sycl_wrappers/algorithm
deleted file mode 100644
index bff60089a903a..0000000000000
--- a/clang/lib/Headers/sycl_wrappers/algorithm
+++ /dev/null
@@ -1,593 +0,0 @@
-// -*- C++ -*-
-//===-------------------------- algorithm ---------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#include <__config>
-#include <initializer_list>
-#include <iterator>
-
-namespace std {
-
-template <class InputIterator, class Predicate>
-bool all_of(InputIterator first, InputIterator last, Predicate pred);
-
-template <class InputIterator, class Predicate>
-bool any_of(InputIterator first, InputIterator last, Predicate pred);
-
-template <class InputIterator, class Predicate>
-bool none_of(InputIterator first, InputIterator last, Predicate pred);
-
-template <class InputIterator, class Function>
-Function for_each(InputIterator first, InputIterator last, Function f);
-
-template <class InputIterator, class Size, class Function>
-InputIterator for_each_n(InputIterator first, Size n, Function f);
-
-template <class InputIterator, class T>
-InputIterator find(InputIterator first, InputIterator last, const T &value);
-
-template <class InputIterator, class Predicate>
-InputIterator find_if(InputIterator first, InputIterator last, Predicate pred);
-
-template <class InputIterator, class Predicate>
-InputIterator find_if_not(InputIterator first, InputIterator last,
-                          Predicate pred);
-
-template <class ForwardIterator1, class ForwardIterator2>
-ForwardIterator1 find_end(ForwardIterator1 first1, ForwardIterator1 last1,
-                          ForwardIterator2 first2, ForwardIterator2 last2);
-
-template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
-ForwardIterator1 find_end(ForwardIterator1 first1, ForwardIterator1 last1,
-                          ForwardIterator2 first2, ForwardIterator2 last2,
-                          BinaryPredicate pred);
-
-template <class ForwardIterator1, class ForwardIterator2>
-ForwardIterator1 find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
-                               ForwardIterator2 first2, ForwardIterator2 last2);
-
-template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
-ForwardIterator1 find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
-                               ForwardIterator2 first2, ForwardIterator2 last2,
-                               BinaryPredicate pred);
-
-template <class ForwardIterator>
-ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last);
-
-template <class ForwardIterator, class BinaryPredicate>
-ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last,
-                              BinaryPredicate pred);
-
-template <class InputIterator, class T>
-typename iterator_traits<InputIterator>::difference_type
-count(InputIterator first, InputIterator last, const T &value);
-
-template <class InputIterator, class Predicate>
-typename iterator_traits<InputIterator>::difference_type
-count_if(InputIterator first, InputIterator last, Predicate pred);
-
-template <class InputIterator1, class InputIterator2>
-pair<InputIterator1, InputIterator2>
-mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
-
-template <class InputIterator1, class InputIterator2>
-pair<InputIterator1, InputIterator2>
-mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
-         InputIterator2 last2); // **C++14**
-
-template <class InputIterator1, class InputIterator2, class BinaryPredicate>
-pair<InputIterator1, InputIterator2>
-mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
-         BinaryPredicate pred);
-
-template <class InputIterator1, class InputIterator2, class BinaryPredicate>
-pair<InputIterator1, InputIterator2>
-mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
-         InputIterator2 last2,
-         BinaryPredicate pred); // **C++14**
-
-template <class InputIterator1, class InputIterator2>
-bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
-
-template <class InputIterator1, class InputIterator2>
-bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
-           InputIterator2 last2); // **C++14**
-
-template <class InputIterator1, class InputIterator2, class BinaryPredicate>
-bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
-           BinaryPredicate pred);
-
-template <class InputIterator1, class InputIterator2, class BinaryPredicate>
-bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
-           InputIterator2 last2,
-           BinaryPredicate pred); // **C++14**
-
-template <class ForwardIterator1, class ForwardIterator2>
-bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
-                    ForwardIterator2 first2);
-
-template <class ForwardIterator1, class ForwardIterator2>
-bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
-                    ForwardIterator2 first2,
-                    ForwardIterator2 last2); // **C++14**
-
-template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
-bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
-                    ForwardIterator2 first2, BinaryPredicate pred);
-
-template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
-bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
-                    ForwardIterator2 first2, ForwardIterator2 last2,
-                    BinaryPredicate pred); // **C++14**
-
-template <class ForwardIterator1, class ForwardIterator2>
-ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,
-                        ForwardIterator2 first2, ForwardIterator2 last2);
-
-template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
-ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,
-                        ForwardIterator2 first2, ForwardIterator2 last2,
-                        BinaryPredicate pred);
-
-template <class ForwardIterator, class Size, class T>
-ForwardIterator search_n(ForwardIterator first, ForwardIterator last,
-                         Size count, const T &value);
-
-template <class ForwardIterator, class Size, class T, class BinaryPredicate>
-ForwardIterator search_n(ForwardIterator first, ForwardIterator last,
-                         Size count, const T &value, BinaryPredicate pred);
-
-template <class InputIterator, class OutputIterator>
-OutputIterator copy(InputIterator first, InputIterator last,
-                    OutputIterator result);
-
-template <class InputIterator, class OutputIterator, class Predicate>
-OutputIterator copy_if(InputIterator first, InputIterator last,
-                       OutputIterator result, Predicate pred);
-
-template <class InputIterator, class Size, class OutputIterator>
-OutputIterator copy_n(InputIterator first, Size n, OutputIterator result);
-
-template <class BidirectionalIterator1, class BidirectionalIterator2>
-BidirectionalIterator2 copy_backward(BidirectionalIterator1 first,
-                                     BidirectionalIterator1 last,
-                                     BidirectionalIterator2 result);
-
-template <class ForwardIterator1, class ForwardIterator2>
-ForwardIterator2 swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1,
-                             ForwardIterator2 first2);
-
-template <class ForwardIterator1, class ForwardIterator2>
-void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
-
-template <class InputIterator, class OutputIterator, class UnaryOperation>
-OutputIterator transform(InputIterator first, InputIterator last,
-                         OutputIterator result, UnaryOperation op);
-
-template <class InputIterator1, class InputIterator2, class OutputIterator,
-          class BinaryOperation>
-OutputIterator transform(InputIterator1 first1, InputIterator1 last1,
-                         InputIterator2 first2, OutputIterator result,
-                         BinaryOperation binary_op);
-
-template <class ForwardIterator, class T>
-void replace(ForwardIterator first, ForwardIterator last, const T &old_value,
-             const T &new_value);
-
-template <class ForwardIterator, class Predicate, class T>
-void replace_if(ForwardIterator first, ForwardIterator last, Predicate pred,
-                const T &new_value);
-
-template <class InputIterator, class OutputIterator, class T>
-OutputIterator replace_copy(InputIterator first, InputIterator last,
-                            OutputIterator result, const T &old_value,
-                            const T &new_value);
-
-template <class InputIterator, class OutputIterator, class Predicate, class T>
-OutputIterator replace_copy_if(InputIterator first, InputIterator last,
-                               OutputIterator result, Predicate pred,
-                               const T &new_value);
-
-template <class ForwardIterator, class T>
-void fill(ForwardIterator first, ForwardIterator last, const T &value);
-
-template <class OutputIterator, class Size, class T>
-OutputIterator fill_n(OutputIterator first, Size n, const T &value);
-
-template <class ForwardIterator, class Generator>
-void generate(ForwardIterator first, ForwardIterator last, Generator gen);
-
-template <class OutputIterator, class Size, class Generator>
-OutputIterator generate_n(OutputIterator first, Size n, Generator gen);
-
-template <class ForwardIterator, class T>
-ForwardIterator remove(ForwardIterator first, ForwardIterator last,
-                       const T &value);
-
-template <class ForwardIterator, class Predicate>
-ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
-                          Predicate pred);
-
-template <class InputIterator, class OutputIterator, class T>
-OutputIterator remove_copy(InputIterator first, InputIterator last,
-                           OutputIterator result, const T &value);
-
-template <class InputIterator, class OutputIterator, class Predicate>
-OutputIterator remove_copy_if(InputIterator first, InputIterator last,
-                              OutputIterator result, Predicate pred);
-
-template <class ForwardIterator>
-ForwardIterator unique(ForwardIterator first, ForwardIterator last);
-
-template <class ForwardIterator, class BinaryPredicate>
-ForwardIterator unique(ForwardIterator first, ForwardIterator last,
-                       BinaryPredicate pred);
-
-template <class InputIterator, class OutputIterator>
-OutputIterator unique_copy(InputIterator first, InputIterator last,
-                           OutputIterator result);
-
-template <class InputIterator, class OutputIterator, class BinaryPredicate>
-OutputIterator unique_copy(InputIterator first, InputIterator last,
-                           OutputIterator result, BinaryPredicate pred);
-
-template <class BidirectionalIterator>
-void reverse(BidirectionalIterator first, BidirectionalIterator last);
-
-template <class BidirectionalIterator, class OutputIterator>
-OutputIterator reverse_copy(BidirectionalIterator first,
-                            BidirectionalIterator last, OutputIterator result);
-
-template <class ForwardIterator>
-ForwardIterator rotate(ForwardIterator first, ForwardIterator middle,
-                       ForwardIterator last);
-
-template <class ForwardIterator, class OutputIterator>
-OutputIterator rotate_copy(ForwardIterator first, ForwardIterator middle,
-                           ForwardIterator last, OutputIterator result);
-
-template <class RandomAccessIterator>
-void random_shuffle(
-    RandomAccessIterator first,
-    RandomAccessIterator last); // deprecated in C++14, removed in C++17
-
-template <class RandomAccessIterator, class RandomNumberGenerator>
-void random_shuffle(
-    RandomAccessIterator first, RandomAccessIterator last,
-    RandomNumberGenerator &rand); // deprecated in C++14, removed in C++17
-
-template <class PopulationIterator, class SampleIterator, class Distance,
-          class UniformRandomBitGenerator>
-SampleIterator sample(PopulationIterator first, PopulationIterator last,
-                      SampleIterator out, Distance n,
-                      UniformRandomBitGenerator &&g);
-
-template <class RandomAccessIterator, class UniformRandomNumberGenerator>
-void shuffle(RandomAccessIterator first, RandomAccessIterator last,
-             UniformRandomNumberGenerator &&g);
-
-template <class InputIterator, class Predicate>
-bool is_partitioned(InputIterator first, InputIterator last, Predicate pred);
-
-template <class ForwardIterator, class Predicate>
-ForwardIterator partition(ForwardIterator first, ForwardIterator last,
-                          Predicate pred);
-
-template <class InputIterator, class OutputIterator1, class OutputIterator2,
-          class Predicate>
-pair<OutputIterator1, OutputIterator2>
-partition_copy(InputIterator first, InputIterator last,
-               OutputIterator1 out_true, OutputIterator2 out_false,
-               Predicate pred);
-
-template <class ForwardIterator, class Predicate>
-ForwardIterator stable_partition(ForwardIterator first, ForwardIterator last,
-                                 Predicate pred);
-
-template <class ForwardIterator, class Predicate>
-ForwardIterator partition_point(ForwardIterator first, ForwardIterator last,
-                                Predicate pred);
-
-template <class ForwardIterator>
-bool is_sorted(ForwardIterator first, ForwardIterator last);
-
-template <class ForwardIterator, class Compare>
-bool is_sorted(ForwardIterator first, ForwardIterator last, Compare comp);
-
-template <class ForwardIterator>
-ForwardIterator is_sorted_until(ForwardIterator first, ForwardIterator last);
-
-template <class ForwardIterator, class Compare>
-ForwardIterator is_sorted_until(ForwardIterator first, ForwardIterator last,
-                                Compare comp);
-
-template <class RandomAccessIterator>
-void sort(RandomAccessIterator first, RandomAccessIterator last);
-
-template <class RandomAccessIterator, class Compare>
-void sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
-
-template <class RandomAccessIterator>
-void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
-
-template <class RandomAccessIterator, class Compare>
-void stable_sort(RandomAccessIterator first, RandomAccessIterator last,
-                 Compare comp);
-
-template <class RandomAccessIterator>
-void partial_sort(RandomAccessIterator first, RandomAccessIterator middle,
-                  RandomAccessIterator last);
-
-template <class RandomAccessIterator, class Compare>
-void partial_sort(RandomAccessIterator first, RandomAccessIterator middle,
-                  RandomAccessIterator last, Compare comp);
-
-template <class InputIterator, class RandomAccessIterator>
-RandomAccessIterator partial_sort_copy(InputIterator first, InputIterator last,
-                                       RandomAccessIterator result_first,
-                                       RandomAccessIterator result_last);
-
-template <class InputIterator, class RandomAccessIterator, class Compare>
-RandomAccessIterator partial_sort_copy(InputIterator first, InputIterator last,
-                                       RandomAccessIterator result_first,
-                                       RandomAccessIterator result_last,
-                                       Compare comp);
-
-template <class RandomAccessIterator>
-void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
-                 RandomAccessIterator last);
-
-template <class RandomAccessIterator, class Compare>
-void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
-                 RandomAccessIterator last, Compare comp);
-
-template <class ForwardIterator, class T>
-ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
-                            const T &value);
-
-template <class ForwardIterator, class T, class Compare>
-ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
-                            const T &value, Compare comp);
-
-template <class ForwardIterator, class T>
-ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
-                            const T &value);
-
-template <class ForwardIterator, class T, class Compare>
-ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
-                            const T &value, Compare comp);
-
-template <class ForwardIterator, class T>
-pair<ForwardIterator, ForwardIterator>
-equal_range(ForwardIterator first, ForwardIterator last, const T &value);
-
-template <class ForwardIterator, class T, class Compare>
-pair<ForwardIterator, ForwardIterator>
-equal_range(ForwardIterator first, ForwardIterator last, const T &value,
-            Compare comp);
-
-template <class ForwardIterator, class T>
-bool binary_search(ForwardIterator first, ForwardIterator last, const T &value);
-
-template <class ForwardIterator, class T, class Compare>
-bool binary_search(ForwardIterator first, ForwardIterator last, const T &value,
-                   Compare comp);
-
-template <class InputIterator1, class InputIterator2, class OutputIterator>
-OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
-                     InputIterator2 first2, InputIterator2 last2,
-                     OutputIterator result);
-
-template <class InputIterator1, class InputIterator2, class OutputIterator,
-          class Compare>
-OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
-                     InputIterator2 first2, InputIterator2 last2,
-                     OutputIterator result, Compare comp);
-
-template <class BidirectionalIterator>
-void inplace_merge(BidirectionalIterator first, BidirectionalIterator middle,
-                   BidirectionalIterator last);
-
-template <class BidirectionalIterator, class Compare>
-void inplace_merge(BidirectionalIterator first, BidirectionalIterator middle,
-                   BidirectionalIterator last, Compare comp);
-
-template <class InputIterator1, class InputIterator2>
-bool includes(InputIterator1 first1, InputIterator1 last1,
-              InputIterator2 first2, InputIterator2 last2);
-
-template <class InputIterator1, class InputIterator2, class Compare>
-bool includes(InputIterator1 first1, InputIterator1 last1,
-              InputIterator2 first2, InputIterator2 last2, Compare comp);
-
-template <class InputIterator1, class InputIterator2, class OutputIterator>
-OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
-                         InputIterator2 first2, InputIterator2 last2,
-                         OutputIterator result);
-
-template <class InputIterator1, class InputIterator2, class OutputIterator,
-          class Compare>
-OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
-                         InputIterator2 first2, InputIterator2 last2,
-                         OutputIterator result, Compare comp);
-
-template <class InputIterator1, class InputIterator2, class OutputIterator>
-OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1,
-                                InputIterator2 first2, InputIterator2 last2,
-                                OutputIterator result);
-
-template <class InputIterator1, class InputIterator2, class OutputIterator,
-          class Compare>
-OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1,
-                                InputIterator2 first2, InputIterator2 last2,
-                                OutputIterator result, Compare comp);
-
-template <class InputIterator1, class InputIterator2, class OutputIterator>
-OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1,
-                              InputIterator2 first2, InputIterator2 last2,
-                              OutputIterator result);
-
-template <class InputIterator1, class InputIterator2, class OutputIterator,
-          class Compare>
-OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1,
-                              InputIterator2 first2, InputIterator2 last2,
-                              OutputIterator result, Compare comp);
-
-template <class InputIterator1, class InputIterator2, class OutputIterator>
-OutputIterator
-set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
-                         InputIterator2 first2, InputIterator2 last2,
-                         OutputIterator result);
-
-template <class InputIterator1, class InputIterator2, class OutputIterator,
-          class Compare>
-OutputIterator
-set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
-                         InputIterator2 first2, InputIterator2 last2,
-                         OutputIterator result, Compare comp);
-
-template <class RandomAccessIterator>
-void push_heap(RandomAccessIterator first, RandomAccessIterator last);
-
-template <class RandomAccessIterator, class Compare>
-void push_heap(RandomAccessIterator first, RandomAccessIterator last,
-               Compare comp);
-
-template <class RandomAccessIterator>
-void pop_heap(RandomAccessIterator first, RandomAccessIterator last);
-
-template <class RandomAccessIterator, class Compare>
-void pop_heap(RandomAccessIterator first, RandomAccessIterator last,
-              Compare comp);
-
-template <class RandomAccessIterator>
-void make_heap(RandomAccessIterator first, RandomAccessIterator last);
-
-template <class RandomAccessIterator, class Compare>
-void make_heap(RandomAccessIterator first, RandomAccessIterator last,
-               Compare comp);
-
-template <class RandomAccessIterator>
-void sort_heap(RandomAccessIterator first, RandomAccessIterator last);
-
-template <class RandomAccessIterator, class Compare>
-void sort_heap(RandomAccessIterator first, RandomAccessIterator last,
-               Compare comp);
-
-template <class RandomAccessIterator>
-bool is_heap(RandomAccessIterator first, RandomAccessIterator last);
-
-template <class RandomAccessIterator, class Compare>
-bool is_heap(RandomAccessIterator first, RandomAccessIterator last,
-             Compare comp);
-
-template <class RandomAccessIterator>
-RandomAccessIterator is_heap_until(RandomAccessIterator first,
-                                   RandomAccessIterator last);
-
-template <class RandomAccessIterator, class Compare>
-RandomAccessIterator is_heap_until(RandomAccessIterator first,
-                                   RandomAccessIterator last, Compare comp);
-
-template <class ForwardIterator>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 ForwardIterator min_element(ForwardIterator first,
-                                                          ForwardIterator last);
-
-template <class ForwardIterator, class Compare>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 ForwardIterator min_element(ForwardIterator first,
-                                                          ForwardIterator last,
-                                                          Compare comp);
-
-template <class T>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 const T &min(const T &a, const T &b);
-
-template <class T, class Compare>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 const T &min(const T &a, const T &b,
-                                           Compare comp);
-
-template <class T> _LIBCPP_CONSTEXPR_AFTER_CXX11 T min(initializer_list<T> t);
-
-template <class T, class Compare>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 T min(initializer_list<T> t, Compare comp);
-
-#if _LIBCPP_STD_VER > 14
-template <class T>
-const T constexpr &clamp(const T &v, const T &lo, const T &hi);
-
-template <class T, class Compare>
-const T constexpr &clamp(const T &v, const T &lo, const T &hi, Compare comp);
-#endif
-
-template <class ForwardIterator>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 ForwardIterator max_element(ForwardIterator first,
-                                                          ForwardIterator last);
-
-template <class ForwardIterator, class Compare>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 ForwardIterator max_element(ForwardIterator first,
-                                                          ForwardIterator last,
-                                                          Compare comp);
-
-template <class T>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 const T &max(const T &a, const T &b);
-
-template <class T, class Compare>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 const T &max(const T &a, const T &b,
-                                           Compare comp);
-
-template <class T> _LIBCPP_CONSTEXPR_AFTER_CXX11 T max(initializer_list<T> t);
-
-template <class T, class Compare>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 T max(initializer_list<T> t, Compare comp);
-
-template <class ForwardIterator>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 pair<ForwardIterator, ForwardIterator>
-minmax_element(ForwardIterator first, ForwardIterator last);
-
-template <class ForwardIterator, class Compare>
-pair<ForwardIterator, ForwardIterator> _LIBCPP_CONSTEXPR_AFTER_CXX11
-minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
-
-template <class T>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 pair<const T &, const T &> minmax(const T &a,
-                                                                const T &b);
-
-template <class T, class Compare>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 pair<const T &, const T &>
-minmax(const T &a, const T &b, Compare comp);
-
-template <class T>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 pair<T, T> minmax(initializer_list<T> t);
-
-template <class T, class Compare>
-_LIBCPP_CONSTEXPR_AFTER_CXX11 pair<T, T> minmax(initializer_list<T> t,
-                                                Compare comp);
-
-template <class InputIterator1, class InputIterator2>
-bool lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
-                             InputIterator2 first2, InputIterator2 last2);
-
-template <class InputIterator1, class InputIterator2, class Compare>
-bool lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
-                             InputIterator2 first2, InputIterator2 last2,
-                             Compare comp);
-
-template <class BidirectionalIterator>
-bool next_permutation(BidirectionalIterator first, BidirectionalIterator last);
-
-template <class BidirectionalIterator, class Compare>
-bool next_permutation(BidirectionalIterator first, BidirectionalIterator last,
-                      Compare comp);
-
-template <class BidirectionalIterator>
-bool prev_permutation(BidirectionalIterator first, BidirectionalIterator last);
-
-template <class BidirectionalIterator, class Compare>
-bool prev_permutation(BidirectionalIterator first, BidirectionalIterator last,
-                      Compare comp);
-
-} // namespace std
diff --git a/clang/lib/Headers/sycl_wrappers/random b/clang/lib/Headers/sycl_wrappers/random
deleted file mode 100644
index 797a36693e180..0000000000000
--- a/clang/lib/Headers/sycl_wrappers/random
+++ /dev/null
@@ -1,1458 +0,0 @@
-// -*- C++ -*-
-//===--------------------------- random -----------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#include <initializer_list>
-#include <iostream>
-#include <limits>
-#include <vector>
-
-namespace std {
-
-// Engines
-
-template <class UIntType, UIntType a, UIntType c, UIntType m>
-class linear_congruential_engine {
-public:
-  // types
-  typedef UIntType result_type;
-
-  // engine characteristics
-  static constexpr result_type multiplier = a;
-  static constexpr result_type increment = c;
-  static constexpr result_type modulus = m;
-  static constexpr result_type min() { return c == 0u ? 1u : 0u; }
-  static constexpr result_type max() { return m - 1u; }
-  static constexpr result_type default_seed = 1u;
-
-  // constructors and seeding functions
-  explicit linear_congruential_engine(result_type s = default_seed);
-  template <class Sseq> explicit linear_congruential_engine(Sseq &q);
-  void seed(result_type s = default_seed);
-  template <class Sseq> void seed(Sseq &q);
-
-  // generating functions
-  result_type operator()();
-  void discard(unsigned long long z);
-};
-
-template <class UIntType, UIntType a, UIntType c, UIntType m>
-bool operator==(const linear_congruential_engine<UIntType, a, c, m> &x,
-                const linear_congruential_engine<UIntType, a, c, m> &y);
-
-template <class UIntType, UIntType a, UIntType c, UIntType m>
-bool operator!=(const linear_congruential_engine<UIntType, a, c, m> &x,
-                const linear_congruential_engine<UIntType, a, c, m> &y);
-
-template <class charT, class traits, class UIntType, UIntType a, UIntType c,
-          UIntType m>
-basic_ostream<charT, traits> &
-operator<<(basic_ostream<charT, traits> &os,
-           const linear_congruential_engine<UIntType, a, c, m> &x);
-
-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);
-
-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 mersenne_twister_engine {
-public:
-  // types
-  typedef UIntType result_type;
-
-  // engine characteristics
-  static constexpr size_t word_size = w;
-  static constexpr size_t state_size = n;
-  static constexpr size_t shift_size = m;
-  static constexpr size_t mask_bits = r;
-  static constexpr result_type xor_mask = a;
-  static constexpr size_t tempering_u = u;
-  static constexpr result_type tempering_d = d;
-  static constexpr size_t tempering_s = s;
-  static constexpr result_type tempering_b = b;
-  static constexpr size_t tempering_t = t;
-  static constexpr result_type tempering_c = c;
-  static constexpr size_t tempering_l = l;
-  static constexpr result_type initialization_multiplier = f;
-  static constexpr result_type min() { return 0; }
-  static constexpr result_type max() { return 2 ^ w - 1; }
-  static constexpr result_type default_seed = 5489u;
-
-  // constructors and seeding functions
-  explicit mersenne_twister_engine(result_type value = default_seed);
-  template <class Sseq> explicit mersenne_twister_engine(Sseq &q);
-  void seed(result_type value = default_seed);
-  template <class Sseq> void seed(Sseq &q);
-
-  // generating functions
-  result_type operator()();
-  void discard(unsigned long long z);
-};
-
-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>
-bool operator==(const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s,
-                                              b, t, c, l, f> &x,
-                const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s,
-                                              b, t, c, l, f> &y);
-
-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>
-bool operator!=(const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s,
-                                              b, t, c, l, f> &x,
-                const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s,
-                                              b, t, c, l, f> &y);
-
-template <class charT, class traits, 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>
-basic_ostream<charT, traits> &
-operator<<(basic_ostream<charT, traits> &os,
-           const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t,
-                                         c, l, f> &x);
-
-template <class charT, class traits, 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>
-basic_istream<charT, traits> &
-operator>>(basic_istream<charT, traits> &is,
-           mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l,
-                                   f> &x);
-
-template <class UIntType, size_t w, size_t s, size_t r>
-class subtract_with_carry_engine {
-public:
-  // types
-  typedef UIntType result_type;
-
-  // engine characteristics
-  static constexpr size_t word_size = w;
-  static constexpr size_t short_lag = s;
-  static constexpr size_t long_lag = r;
-  static constexpr result_type min();
-  static constexpr result_type max();
-  static constexpr result_type default_seed = 19780503u;
-
-  // constructors and seeding functions
-  explicit subtract_with_carry_engine(result_type value = default_seed);
-  template <class Sseq> explicit subtract_with_carry_engine(Sseq &q);
-  void seed(result_type value = default_seed);
-  template <class Sseq> void seed(Sseq &q);
-
-  // generating functions
-  result_type operator()();
-  void discard(unsigned long long z);
-};
-
-template <class UIntType, size_t w, size_t s, size_t r>
-bool operator==(const subtract_with_carry_engine<UIntType, w, s, r> &x,
-                const subtract_with_carry_engine<UIntType, w, s, r> &y);
-
-template <class UIntType, size_t w, size_t s, size_t r>
-bool operator!=(const subtract_with_carry_engine<UIntType, w, s, r> &x,
-                const subtract_with_carry_engine<UIntType, w, s, r> &y);
-
-template <class charT, class traits, class UIntType, size_t w, size_t s,
-          size_t r>
-basic_ostream<charT, traits> &
-operator<<(basic_ostream<charT, traits> &os,
-           const subtract_with_carry_engine<UIntType, w, s, r> &x);
-
-template <class charT, class traits, class UIntType, size_t w, size_t s,
-          size_t r>
-basic_istream<charT, traits> &
-operator>>(basic_istream<charT, traits> &is,
-           subtract_with_carry_engine<UIntType, w, s, r> &x);
-
-template <class Engine, size_t p, size_t r> class discard_block_engine {
-public:
-  // types
-  typedef typename Engine::result_type result_type;
-
-  // engine characteristics
-  static constexpr size_t block_size = p;
-  static constexpr size_t used_block = r;
-  static constexpr result_type min() { return Engine::min(); }
-  static constexpr result_type max() { return Engine::max(); }
-
-  // constructors and seeding functions
-  discard_block_engine();
-  explicit discard_block_engine(const Engine &e);
-  explicit discard_block_engine(Engine &&e);
-  explicit discard_block_engine(result_type s);
-  template <class Sseq> explicit discard_block_engine(Sseq &q);
-  void seed();
-  void seed(result_type s);
-  template <class Sseq> void seed(Sseq &q);
-
-  // generating functions
-  result_type operator()();
-  void discard(unsigned long long z);
-
-  // property functions
-  const Engine &base() const noexcept;
-};
-
-template <class Engine, size_t p, size_t r>
-bool operator==(const discard_block_engine<Engine, p, r> &x,
-                const discard_block_engine<Engine, p, r> &y);
-
-template <class Engine, size_t p, size_t r>
-bool operator!=(const discard_block_engine<Engine, p, r> &x,
-                const discard_block_engine<Engine, p, r> &y);
-
-template <class charT, class traits, class Engine, size_t p, size_t r>
-basic_ostream<charT, traits> &
-operator<<(basic_ostream<charT, traits> &os,
-           const discard_block_engine<Engine, p, r> &x);
-
-template <class charT, class traits, class Engine, size_t p, size_t r>
-basic_istream<charT, traits> &operator>>(basic_istream<charT, traits> &is,
-                                         discard_block_engine<Engine, p, r> &x);
-
-template <class Engine, size_t w, class UIntType>
-class independent_bits_engine {
-public:
-  // types
-  typedef UIntType result_type;
-
-  // engine characteristics
-  static constexpr result_type min() { return 0; }
-  static constexpr result_type max() { return 2 ^ w - 1; }
-
-  // constructors and seeding functions
-  independent_bits_engine();
-  explicit independent_bits_engine(const Engine &e);
-  explicit independent_bits_engine(Engine &&e);
-  explicit independent_bits_engine(result_type s);
-  template <class Sseq> explicit independent_bits_engine(Sseq &q);
-  void seed();
-  void seed(result_type s);
-  template <class Sseq> void seed(Sseq &q);
-
-  // generating functions
-  result_type operator()();
-  void discard(unsigned long long z);
-
-  // property functions
-  const Engine &base() const noexcept;
-};
-
-template <class Engine, size_t w, class UIntType>
-bool operator==(const independent_bits_engine<Engine, w, UIntType> &x,
-                const independent_bits_engine<Engine, w, UIntType> &y);
-
-template <class Engine, size_t w, class UIntType>
-bool operator!=(const independent_bits_engine<Engine, w, UIntType> &x,
-                const independent_bits_engine<Engine, w, UIntType> &y);
-
-template <class charT, class traits, class Engine, size_t w, class UIntType>
-basic_ostream<charT, traits> &
-operator<<(basic_ostream<charT, traits> &os,
-           const independent_bits_engine<Engine, w, UIntType> &x);
-
-template <class charT, class traits, class Engine, size_t w, class UIntType>
-basic_istream<charT, traits> &
-operator>>(basic_istream<charT, traits> &is,
-           independent_bits_engine<Engine, w, UIntType> &x);
-
-template <class Engine, size_t k> class shuffle_order_engine {
-public:
-  // types
-  typedef typename Engine::result_type result_type;
-
-  // engine characteristics
-  static constexpr size_t table_size = k;
-  static constexpr result_type min() { return Engine::min; }
-  static constexpr result_type max() { return Engine::max; }
-
-  // constructors and seeding functions
-  shuffle_order_engine();
-  explicit shuffle_order_engine(const Engine &e);
-  explicit shuffle_order_engine(Engine &&e);
-  explicit shuffle_order_engine(result_type s);
-  template <class Sseq> explicit shuffle_order_engine(Sseq &q);
-  void seed();
-  void seed(result_type s);
-  template <class Sseq> void seed(Sseq &q);
-
-  // generating functions
-  result_type operator()();
-  void discard(unsigned long long z);
-
-  // property functions
-  const Engine &base() const noexcept;
-};
-
-template <class Engine, size_t k>
-bool operator==(const shuffle_order_engine<Engine, k> &x,
-                const shuffle_order_engine<Engine, k> &y);
-
-template <class Engine, size_t k>
-bool operator!=(const shuffle_order_engine<Engine, k> &x,
-                const shuffle_order_engine<Engine, k> &y);
-
-template <class charT, class traits, class Engine, size_t k>
-basic_ostream<charT, traits> &
-operator<<(basic_ostream<charT, traits> &os,
-           const shuffle_order_engine<Engine, k> &x);
-
-template <class charT, class traits, class Engine, size_t k>
-basic_istream<charT, traits> &operator>>(basic_istream<charT, traits> &is,
-                                         shuffle_order_engine<Engine, k> &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 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, 0xb5026f5aa96619e9, 29, 0x5555555555555555,
-    17, 0x71d67fffeda60000, 37, 0xfff7eee000000000, 43, 6364136223846793005>
-    mt19937_64;
-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 discard_block_engine<ranlux24_base, 223, 23> ranlux24;
-typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
-typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
-typedef minstd_rand default_random_engine;
-
-// Generators
-
-class random_device {
-public:
-  // types
-  typedef unsigned int result_type;
-
-  // generator characteristics
-  static constexpr result_type min() {
-    return numeric_limits<result_type>::min();
-  }
-  static constexpr result_type max() {
-    return numeric_limits<result_type>::max();
-  }
-
-  // constructors
-  explicit random_device(const string &token = "/dev/urandom");
-
-  // generating functions
-  result_type operator()();
-
-  // property functions
-  double entropy() const noexcept;
-
-  // no copy functions
-  random_device(const random_device &) = delete;
-  void operator=(const random_device &) = delete;
-};
-
-// Utilities
-
-class seed_seq {
-public:
-  // types
-  typedef uint_least32_t result_type;
-
-  // constructors
-  seed_seq();
-  template <class T> seed_seq(initializer_list<T> il);
-  template <class InputIterator>
-  seed_seq(InputIterator begin, InputIterator end);
-
-  // generating functions
-  template <class RandomAccessIterator>
-  void generate(RandomAccessIterator begin, RandomAccessIterator end);
-
-  // property functions
-  size_t size() const;
-  template <class OutputIterator> void param(OutputIterator dest) const;
-
-  // no copy functions
-  seed_seq(const seed_seq &) = delete;
-  void operator=(const seed_seq &) = delete;
-};
-
-template <class RealType, size_t bits, class URNG>
-RealType generate_canonical(URNG &g);
-
-// Distributions
-
-template <class IntType = int> class uniform_int_distribution {
-public:
-  // types
-  typedef IntType result_type;
-
-  class param_type {
-  public:
-    typedef uniform_int_distribution distribution_type;
-
-    explicit param_type(IntType a = 0,
-                        IntType b = numeric_limits<IntType>::max());
-
-    result_type a() const;
-    result_type b() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructors and reset functions
-  explicit uniform_int_distribution(IntType a = 0,
-                                    IntType b = numeric_limits<IntType>::max());
-  explicit uniform_int_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  result_type a() const;
-  result_type b() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const uniform_int_distribution &x,
-                         const uniform_int_distribution &y);
-  friend bool operator!=(const uniform_int_distribution &x,
-                         const uniform_int_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os,
-             const uniform_int_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is, uniform_int_distribution &x);
-};
-
-template <class RealType = double> class uniform_real_distribution {
-public:
-  // types
-  typedef RealType result_type;
-
-  class param_type {
-  public:
-    typedef uniform_real_distribution distribution_type;
-
-    explicit param_type(RealType a = 0, RealType b = 1);
-
-    result_type a() const;
-    result_type b() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructors and reset functions
-  explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0);
-  explicit uniform_real_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  result_type a() const;
-  result_type b() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const uniform_real_distribution &x,
-                         const uniform_real_distribution &y);
-  friend bool operator!=(const uniform_real_distribution &x,
-                         const uniform_real_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os,
-             const uniform_real_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is, uniform_real_distribution &x);
-};
-
-class bernoulli_distribution {
-public:
-  // types
-  typedef bool result_type;
-
-  class param_type {
-  public:
-    typedef bernoulli_distribution distribution_type;
-
-    explicit param_type(double p = 0.5);
-
-    double p() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructors and reset functions
-  explicit bernoulli_distribution(double p = 0.5);
-  explicit bernoulli_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  double p() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const bernoulli_distribution &x,
-                         const bernoulli_distribution &y);
-  friend bool operator!=(const bernoulli_distribution &x,
-                         const bernoulli_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os, const bernoulli_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is, bernoulli_distribution &x);
-};
-
-template <class IntType = int> class binomial_distribution {
-public:
-  // types
-  typedef IntType result_type;
-
-  class param_type {
-  public:
-    typedef binomial_distribution distribution_type;
-
-    explicit param_type(IntType t = 1, double p = 0.5);
-
-    IntType t() const;
-    double p() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructors and reset functions
-  explicit binomial_distribution(IntType t = 1, double p = 0.5);
-  explicit binomial_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  IntType t() const;
-  double p() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const binomial_distribution &x,
-                         const binomial_distribution &y);
-  friend bool operator!=(const binomial_distribution &x,
-                         const binomial_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os, const binomial_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is, binomial_distribution &x);
-};
-
-template <class IntType = int> class geometric_distribution {
-public:
-  // types
-  typedef IntType result_type;
-
-  class param_type {
-  public:
-    typedef geometric_distribution distribution_type;
-
-    explicit param_type(double p = 0.5);
-
-    double p() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructors and reset functions
-  explicit geometric_distribution(double p = 0.5);
-  explicit geometric_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  double p() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const geometric_distribution &x,
-                         const geometric_distribution &y);
-  friend bool operator!=(const geometric_distribution &x,
-                         const geometric_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os, const geometric_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is, geometric_distribution &x);
-};
-
-template <class IntType = int> class negative_binomial_distribution {
-public:
-  // types
-  typedef IntType result_type;
-
-  class param_type {
-  public:
-    typedef negative_binomial_distribution distribution_type;
-
-    explicit param_type(result_type k = 1, double p = 0.5);
-
-    result_type k() const;
-    double p() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructor and reset functions
-  explicit negative_binomial_distribution(result_type k = 1, double p = 0.5);
-  explicit negative_binomial_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  result_type k() const;
-  double p() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const negative_binomial_distribution &x,
-                         const negative_binomial_distribution &y);
-  friend bool operator!=(const negative_binomial_distribution &x,
-                         const negative_binomial_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os,
-             const negative_binomial_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is,
-             negative_binomial_distribution &x);
-};
-
-template <class IntType = int> class poisson_distribution {
-public:
-  // types
-  typedef IntType result_type;
-
-  class param_type {
-  public:
-    typedef poisson_distribution distribution_type;
-
-    explicit param_type(double mean = 1.0);
-
-    double mean() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructors and reset functions
-  explicit poisson_distribution(double mean = 1.0);
-  explicit poisson_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  double mean() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const poisson_distribution &x,
-                         const poisson_distribution &y);
-  friend bool operator!=(const poisson_distribution &x,
-                         const poisson_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os, const poisson_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is, poisson_distribution &x);
-};
-
-template <class RealType = double> class exponential_distribution {
-public:
-  // types
-  typedef RealType result_type;
-
-  class param_type {
-  public:
-    typedef exponential_distribution distribution_type;
-
-    explicit param_type(result_type lambda = 1.0);
-
-    result_type lambda() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructors and reset functions
-  explicit exponential_distribution(result_type lambda = 1.0);
-  explicit exponential_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  result_type lambda() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const exponential_distribution &x,
-                         const exponential_distribution &y);
-  friend bool operator!=(const exponential_distribution &x,
-                         const exponential_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os,
-             const exponential_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is, exponential_distribution &x);
-};
-
-template <class RealType = double> class gamma_distribution {
-public:
-  // types
-  typedef RealType result_type;
-
-  class param_type {
-  public:
-    typedef gamma_distribution distribution_type;
-
-    explicit param_type(result_type alpha = 1, result_type beta = 1);
-
-    result_type alpha() const;
-    result_type beta() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructors and reset functions
-  explicit gamma_distribution(result_type alpha = 1, result_type beta = 1);
-  explicit gamma_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  result_type alpha() const;
-  result_type beta() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const gamma_distribution &x,
-                         const gamma_distribution &y);
-  friend bool operator!=(const gamma_distribution &x,
-                         const gamma_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os, const gamma_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is, gamma_distribution &x);
-};
-
-template <class RealType = double> class weibull_distribution {
-public:
-  // types
-  typedef RealType result_type;
-
-  class param_type {
-  public:
-    typedef weibull_distribution distribution_type;
-
-    explicit param_type(result_type alpha = 1, result_type beta = 1);
-
-    result_type a() const;
-    result_type b() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructor and reset functions
-  explicit weibull_distribution(result_type a = 1, result_type b = 1);
-  explicit weibull_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  result_type a() const;
-  result_type b() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const weibull_distribution &x,
-                         const weibull_distribution &y);
-  friend bool operator!=(const weibull_distribution &x,
-                         const weibull_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os, const weibull_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is, weibull_distribution &x);
-};
-
-template <class RealType = double> class extreme_value_distribution {
-public:
-  // types
-  typedef RealType result_type;
-
-  class param_type {
-  public:
-    typedef extreme_value_distribution distribution_type;
-
-    explicit param_type(result_type a = 0, result_type b = 1);
-
-    result_type a() const;
-    result_type b() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructor and reset functions
-  explicit extreme_value_distribution(result_type a = 0, result_type b = 1);
-  explicit extreme_value_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  result_type a() const;
-  result_type b() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const extreme_value_distribution &x,
-                         const extreme_value_distribution &y);
-  friend bool operator!=(const extreme_value_distribution &x,
-                         const extreme_value_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os,
-             const extreme_value_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is, extreme_value_distribution &x);
-};
-
-template <class RealType = double> class normal_distribution {
-public:
-  // types
-  typedef RealType result_type;
-
-  class param_type {
-  public:
-    typedef normal_distribution distribution_type;
-
-    explicit param_type(result_type mean = 0, result_type stddev = 1);
-
-    result_type mean() const;
-    result_type stddev() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructors and reset functions
-  explicit normal_distribution(result_type mean = 0, result_type stddev = 1);
-  explicit normal_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  result_type mean() const;
-  result_type stddev() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const normal_distribution &x,
-                         const normal_distribution &y);
-  friend bool operator!=(const normal_distribution &x,
-                         const normal_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os, const normal_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is, normal_distribution &x);
-};
-
-template <class RealType = double> class lognormal_distribution {
-public:
-  // types
-  typedef RealType result_type;
-
-  class param_type {
-  public:
-    typedef lognormal_distribution distribution_type;
-
-    explicit param_type(result_type m = 0, result_type s = 1);
-
-    result_type m() const;
-    result_type s() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructor and reset functions
-  explicit lognormal_distribution(result_type m = 0, result_type s = 1);
-  explicit lognormal_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  result_type m() const;
-  result_type s() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const lognormal_distribution &x,
-                         const lognormal_distribution &y);
-  friend bool operator!=(const lognormal_distribution &x,
-                         const lognormal_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os, const lognormal_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is, lognormal_distribution &x);
-};
-
-template <class RealType = double> class chi_squared_distribution {
-public:
-  // types
-  typedef RealType result_type;
-
-  class param_type {
-  public:
-    typedef chi_squared_distribution distribution_type;
-
-    explicit param_type(result_type n = 1);
-
-    result_type n() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructor and reset functions
-  explicit chi_squared_distribution(result_type n = 1);
-  explicit chi_squared_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  result_type n() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const chi_squared_distribution &x,
-                         const chi_squared_distribution &y);
-  friend bool operator!=(const chi_squared_distribution &x,
-                         const chi_squared_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os,
-             const chi_squared_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is, chi_squared_distribution &x);
-};
-
-template <class RealType = double> class cauchy_distribution {
-public:
-  // types
-  typedef RealType result_type;
-
-  class param_type {
-  public:
-    typedef cauchy_distribution distribution_type;
-
-    explicit param_type(result_type a = 0, result_type b = 1);
-
-    result_type a() const;
-    result_type b() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructor and reset functions
-  explicit cauchy_distribution(result_type a = 0, result_type b = 1);
-  explicit cauchy_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  result_type a() const;
-  result_type b() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const cauchy_distribution &x,
-                         const cauchy_distribution &y);
-  friend bool operator!=(const cauchy_distribution &x,
-                         const cauchy_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os, const cauchy_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is, cauchy_distribution &x);
-};
-
-template <class RealType = double> class fisher_f_distribution {
-public:
-  // types
-  typedef RealType result_type;
-
-  class param_type {
-  public:
-    typedef fisher_f_distribution distribution_type;
-
-    explicit param_type(result_type m = 1, result_type n = 1);
-
-    result_type m() const;
-    result_type n() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructor and reset functions
-  explicit fisher_f_distribution(result_type m = 1, result_type n = 1);
-  explicit fisher_f_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  result_type m() const;
-  result_type n() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const fisher_f_distribution &x,
-                         const fisher_f_distribution &y);
-  friend bool operator!=(const fisher_f_distribution &x,
-                         const fisher_f_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os, const fisher_f_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is, fisher_f_distribution &x);
-};
-
-template <class RealType = double> class student_t_distribution {
-public:
-  // types
-  typedef RealType result_type;
-
-  class param_type {
-  public:
-    typedef student_t_distribution distribution_type;
-
-    explicit param_type(result_type n = 1);
-
-    result_type n() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructor and reset functions
-  explicit student_t_distribution(result_type n = 1);
-  explicit student_t_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  result_type n() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const student_t_distribution &x,
-                         const student_t_distribution &y);
-  friend bool operator!=(const student_t_distribution &x,
-                         const student_t_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os, const student_t_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is, student_t_distribution &x);
-};
-
-template <class IntType = int> class discrete_distribution {
-public:
-  // types
-  typedef IntType result_type;
-
-  class param_type {
-  public:
-    typedef discrete_distribution distribution_type;
-
-    param_type();
-    template <class InputIterator>
-    param_type(InputIterator firstW, InputIterator lastW);
-    param_type(initializer_list<double> wl);
-    template <class UnaryOperation>
-    param_type(size_t nw, double xmin, double xmax, UnaryOperation fw);
-
-    vector<double> probabilities() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructor and reset functions
-  discrete_distribution();
-  template <class InputIterator>
-  discrete_distribution(InputIterator firstW, InputIterator lastW);
-  discrete_distribution(initializer_list<double> wl);
-  template <class UnaryOperation>
-  discrete_distribution(size_t nw, double xmin, double xmax, UnaryOperation fw);
-  explicit discrete_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  vector<double> probabilities() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const discrete_distribution &x,
-                         const discrete_distribution &y);
-  friend bool operator!=(const discrete_distribution &x,
-                         const discrete_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os, const discrete_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is, discrete_distribution &x);
-};
-
-template <class RealType = double> class piecewise_constant_distribution {
-  // types
-  typedef RealType result_type;
-
-  class param_type {
-  public:
-    typedef piecewise_constant_distribution distribution_type;
-
-    param_type();
-    template <class InputIteratorB, class InputIteratorW>
-    param_type(InputIteratorB firstB, InputIteratorB lastB,
-               InputIteratorW firstW);
-    template <class UnaryOperation>
-    param_type(initializer_list<result_type> bl, UnaryOperation fw);
-    template <class UnaryOperation>
-    param_type(size_t nw, result_type xmin, result_type xmax,
-               UnaryOperation fw);
-
-    vector<result_type> intervals() const;
-    vector<result_type> densities() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructor and reset functions
-  piecewise_constant_distribution();
-  template <class InputIteratorB, class InputIteratorW>
-  piecewise_constant_distribution(InputIteratorB firstB, InputIteratorB lastB,
-                                  InputIteratorW firstW);
-  template <class UnaryOperation>
-  piecewise_constant_distribution(initializer_list<result_type> bl,
-                                  UnaryOperation fw);
-  template <class UnaryOperation>
-  piecewise_constant_distribution(size_t nw, result_type xmin, result_type xmax,
-                                  UnaryOperation fw);
-  explicit piecewise_constant_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  vector<result_type> intervals() const;
-  vector<result_type> densities() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const piecewise_constant_distribution &x,
-                         const piecewise_constant_distribution &y);
-  friend bool operator!=(const piecewise_constant_distribution &x,
-                         const piecewise_constant_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os,
-             const piecewise_constant_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is,
-             piecewise_constant_distribution &x);
-};
-
-template <class RealType = double> class piecewise_linear_distribution {
-  // types
-  typedef RealType result_type;
-
-  class param_type {
-  public:
-    typedef piecewise_linear_distribution distribution_type;
-
-    param_type();
-    template <class InputIteratorB, class InputIteratorW>
-    param_type(InputIteratorB firstB, InputIteratorB lastB,
-               InputIteratorW firstW);
-    template <class UnaryOperation>
-    param_type(initializer_list<result_type> bl, UnaryOperation fw);
-    template <class UnaryOperation>
-    param_type(size_t nw, result_type xmin, result_type xmax,
-               UnaryOperation fw);
-
-    vector<result_type> intervals() const;
-    vector<result_type> densities() const;
-
-    friend bool operator==(const param_type &x, const param_type &y);
-    friend bool operator!=(const param_type &x, const param_type &y);
-  };
-
-  // constructor and reset functions
-  piecewise_linear_distribution();
-  template <class InputIteratorB, class InputIteratorW>
-  piecewise_linear_distribution(InputIteratorB firstB, InputIteratorB lastB,
-                                InputIteratorW firstW);
-
-  template <class UnaryOperation>
-  piecewise_linear_distribution(initializer_list<result_type> bl,
-                                UnaryOperation fw);
-
-  template <class UnaryOperation>
-  piecewise_linear_distribution(size_t nw, result_type xmin, result_type xmax,
-                                UnaryOperation fw);
-
-  explicit piecewise_linear_distribution(const param_type &parm);
-  void reset();
-
-  // generating functions
-  template <class URNG> result_type operator()(URNG &g);
-  template <class URNG> result_type operator()(URNG &g, const param_type &parm);
-
-  // property functions
-  vector<result_type> intervals() const;
-  vector<result_type> densities() const;
-
-  param_type param() const;
-  void param(const param_type &parm);
-
-  result_type min() const;
-  result_type max() const;
-
-  friend bool operator==(const piecewise_linear_distribution &x,
-                         const piecewise_linear_distribution &y);
-  friend bool operator!=(const piecewise_linear_distribution &x,
-                         const piecewise_linear_distribution &y);
-
-  template <class charT, class traits>
-  friend basic_ostream<charT, traits> &
-  operator<<(basic_ostream<charT, traits> &os,
-             const piecewise_linear_distribution &x);
-
-  template <class charT, class traits>
-  friend basic_istream<charT, traits> &
-  operator>>(basic_istream<charT, traits> &is,
-             piecewise_linear_distribution &x);
-};
-
-} // namespace std